1 files changed, 29 insertions, 22 deletions

diff --git a/src/components/connection_handler/src/heartbeat_monitor.cc b/src/components/connection_handler/src/heartbeat_monitor.cc
index 2349e0589f..0ed8b704a2 100644
--- a/src/components/connection_handler/src/heartbeat_monitor.cc
+++ b/src/components/connection_handler/src/heartbeat_monitor.cc
@@ -43,17 +43,16 @@ using namespace sync_primitives;
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "HeartBeatMonitor")
 
-HeartBeatMonitor::HeartBeatMonitor(int32_t heartbeat_timeout_seconds,
+HeartBeatMonitor::HeartBeatMonitor(uint32_t heartbeat_timeout_mseconds,
                                    Connection *connection)
-    : default_heartbeat_timeout_(heartbeat_timeout_seconds),
+    : default_heartbeat_timeout_(heartbeat_timeout_mseconds),
       connection_(connection),
       sessions_list_lock_(true),
       run_(true) {
 }
 
 void HeartBeatMonitor::Process() {
-  AutoLock auto_lock(sessions_list_lock_);
-
+  sessions_list_lock_.Acquire();
   SessionMap::iterator it = sessions_.begin();
   while (it != sessions_.end()) {
     SessionState &state = it->second;
@@ -61,7 +60,10 @@ void HeartBeatMonitor::Process() {
       const uint8_t session_id = it->first;
       if (state.IsReadyToClose()) {
         LOG4CXX_WARN(logger_, "Will close session");
+        sessions_list_lock_.Release();
+        RemoveSession(session_id);
         connection_->CloseSession(session_id);
+        sessions_list_lock_.Acquire();
         it = sessions_.begin();
         continue;
       } else {
@@ -73,6 +75,7 @@ void HeartBeatMonitor::Process() {
     }
     ++it;
   }
+  sessions_list_lock_.Release();
 }
 
 void HeartBeatMonitor::threadMain() {
@@ -95,12 +98,12 @@ void HeartBeatMonitor::AddSession(uint8_t session_id) {
         "Session with id " << static_cast<int32_t>(session_id) << " already exists");
     return;
   }
-  sessions_.insert(std::make_pair(session_id,
-                                  SessionState(default_heartbeat_timeout_)));
+  sessions_.insert(std::make_pair(session_id, SessionState(default_heartbeat_timeout_)));
   LOG4CXX_INFO(logger_, "Start heartbeat for session " << session_id);
 }
 
 void HeartBeatMonitor::RemoveSession(uint8_t session_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
   AutoLock auto_lock(sessions_list_lock_);
 
   LOG4CXX_DEBUG(logger_,
@@ -114,6 +117,7 @@ void HeartBeatMonitor::RemoveSession(uint8_t session_id) {
 }
 
 void HeartBeatMonitor::KeepAlive(uint8_t session_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
   AutoLock auto_lock(sessions_list_lock_);
 
   if (sessions_.end() != sessions_.find(session_id)) {
@@ -133,7 +137,7 @@ void HeartBeatMonitor::exitThreadMain() {
   heartbeat_monitor_.NotifyOne();
 }
 
-void HeartBeatMonitor::set_heartbeat_timeout_seconds(int32_t timeout,
+void HeartBeatMonitor::set_heartbeat_timeout_milliseconds(uint32_t timeout,
                                                      uint8_t session_id) {
   LOG4CXX_DEBUG(logger_, "Set new heart beat timeout " << timeout <<
                 "For session: " << session_id);
@@ -144,46 +148,49 @@ void HeartBeatMonitor::set_heartbeat_timeout_seconds(int32_t timeout,
   }
 }
 
-HeartBeatMonitor::SessionState::SessionState(int32_t heartbeat_timeout_seconds)
-  : heartbeat_timeout_seconds_(heartbeat_timeout_seconds),
-    is_heartbeat_sent(false) {
+HeartBeatMonitor::SessionState::SessionState(uint32_t heartbeat_timeout_mseconds)
+  : heartbeat_timeout_mseconds_(heartbeat_timeout_mseconds),
+    is_heartbeat_sent_(false) {
   LOG4CXX_AUTO_TRACE(logger_);
   RefreshExpiration();
 }
 
-void HeartBeatMonitor::SessionState::RefreshExpiration () {
-  LOG4CXX_DEBUG(logger_, "Refresh expiration: " << heartbeat_timeout_seconds_);
-  heartbeat_expiration = date_time::DateTime::getCurrentTime();
-  heartbeat_expiration.tv_sec += heartbeat_timeout_seconds_;
+void HeartBeatMonitor::SessionState::RefreshExpiration() {
+  LOG4CXX_DEBUG(logger_, "Refresh expiration: " << heartbeat_timeout_mseconds_);
+  using namespace date_time;
+  TimevalStruct time = DateTime::getCurrentTime();
+  DateTime::AddMilliseconds(time, heartbeat_timeout_mseconds_);
+  heartbeat_expiration_ = time;
+
 }
 
 void HeartBeatMonitor::SessionState::UpdateTimeout(
-    int32_t heartbeat_timeout_seconds) {
+    uint32_t heartbeat_timeout_mseconds) {
   LOG4CXX_DEBUG(logger_, "Update timout with value " <<
-                heartbeat_timeout_seconds_);
-  heartbeat_timeout_seconds_ = heartbeat_timeout_seconds;
+                heartbeat_timeout_mseconds_);
+  heartbeat_timeout_mseconds_ = heartbeat_timeout_mseconds;
   RefreshExpiration();
 }
 
 void HeartBeatMonitor::SessionState::PrepareToClose() {
-  is_heartbeat_sent = true;
+  is_heartbeat_sent_ = true;
   LOG4CXX_DEBUG(logger_, "Prepare to close");
   RefreshExpiration();
 }
 
 bool HeartBeatMonitor::SessionState::IsReadyToClose() const {
-  return is_heartbeat_sent;
+  return is_heartbeat_sent_;
 }
 
 void HeartBeatMonitor::SessionState::KeepAlive() {
-  is_heartbeat_sent = false;
-  LOG4CXX_DEBUG(logger_, "keep alive");
+  LOG4CXX_AUTO_TRACE(logger_);
+  is_heartbeat_sent_ = false;
   RefreshExpiration();
 }
 
 bool HeartBeatMonitor::SessionState::HasTimeoutElapsed() {
   TimevalStruct now = date_time::DateTime::getCurrentTime();
-  return date_time::DateTime::Greater(now, heartbeat_expiration);
+  return date_time::DateTime::Greater(now, heartbeat_expiration_);
 }
 
 }  // namespace connection_handler