Implement Basic Incremental Startup

chart/templates/deployment.yaml

@@ -54,15 +54,31 @@ spec:
             - name: http
               containerPort: 8000
               protocol: TCP
+          startupProbe:
+            httpGet:
+              path: /healthz
+              port: http
+            initialDelaySeconds: 10
+            periodSeconds: 5
+            timeoutSeconds: 1
           livenessProbe:
             httpGet:
               path: /healthz
               port: http
+            initialDelaySeconds: 20
+            periodSeconds: 20
+            timeoutSeconds: 5
+            successThreshold: 1 
+            failureThreshold: 3
           readinessProbe:
             httpGet:
               path: /healthz
               port: http
-            timeoutSeconds: 20
+            initialDelaySeconds: 20
+            periodSeconds: 5
+            timeoutSeconds: 1
+            successThreshold: 1
+            failureThreshold: 3          
           resources:
             {{- toYaml .Values.resources | nindent 12 }}
       {{- with .Values.nodeSelector }}

src/main.rs

 // SPDX-FileCopyrightText: 2024 Phil Höfer <phil@suma-ev.de>
 // SPDX-License-Identifier: AGPL-3.0-only
 
-use core::str;
+use core::{str, time};
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::{self, BufRead, BufReader};
@@ -93,14 +93,32 @@ fn main() -> Result<(), io::Error> {
 
     let server = Server::http("0.0.0.0:8000").unwrap();
 
-    for request in server.incoming_requests() {
-        process_request(request, config.clone(), &mut markov_chain, last_update, last_decay)
+    loop {
+        let request = server.recv_timeout(std::time::Duration::from_secs(10));
+        match request {
+            Ok(Some(r)) => {
+                process_request(r, config.clone(), &mut markov_chain);
+            },
+            _ => {
+                let now = std::time::SystemTime::now();
+                let update_elapsed = now.duration_since(last_update).expect("Time went backwards");
+                if update_elapsed >= std::time::Duration::from_secs(2 * 60 * 60) || (markov_chain.update_count()<10000) { //every 2h
+                    read_from_db(config.clone(), &mut markov_chain);
+                    last_update = now;
+                }
+                let decay_elapsed = now.duration_since(last_decay).expect("Time went backwards");
+                if decay_elapsed >= std::time::Duration::from_secs(24 * 60 * 60) || (markov_chain.update_count()<1000) { //every 24h
+                    markov_chain.decay();
+                    last_decay = now;
+                }
+            }
+        }
     }
 
     Ok(())
 }
 
-fn process_request(request: tiny_http::Request, config: HashMap<String, String>, markov_chain: &mut CompositePredictor, mut last_update: SystemTime, mut last_decay: SystemTime) {
+fn process_request(request: tiny_http::Request, config: HashMap<String, String>, markov_chain: &mut CompositePredictor) {
     //   println!("received request! method: {:?}, url: {:?}, headers: {:?}",
         //       request.method(),
         //       request.url(),
@@ -142,17 +160,6 @@ fn process_request(request: tiny_http::Request, config: HashMap<String, String>,
                 let response = Response::from_string(
                     format!("[\"{}\",[{}]]", query, predictions.join(",")));
                 request.respond(response);
-                let now = std::time::SystemTime::now();
-                let update_elapsed = now.duration_since(last_update).expect("Time went backwards");
-                if update_elapsed >= std::time::Duration::from_secs(2 * 60 * 60) || (markov_chain.update_count()<10000) { //every 2h
-                    read_from_db(config.clone(), markov_chain);
-                    last_update = now;
-                }
-                let decay_elapsed = now.duration_since(last_decay).expect("Time went backwards");
-                if decay_elapsed >= std::time::Duration::from_secs(24 * 60 * 60) || (markov_chain.update_count()<10000) { //every 24h
-                    markov_chain.decay();
-                    last_decay = now;
-                }
             },
             Err(e) => {
                 //println!("Error: {}",e);