Fix Coverity issues

fairmq/FairMQChannel.cxx

@@ -14,6 +14,8 @@
 
 #include <set>
 
+#include <boost/exception/all.hpp>
+
 #include "FairMQChannel.h"
 #include "FairMQLogger.h"
 
@@ -49,79 +51,172 @@ FairMQChannel::FairMQChannel(const string& type, const string& method, const str
 
 std::string FairMQChannel::GetType()
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         return fType;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 
 std::string FairMQChannel::GetMethod()
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         return fMethod;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 
 std::string FairMQChannel::GetAddress()
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         return fAddress;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 
 int FairMQChannel::GetSndBufSize()
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         return fSndBufSize;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 
 int FairMQChannel::GetRcvBufSize()
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         return fRcvBufSize;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 
 int FairMQChannel::GetRateLogging()
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         return fRateLogging;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 
 void FairMQChannel::UpdateType(const std::string& type)
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         fType = type;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 void FairMQChannel::UpdateMethod(const std::string& method)
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         fMethod = method;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 void FairMQChannel::UpdateAddress(const std::string& address)
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         fAddress = address;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 void FairMQChannel::UpdateSndBufSize(const int sndBufSize)
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         fSndBufSize = sndBufSize;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 void FairMQChannel::UpdateRcvBufSize(const int rcvBufSize)
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         fRcvBufSize = rcvBufSize;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 void FairMQChannel::UpdateRateLogging(const int rateLogging)
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         fRateLogging = rateLogging;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 
 bool FairMQChannel::IsValid()
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
         return fIsValid;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 
 bool FairMQChannel::ValidateChannel()
 {
+    try
+    {
         boost::unique_lock<boost::mutex> scoped_lock(channelMutex);
 
         stringstream ss;
@@ -182,6 +277,11 @@ bool FairMQChannel::ValidateChannel()
         ss << "VALID";
         LOG(DEBUG) << ss.str();
         return true;
+    }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
 }
 
 void FairMQChannel::ResetChannel()

fairmq/FairMQStateMachine.cxx

@@ -98,7 +98,11 @@ bool FairMQStateMachine::ChangeState(int event)
                 return false;
         }
     }
-    catch (boost::exception &e)
+    catch (boost::thread_interrupted& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
+    catch (boost::exception& e)
     {
         LOG(ERROR) << boost::diagnostic_information(e);
     }
@@ -120,12 +124,19 @@ void FairMQStateMachine::WaitForEndOfState(int event)
             case RUN:
             case RESET_TASK:
             case RESET_DEVICE:
+            {
+                try
                 {
                     boost::unique_lock<boost::mutex> lock(fStateMutex);
                     while (!fStateFinished)
                     {
                         fStateCondition.wait(lock);
                     }
+                }
+                catch (boost::exception& e)
+                {
+                    LOG(ERROR) << boost::diagnostic_information(e);
+                }
                 break;
             }
             default:
@@ -133,7 +144,7 @@ void FairMQStateMachine::WaitForEndOfState(int event)
                 break;
         }
     }
-    catch (boost::exception &e)
+    catch (boost::thread_interrupted& e)
     {
         LOG(ERROR) << boost::diagnostic_information(e);
     }
@@ -173,7 +184,7 @@ bool FairMQStateMachine::WaitForEndOfStateForMs(int event, int durationInMs)
                 return false;
         }
     }
-    catch (boost::exception &e)
+    catch (boost::thread_interrupted &e)
     {
         LOG(ERROR) << boost::diagnostic_information(e);
     }