no need to pass the front timeout value from the poll loop

sozu-proxy · Nov 26, 2020 · 4fa0467 · 4fa0467
1 parent 8db6951
commit 4fa0467
Show file tree

Hide file tree

Showing 9 changed files with 26 additions and 19 deletions.
diff --git a/lib/src/http.rs b/lib/src/http.rs
@@ -485,11 +485,11 @@ impl ProxySession for Session {
     result
   }
 
-  fn timeout(&mut self, token: Token, timeout: &Duration) -> SessionResult {
+  fn timeout(&mut self, token: Token) -> SessionResult {
     match *unwrap_msg!(self.protocol.as_mut()) {
       State::Expect(_)  => SessionResult::CloseSession,
-      State::Http(ref mut http) => http.timeout(token, timeout, &mut self.metrics),
-      State::WebSocket(ref mut pipe) => pipe.timeout(token, timeout, &mut self.metrics),
+      State::Http(ref mut http) => http.timeout(token, &mut self.metrics),
+      State::WebSocket(ref mut pipe) => pipe.timeout(token, &mut self.metrics),
     }
   }
 

diff --git a/lib/src/https_openssl.rs b/lib/src/https_openssl.rs
@@ -616,14 +616,14 @@ impl ProxySession for Session {
     result
   }
 
-  fn timeout(&mut self, token: Token, timeout: &Duration) -> SessionResult {
+  fn timeout(&mut self, token: Token) -> SessionResult {
     match *unwrap_msg!(self.protocol.as_mut()) {
       State::Expect(_,_) => SessionResult::CloseSession,
       State::Handshake(_) => SessionResult::CloseSession,
       State::WebSocket(_) => SessionResult::CloseSession,
       //FIXME: not implemented yet
       State::Http2(_)  => SessionResult::CloseSession,
-      State::Http(ref mut http) => http.timeout(token, timeout, &mut self.metrics),
+      State::Http(ref mut http) => http.timeout(token, &mut self.metrics),
     }
   }
 

diff --git a/lib/src/https_rustls/session.rs b/lib/src/https_rustls/session.rs
@@ -561,9 +561,9 @@ impl ProxySession for Session {
     result
   }
 
-  fn timeout(&mut self, token: Token, timeout: &Duration) -> SessionResult {
+  fn timeout(&mut self, token: Token) -> SessionResult {
     match *unwrap_msg!(self.protocol.as_mut()) {
-      State::Http(ref mut http) => http.timeout(token, timeout, &mut self.metrics),
+      State::Http(ref mut http) => http.timeout(token, &mut self.metrics),
       _ => SessionResult::CloseSession,
     }
   }

diff --git a/lib/src/lib.rs b/lib/src/lib.rs
@@ -250,7 +250,7 @@ pub trait ProxySession {
   fn process_events(&mut self, token: Token, events: Ready);
   fn close(&mut self, poll: &mut Poll) -> CloseResult;
   fn close_backend(&mut self, token: Token, poll: &mut Poll);
-  fn timeout(&mut self, t: Token, front_timeout: &Duration) -> SessionResult;
+  fn timeout(&mut self, t: Token) -> SessionResult;
   fn last_event(&self) -> Instant;
   fn print_state(&self);
   fn tokens(&self) -> Vec<Token>;

diff --git a/lib/src/protocol/http/mod.rs b/lib/src/protocol/http/mod.rs
@@ -1434,12 +1434,14 @@ impl<Front:SocketHandler> Http<Front> {
       .unwrap_or(true)
   }
 
-  pub fn timeout(&mut self, token: Token, front_timeout: &Duration, metrics: &mut SessionMetrics) -> SessionResult {
+  pub fn timeout(&mut self, token: Token, metrics: &mut SessionMetrics) -> SessionResult {
+      info!("got timeout for token: {:?}", token);
     if self.frontend_token == token {
       let dur = Instant::now() - self.frontend_last_event;
-      if dur < *front_timeout {
+      let front_timeout = self.front_timeout.duration();
+      if dur < front_timeout {
         TIMER.with(|timer| {
-            timer.borrow_mut().set_timeout(*front_timeout - dur, token);
+            timer.borrow_mut().set_timeout(front_timeout - dur, token);
         });
         SessionResult::Continue
       } else {

diff --git a/lib/src/protocol/pipe.rs b/lib/src/protocol/pipe.rs
@@ -129,7 +129,7 @@ impl<Front:SocketHandler> Pipe<Front> {
     self.backend_token
   }
 
-  pub fn timeout(&mut self, _token: Token, _front_timeout: &Duration, _metrics: &mut SessionMetrics) -> SessionResult {
+  pub fn timeout(&mut self, _token: Token, _metrics: &mut SessionMetrics) -> SessionResult {
       //FIXME
       SessionResult::CloseSession
   }

diff --git a/lib/src/server.rs b/lib/src/server.rs
@@ -1426,7 +1426,7 @@ impl Server {
 
     let session_token = token.0;
     if self.sessions.contains(session_token) {
-      let order = self.sessions[session_token].borrow_mut().timeout(token, &self.front_timeout);
+      let order = self.sessions[session_token].borrow_mut().timeout(token);
       self.interpret_session_order(SessionToken(session_token), order);
     }
   }
@@ -1487,9 +1487,9 @@ impl ProxySession for ListenSession {
   fn close_backend(&mut self, _token: Token, _poll: &mut Poll) {
   }
 
-  fn timeout(&mut self, _token: Token, _front_timeout: &Duration) -> SessionResult {
-    error!("called ProxySession::timeout(token={:?}, time, front_timeout = {:?}) on ListenSession {{ protocol: {:?} }}",
-      _token, _front_timeout, self.protocol);
+  fn timeout(&mut self, _token: Token) -> SessionResult {
+    error!("called ProxySession::timeout(token={:?}, time) on ListenSession {{ protocol: {:?} }}",
+      _token, self.protocol);
     SessionResult::CloseSession
   }
 }

diff --git a/lib/src/tcp.rs b/lib/src/tcp.rs
@@ -520,12 +520,13 @@ impl ProxySession for Session {
     result
   }
 
-  fn timeout(&mut self, token: Token, front_timeout: &Duration) -> SessionResult {
+  fn timeout(&mut self, token: Token) -> SessionResult {
     if self.frontend_token == token {
       let dur = Instant::now() - self.last_event;
-      if dur < *front_timeout {
+      let front_timeout = self.front_timeout.duration();
+      if dur < front_timeout {
         TIMER.with(|timer| {
-          timer.borrow_mut().set_timeout(*front_timeout - dur, token);
+          timer.borrow_mut().set_timeout(front_timeout - dur, token);
         });
         SessionResult::Continue
       } else {

diff --git a/lib/src/timer.rs b/lib/src/timer.rs
@@ -124,6 +124,10 @@ impl TimeoutContainer {
       self.duration = duration;
   }
 
+  pub fn duration(&mut self) -> Duration {
+      self.duration
+  }
+
   pub fn cancel(&mut self) -> bool {
       match self.timeout.take() {
         None => {