Dev/rx disable datastream port (#1448)

- changed 
   - command from `datastream` to `udp_datastream` to be more specific
   - Detector API:
      - setNumberofUDPInterfaces(pos) =>setNumberofUDPInterfaces() # no position anymore
      - getDataStream(portPosition, pos) =>getUDPDataStream(portPosition, pos)
      - setDataStream(portPosition, pos) => setUDPDataStream(portPosition) # no position anymore
      
   - modified the dataprocessing thread: 
      - if gui or call back, start zmq processing (connecting sockets) before starting receiver (disabled ports sends dummy that the client zmq sockets are not ready for)
      - if only progress, starting progress processing thread after startReceiver
      -


- added
   - Detector API:
      - getRxDisabledUDPPortIndices()
      - getPortPositionList()  
   - allow disabling/enabling udp interface in receiver for Jungfrua/Moench when both udp interfaces is enabled  (This is to go fast, where only one half of the module matters)
   - write ports type and disabled ports to master file (tests for it as well)
   - tests for python commands as well
   - datastream command to deprecated commands
   - refactored tests to make the new parameters fit

* first draft of disabling data port at the receiver side. Todo: master file and stream for gui to use

* updated help in command

* formatting

* md5 unchanged

* fix test, check port position for detector type

* wip, udp port enable metadata in client, to:receiver, zmq streaming

* wip, master attributes

* wip, imple=> save only disabled ports with port index, 1 interface, is empty

* works in file. still needs refactoring

* updated writer versions

* udp ports type pass, disabled with api yet

* fixed disabled ports meta data as well

* fixed in developer via other PR

* renamed.more intuitive

* fix in gui that wont wait for disabled ports

* added tests for master file

* extra tests

* move the master fiel tests into its own tests with the disable marker for github tests

* refactoring

* python test

* more intuitive and doc

* release notes

* example for python

* back to before

* minor documentation fix and sending nports unnecessarily for getRxUDPPortDisableMetadata

* doc

* review fixes, 1. using std::array instead of vector, 2. moving udp_datastream command testing with different values into master attributes testing file because we test the master file

* minor

* review: update help

* progress printed before assigned

* try catch inside hdf5

* auto generated code for CLI and formatting

* missing packets should not be checked at github workflow level

* formatting

* improved python doc for udp_datastream help

* indent doc python done

slsDetectorSoftware/src/Module.cpp

@@ -1407,6 +1407,76 @@ void Module::setTransmissionDelayRight(int value) {
     sendToDetector(F_SET_TRANSMISSION_DELAY_RIGHT, value, nullptr);
 }
 
+bool Module::getUDPDataStream(const portPosition port) const {
+    // receiver only
+    if (shm()->detType == JUNGFRAU || shm()->detType == MOENCH) {
+        if (!shm()->useReceiverFlag) {
+            throw RuntimeError("No receiver to get udp datastream.");
+        }
+        return sendToReceiver<int>(F_RECEIVER_GET_UDP_DATASTREAM,
+                                   static_cast<int>(port));
+    } else
+        return sendToDetector<int>(F_GET_DATASTREAM, static_cast<int>(port));
+}
+
+void Module::setUDPDataStream(const portPosition port, const bool enable) {
+    int args[]{static_cast<int>(port), static_cast<int>(enable)};
+    if (shm()->detType == JUNGFRAU || shm()->detType == MOENCH) {
+        if (!shm()->useReceiverFlag) {
+            throw RuntimeError("No receiver to set udp datastream.");
+        }
+        sendToReceiver(F_RECEIVER_SET_UDP_DATASTREAM, args, nullptr);
+    } else {
+        sendToDetector(F_SET_DATASTREAM, args, nullptr);
+        if (shm()->useReceiverFlag) {
+            sendToReceiver(F_RECEIVER_SET_UDP_DATASTREAM, args, nullptr);
+        }
+    }
+}
+
+void Module::updateRxUDPPortDisableMetadata(const std::vector<int> &disable) {
+    if (!shm()->useReceiverFlag) {
+        return;
+    }
+    LOG(logDEBUG) << "Updating UDP port disable metadata in Receiver 0";
+    auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
+
+    client.Send(F_RECEIVER_SET_UDP_PORT_DISABLE_META);
+    client.setFnum(F_RECEIVER_SET_UDP_PORT_DISABLE_META);
+
+    auto nports = static_cast<int>(disable.size());
+    client.Send(nports);
+    if (nports > 0) {
+        client.Send(disable);
+    }
+    if (client.Receive<int>() == FAIL) {
+        throw ReceiverError("Receiver " + std::to_string(moduleIndex) +
+                            " returned error: " + client.readErrorMessage());
+    }
+}
+
+std::vector<int> Module::getRxUDPPortDisableMetadata() const {
+    if (!shm()->useReceiverFlag) {
+        throw RuntimeError("No receiver to get disabled udp port indices.");
+    }
+
+    LOG(logDEBUG) << "Getting UDP port disable metadata in Receiver 0";
+    auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
+
+    client.Send(F_RECEIVER_GET_UDP_PORT_DISABLE_META);
+    client.setFnum(F_RECEIVER_GET_UDP_PORT_DISABLE_META);
+    if (client.Receive<int>() == FAIL) {
+        throw ReceiverError("Receiver " + std::to_string(moduleIndex) +
+                            " returned error: " + client.readErrorMessage());
+    }
+    auto nports = client.Receive<int>();
+    std::vector<int> retval(nports);
+    if (nports > 0) {
+        client.Receive(retval);
+    }
+    return retval;
+}
+
 // Receiver Config
 
 bool Module::getUseReceiverFlag() const { return shm()->useReceiverFlag; }
@@ -1948,18 +2018,6 @@ void Module::setQuad(const bool enable) {
     }
 }
 
-bool Module::getDataStream(const portPosition port) const {
-    return sendToDetector<int>(F_GET_DATASTREAM, static_cast<int>(port));
-}
-
-void Module::setDataStream(const portPosition port, const bool enable) {
-    int args[]{static_cast<int>(port), static_cast<int>(enable)};
-    sendToDetector(F_SET_DATASTREAM, args, nullptr);
-    if (shm()->useReceiverFlag) {
-        sendToReceiver(F_RECEIVER_SET_DATASTREAM, args, nullptr);
-    }
-}
-
 bool Module::getTop() const {
     return (static_cast<bool>(sendToDetector<int>(F_GET_TOP)));
 }