Issue 182 - Error handling, propagation, etc.

DEVELOPMENT-CURRENT-COMMANDS.md

@@ -1,8 +1,13 @@
 # stress
 
 curl -v http://localhost:5001/ping
+
 TOKIO_WORKER_THREADS=1 oha -c 20 -z 60s http://127.0.0.1:5001/ping
+
+TOKIO_WORKER_THREADS=1 oha -c 20 -z 60s -D target/release/extension -T application/octet-stream -m POST http://127.0.0.1:5001/echo
+
 k6 run k6/ping-dispatch-local.js
+
 curl -X POST -H "Content-Type: text/markdown" --data-binary @README.md http://localhost:5001/echo --compressed -o README2.md -v
 
 # node

extension/src/app_request.rs

@@ -116,10 +116,6 @@ mod tests {
           async move {
             // Increment the request count
             request_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-            println!(
-              "Request count: {}",
-              request_count.load(std::sync::atomic::Ordering::SeqCst)
-            );
 
             if request_count.load(std::sync::atomic::Ordering::SeqCst) == 1 {
               let req =
@@ -235,10 +231,6 @@ mod tests {
             async move {
               // Increment the request count
               request_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-              println!(
-                "Request count: {}",
-                request_count.load(std::sync::atomic::Ordering::SeqCst)
-              );
 
               if request_count.load(std::sync::atomic::Ordering::SeqCst) == 1 {
                 let req =
@@ -357,10 +349,6 @@ mod tests {
           async move {
             // Increment the request count
             request_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-            println!(
-              "Request count: {}",
-              request_count.load(std::sync::atomic::Ordering::SeqCst)
-            );
 
             // Create a channel for the stream
             let (mut tx, rx) = tokio::io::duplex(65_536);
@@ -485,10 +473,6 @@ mod tests {
           async move {
             // Increment the request count
             request_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-            println!(
-              "Request count: {}",
-              request_count.load(std::sync::atomic::Ordering::SeqCst)
-            );
 
             // Create a channel for the stream
             let (mut tx, rx) = tokio::io::duplex(65_536);

extension/src/app_start.rs

@@ -32,23 +32,13 @@ async fn create_connection(
     }
     Ok(Err(err)) => {
       // Connection error
-      log::error!(
-        "Health check - Contained App TcpStream::connect error: {}, endpoint: {}",
-        err,
-        healthcheck_addr
-      );
       return Err(anyhow::anyhow!(
         "Health check - TcpStream::connect error: {}",
         err
       ));
     }
     Err(err) => {
       // Timeout
-      log::error!(
-        "Health check - Contained App TcpStream::connect timed out: {}, endpoint: {}",
-        err,
-        healthcheck_addr
-      );
       return Err(anyhow::anyhow!(
         "Health check - TcpStream::connect timed out: {}",
         err
@@ -144,8 +134,7 @@ pub async fn health_check_contained_app(
             }
           }));
         }
-        Err(e) => {
-          log::error!("Failed to create connection: {}", e);
+        Err(_) => {
           continue;
         }
       }

extension/src/connect_to_app.rs

@@ -156,7 +156,6 @@ pub async fn connect_to_app(
   // }
 
   // This task just keeps the connection from being dropped
-  // TODO: Let's return this and hold it elsewhere
   tokio::task::spawn(async move {
     if let Err(err) = connection.await {
       log::error!(
@@ -179,6 +178,7 @@ mod tests {
   use crate::endpoint::{Endpoint, Scheme};
   use httpmock::{Method::GET, MockServer};
   use std::sync::Arc;
+  use tokio_test::assert_err;
 
   #[tokio::test]
   async fn test_connect_to_app_dns_failure() {
@@ -225,15 +225,15 @@ mod tests {
   #[tokio::test]
   async fn test_connect_to_app_blackhole_timeout() {
     // 192.0.2.0/24 (TEST-NET-1)
-    let router_endpoint = Endpoint::new(Scheme::Http, "192.0.2.0", 12345);
+    let app_endpoint = Endpoint::new(Scheme::Http, "192.0.2.0", 12345);
     let pool_id = Arc::from("pool_id");
     let lambda_id = Arc::from("lambda_id");
     let channel_id = Arc::from("channel_id");
 
     // Act
     let start = std::time::Instant::now();
     let sender = connect_to_app(
-      &router_endpoint,
+      &app_endpoint,
       Arc::clone(&pool_id),
       Arc::clone(&lambda_id),
       Arc::clone(&channel_id),
@@ -242,13 +242,7 @@ mod tests {
     let duration = std::time::Instant::now().duration_since(start);
 
     // Assert
-    match sender {
-      Ok(_) => assert!(sender.is_err(), "Connection should not be established"),
-      Err(e) => assert_eq!(
-        e.to_string(),
-        "TcpStream::connect timed out: deadline has elapsed"
-      ),
-    }
+    assert_err!(sender, "Connection should not be established");
     assert!(
       duration >= std::time::Duration::from_secs(5),
       "Connection should take at least 5 seconds"
@@ -268,15 +262,15 @@ mod tests {
       then.status(200).body("OK");
     });
 
-    let router_endpoint = Endpoint::new(Scheme::Http, "localhost", app_server.port());
+    let app_endpoint = Endpoint::new(Scheme::Http, "localhost", app_server.port());
     let pool_id = Arc::from("pool_id");
     let lambda_id = Arc::from("lambda_id");
     let channel_id = Arc::from("channel_id");
 
     // Act
     let start = std::time::Instant::now();
-    let sender = connect_to_app(
-      &router_endpoint,
+    let result = connect_to_app(
+      &app_endpoint,
       Arc::clone(&pool_id),
       Arc::clone(&lambda_id),
       Arc::clone(&channel_id),
@@ -285,10 +279,7 @@ mod tests {
     let duration = std::time::Instant::now().duration_since(start);
 
     // Assert
-    match sender {
-      Ok(_) => assert!(sender.is_ok(), "Connection should be established"),
-      Err(e) => assert_eq!(e.to_string(), "Contained App ready check timed out"),
-    }
+    assert!(result.is_ok(), "Connection should be established");
     assert!(
       duration <= std::time::Duration::from_secs(2),
       "Connection should take at most 2 seconds"