server: trace a bit more

[hippotat.git] / src / bin / server.rs

diff --git a/src/bin/server.rs b/src/bin/server.rs
index 1764470ba118ae8dc47c560a6161a1b20f13b79f..ae130d8307960837b231a07d7dc0e6779b2330a9 100644 (file)
--- a/src/bin/server.rs
+++ b/src/bin/server.rs
@@ -183,6 +183,7 @@ async fn handle(
     // boundary, start, &comp.name, &client.ic);
 
     let (reply_to, reply_recv) = tokio::sync::oneshot::channel();
+    trace!("{} request xxx={}", &client.ic, initial.len());
     let wreq = WebRequest {
       initial,
       initial_remaining,
@@ -192,7 +193,6 @@ async fn handle(
       warnings: mem::take(&mut warnings),
       reply_to
     };
-    trace!("{} request", &client.ic);
 
     client.web.try_send(wreq)
       .map_err(|_| anyhow!("client task shut down!"))?;
@@ -266,6 +266,8 @@ async fn run_client(ic: Arc<InstanceConfig>,
 
         match async {
 
+          let initial_used = initial.len() - initial_remaining;
+
           let whole_request = read_limited_bytes(
             ic.max_batch_up.sat(),
             initial,
@@ -275,58 +277,51 @@ async fn run_client(ic: Arc<InstanceConfig>,
 
           let (meta, comps) =
             multipart::ComponentIterator::resume_mid_component(
-              &whole_request[initial_remaining..],
+              &whole_request[initial_used..],
               boundary_finder
             ).context("resume parsing body, after auth checks")?;
 
           let mut meta = MetadataFieldIterator::new(&meta);
-/*
-          macro_rules!(
-
-          let target_requests_outstanding = {
-            let server = ic.target_requests_outstanding;
-            let client: u32 = meta.need_parse()?;
-            if client != server {
-              throw!(anyhow!("mismatch: client={} != server={}",
-                             client, server));
-            }
-            Ok::<_,AE>(client)
-          }.context("target_requests_outstanding")?;
-
-          let http_timeout: u64 = {
-            let server = ic.http_timeout;
-            let client = Duration::from_secs(meta.need_parse()?);
-            if client > server {
-              throw!(anyhow!("mismatch: client={} > server={}",
-                             client, server));
-            }
-            Ok::<_,AE>(client)
-          }.context("http_timeout")?;
-
-          let max_batch_down = {
-            let server = ic.max_batch_down;
-            let client: u32 = meta.parse().context("max_batch_down")?;
-            let to_use = min(client, server);
-            Ok::<_,AE>(to_use)
-          }.context("max_batch_down")?;
-
-          let max_batch_up = {
-            let server = ic.max_batch_up;
-            let client = meta.parse().context("max_batch_up")?;
-            if client > server {
-              throw!(anyhow!("mismatch: client={} != server={}",
-                             client, server));
+
+          macro_rules! meta {
+            { $v:ident, ( $( $badcmp:tt )? ), $ret:expr,
+              let $server:ident, $client:ident $($code:tt)*
+            } => {
+              let $v = (||{
+                let $server = ic.$v;
+                let $client $($code)*
+                $(
+                  if $client $badcmp $server {
+                    throw!(anyhow!("mismatch: client={:?} {} server={:?}",
+                                   $client, stringify!($badcmp), $server));
+                  }
+                )?
+                Ok::<_,AE>($ret)
+              })().context(stringify!($v))?;
+              dbg!(&$v);
             }
-              
-            throw!(anyhow!(
- "target_requests_outstanding mismatch: client={} server={}",
-              target_requests_outstanding, 
-              ic.target_requests_outstanding
-            ))
           }
 
-          if ic.
-*/
+          meta!{
+            target_requests_outstanding, ( != ), client,
+            let server, client: u32 = meta.need_parse()?;
+          }
+
+          meta!{
+            http_timeout, ( > ), client,
+            let server, client = Duration::from_secs(meta.need_parse()?);
+          }
+
+          meta!{
+            max_batch_down, (), min(client, server),
+            let server, client: u32 = meta.parse()?.unwrap_or(server);
+          }
+
+          meta!{
+            max_batch_up, ( > ), client,
+            let server, client = meta.parse()?.unwrap_or(server);
+          }
+
           Ok::<_,AE>(())
         }.await {
           Ok(()) => outstanding.push_back(Outstanding {