Fix Coverity issues

fairmq/FairMQChannel.cxx

@@ -14,6 +14,8 @@
 
 #include <set>
 
+#include <boost/exception/all.hpp>
+
 #include "FairMQChannel.h"
 #include "FairMQLogger.h"
 
@@ -48,79 +50,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);
 
@@ -183,6 +278,11 @@ bool FairMQChannel::ValidateChannel()
         LOG(DEBUG) << ss.str();
         return true;
     }
+    catch (boost::exception& e)
+    {
+        LOG(ERROR) << boost::diagnostic_information(e);
+    }
+}
 
 void FairMQChannel::ResetChannel()
 {

fairmq/FairMQStateMachine.cxx

@@ -98,6 +98,10 @@ bool FairMQStateMachine::ChangeState(int event)
                 return false;
         }
     }
+    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);
     }