no timeout

1 files changed, 58 insertions, 83 deletions

diff --git a/src/session/segment_buffer.rs b/src/session/segment_buffer.rs
index f0ca20e..6e6ceae 100644
--- a/src/session/segment_buffer.rs
+++ b/src/session/segment_buffer.rs
@@ -5,7 +5,6 @@ use std::num::Wrapping;
 pub enum Description {
     Ok,
     TooManyPacket,
-    Timeout,
     WindowFull,
 }
 
@@ -36,10 +35,8 @@ pub struct Stream {
 
     max_packets: usize,
     window_size: usize,
-    timeout: u64,
     
     used_window_size: usize,
-    last_ts: Option<u64>,
 
     // todo: 完全抽象，不要timestamp，window size 和 max packets 改名。next rel seq改名。
     // todo: 起始偏移量一定是0. isn 不要了
@@ -49,18 +46,16 @@ pub struct Stream {
 }
 
 impl Stream {
-    pub fn new(window_size: usize, max_packets: usize, timeout: u64) -> Self { // todo: 删掉isn，重命名，不要timeout
+    pub fn new(window_size: usize, max_packets: usize) -> Self { // todo: 删掉isn，重命名，不要timeout
         Stream {
             next_offset: Wrapping(0),
             segments: BTreeMap::new(),
             max_packets,
             window_size,
-            timeout,
             used_window_size: 0,
-            last_ts: None,
         }
     }
-    pub fn update(&mut self, offset: u32, payload: &[u8], time_stamp: u64) -> Description {
+    pub fn update(&mut self, offset: u32, payload: &[u8]) -> Description {
         if self.segments.len() >= self.max_packets {
             return Description::TooManyPacket;
         }
@@ -69,17 +64,6 @@ impl Stream {
             return Description::WindowFull;
         }
 
-        if self.last_ts.is_none() {
-            self.last_ts = Some(time_stamp);
-        } else {
-            let last_ts = self.last_ts.unwrap();
-            if (time_stamp > last_ts) && (time_stamp - last_ts > self.timeout) {
-                return Description::Timeout;
-            }
-        }
-
-        self.last_ts = Some(std::cmp::max(self.last_ts.unwrap(), time_stamp));
-
         if payload.is_empty() {
             return Description::Ok;
         }
@@ -163,10 +147,10 @@ mod tests {
 
     #[test]
     fn several_ordered_segments() {
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(0, &[1, 2, 3], 0), Description::Ok);
-        assert_eq!(s.update(3, &[4, 5], 0), Description::Ok);
-        assert_eq!(s.update(5, &[6], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(0, &[1, 2, 3]), Description::Ok);
+        assert_eq!(s.update(3, &[4, 5]), Description::Ok);
+        assert_eq!(s.update(5, &[6]), Description::Ok);
         
         assert_eq!(s.pullup().unwrap(), &[1, 2, 3, 4, 5, 6]);
         assert_eq!(s.clear(), Vec::<Vec<u8>>::new());
@@ -174,10 +158,10 @@ mod tests {
 
     #[test]
     fn several_unordered_segments() {
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(5, &[6], 0), Description::Ok);
-        assert_eq!(s.update(0, &[1, 2, 3], 0), Description::Ok);
-        assert_eq!(s.update(3, &[4, 5], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(5, &[6]), Description::Ok);
+        assert_eq!(s.update(0, &[1, 2, 3]), Description::Ok);
+        assert_eq!(s.update(3, &[4, 5]), Description::Ok);
 
         let expected_clear = vec![vec![1, 2, 3, 4, 5, 6]];
         assert_eq!(s.clear(), expected_clear);
@@ -185,11 +169,11 @@ mod tests {
 
     #[test]
     fn with_hole() {
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(0, &[1, 2], 0), Description::Ok); // miss 3
-        assert_eq!(s.update(3, &[4, 5], 0), Description::Ok);
-        assert_eq!(s.update(5, &[6], 0), Description::Ok);  // miss 7
-        assert_eq!(s.update(7, &[8, 9], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(0, &[1, 2]), Description::Ok); // miss 3
+        assert_eq!(s.update(3, &[4, 5]), Description::Ok);
+        assert_eq!(s.update(5, &[6]), Description::Ok);  // miss 7
+        assert_eq!(s.update(7, &[8, 9]), Description::Ok);
 
         let expected_clear = vec![vec![1, 2], vec![4, 5, 6], vec![8, 9]];
         assert_eq!(s.clear(), expected_clear);
@@ -197,10 +181,10 @@ mod tests {
 
     #[test]
     fn duplicate_packet() {
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(0, &[1, 2, 3], 0), Description::Ok);
-        assert_eq!(s.update(0, &[1, 2, 3], 0), Description::Ok);
-        assert_eq!(s.update(3, &[4, 5], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(0, &[1, 2, 3]), Description::Ok);
+        assert_eq!(s.update(0, &[1, 2, 3]), Description::Ok);
+        assert_eq!(s.update(3, &[4, 5]), Description::Ok);
 
         let expected_clear = vec![vec![1, 2, 3, 4, 5]];
         assert_eq!(s.clear(), expected_clear);
@@ -208,21 +192,21 @@ mod tests {
 
     #[test]
     fn pop_empty() {
-        let mut s = Stream::new(10000, 100, 10000);
+        let mut s = Stream::new(10000, 100);
         assert_eq!(s.pullup(), None);
     }
 
     #[test]
     fn pop_blocked_by_hole() {
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(0, &[1, 2], 0), Description::Ok); // miss 3
-        assert_eq!(s.update(3, &[4, 5], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(0, &[1, 2]), Description::Ok); // miss 3
+        assert_eq!(s.update(3, &[4, 5]), Description::Ok);
 
         assert_eq!(s.pullup().unwrap(), &[1, 2]);
         assert_eq!(s.pullup(), None);
         assert_eq!(s.pullup(), None);
 
-        assert_eq!(s.update(2, &[3], 0), Description::Ok);
+        assert_eq!(s.update(2, &[3]), Description::Ok);
         assert_eq!(s.pullup().unwrap(), &[3, 4, 5]);
     }
 
@@ -230,10 +214,10 @@ mod tests {
     fn overlap_when_popped() {
         // [1,2,3] -> popped
         // [3,4,5,6] -> [4,5,6]
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(0, &[1, 2, 3], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(0, &[1, 2, 3]), Description::Ok);
         assert_eq!(s.pullup().unwrap(), &[1, 2, 3]);
-        assert_eq!(s.update(2, &[3, 4, 5, 6], 0), Description::Ok);
+        assert_eq!(s.update(2, &[3, 4, 5, 6]), Description::Ok);
         assert_eq!(s.pullup().unwrap(), &[4, 5, 6]);
     }
 
@@ -241,10 +225,10 @@ mod tests {
     fn overlap_as_old_packet() {
         // [1,2,3,4,5,6] -> popped
         // [2,3,4] -> drop(description: old packet)
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(0, &[1, 2, 3, 4, 5, 6], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(0, &[1, 2, 3, 4, 5, 6]), Description::Ok);
         assert_eq!(s.pullup().unwrap(), &[1, 2, 3, 4, 5, 6]);
-        assert_eq!(s.update(1, &[2, 3, 4], 0), Description::Ok);
+        assert_eq!(s.update(1, &[2, 3, 4]), Description::Ok);
         assert_eq!(s.pullup(), None);
     }
 
@@ -253,12 +237,12 @@ mod tests {
         // [2,3,4] -> wait
         // [3,4,5] -> wait(join the first as [2,3,4,5])
         // [1] -> send [1 2,3,4,5]
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(1, &[2, 3, 4], 0), Description::Ok);
-        assert_eq!(s.update(2, &[3, 4, 5], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(1, &[2, 3, 4]), Description::Ok);
+        assert_eq!(s.update(2, &[3, 4, 5]), Description::Ok);
         assert!(s.pullup().is_none());
 
-        assert_eq!(s.update(0, &[1], 0), Description::Ok);
+        assert_eq!(s.update(0, &[1]), Description::Ok);
         assert_eq!(s.pullup().unwrap(), &[1, 2, 3, 4, 5]);
     }
 
@@ -267,12 +251,12 @@ mod tests {
         // [2,3,4,5] -> wait
         // [3,4,5] -> del(overlapped)
         // [1,2,3] -> send [1,2,3,4,5]
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(1, &[2, 3, 4, 5], 0), Description::Ok);
-        assert_eq!(s.update(2, &[3, 4, 5], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(1, &[2, 3, 4, 5]), Description::Ok);
+        assert_eq!(s.update(2, &[3, 4, 5]), Description::Ok);
         assert!(s.pullup().is_none());
 
-        assert_eq!(s.update(0, &[1, 2, 3], 0), Description::Ok);
+        assert_eq!(s.update(0, &[1, 2, 3]), Description::Ok);
         assert_eq!(s.pullup().unwrap(), &[1, 2, 3, 4, 5]);
     }
 
@@ -281,12 +265,12 @@ mod tests {
         // [2] -> wait
         // [3] -> wait
         // [1,2,3,4] -> send [1,2,3,4]
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(1, &[2], 0), Description::Ok);
-        assert_eq!(s.update(2, &[3], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(1, &[2]), Description::Ok);
+        assert_eq!(s.update(2, &[3]), Description::Ok);
         assert!(s.pullup().is_none());
 
-        assert_eq!(s.update(0, &[1, 2, 3, 4], 0), Description::Ok);
+        assert_eq!(s.update(0, &[1, 2, 3, 4]), Description::Ok);
         assert_eq!(s.pullup().unwrap(), &[1, 2, 3, 4]);   
     }
 
@@ -295,51 +279,42 @@ mod tests {
         // [2,3,4] -> wait
         // [3,4,5] -> clear ( return [2,3,4,5] )
         // [1] -> send [1]
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(1, &[2, 3, 4], 0), Description::Ok);
-        assert_eq!(s.update(2, &[3, 4, 5], 0), Description::Ok);
+        let mut s = Stream::new(10000, 100);
+        assert_eq!(s.update(1, &[2, 3, 4]), Description::Ok);
+        assert_eq!(s.update(2, &[3, 4, 5]), Description::Ok);
         assert_eq!(s.clear(), vec![vec![2, 3, 4, 5]]);
 
-        assert_eq!(s.update(0, &[1], 0), Description::Ok);
+        assert_eq!(s.update(0, &[1]), Description::Ok);
         assert_eq!(s.pullup().unwrap(), &[1]);
     }
 
     #[test]
-    fn timeout() {
-        let mut s = Stream::new(10000, 100, 10000);
-        assert_eq!(s.update(0, &[1, 2, 3, 4], 10001), Description::Ok);
-        assert_eq!(s.update(4, &[2, 3, 4, 5], 20002), Description::Timeout);
-
-        assert_eq!(s.clear(), vec![vec![1, 2, 3, 4]]);
-    }
-
-    #[test]
     fn full_window() {
-        let mut s = Stream::new(10, 100, 10000);
+        let mut s = Stream::new(10, 100);
 
-        assert_eq!(s.update(0, &[1, 2, 3, 4], 0), Description::Ok);
-        assert_eq!(s.update(4, &[5, 6, 7, 8], 0), Description::Ok);
-        assert_eq!(s.update(8, &[2, 3, 4, 5], 0), Description::WindowFull);
+        assert_eq!(s.update(0, &[1, 2, 3, 4]), Description::Ok);
+        assert_eq!(s.update(4, &[5, 6, 7, 8]), Description::Ok);
+        assert_eq!(s.update(8, &[2, 3, 4, 5]), Description::WindowFull);
 
         assert_eq!(s.pullup().unwrap(), &[1, 2, 3, 4, 5, 6, 7, 8]); // pop will clear window size
 
         let v:Vec<_> = (1..=10).collect();
-        assert_eq!(s.update(8, v.as_slice(), 0), Description::Ok);
-        assert_eq!(s.update(18, &[1], 0), Description::WindowFull);
+        assert_eq!(s.update(8, v.as_slice()), Description::Ok);
+        assert_eq!(s.update(18, &[1]), Description::WindowFull);
     }
 
     #[test]
     fn too_many_packet() {
-        let mut s = Stream::new(10000, 2, 10000);
+        let mut s = Stream::new(10000, 2);
 
-        assert_eq!(s.update(0, &[1, 2, 3, 4], 0), Description::Ok);
-        assert_eq!(s.update(5, &[6, 7, 8], 0), Description::Ok); // hole
-        assert_eq!(s.update(8, &[2, 3, 4, 5], 0), Description::TooManyPacket);
+        assert_eq!(s.update(0, &[1, 2, 3, 4]), Description::Ok);
+        assert_eq!(s.update(5, &[6, 7, 8]), Description::Ok); // hole
+        assert_eq!(s.update(8, &[2, 3, 4, 5]), Description::TooManyPacket);
 
         assert_eq!(s.pullup().unwrap(), &[1, 2, 3, 4]); // pop 1
 
-        assert_eq!(s.update(8, &[11], 0), Description::Ok);
-        assert_eq!(s.update(9, &[12], 0), Description::TooManyPacket);
+        assert_eq!(s.update(8, &[11]), Description::Ok);
+        assert_eq!(s.update(9, &[12]), Description::TooManyPacket);
         assert_eq!(s.clear(), vec![vec![6, 7, 8, 11]]);
     }
 }