exception messages (#656)

* fix exception messages for more printout about sockets or more detail

slsReceiverSoftware/src/ClientInterface.cpp

@@ -320,165 +320,122 @@ int ClientInterface::setup_receiver(Interface &socket) {
     auto arg = socket.Receive<rxParameters>();
     LOG(logDEBUG) << ToString(arg);
 
-    // if object exists, verify unlocked and idle, else only verify lock
-    // (connecting first time)
-    if (receiver != nullptr) {
-        verifyIdle(socket);
-    }
-
-    // basic setup
-    setDetectorType(arg.detType);
-    impl()->setDetectorSize(arg.numberOfModule);
-    impl()->setModulePositionId(arg.moduleIndex);
-    impl()->setDetectorHostname(arg.hostname);
-
-    // udp setup
-    // update retvals only if detmac is not the same as in detector
     MacAddr retvals[2];
-    if (arg.udp_dstip != 0) {
+    try {
-        MacAddr r = setUdpIp(IpAddr(arg.udp_dstip));
+        // if object exists, verify unlocked and idle, else only verify lock
-        MacAddr detMac{arg.udp_dstmac};
+        // (connecting first time)
-        if (detMac != r) {
+        if (receiver != nullptr) {
-            retvals[0] = r;
+            verifyIdle(socket);
         }
-    }
-    if (arg.udp_dstip2 != 0) {
-        MacAddr r = setUdpIp2(IpAddr(arg.udp_dstip2));
-        MacAddr detMac{arg.udp_dstmac2};
-        if (detMac != r) {
-            retvals[1] = r;
-        }
-    }
-    impl()->setUDPPortNumber(arg.udp_dstport);
-    impl()->setUDPPortNumber2(arg.udp_dstport2);
-    if (detType == JUNGFRAU || detType == GOTTHARD2) {
-        try {
-            impl()->setNumberofUDPInterfaces(arg.udpInterfaces);
-        } catch (const RuntimeError &e) {
-            throw RuntimeError("Failed to set number of interfaces to " +
-                               std::to_string(arg.udpInterfaces));
-        }
-    }
-    impl()->setUDPSocketBufferSize(0);
 
-    // acquisition parameters
+        // basic setup
-    impl()->setNumberOfFrames(arg.frames);
+        setDetectorType(arg.detType);
-    impl()->setNumberOfTriggers(arg.triggers);
+        impl()->setDetectorSize(arg.numberOfModule);
-    if (detType == GOTTHARD2) {
+        impl()->setModulePositionId(arg.moduleIndex);
-        impl()->setNumberOfBursts(arg.bursts);
+        impl()->setDetectorHostname(arg.hostname);
-    }
+
-    if (detType == JUNGFRAU) {
+        // udp setup
-        impl()->setNumberOfAdditionalStorageCells(arg.additionalStorageCells);
+        // update retvals only if detmac is not the same as in detector
-    }
+        if (arg.udp_dstip != 0) {
-    if (detType == MOENCH || detType == CHIPTESTBOARD) {
+            MacAddr r = setUdpIp(IpAddr(arg.udp_dstip));
-        try {
+            MacAddr detMac{arg.udp_dstmac};
+            if (detMac != r) {
+                retvals[0] = r;
+            }
+        }
+        if (arg.udp_dstip2 != 0) {
+            MacAddr r = setUdpIp2(IpAddr(arg.udp_dstip2));
+            MacAddr detMac{arg.udp_dstmac2};
+            if (detMac != r) {
+                retvals[1] = r;
+            }
+        }
+        impl()->setUDPPortNumber(arg.udp_dstport);
+        impl()->setUDPPortNumber2(arg.udp_dstport2);
+        if (detType == JUNGFRAU || detType == GOTTHARD2) {
+            impl()->setNumberofUDPInterfaces(arg.udpInterfaces);
+        }
+        impl()->setUDPSocketBufferSize(0);
+
+        // acquisition parameters
+        impl()->setNumberOfFrames(arg.frames);
+        impl()->setNumberOfTriggers(arg.triggers);
+        if (detType == GOTTHARD2) {
+            impl()->setNumberOfBursts(arg.bursts);
+        }
+        if (detType == JUNGFRAU) {
+            impl()->setNumberOfAdditionalStorageCells(
+                arg.additionalStorageCells);
+        }
+        if (detType == MOENCH || detType == CHIPTESTBOARD) {
             impl()->setNumberofAnalogSamples(arg.analogSamples);
-        } catch (const RuntimeError &e) {
-            throw RuntimeError("Could not set num analog samples to " +
-                               std::to_string(arg.analogSamples) +
-                               " due to fifo structure memory allocation.");
         }
-    }
+        if (detType == CHIPTESTBOARD) {
-    if (detType == CHIPTESTBOARD) {
-        try {
             impl()->setNumberofDigitalSamples(arg.digitalSamples);
-        } catch (const RuntimeError &e) {
-            throw RuntimeError("Could not set num digital samples to " +
-                               std::to_string(arg.analogSamples) +
-                               " due to fifo structure memory allocation.");
         }
-    }
+        if (detType != MYTHEN3) {
-    if (detType != MYTHEN3) {
+            impl()->setAcquisitionTime(std::chrono::nanoseconds(arg.expTimeNs));
-        impl()->setAcquisitionTime(std::chrono::nanoseconds(arg.expTimeNs));
+        }
-    }
+        impl()->setAcquisitionPeriod(std::chrono::nanoseconds(arg.periodNs));
-    impl()->setAcquisitionPeriod(std::chrono::nanoseconds(arg.periodNs));
+        if (detType == EIGER) {
-    if (detType == EIGER) {
+            impl()->setSubExpTime(std::chrono::nanoseconds(arg.subExpTimeNs));
-        impl()->setSubExpTime(std::chrono::nanoseconds(arg.subExpTimeNs));
+            impl()->setSubPeriod(std::chrono::nanoseconds(arg.subExpTimeNs) +
-        impl()->setSubPeriod(std::chrono::nanoseconds(arg.subExpTimeNs) +
+                                 std::chrono::nanoseconds(arg.subDeadTimeNs));
-                             std::chrono::nanoseconds(arg.subDeadTimeNs));
+            impl()->setActivate(static_cast<bool>(arg.activate));
-        impl()->setActivate(static_cast<bool>(arg.activate));
+            impl()->setDetectorDataStream(LEFT, arg.dataStreamLeft);
-        impl()->setDetectorDataStream(LEFT, arg.dataStreamLeft);
+            impl()->setDetectorDataStream(RIGHT, arg.dataStreamRight);
-        impl()->setDetectorDataStream(RIGHT, arg.dataStreamRight);
-        try {
             impl()->setQuad(arg.quad == 0 ? false : true);
-        } catch (const RuntimeError &e) {
+            impl()->setThresholdEnergy(arg.thresholdEnergyeV[0]);
-            throw RuntimeError("Could not set quad to " +
-                               std::to_string(arg.quad) +
-                               " due to fifo strucutre memory allocation");
         }
-        impl()->setThresholdEnergy(arg.thresholdEnergyeV[0]);
+        if (detType == EIGER || detType == JUNGFRAU) {
-    }
+            impl()->setReadNRows(arg.readNRows);
-    if (detType == EIGER || detType == JUNGFRAU) {
-        impl()->setReadNRows(arg.readNRows);
-    }
-    if (detType == MYTHEN3) {
-        std::array<int, 3> val;
-        for (int i = 0; i < 3; ++i) {
-            val[i] = arg.thresholdEnergyeV[i];
         }
-        impl()->setThresholdEnergy(val);
+        if (detType == MYTHEN3) {
-    }
+            std::array<int, 3> val;
-    if (detType == EIGER || detType == MYTHEN3) {
+            for (int i = 0; i < 3; ++i) {
-        try {
+                val[i] = arg.thresholdEnergyeV[i];
+            }
+            impl()->setThresholdEnergy(val);
+        }
+        if (detType == EIGER || detType == MYTHEN3) {
             impl()->setDynamicRange(arg.dynamicRange);
-        } catch (const RuntimeError &e) {
-            throw RuntimeError(
-                "Could not set dynamic range. Could not allocate "
-                "memory for fifo or could not start listening/writing threads");
         }
-    }
+        impl()->setTimingMode(arg.timMode);
-    impl()->setTimingMode(arg.timMode);
+        if (detType == EIGER || detType == MOENCH || detType == CHIPTESTBOARD ||
-    if (detType == EIGER || detType == MOENCH || detType == CHIPTESTBOARD ||
+            detType == MYTHEN3) {
-        detType == MYTHEN3) {
-        try {
             impl()->setTenGigaEnable(arg.tenGiga);
-        } catch (const RuntimeError &e) {
-            throw RuntimeError("Could not set 10GbE.");
         }
-    }
+        if (detType == CHIPTESTBOARD) {
-    if (detType == CHIPTESTBOARD) {
-        try {
             impl()->setReadoutMode(arg.roMode);
-        } catch (const RuntimeError &e) {
-            throw RuntimeError("Could not set read out mode "
-                               "due to fifo memory allocation.");
         }
-    }
+        if (detType == CHIPTESTBOARD || detType == MOENCH) {
-    if (detType == CHIPTESTBOARD || detType == MOENCH) {
-        try {
             impl()->setADCEnableMask(arg.adcMask);
-        } catch (const RuntimeError &e) {
-            throw RuntimeError("Could not set adc enable mask "
-                               "due to fifo memory allcoation");
-        }
-        try {
             impl()->setTenGigaADCEnableMask(arg.adc10gMask);
-        } catch (const RuntimeError &e) {
-            throw RuntimeError("Could not set 10Gb adc enable mask "
-                               "due to fifo memory allcoation");
         }
-    }
+        if (detType == GOTTHARD) {
-    if (detType == GOTTHARD) {
-        try {
             impl()->setDetectorROI(arg.roi);
-        } catch (const RuntimeError &e) {
-            throw RuntimeError("Could not set ROI");
         }
+        if (detType == MYTHEN3) {
+            impl()->setCounterMask(arg.countermask);
+            impl()->setAcquisitionTime1(
+                std::chrono::nanoseconds(arg.expTime1Ns));
+            impl()->setAcquisitionTime2(
+                std::chrono::nanoseconds(arg.expTime2Ns));
+            impl()->setAcquisitionTime3(
+                std::chrono::nanoseconds(arg.expTime3Ns));
+            impl()->setGateDelay1(std::chrono::nanoseconds(arg.gateDelay1Ns));
+            impl()->setGateDelay2(std::chrono::nanoseconds(arg.gateDelay2Ns));
+            impl()->setGateDelay3(std::chrono::nanoseconds(arg.gateDelay3Ns));
+            impl()->setNumberOfGates(arg.gates);
+        }
+        if (detType == GOTTHARD2) {
+            impl()->setBurstMode(arg.burstType);
+        }
+        impl()->setScan(arg.scanParams);
+    } catch (std::exception &e) {
+        throw RuntimeError("Could not setup receiver [" +
+                           std::string(e.what()) + ']');
     }
-    if (detType == MYTHEN3) {
-        impl()->setCounterMask(arg.countermask);
-        impl()->setAcquisitionTime1(std::chrono::nanoseconds(arg.expTime1Ns));
-        impl()->setAcquisitionTime2(std::chrono::nanoseconds(arg.expTime2Ns));
-        impl()->setAcquisitionTime3(std::chrono::nanoseconds(arg.expTime3Ns));
-        impl()->setGateDelay1(std::chrono::nanoseconds(arg.gateDelay1Ns));
-        impl()->setGateDelay2(std::chrono::nanoseconds(arg.gateDelay2Ns));
-        impl()->setGateDelay3(std::chrono::nanoseconds(arg.gateDelay3Ns));
-        impl()->setNumberOfGates(arg.gates);
-    }
-    if (detType == GOTTHARD2) {
-        impl()->setBurstMode(arg.burstType);
-    }
-    impl()->setScan(arg.scanParams);
 
     return socket.sendResult(retvals);
 }
@@ -502,13 +459,10 @@ void ClientInterface::setDetectorType(detectorType arg) {
         detType = GENERIC;
         receiver = make_unique<Implementation>(arg);
         detType = arg;
-    } catch (std::exception &e) {
+    } catch (const std::exception &e) {
-        std::ostringstream os;
+        throw RuntimeError("Could not set detector type in the receiver. [" +
-        os << "Could not set detector type in the receiver. ";
+                           std::string(e.what()) + ']');
-        os << e.what();
-        throw RuntimeError(os.str());
     }
-
     // callbacks after (in setdetectortype, the object is reinitialized)
     if (startAcquisitionCallBack != nullptr)
         impl()->registerCallBackStartAcquisition(startAcquisitionCallBack,
@@ -536,8 +490,8 @@ int ClientInterface::set_detector_roi(Interface &socket) {
     verifyIdle(socket);
     try {
         impl()->setDetectorROI(arg);
-    } catch (const RuntimeError &e) {
+    } catch (const std::exception &e) {
-        throw RuntimeError("Could not set ROI");
+        throw RuntimeError("Could not set ROI [" + std::string(e.what()) + ']');
     }
     return socket.Send(OK);
 }
@@ -616,10 +570,10 @@ int ClientInterface::set_num_analog_samples(Interface &socket) {
     }
     try {
         impl()->setNumberofAnalogSamples(value);
-    } catch (const RuntimeError &e) {
+    } catch (const std::exception &e) {
-        throw RuntimeError("Could not set num analog samples to " +
+        throw RuntimeError("Could not set number of analog samples to " +
-                           std::to_string(value) +
+                           std::to_string(value) + " [" +
-                           " due to fifo structure memory allocation.");
+                           std::string(e.what()) + ']');
     }
     return socket.Send(OK);
 }
@@ -632,11 +586,12 @@ int ClientInterface::set_num_digital_samples(Interface &socket) {
     }
     try {
         impl()->setNumberofDigitalSamples(value);
-    } catch (const RuntimeError &e) {
+    } catch (const std::exception &e) {
-        throw RuntimeError("Could not set num digital samples to " +
+        throw RuntimeError("Could not set number of digital samples to " +
-                           std::to_string(value) +
+                           std::to_string(value) + " [" +
-                           " due to fifo structure memory allocation.");
+                           std::string(e.what()) + ']');
     }
+
     return socket.Send(OK);
 }
 
@@ -743,9 +698,9 @@ int ClientInterface::set_dynamic_range(Interface &socket) {
         } else {
             try {
                 impl()->setDynamicRange(dr);
-            } catch (const RuntimeError &e) {
+            } catch (const std::exception &e) {
-                throw RuntimeError("Could not allocate memory for fifo or "
+                throw RuntimeError("Could not set dynamic range [" +
-                                   "could not start listening/writing threads");
+                                   std::string(e.what()) + ']');
             }
         }
     }
@@ -781,7 +736,12 @@ int ClientInterface::get_status(Interface &socket) {
 int ClientInterface::start_receiver(Interface &socket) {
     if (impl()->getStatus() == IDLE) {
         LOG(logDEBUG1) << "Starting Receiver";
-        impl()->startReceiver();
+        try {
+            impl()->startReceiver();
+        } catch (const std::exception &e) {
+            throw RuntimeError("Could not start reciever [" +
+                               std::string(e.what()) + ']');
+        }
     }
     return socket.Send(OK);
 }
@@ -791,12 +751,16 @@ int ClientInterface::stop_receiver(Interface &socket) {
     if (impl()->getStatus() == RUNNING) {
         LOG(logDEBUG1) << "Stopping Receiver";
         impl()->setStoppedFlag(static_cast<bool>(arg));
-        impl()->stopReceiver();
+        try {
+            impl()->stopReceiver();
+        } catch (const std::exception &e) {
+            throw RuntimeError("Could not stop receiver [" +
+                               std::string(e.what()) + ']');
+        }
     }
     auto s = impl()->getStatus();
     if (s != IDLE)
-        throw RuntimeError("Could not stop receiver. It as it is: " +
+        throw RuntimeError("Could not stop receiver. Status: " + ToString(s));
-                           ToString(s));
 
     return socket.Send(OK);
 }
@@ -811,7 +775,12 @@ int ClientInterface::set_file_dir(Interface &socket) {
         throw RuntimeError("Receiver path needs to be absolute path");
 
     LOG(logDEBUG1) << "Setting file path: " << fpath;
-    impl()->setFilePath(fpath);
+    try {
+        impl()->setFilePath(fpath);
+    } catch (const std::exception &e) {
+        throw RuntimeError("Could not set file path [" + std::string(e.what()) +
+                           ']');
+    }
     return socket.Send(OK);
 }
 
@@ -893,7 +862,12 @@ int ClientInterface::set_file_write(Interface &socket) {
     }
     verifyIdle(socket);
     LOG(logDEBUG1) << "Setting File write enable:" << enable;
-    impl()->setFileWriteEnable(enable);
+    try {
+        impl()->setFileWriteEnable(enable);
+    } catch (const std::exception &e) {
+        throw RuntimeError("Could not enable/disable file write [" +
+                           std::string(e.what()) + ']');
+    }
     return socket.Send(OK);
 }
 
@@ -948,8 +922,9 @@ int ClientInterface::enable_tengiga(Interface &socket) {
         LOG(logDEBUG1) << "Setting 10GbE:" << val;
         try {
             impl()->setTenGigaEnable(val);
-        } catch (const RuntimeError &e) {
+        } catch (const std::exception &e) {
-            throw RuntimeError("Could not set 10GbE.");
+            throw RuntimeError("Could not set 10GbE. [" +
+                               std::string(e.what()) + ']');
         }
     }
     int retval = impl()->getTenGigaEnable();
@@ -965,9 +940,9 @@ int ClientInterface::set_fifo_depth(Interface &socket) {
         LOG(logDEBUG1) << "Setting fifo depth:" << value;
         try {
             impl()->setFifoDepth(value);
-        } catch (const RuntimeError &e) {
+        } catch (const std::exception &e) {
-            throw RuntimeError("Could not set fifo depth due to fifo structure "
+            throw RuntimeError("Could not set fifo depth [" +
-                               "memory allocation.");
+                               std::string(e.what()) + ']');
         }
     }
     int retval = impl()->getFifoDepth();
@@ -1002,10 +977,12 @@ int ClientInterface::set_streaming(Interface &socket) {
     LOG(logDEBUG1) << "Setting data stream enable:" << index;
     try {
         impl()->setDataStreamEnable(index);
-    } catch (const RuntimeError &e) {
+    } catch (const std::exception &e) {
         throw RuntimeError("Could not set data stream enable to " +
-                           std::to_string(index));
+                           std::to_string(index) + " [" +
+                           std::string(e.what()) + ']');
     }
+
     return socket.Send(OK);
 }
 
@@ -1064,7 +1041,12 @@ int ClientInterface::set_file_format(Interface &socket) {
     }
     verifyIdle(socket);
     LOG(logDEBUG1) << "Setting file format:" << f;
-    impl()->setFileFormat(f);
+    try {
+        impl()->setFileFormat(f);
+    } catch (const std::exception &e) {
+        throw RuntimeError("Could not set file format to " + ToString(f) +
+                           " [" + std::string(e.what()) + ']');
+    }
 
     auto retval = impl()->getFileFormat();
     validate(f, retval, "set file format", DEC);
@@ -1185,7 +1167,13 @@ int ClientInterface::set_udp_socket_buffer_size(Interface &socket) {
                 "Receiver socket buffer size exceeded max (INT_MAX/2)");
         }
         LOG(logDEBUG1) << "Setting UDP Socket Buffer size: " << size;
-        impl()->setUDPSocketBufferSize(size);
+        try {
+            impl()->setUDPSocketBufferSize(size);
+        } catch (const std::exception &e) {
+            throw RuntimeError("Could not set udp socket buffer size to " +
+                               std::to_string(size) + " [" +
+                               std::string(e.what()) + ']');
+        }
     }
     int retval = impl()->getUDPSocketBufferSize();
     if (size != 0)
@@ -1264,9 +1252,9 @@ int ClientInterface::set_readout_mode(Interface &socket) {
         LOG(logDEBUG1) << "Setting readout mode: " << arg;
         try {
             impl()->setReadoutMode(arg);
-        } catch (const RuntimeError &e) {
+        } catch (const std::exception &e) {
-            throw RuntimeError(
+            throw RuntimeError("Could not set read out mode [" +
-                "Could not set read out mode due to fifo memory allocation.");
+                               std::string(e.what()) + ']');
         }
     }
     auto retval = impl()->getReadoutMode();
@@ -1282,10 +1270,11 @@ int ClientInterface::set_adc_mask(Interface &socket) {
     LOG(logDEBUG1) << "Setting 1Gb ADC enable mask: " << arg;
     try {
         impl()->setADCEnableMask(arg);
-    } catch (const RuntimeError &e) {
+    } catch (const std::exception &e) {
-        throw RuntimeError(
+        throw RuntimeError("Could not set adc enable mask [" +
-            "Could not set adc enable mask due to fifo memory allcoation");
+                           std::string(e.what()) + ']');
     }
+
     auto retval = impl()->getADCEnableMask();
     if (retval != arg) {
         std::ostringstream os;
@@ -1349,10 +1338,10 @@ int ClientInterface::set_quad_type(Interface &socket) {
         LOG(logDEBUG1) << "Setting quad:" << quadEnable;
         try {
             impl()->setQuad(quadEnable == 0 ? false : true);
-        } catch (const RuntimeError &e) {
+        } catch (const std::exception &e) {
             throw RuntimeError("Could not set quad to " +
-                               std::to_string(quadEnable) +
+                               std::to_string(quadEnable) + " [" +
-                               " due to fifo strucutre memory allocation");
+                               std::string(e.what()) + ']');
         }
     }
     int retval = impl()->getQuad() ? 1 : 0;
@@ -1487,10 +1476,12 @@ int ClientInterface::set_num_interfaces(Interface &socket) {
     LOG(logDEBUG1) << "Setting Number of UDP Interfaces:" << arg;
     try {
         impl()->setNumberofUDPInterfaces(arg);
-    } catch (const RuntimeError &e) {
+    } catch (const std::exception &e) {
-        throw RuntimeError("Failed to set number of interfaces to " +
+        throw RuntimeError("Could not set number of interfaces to " +
-                           std::to_string(arg));
+                           std::to_string(arg) + " [" + std::string(e.what()) +
+                           ']');
     }
+
     return socket.Send(OK);
 }
 
@@ -1500,10 +1491,11 @@ int ClientInterface::set_adc_mask_10g(Interface &socket) {
     LOG(logDEBUG1) << "Setting 10Gb ADC enable mask: " << arg;
     try {
         impl()->setTenGigaADCEnableMask(arg);
-    } catch (const RuntimeError &e) {
+    } catch (const std::exception &e) {
-        throw RuntimeError(
+        throw RuntimeError("Could not set 10Gb adc enable mask [" +
-            "Could not set 10Gb adc enable mask due to fifo memory allcoation");
+                           std::string(e.what()) + ']');
     }
+
     auto retval = impl()->getTenGigaADCEnableMask();
     if (retval != arg) {
         std::ostringstream os;
@@ -1519,7 +1511,12 @@ int ClientInterface::set_counter_mask(Interface &socket) {
     auto arg = socket.Receive<uint32_t>();
     verifyIdle(socket);
     LOG(logDEBUG1) << "Setting counters: " << arg;
-    impl()->setCounterMask(arg);
+    try {
+        impl()->setCounterMask(arg);
+    } catch (const std::exception &e) {
+        throw RuntimeError("Could not set counter mask [" +
+                           std::string(e.what()) + ']');
+    }
     return socket.Send(OK);
 }
 
@@ -1715,7 +1712,12 @@ int ClientInterface::set_arping(Interface &socket) {
     }
     verifyIdle(socket);
     LOG(logDEBUG1) << "Starting/ Killing arping thread:" << value;
-    impl()->setArping(value, udpips);
+    try {
+        impl()->setArping(value, udpips);
+    } catch (const std::exception &e) {
+        throw RuntimeError("Could not start/kill arping thread [" +
+                           std::string(e.what()) + ']');
+    }
     return socket.Send(OK);
 }
 
@@ -1733,9 +1735,11 @@ int ClientInterface::set_receiver_roi(Interface &socket) {
     verifyIdle(socket);
     try {
         impl()->setReceiverROI(arg);
-    } catch (const RuntimeError &e) {
+    } catch (const std::exception &e) {
-        throw RuntimeError("Could not set ReceiverROI");
+        throw RuntimeError("Could not set Receiver ROI [" +
+                           std::string(e.what()) + ']');
     }
+
     return socket.Send(OK);
 }
 
@@ -1747,9 +1751,11 @@ int ClientInterface::set_receiver_roi_metadata(Interface &socket) {
     verifyIdle(socket);
     try {
         impl()->setReceiverROIMetadata(arg);
-    } catch (const RuntimeError &e) {
+    } catch (const std::exception &e) {
-        throw RuntimeError("Could not set ReceiverROI metadata");
+        throw RuntimeError("Could not set ReceiverROI metadata [" +
+                           std::string(e.what()) + ']');
     }
+
     return socket.Send(OK);
 }
 

slsReceiverSoftware/src/Implementation.cpp

@@ -78,11 +78,12 @@ void Implementation::SetupFifoStructure() {
         try {
             fifo.push_back(
                 sls::make_unique<Fifo>(i, datasize, generalData->fifoDepth));
-        } catch (...) {
+        } catch (const std::exception &e) {
             fifo.clear();
             generalData->fifoDepth = 0;
-            throw RuntimeError("Could not allocate memory for fifo structure " +
+            std::ostringstream oss;
-                               std::to_string(i) + ". FifoDepth is now 0.");
+            oss << e.what() << ". Fifo depth is now 0";
+            throw RuntimeError(oss.str());
         }
         // set the listener & dataprocessor threads to point to the right fifo
         if (listener.size())
@@ -165,12 +166,10 @@ void Implementation::setDetectorType(const detectorType d) {
             SetupListener(i);
             dataProcessor.push_back(sls::make_unique<DataProcessor>(i));
             SetupDataProcessor(i);
-        } catch (...) {
+        } catch (const std::exception &e) {
             listener.clear();
             dataProcessor.clear();
-            throw RuntimeError(
+            throw;
-                "Could not create listener/dataprocessor threads (index:" +
-                std::to_string(i) + ")");
         }
     }
 
@@ -668,8 +667,9 @@ void Implementation::startReceiver() {
             startAcquisitionCallBack(filePath, fileName, fileIndex, imageSize,
                                      pStartAcquisition);
         } catch (const std::exception &e) {
-            throw RuntimeError("Start Acquisition Callback Error: " +
+            std::ostringstream oss;
-                               std::string(e.what()));
+            oss << "Start Acquisition Callback Error: " << e.what();
+            throw RuntimeError(oss.str());
         }
         if (rawDataReadyCallBack != nullptr) {
             LOG(logINFO) << "Data Write has been defined externally";
@@ -784,8 +784,9 @@ void Implementation::stopReceiver() {
                 status = IDLE;
                 LOG(logINFO) << "Receiver Stopped";
                 LOG(logINFO) << "Status: " << ToString(status);
-                throw RuntimeError("Acquisition Finished Callback Error: " +
+                std::ostringstream oss;
-                                   std::string(e.what()));
+                oss << "Acquisition Finished Callback Error: " << e.what();
+                throw RuntimeError(oss.str());
             }
         }
     }
@@ -866,7 +867,7 @@ void Implementation::CreateUDPSockets() {
         }
     } catch (const RuntimeError &e) {
         shutDownUDPSockets();
-        throw RuntimeError("Could not create UDP Socket(s).");
+        throw;
     }
     LOG(logDEBUG) << "UDP socket(s) created successfully.";
 }
@@ -886,7 +887,9 @@ void Implementation::SetupWriter() {
         shutDownUDPSockets();
         for (const auto &it : dataProcessor)
             it->CloseFiles();
-        throw RuntimeError("Could not create first data file.");
+        std::ostringstream oss;
+        oss << "Could not set up writer: " << e.what();
+        throw RuntimeError(oss.str());
     }
 }
 
@@ -975,10 +978,9 @@ void Implementation::StartMasterWriter() {
             }
         }
 #endif
-    } catch (std::exception &e) {
+    } catch (const std::exception &e) {
         // ignore it and just print it
-        LOG(logWARNING) << "Caught exception when handling virtual hdf5 file ["
+        LOG(logWARNING) << "Error creating master/virtualfiles: " << e.what();
-                        << e.what() << "]";
     }
 }
 
@@ -1039,12 +1041,10 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
                 SetupListener(i);
                 dataProcessor.push_back(sls::make_unique<DataProcessor>(i));
                 SetupDataProcessor(i);
-            } catch (...) {
+            } catch (const std::exception &e) {
                 listener.clear();
                 dataProcessor.clear();
-                throw RuntimeError(
+                throw;
-                    "Could not create listener/dataprocessor threads (index:" +
-                    std::to_string(i) + ")");
             }
 
             // streamer threads
@@ -1052,16 +1052,14 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
                 try {
                     dataStreamer.push_back(sls::make_unique<DataStreamer>(i));
                     SetupDataStreamer(i);
-                } catch (...) {
+                } catch (const std::exception &e) {
                     if (dataStreamEnable) {
                         dataStreamer.clear();
                         dataStreamEnable = false;
                         for (const auto &it : dataProcessor)
                             it->SetDataStreamEnable(dataStreamEnable);
                     }
-                    throw RuntimeError(
+                    throw;
-                        "Could not create datastreamer threads (index:" +
-                        std::to_string(i) + ")");
                 }
             }
         }
