Merge pull request #13 from CleverCloud/stoppable_converter

Allow converter to stop in the middle of blocks

Author: Keksoj

src/protocol/h1/converter.rs

@@ -16,7 +16,7 @@ impl Version {
 }
 
 impl<T: AsBuffer> BlockConverter<T> for H1BlockConverter {
-    fn call(&mut self, block: Block, kawa: &mut Kawa<T>) {
+    fn call(&mut self, block: Block, kawa: &mut Kawa<T>) -> bool {
         match block {
             Block::StatusLine => match kawa.detached.status_line.pop() {
                 StatusLine::Request {
@@ -52,7 +52,7 @@ impl<T: AsBuffer> BlockConverter<T> for H1BlockConverter {
             },
             Block::Cookies => {
                 if kawa.detached.jar.is_empty() {
-                    return;
+                    return true;
                 }
                 kawa.push_out(Store::Static(b"Cookie: "));
                 let mut first = true;
@@ -104,5 +104,6 @@ impl<T: AsBuffer> BlockConverter<T> for H1BlockConverter {
                 }
             }
         }
+        true
     }
 }

src/protocol/h2/converter.rs

@@ -8,7 +8,7 @@ use crate::{
 pub struct H2BlockConverter;
 
 impl<T: AsBuffer> BlockConverter<T> for H2BlockConverter {
-    fn call(&mut self, block: Block, kawa: &mut Kawa<T>) {
+    fn call(&mut self, block: Block, kawa: &mut Kawa<T>) -> bool {
         match block {
             Block::StatusLine => match kawa.detached.status_line.pop() {
                 StatusLine::Request {
@@ -36,7 +36,7 @@ impl<T: AsBuffer> BlockConverter<T> for H2BlockConverter {
             },
             Block::Cookies => {
                 if kawa.detached.jar.is_empty() {
-                    return;
+                    return true;
                 }
                 kawa.push_out(Store::Static(b"------------ HEADER"));
                 for cookie in kawa
@@ -72,7 +72,7 @@ impl<T: AsBuffer> BlockConverter<T> for H2BlockConverter {
                         || compare_no_case(key, b"transfer-encoding")
                         || compare_no_case(key, b"upgrade")
                     {
-                        return;
+                        return true;
                     }
                 }
                 kawa.push_out(Store::Static(b"------------ HEADER\n"));
@@ -106,5 +106,6 @@ impl<T: AsBuffer> BlockConverter<T> for H2BlockConverter {
                 }
             }
         }
+        true
     }
 }

src/storage/mod.rs

@@ -13,6 +13,6 @@ pub use vecdeque::VecDeque;
 
 pub trait BlockConverter<T: AsBuffer> {
     fn initialize(&mut self, _kawa: &mut Kawa<T>) {}
-    fn call(&mut self, block: Block, kawa: &mut Kawa<T>);
+    fn call(&mut self, block: Block, kawa: &mut Kawa<T>) -> bool;
     fn finalize(&mut self, _kawa: &mut Kawa<T>) {}
 }

src/storage/repr.rs

@@ -78,7 +78,9 @@ impl<T: AsBuffer> Kawa<T> {
     pub fn prepare<C: BlockConverter<T>>(&mut self, converter: &mut C) {
         converter.initialize(self);
         while let Some(block) = self.blocks.pop_front() {
-            converter.call(block, self);
+            if !converter.call(block, self) {
+                break;
+            }
         }
         converter.finalize(self);
     }
@@ -109,8 +111,8 @@ impl<T: AsBuffer> Kawa<T> {
     /// note: this function assumes blocks is empty! To respect this invariant you should always
     /// call prepare before consume
     pub fn consume(&mut self, mut amount: usize) {
-        assert!(self.blocks.is_empty());
-        assert!(self.detached.jar.is_empty());
+        // assert!(self.blocks.is_empty());
+        // assert!(self.detached.jar.is_empty());
         if amount > 0 {
             self.consumed = true;
         }
@@ -142,7 +144,12 @@ impl<T: AsBuffer> Kawa<T> {
                 return slice.start as usize;
             }
         }
-        self.storage.head
+        if self.blocks.is_empty() {
+            // conservative estimate
+            self.storage.head
+        } else {
+            self.storage.start
+        }
     }
 
     pub fn push_block(&mut self, block: Block) {
@@ -487,6 +494,17 @@ impl Store {
         }
     }
 
+    pub fn len(&self) -> usize {
+        match self {
+            Store::Empty => 0,
+            Store::Slice(s) | Store::Detached(s) => s.len(),
+            Store::Static(s) => s.len(),
+            Store::Alloc(s, i) => s.len() - *i as usize,
+            #[cfg(feature = "rc-alloc")]
+            Store::Shared(s, i) => s.len() - *i as usize,
+        }
+    }
+
     pub fn is_empty(&self) -> bool {
         matches!(self, Store::Empty)
     }
@@ -539,6 +557,37 @@ impl Store {
         }
     }
 
+    pub fn split(self, at: usize) -> (Store, Store) {
+        let at32 = at as u32;
+        match self {
+            Store::Empty => (Store::Empty, Store::Empty),
+            Store::Slice(Slice { start, len }) => (
+                Store::Slice(Slice { start, len: at32 }),
+                Store::Slice(Slice {
+                    start: start + at32,
+                    len: len - at32,
+                }),
+            ),
+            Store::Detached(Slice { start, len }) => (
+                Store::Detached(Slice { start, len: at32 }),
+                Store::Detached(Slice {
+                    start: start + at32,
+                    len: len - at32,
+                }),
+            ),
+            Store::Static(s) => (Store::Static(&s[..at]), Store::Static(&s[at..])),
+            Store::Alloc(s, i) => (
+                Store::from_slice(&s[i as usize..i as usize + at]),
+                Store::Alloc(s, i + at32),
+            ),
+            #[cfg(feature = "rc-alloc")]
+            Store::Shared(s, i) => (
+                Store::from_slice(&s[i as usize..i as usize + at]),
+                Store::Shared(s, i + at32),
+            ),
+        }
+    }
+
     fn consume(self, amount: usize) -> (usize, Option<Store>) {
         match self {
             Store::Empty => (amount, None),