AcquisitionDeviceGroup: added GetNetworkConfig()

acquisition_device/AcquisitionDevice.cpp

@@ -233,4 +233,12 @@ void AcquisitionDevice::SetIPv4Address(uint32_t ipv4_addr_network_order) {
 
 void AcquisitionDevice::SetMACAddress(uint64_t mac_addr_network_order) {
     mac_addr = mac_addr_network_order;
+}
+
+AcquisitionDeviceNetConfig AcquisitionDevice::GetNetConfig() const {
+    return {
+        .mac_addr = GetMACAddress(),
+        .ipv4_addr = GetIPv4Address(),
+        .udp_port = GetUDPPort()
+    };
 }

acquisition_device/AcquisitionDevice.h

@@ -55,6 +55,12 @@ struct AcquisitionDeviceStatistics {
     std::vector<uint64_t> packets_received_per_module;
 };
 
+struct AcquisitionDeviceNetConfig {
+    std::string mac_addr;
+    std::string ipv4_addr;
+    uint64_t udp_port;
+};
+
 class AcquisitionDevice {
      std::vector<int16_t> buffer_err;
 
@@ -133,8 +139,7 @@ public:
     virtual std::vector<uint16_t> GetInternalGeneratorFrame() const {
         return {};
     }
-
-
+    AcquisitionDeviceNetConfig GetNetConfig() const;
 };
 
 

acquisition_device/AcquisitionDeviceGroup.cpp

@@ -32,3 +32,10 @@ void AcquisitionDeviceGroup::AddHLSDevice(int64_t buffer_size_modules) {
 void AcquisitionDeviceGroup::AddMockDevice(int64_t buffer_size_modules) {
     aq_devices.emplace_back(std::make_unique<MockAcquisitionDevice>(aq_devices.size(), buffer_size_modules));
 }
+
+std::vector<AcquisitionDeviceNetConfig> AcquisitionDeviceGroup::GetNetworkConfig() {
+    std::vector<AcquisitionDeviceNetConfig> ret;
+    for (const auto &i: aq_devices)
+        ret.push_back(i->GetNetConfig());
+    return ret;
+}

acquisition_device/AcquisitionDeviceGroup.h

@@ -16,6 +16,7 @@ public:
     void AddPCIeDevice(const std::string &device_name);
     void AddHLSDevice(int64_t buffer_size_modules);
     void AddMockDevice(int64_t buffer_size_modules);
+    std::vector<AcquisitionDeviceNetConfig> GetNetworkConfig();
 };
 
 #endif //JUNGFRAUJOCH_ACQUISITIONDEVICEGROUP_H

receiver/JFJochReceiver.cpp

@@ -721,3 +721,11 @@ void JFJochReceiver::UpdateMaxDelay(int64_t delay) {
 float JFJochReceiver::GetAvailableSendBuffers() const {
     return static_cast<float>(send_buffer_avail.Size()) / static_cast<float>(send_buffer_count);
 }
+
+JFJochReceiverStatus JFJochReceiver::GetStatus() const {
+    return {
+            .progress = GetProgress(),
+            .indexing_rate = GetIndexingRate(),
+            .send_buffers_avail = GetAvailableSendBuffers()
+    };
+}

receiver/JFJochReceiver.h

@@ -31,6 +31,12 @@
 #include "../common/ADUHistogram.h"
 #include "../common/Plot.h"
 
+struct JFJochReceiverStatus {
+    float progress;
+    float indexing_rate;
+    float send_buffers_avail;
+};
+
 struct JFJochReceiverOutput {
     std::vector<JFModulePedestal> pedestal_result;
     std::vector<uint64_t> received_packets;
@@ -149,6 +155,9 @@ public:
     void Cancel();
     float GetProgress() const;
     float GetIndexingRate() const;
+
+    JFJochReceiverStatus GetStatus() const;
+
     void SetDataProcessingSettings(const DataProcessingSettings &data_processing_settings);
 
     float GetAvailableSendBuffers() const;

receiver/JFJochReceiverService.cpp

@@ -171,25 +171,26 @@ grpc::Status JFJochReceiverService::Abort(grpc::ServerContext *context, const JF
     }
 }
 
-
-grpc::Status JFJochReceiverService::GetStatus(grpc::ServerContext *context, const JFJochProtoBuf::Empty *request,
-                                              JFJochProtoBuf::ReceiverStatus *response) {
+JFJochReceiverStatus JFJochReceiverService::GetStatus() {
     // Need to hold mutex, as receiver might not exist here, if state is idle
     std::unique_lock<std::mutex> ul(state_mutex);
 
-    response->set_progress(-1);
-    response->set_send_buffers_avail(-1);
-    response->set_indexing_rate(-1);
-    if (state == ReceiverState::Running) {
-        response->set_progress(receiver->GetProgress());
-        response->set_send_buffers_avail(receiver->GetAvailableSendBuffers());
-    }
-    if (receiver) {
-        double indexing_rate = receiver->GetIndexingRate();
-        if (!std::isnan(indexing_rate))
-            response->set_indexing_rate(indexing_rate);
-    }
+    if (state == ReceiverState::Running)
+        return receiver->GetStatus();
+    else
+        return {
+                .progress = -1,
+                .indexing_rate = -1,
+                .send_buffers_avail = -1
+        };
+}
 
+grpc::Status JFJochReceiverService::GetStatus(grpc::ServerContext *context, const JFJochProtoBuf::Empty *request,
+                                              JFJochProtoBuf::ReceiverStatus *response) {
+    auto tmp = GetStatus();
+    response->set_send_buffers_avail(tmp.send_buffers_avail);
+    response->set_indexing_rate(tmp.indexing_rate);
+    response->set_progress(tmp.progress);
     return grpc::Status::OK;
 }
 
@@ -230,11 +231,13 @@ grpc::Status JFJochReceiverService::SetDataProcessingSettings(grpc::ServerContex
 
 grpc::Status JFJochReceiverService::GetNetworkConfig(grpc::ServerContext *context, const JFJochProtoBuf::Empty *request,
                                                      JFJochProtoBuf::ReceiverNetworkConfig *response) {
-    for (int i = 0; i < aq_devices.size(); i++) {
+    auto v = GetNetworkConfig();
+
+    for (const auto &i: v) {
         auto dev_net_cfg = response->add_device();
-        dev_net_cfg->set_mac_addr(aq_devices[i].GetMACAddress());
-        dev_net_cfg->set_ipv4_addr(aq_devices[i].GetIPv4Address());
-        dev_net_cfg->set_udp_port(aq_devices[i].GetUDPPort());
+        dev_net_cfg->set_mac_addr(i.mac_addr);
+        dev_net_cfg->set_ipv4_addr(i.ipv4_addr);
+        dev_net_cfg->set_udp_port(i.udp_port);
     }
     return grpc::Status::OK;
 }
@@ -336,3 +339,6 @@ RadialIntegrationProfiles JFJochReceiverService::GetRadialIntegrationProfiles()
         return {};
 }
 
+std::vector<AcquisitionDeviceNetConfig> JFJochReceiverService::GetNetworkConfig() {
+    return aq_devices.GetNetworkConfig();
+}

receiver/JFJochReceiverService.h

@@ -47,6 +47,8 @@ public:
     void SetDataProcessingSettings(const DataProcessingSettings& settings);
     Plot GetDataProcessingPlot(const PlotRequest& request);
     RadialIntegrationProfiles GetRadialIntegrationProfiles();
+    JFJochReceiverStatus GetStatus();
+    std::vector<AcquisitionDeviceNetConfig> GetNetworkConfig();
 
     grpc::Status Start(grpc::ServerContext* context, const JFJochProtoBuf::ReceiverInput* request,
                        JFJochProtoBuf::Empty* response) override;