@@ -1172,12 +1170,12 @@ void Implementation::setDataStreamEnable(const bool enable) {
                 try {
                     dataStreamer.push_back(sls::make_unique<DataStreamer>(i));
                     SetupDataStreamer(i);
-                } catch (...) {
+                } catch (const std::exception &e) {
                     dataStreamer.clear();
                     dataStreamEnable = false;
                     for (const auto &it : dataProcessor)
                         it->SetDataStreamEnable(dataStreamEnable);
-                    throw RuntimeError("Could not set data stream enable.");
+                    throw;
                 }
             }
             SetThreadPriorities();

slsReceiverSoftware/src/Implementation.h

@@ -323,7 +323,7 @@ class Implementation : private virtual slsDetectorDefs {
 
     // acquisition
     std::atomic<runStatus> status{IDLE};
-    bool stoppedFlag{false};
+    std::atomic<bool> stoppedFlag{false};
     scanParameters scanParams{};
 
     // network configuration (UDP)

slsReceiverSoftware/src/Listener.cpp

@@ -148,30 +148,34 @@ void Listener::RecordFirstIndex(uint64_t fnum) {
 }
 
 void Listener::CreateUDPSocket(int &actualSize) {
-    if (disabledPort) {
-        return;
-    }
-    uint32_t packetSize = generalData->packetSize;
-    if (generalData->detType == GOTTHARD2 && index != 0) {
-        packetSize = generalData->vetoPacketSize;
-    }
-
     try {
+        if (disabledPort) {
+            return;
+        }
+        uint32_t packetSize = generalData->packetSize;
+        if (generalData->detType == GOTTHARD2 && index != 0) {
+            packetSize = generalData->vetoPacketSize;
+        }
+
         udpSocket = nullptr;
         udpSocket = make_unique<UdpRxSocket>(
             udpPortNumber, packetSize,
             (eth.length() ? InterfaceNameToIp(eth).str().c_str() : nullptr),
             generalData->udpSocketBufferSize);
         LOG(logINFO) << index << ": UDP port opened at port " << udpPortNumber;
-    } catch (...) {
+
-        throw RuntimeError("Could not create UDP socket on port " +
+        udpSocketAlive = true;
-                           std::to_string(udpPortNumber));
+
+        // doubled due to kernel bookkeeping (could also be less due to
+        // permissions)
+        actualSize = udpSocket->getBufferSize();
+
+    } catch (std::exception &e) {
+        std::ostringstream oss;
+        oss << "Could not create UDP socket on port " << udpPortNumber << " ["
+            << e.what() << ']';
+        throw RuntimeError(oss.str());
     }
-
-    udpSocketAlive = true;
-
-    // doubled due to kernel bookkeeping (could also be less due to permissions)
-    actualSize = udpSocket->getBufferSize();
 }
 
 void Listener::ShutDownUDPSocket() {

slsSupportLib/src/UdpRxSocket.cpp

@@ -27,15 +27,18 @@ UdpRxSocket::UdpRxSocket(int port, ssize_t packet_size, const char *hostname,
     const std::string portname = std::to_string(port);
     if (getaddrinfo(hostname, portname.c_str(), &hints, &res)) {
         throw RuntimeError("Failed at getaddrinfo with " +
-                           std::string(hostname));
+                           std::string(hostname) + " [" +
+                           std::string(strerror(errno)) + ']');
     }
     sockfd_ = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
     if (sockfd_ == -1) {
-        throw RuntimeError("Failed to create UDP RX socket");
+        throw RuntimeError("Failed to create UDP RX socket [" +
+                           std::string(strerror(errno)) + ']');
     }
     if (bind(sockfd_, res->ai_addr, res->ai_addrlen) == -1) {
         close(sockfd_);
-        throw RuntimeError("Failed to bind UDP RX socket");
+        throw RuntimeError("Failed to bind UDP RX socket [" +
+                           std::string(strerror(errno)) + ']');
     }
     freeaddrinfo(res);
 
@@ -74,13 +77,15 @@ int UdpRxSocket::getBufferSize() const {
     int ret = 0;
     socklen_t optlen = sizeof(ret);
     if (getsockopt(sockfd_, SOL_SOCKET, SO_RCVBUF, &ret, &optlen) == -1)
-        throw RuntimeError("Could not get socket buffer size");
+        throw RuntimeError("Could not get socket buffer size [" +
+                           std::string(strerror(errno)) + ']');
     return ret;
 }
 
 void UdpRxSocket::setBufferSize(int size) {
     if (setsockopt(sockfd_, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)))
-        throw RuntimeError("Could not set socket buffer size");
+        throw RuntimeError("Could not set socket buffer size [" +
+                           std::string(strerror(errno)) + ']');
 }
 
 void UdpRxSocket::Shutdown() {