jfjoch_process: reorder sp-search routine with timer-output

This is an UNSTABLE release. The release has significant modifications and bug fixes, if things go wrong, it is better to revert to 1.0.0-rc.132.

* jfjoch_broker: Use httplib for HTTP server instead of Pistache
* jfjoch_broker: Drop OpenSSL support
* jfjoch_broker: Base work for multi-lattice support in the future
* Update dependencies to more recent versions (spdlog, HDF5, Catch2, httplib)

Reviewed-on: #41

.gitea/workflows/build_and_test.yml

@@ -76,6 +76,21 @@ jobs:
             upload_url: https://gitea.psi.ch/api/packages/mx/debian/pool/noble/nocuda/upload
     steps:
       - uses: actions/checkout@v4
+      - name: Install CMake 3.26 on Ubuntu 22.04
+        if: matrix.distro == 'ubuntu2204' || matrix.distro == 'ubuntu2204_nocuda'
+        shell: bash
+        run: |
+          set -euo pipefail
+          apt-get update
+          apt-get install -y wget gpg ca-certificates
+          wget -qO- https://apt.kitware.com/keys/kitware-archive-latest.asc \
+            | gpg --dearmor \
+            | tee /usr/share/keyrings/kitware-archive-keyring.gpg > /dev/null
+          echo "deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main" \
+            | tee /etc/apt/sources.list.d/kitware.list > /dev/null
+          apt-get update
+          apt-get install -y cmake=3.26.* cmake-data=3.26.* kitware-archive-keyring
+          cmake --version
       - name: Build packages
         shell: bash
         run: |

CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.19)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.26)
 
 FILE(STRINGS VERSION JFJOCH_VERSION)
 
@@ -87,10 +87,19 @@ SET(HDF5_BUILD_CPP_LIB OFF)
 SET(HDF5_ENABLE_Z_LIB_SUPPORT ON)
 SET(HDF5_EXTERNALLY_CONFIGURED 1)
 
+SET(SPDLOG_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+SET(SPDLOG_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+SET(SPDLOG_BUILD_BENCH OFF CACHE BOOL "" FORCE)
+set(SPDLOG_BUILD_SHARED OFF CACHE BOOL "" FORCE)
+SET(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+
+SET(HTTPLIB_USE_NON_BLOCKING_GETADDRINFO OFF CACHE BOOL "" FORCE)
+SET(HTTPLIB_REQUIRE_ZLIB ON CACHE BOOL "" FORCE)
+
 FetchContent_Declare(
-        pistache_http
-        GIT_REPOSITORY https://github.com/fleon-psi/pistache
-        GIT_TAG        0393f6c
+        spdlog
+        GIT_REPOSITORY https://github.com/gabime/spdlog.git
+        GIT_TAG v1.17.0
         EXCLUDE_FROM_ALL
 )
 
@@ -104,7 +113,7 @@ FetchContent_Declare(
 
 FetchContent_Declare(hdf5
         GIT_REPOSITORY https://github.com/HDFGroup/hdf5/
-        GIT_TAG hdf5_1.14.6
+        GIT_TAG hdf5_2.1.0
         GIT_SHALLOW 1
         EXCLUDE_FROM_ALL)
 
@@ -117,16 +126,24 @@ FetchContent_Declare(
         sls_detector_package
         GIT_REPOSITORY https://github.com/slsdetectorgroup/slsDetectorPackage
         GIT_TAG ${SLS_DETECTOR_GIT_TAG}
+        EXCLUDE_FROM_ALL
 )
 
 FetchContent_Declare(
         catch2
         GIT_REPOSITORY https://github.com/catchorg/Catch2
-        GIT_TAG 4e8d92b
+        GIT_TAG v3.13.0
         EXCLUDE_FROM_ALL
 )
 
-FetchContent_MakeAvailable(pistache_http zstd sls_detector_package catch2 hdf5)
+FetchContent_Declare(
+        httplib
+        GIT_REPOSITORY https://github.com/yhirose/cpp-httplib.git
+        GIT_TAG v0.39.0
+        EXCLUDE_FROM_ALL
+)
+
+FetchContent_MakeAvailable(zstd sls_detector_package catch2 hdf5 spdlog httplib)
 
 ADD_SUBDIRECTORY(jungfrau)
 ADD_SUBDIRECTORY(compression)

VERSION

@@ -1 +1 @@
-1.0.0-rc.127
+1.0.0-rc.134

broker/CMakeLists.txt

@@ -15,8 +15,8 @@ ADD_LIBRARY(JFJochBroker STATIC
 
 TARGET_LINK_LIBRARIES(JFJochBroker JFJochReceiver JFJochDetector JFJochCommon JFJochAPI JFJochPreview)
 
-ADD_EXECUTABLE(jfjoch_broker jfjoch_broker.cpp JFJochBrokerHttp.cpp JFJochBrokerHttp.h
-        gen/api/DefaultApi.cpp gen/api/DefaultApi.h gen/api/ApiBase.h gen/api/ApiBase.cpp)
-TARGET_LINK_LIBRARIES(jfjoch_broker JFJochBroker pistache_static ${CMAKE_DL_LIBS})
+ADD_EXECUTABLE(jfjoch_broker jfjoch_broker.cpp JFJochBrokerHttp.cpp JFJochBrokerHttp.h)
+
+TARGET_LINK_LIBRARIES(jfjoch_broker JFJochBroker httplib::httplib ${CMAKE_DL_LIBS})
 TARGET_INCLUDE_DIRECTORIES(jfjoch_broker PUBLIC gen/api)
 INSTALL(TARGETS jfjoch_broker RUNTIME COMPONENT jfjoch)

broker/JFJochBrokerHttp.h

@@ -1,206 +1,195 @@
 // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
 // SPDX-License-Identifier: GPL-3.0-only
 // Using OpenAPI licensed with Apache License 2.0
+#pragma once
 
-#ifndef JUNGFRAUJOCH_JFJOCHBROKERHTTP_H
-#define JUNGFRAUJOCH_JFJOCHBROKERHTTP_H
+#include <httplib.h>
+#include <nlohmann/json.hpp>
 
-#include <pistache/endpoint.h>
-#include <pistache/router.h>
-#include <pistache/client.h>
-#include <pistache/http.h>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
 
 #include "../common/Logger.h"
+#include "JFJochServices.h"
 #include "JFJochStateMachine.h"
-#include "gen/api/DefaultApi.h"
+#include "OpenAPIConvert.h"
 
+#include "gen/model/Azim_int_settings.h"
+#include "gen/model/Broker_status.h"
+#include "gen/model/Dark_mask_settings.h"
+#include "gen/model/Dataset_settings.h"
+#include "gen/model/Detector_selection.h"
+#include "gen/model/Detector_settings.h"
+#include "gen/model/Detector_status.h"
+#include "gen/model/Error_message.h"
+#include "gen/model/File_writer_settings.h"
+#include "gen/model/Image_buffer_status.h"
+#include "gen/model/Image_format_settings.h"
+#include "gen/model/Image_pusher_status.h"
+#include "gen/model/Indexing_settings.h"
+#include "gen/model/Instrument_metadata.h"
+#include "gen/model/Jfjoch_statistics.h"
+#include "gen/model/Plots.h"
+#include "gen/model/Roi_definitions.h"
+#include "gen/model/Scan_result.h"
+#include "gen/model/Spot_finding_settings.h"
+#include "gen/model/Zeromq_metadata_settings.h"
+#include "gen/model/Zeromq_preview_settings.h"
 
-class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
+class JFJochBrokerHttp {
     Logger logger{"JFJochBroker"};
-    JFJochServices services {logger};
-
-    void config_image_format_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_image_format_put(const org::openapitools::server::model::Image_format_settings &imageFormatSettings,
-                                 Pistache::Http::ResponseWriter &response) override;
-
-    void fpga_status_get(Pistache::Http::ResponseWriter &response) override;
-
+    JFJochServices services{logger};
     JFJochStateMachine state_machine;
     std::string frontend_directory;
 
-    void config_detector_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_detector_put(const org::openapitools::server::model::Detector_settings &detectorSettings,
-                             Pistache::Http::ResponseWriter &response) override;
-
-    void config_azim_int_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_azim_int_put(const org::openapitools::server::model::Azim_int_settings &radIntSettings,
-                             Pistache::Http::ResponseWriter &response) override;
-
-    void config_select_detector_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_select_detector_put(const org::openapitools::server::model::Detector_selection &detectorSelection,
-                                    Pistache::Http::ResponseWriter &response) override;
-
-    void detector_status_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_spot_finding_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_spot_finding_put(const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings,
-                                 Pistache::Http::ResponseWriter &response) override;
-
-    void statistics_calibration_get(Pistache::Http::ResponseWriter &response) override;
-
-    void statistics_data_collection_get(Pistache::Http::ResponseWriter &response) override;
-
-    void cancel_post(Pistache::Http::ResponseWriter &response) override;
-
-    void deactivate_post(Pistache::Http::ResponseWriter &response) override;
-
-    void initialize_post(Pistache::Http::ResponseWriter &response) override;
-
-    void start_post(const org::openapitools::server::model::Dataset_settings &datasetSettings,
-                    Pistache::Http::ResponseWriter &response) override;
-
-    void status_get(Pistache::Http::ResponseWriter &response) override;
-
-    void wait_till_done_post(const std::optional<int32_t> &timeoutMs, Pistache::Http::ResponseWriter &response) override;
-    void trigger_post(Pistache::Http::ResponseWriter &response) override;
-    void pedestal_post(Pistache::Http::ResponseWriter &response) override;
-
-    void preview_pedestal_tiff_get(const std::optional<int32_t> &gainLevel,
-                                   const std::optional<int32_t> &sc,
-                                   Pistache::Http::ResponseWriter &response) override;
-
-    void config_roi_get(Pistache::Http::ResponseWriter &response) override;
-    void config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions,
-                        Pistache::Http::ResponseWriter &response) override;
-
-    void config_internal_generator_image_put(const Pistache::Rest::Request &request,
-                                             Pistache::Http::ResponseWriter &response) override;
-
-    void xfel_event_code_get(Pistache::Http::ResponseWriter &response) override;
-    void xfel_pulse_id_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_mask_tiff_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_user_mask_tiff_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_user_mask_tiff_put(const Pistache::Rest::Request &request,
-                                   Pistache::Http::ResponseWriter &response) override;
-
-    void config_internal_generator_image_tiff_put(const Pistache::Rest::Request &request,
-                                                  Pistache::Http::ResponseWriter &response) override;
-
-    void config_instrument_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_instrument_put(const org::openapitools::server::model::Instrument_metadata &instrumentMetadata,
-                               Pistache::Http::ResponseWriter &response) override;
-
-    void GetStaticFile(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    std::pair<Pistache::Http::Code, std::string> handleOperationException(const std::exception &ex) const noexcept override;
-
-    template <class T>
-    void ProcessOutput(const T& output, Pistache::Http::ResponseWriter &response, bool compression = false) {
-        std::stringstream s;
-        if(!output.validate(s)) {
-            logger.Error(s.str());
-            response.send(Pistache::Http::Code::Internal_Server_Error, s.str(), MIME(Text, Plain));
-        } else {
-            nlohmann::json j = output;
-            if (compression)
-                response.setCompression(Pistache::Http::Header::Encoding::Deflate);
-            response.send(Pistache::Http::Code::Ok, j.dump(), MIME(Application, Json));
-        }
+    static void send_plain(httplib::Response &res, int code, const std::string &body) {
+        res.status = code;
+        res.set_content(body, "text/plain");
     }
 
-    void version_get(Pistache::Http::ResponseWriter &response) override;
+    template<class T>
+    void ProcessOutput(const T &output, httplib::Response &response) {
+        std::stringstream s;
+        if (!output.validate(s)) {
+            logger.Error(s.str());
+            response.status = 500;
+            response.set_content(s.str(), "text/plain");
+            return;
+        }
 
-    void config_image_format_conversion_post(Pistache::Http::ResponseWriter &response) override;
+        nlohmann::json j = output;
+        response.status = 200;
+        response.set_content(j.dump(), "application/json");
+    }
 
-    void config_image_format_raw_post(Pistache::Http::ResponseWriter &response) override;
+    std::pair<int, std::string> handleParsingException(const std::exception &ex) const noexcept;
+    std::pair<int, std::string> handleOperationException(const std::exception &ex) const noexcept;
 
-    void statistics_get(const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) override;
+    void register_routes(httplib::Server &server);
 
-    void config_zeromq_preview_get(Pistache::Http::ResponseWriter &response) override;
+    void cancel_post(httplib::Response &response);
+    void deactivate_post(httplib::Response &response);
+    void initialize_post(httplib::Response &response);
 
-    void
-    config_zeromq_preview_put(const org::openapitools::server::model::Zeromq_preview_settings &zeromqPreviewSettings,
-                              Pistache::Http::ResponseWriter &response) override;
+    void start_post(const org::openapitools::server::model::Dataset_settings &datasetSettings,
+                    httplib::Response &response);
+    void status_get(httplib::Response &response);
+    void wait_till_done_post(const std::optional<int32_t> &timeout, httplib::Response &response);
+    void trigger_post(httplib::Response &response);
+    void pedestal_post(httplib::Response &response);
 
-    void config_zeromq_metadata_get(Pistache::Http::ResponseWriter &response) override;
+    void config_detector_get(httplib::Response &response);
+    void config_detector_put(const org::openapitools::server::model::Detector_settings &detectorSettings,
+                             httplib::Response &response);
 
-    void config_zeromq_metadata_put(
-            const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings,
-            Pistache::Http::ResponseWriter &response) override;
+    void config_azim_int_get(httplib::Response &response);
+    void config_azim_int_put(const org::openapitools::server::model::Azim_int_settings &azimIntSettings,
+                             httplib::Response &response);
 
-    void config_mask_get(Pistache::Http::ResponseWriter &response) override;
+    void config_select_detector_get(httplib::Response &response);
+    void config_select_detector_put(const org::openapitools::server::model::Detector_selection &detectorSelection,
+                                    httplib::Response &response);
 
-    void config_user_mask_get(Pistache::Http::ResponseWriter &response) override;
+    void config_spot_finding_get(httplib::Response &response);
+    void config_spot_finding_put(const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings,
+                                 httplib::Response &response);
 
-    void config_user_mask_put(const Pistache::Rest::Request &request,
-                              Pistache::Http::ResponseWriter &response) override;
+    void statistics_calibration_get(httplib::Response &response);
+    void statistics_data_collection_get(httplib::Response &response);
 
-    void image_buffer_clear_post(Pistache::Http::ResponseWriter &response) override;
+    void config_file_writer_get(httplib::Response &response);
+    void config_file_writer_put(const org::openapitools::server::model::File_writer_settings &fileWriterSettings,
+                                httplib::Response &response);
 
-    void image_buffer_image_cbor_get(const std::optional<int64_t> &id,
-                                     Pistache::Http::ResponseWriter &response) override;
+    void config_image_format_get(httplib::Response &response);
+    void config_image_format_put(const org::openapitools::server::model::Image_format_settings &imageFormatSettings,
+                                 httplib::Response &response);
+    void config_image_format_conversion_post(httplib::Response &response);
+    void config_image_format_raw_post(httplib::Response &response);
 
-    void image_buffer_image_jpeg_get(const std::optional<int64_t> &id,
-                                     const std::optional<bool> &showUserMask,
-                                     const std::optional<bool> &showRoi,
-                                     const std::optional<bool> &showSpots,
-                                     const std::optional<bool> &showBeamCenter,
-                                     const std::optional<float> &saturation,
-                                     const std::optional<int64_t> &jpegQuality,
-                                     const std::optional<float> &showResRing,
-                                     const std::optional<std::string> &color,
-                                     const std::optional<bool> &showResEst,
-                                     Pistache::Http::ResponseWriter &response) override;
+    void fpga_status_get(httplib::Response &response);
 
-    void image_buffer_image_tiff_get(const std::optional<int64_t> &id, Pistache::Http::ResponseWriter &response) override;
+    void statistics_get(httplib::Response &response);
 
-    void image_buffer_start_cbor_get(Pistache::Http::ResponseWriter &response) override;
+    void config_zeromq_preview_get(httplib::Response &response);
+    void config_zeromq_preview_put(const org::openapitools::server::model::Zeromq_preview_settings &zeromqPreviewSettings,
+                                   httplib::Response &response);
 
-    void image_buffer_status_get(Pistache::Http::ResponseWriter &response) override;
-    void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning,
-                          const std::optional<bool> &compression, const std::optional<float> &fill,
-                          const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit,
-                          Pistache::Http::ResponseWriter &response) override;
+    void config_zeromq_metadata_get(httplib::Response &response);
+    void config_zeromq_metadata_put(const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings,
+                                    httplib::Response &response);
 
+    void config_internal_generator_image_put(const std::optional<int64_t> &id,
+                                             const httplib::Request &request,
+                                             httplib::Response &response);
+
+    void config_internal_generator_image_tiff_put(const std::optional<int64_t> &id,
+                                                  const httplib::Request &request,
+                                                  httplib::Response &response);
+
+    void image_buffer_clear_post(httplib::Response &response);
+    void image_buffer_image_cbor_get(const std::optional<int64_t> &id, httplib::Response &response);
+    void image_buffer_image_jpeg_get(const std::optional<int64_t> &id, const std::optional<bool> &showUserMask,
+                                     const std::optional<bool> &showRoi, const std::optional<bool> &showSpots,
+                                     const std::optional<bool> &showBeamCenter, const std::optional<float> &saturation,
+                                     const std::optional<int64_t> &jpegQuality, const std::optional<float> &showResRing,
+                                     const std::optional<std::string> &color, const std::optional<bool> &showResEst,
+                                     httplib::Response &response);
+    void image_buffer_image_tiff_get(const std::optional<int64_t> &id, httplib::Response &response);
+    void image_buffer_start_cbor_get(httplib::Response &response);
+    void image_buffer_status_get(httplib::Response &response);
+
+    void detector_status_get(httplib::Response &response);
+    void image_pusher_status_get(httplib::Response &response);
+
+    void preview_pedestal_tiff_get(const std::optional<int32_t> &gainLevel, const std::optional<int32_t> &sc,
+                                   httplib::Response &response);
     void preview_plot_bin_get(const std::optional<std::string> &type, const std::optional<std::string> &roi,
-                              Pistache::Http::ResponseWriter &response) override;
+                              httplib::Response &response);
+    void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning,
+                          const std::optional<float> &fill,
+                          const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit,
+                          httplib::Response &response);
 
-    void config_indexing_get(Pistache::Http::ResponseWriter &response) override;
+    void config_mask_get(httplib::Response &response);
+    void config_mask_tiff_get(httplib::Response &response);
+    void config_user_mask_get(httplib::Response &response);
+    void config_user_mask_put(const httplib::Request &request, httplib::Response &response);
+    void config_user_mask_tiff_get(httplib::Response &response);
+    void config_user_mask_tiff_put(const httplib::Request &request, httplib::Response &response);
 
+    void config_roi_get(httplib::Response &response);
+    void config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions,
+                        httplib::Response &response);
+
+    void result_scan_get(httplib::Response &response);
+    void version_get(httplib::Response &response);
+
+    void config_instrument_get(httplib::Response &response);
+    void config_instrument_put(const org::openapitools::server::model::Instrument_metadata &instrumentMetadata,
+                               httplib::Response &response);
+
+    void config_indexing_get(httplib::Response &response);
     void config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings,
-                             Pistache::Http::ResponseWriter &response) override;
+                             httplib::Response &response);
 
-    void result_scan_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_dark_mask_get(Pistache::Http::ResponseWriter &response) override;
+    void config_dark_mask_get(httplib::Response &response);
     void config_dark_mask_put(const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings,
-        Pistache::Http::ResponseWriter &response) override;
+                              httplib::Response &response);
+
+    void xfel_event_code_get(httplib::Response &response);
+    void xfel_pulse_id_get(httplib::Response &response);
+
 public:
-    JFJochBrokerHttp(const DiffractionExperiment& experiment,
-        const SpotFindingSettings &spot_finding_settings,
-        std::shared_ptr<Pistache::Rest::Router> &rtr);
+    JFJochBrokerHttp(const DiffractionExperiment &experiment,
+                     const SpotFindingSettings &spot_finding_settings);
 
     void AddDetectorSetup(const DetectorSetup &setup);
-    JFJochServices& Services();
+    JFJochServices &Services();
+    JFJochBrokerHttp &FrontendDirectory(const std::string &directory);
+    void attach(httplib::Server &server);
 
-    JFJochBrokerHttp& FrontendDirectory(const std::string &directory);
-
-    ~JFJochBrokerHttp() override = default;
-
-private:
-    void config_file_writer_get(Pistache::Http::ResponseWriter &response) override;
-
-    void config_file_writer_put(const org::openapitools::server::model::File_writer_settings &fileWriterSettings,
-                                Pistache::Http::ResponseWriter &response) override;
+    ~JFJochBrokerHttp() = default;
 };
-
-
-#endif //JUNGFRAUJOCH_JFJOCHBROKERHTTP_H

broker/JFJochBrokerParser.cpp

@@ -192,17 +192,15 @@ std::unique_ptr<ImagePusher> ParseZMQImagePusher(const org::openapitools::server
 }
 
 std::unique_ptr<ImagePusher> ParseTCPImagePusher(const org::openapitools::server::model::Jfjoch_settings &j) {
-    if (!j.zeromqIsSet())
-        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Socket settings must be provided");
+    if (!j.tcpIsSet())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "TCP/IP Socket settings must be provided");
 
     std::optional<int32_t> send_buffer_size;
-    if (j.getZeromq().sendBufferSizeIsSet())
-        send_buffer_size = j.getZeromq().getSendBufferSize();
+    if (j.getTcp().sendBufferSizeIsSet())
+        send_buffer_size = j.getTcp().getSendBufferSize();
 
-    auto tmp = std::make_unique<TCPStreamPusher>(j.getZeromq().getImageSocket(), send_buffer_size);
+    auto tmp = std::make_unique<TCPStreamPusher>(j.getTcp().getImageSocket(), j.getTcp().getNwriters(), send_buffer_size);
 
-    if (j.getZeromq().writerNotificationSocketIsSet())
-        tmp->WriterNotificationSocket(j.getZeromq().getWriterNotificationSocket());
     return std::move(tmp);
 }
 

broker/JFJochServices.cpp

@@ -269,4 +269,14 @@ void JFJochServices::LoadDetectorPixelMask(PixelMask &mask) {
 void JFJochServices::SetupIndexing(const IndexingSettings &input) {
     if (receiver)
         receiver->Indexing(input);
-}
+}
+
+ImagePusherStatus JFJochServices::GetImagePusherStatus() const {
+    if (receiver)
+        return receiver->GetImagePusherStatus();
+    return {
+        .pusher_type = ImagePusherType::None,
+        .address = {},
+        .connected_writers = 0
+    };
+}

broker/JFJochServices.h

@@ -67,6 +67,8 @@ public:
     void LoadDetectorPixelMask(PixelMask &mask);
 
     void SetupIndexing(const IndexingSettings& input);
+
+    ImagePusherStatus GetImagePusherStatus() const;
 };
 
 

broker/JFJochStateMachine.cpp

@@ -6,6 +6,7 @@
 #include "JFJochStateMachine.h"
 #include "../preview/JFJochTIFF.h"
 #include "../common/CUDAWrapper.h"
+#include "../common/GitInfo.h"
 
 JFJochStateMachine::JFJochStateMachine(const DiffractionExperiment& in_experiment,
                                        JFJochServices &in_services,
@@ -484,6 +485,7 @@ std::optional<MeasurementStatistics> JFJochStateMachine::GetMeasurementStatistic
         tmp.saturated_pixels = rcv_status->saturated_pixels;
         tmp.roi_beam_sum = rcv_status->roi_beam_sum;
         tmp.roi_beam_npixel = rcv_status->roi_beam_npixel;
+        tmp.images_written = rcv_status->images_written;
     }
     return tmp;
 }
@@ -551,6 +553,7 @@ BrokerStatus JFJochStateMachine::GetStatus() const {
     BrokerStatus ret = broker_status;
     ret.progress = services.GetReceiverProgress();
     ret.gpu_count = gpu_count;
+    ret.broker_version = jfjoch_version();
     return ret;
 }
 
@@ -1039,3 +1042,7 @@ void JFJochStateMachine::SetDarkMaskSettings(const DarkMaskSettings &settings) {
         measurement = std::async(std::launch::async, &JFJochStateMachine::PedestalThread, this, std::move(ul));
     }
 }
+
+ImagePusherStatus JFJochStateMachine::GetImagePusherStatus() const {
+    return services.GetImagePusherStatus();
+}

broker/JFJochStateMachine.h

@@ -15,16 +15,7 @@
 
 #include "JFJochServices.h"
 #include "../common/ROIMap.h"
-
-enum class JFJochState {Inactive, Idle, Measuring, Error, Busy, Calibration};
-
-struct BrokerStatus {
-    JFJochState state = JFJochState::Inactive;
-    std::optional<float> progress;
-    std::optional<std::string> message;
-    enum class MessageSeverity {Error, Info, Warning, Success} message_severity = MessageSeverity::Error;
-    int64_t gpu_count;
-};
+#include "../common/BrokerStatus.h"
 
 struct DetectorListElement {
     std::string description;
@@ -55,6 +46,8 @@ struct MeasurementStatistics {
     int64_t images_collected;
     int64_t images_sent;
     int64_t images_skipped;
+    std::optional<int64_t> images_written;
+
     int64_t max_image_number_sent;
     std::optional<float> collection_efficiency;
     std::optional<float> compression_ratio;
@@ -251,6 +244,8 @@ public:
 
     void SetDarkMaskSettings(const DarkMaskSettings& settings);
     DarkMaskSettings GetDarkMaskSettings() const;
+
+    ImagePusherStatus GetImagePusherStatus() const;
 };
 
 

broker/OpenAPIConvert.cpp

@@ -241,6 +241,7 @@ org::openapitools::server::model::Broker_status Convert(const BrokerStatus& inpu
         ret.setProgress(input.progress.value());
 
     ret.setGpuCount(input.gpu_count);
+    ret.setBrokerVersion(input.broker_version);
     return ret;
 }
 
@@ -869,7 +870,6 @@ PlotType ConvertPlotType(const std::optional<std::string>& input) {
     if (input == "packets_received") return PlotType::PacketsReceived;
     if (input == "max_pixel_value") return PlotType::MaxValue;
     if (input == "resolution_estimate") return PlotType::ResolutionEstimate;
-    if (input == "indexing_time") return PlotType::IndexingTime;
     if (input == "pixel_sum") return PlotType::PixelSum;
     if (input == "processing_time") return PlotType::ImageProcessingTime;
     if (input == "beam_center_x") return PlotType::RefinementBeamX;
@@ -1089,3 +1089,34 @@ DarkMaskSettings Convert(const org::openapitools::server::model::Dark_mask_setti
             .Threshold_keV(input.getDetectorThresholdKeV());
     return ret;
 }
+
+org::openapitools::server::model::Image_pusher_status Convert(const ImagePusherStatus& input) {
+    org::openapitools::server::model::Image_pusher_status ret;
+    ret.setAddr(input.address);
+    ret.setConnectedWriters(input.connected_writers);
+    org::openapitools::server::model::Image_pusher_type tmp;
+    switch (input.pusher_type) {
+        case ImagePusherType::HDF5:
+            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::HDF5);
+            break;
+        case ImagePusherType::CBOR:
+            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::CBOR);
+            break;
+        case ImagePusherType::TCP:
+            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::TCP);
+            break;
+        case ImagePusherType::ZMQ:
+            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::ZEROMQ);
+            break;
+        default:
+            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::NONE);
+            break;
+    }
+    ret.setPusherType(tmp);
+    if (input.images_written)
+        ret.setImagesWritten(input.images_written.value());
+    if (input.images_write_error)
+        ret.setImagesWriteError(input.images_write_error.value());
+    ret.setWriterFifoUtilization(input.writer_fifo_utilization);
+    return ret;
+}

broker/OpenAPIConvert.h

@@ -5,6 +5,7 @@
 #define JFJOCH_OPENAPICONVERT_H
 
 #include "Dark_mask_settings.h"
+#include "Image_pusher_status.h"
 #include "gen/model/Spot_finding_settings.h"
 #include "gen/model/Measurement_statistics.h"
 #include "gen/model/Detector_settings.h"
@@ -39,6 +40,7 @@
 #include "../jungfrau/JFCalibration.h"
 #include "../common/InstrumentMetadata.h"
 #include "../common/ScanResult.h"
+#include "../image_pusher/ImagePusher.h"
 
 SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding_settings &input);
 org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindingSettings &input);
@@ -92,4 +94,6 @@ org::openapitools::server::model::Scan_result Convert(const ScanResult& input);
 
 org::openapitools::server::model::Dark_mask_settings Convert(const DarkMaskSettings& input);
 DarkMaskSettings Convert(const org::openapitools::server::model::Dark_mask_settings& input);
+
+org::openapitools::server::model::Image_pusher_status Convert(const ImagePusherStatus& input);
 #endif //JFJOCH_OPENAPICONVERT_H

broker/gen/api/ApiBase.cpp

@@ -1,22 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.127
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-#include "ApiBase.h"
-
-namespace org::openapitools::server::api
-{
-
-ApiBase::ApiBase(const std::shared_ptr<Pistache::Rest::Router>& rtr) : router(rtr)
-{
-}
-
-
-} // Namespace org::openapitools::server::api

broker/gen/api/ApiBase.h

@@ -1,51 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.127
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-/*
- * ApiBase.h
- *
- * Generalization of the Api classes
- */
-
-#ifndef ApiBase_H_
-#define ApiBase_H_
-
-#include <pistache/router.h>
-#include <memory>
-
-namespace org::openapitools::server::api
-{
-
-
-    
-
-
-class ApiBase {
-public:
-    explicit ApiBase(const std::shared_ptr<Pistache::Rest::Router>& rtr);
-    virtual ~ApiBase() = default;
-    virtual void init() = 0;
-
-    
-    
-
-
-protected:
-    const std::shared_ptr<Pistache::Rest::Router> router;
-    
-    
-
-
-};
-
-} // namespace org::openapitools::server::api
-
-#endif /* ApiBase_H_ */

broker/gen/api/DefaultApi.h

@@ -1,625 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.127
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-/*
- * DefaultApi.h
- *
- * 
- */
-
-#ifndef DefaultApi_H_
-#define DefaultApi_H_
-
-
-#include "ApiBase.h"
-
-#include <pistache/http.h>
-#include <pistache/router.h>
-#include <pistache/http_headers.h>
-
-#include <optional>
-#include <utility>
-
-#include "Azim_int_settings.h"
-#include "Broker_status.h"
-#include "Calibration_statistics_inner.h"
-#include "Dark_mask_settings.h"
-#include "Dataset_settings.h"
-#include "Detector_list.h"
-#include "Detector_selection.h"
-#include "Detector_settings.h"
-#include "Detector_status.h"
-#include "Error_message.h"
-#include "File_writer_settings.h"
-#include "Fpga_status_inner.h"
-#include "Image_buffer_status.h"
-#include "Image_format_settings.h"
-#include "Indexing_settings.h"
-#include "Instrument_metadata.h"
-#include "Jfjoch_statistics.h"
-#include "Measurement_statistics.h"
-#include "Plots.h"
-#include "Roi_definitions.h"
-#include "Scan_result.h"
-#include "Spot_finding_settings.h"
-#include "Zeromq_metadata_settings.h"
-#include "Zeromq_preview_settings.h"
-#include <string>
-#include <vector>
-
-namespace org::openapitools::server::api
-{
-
-class  DefaultApi : public ApiBase {
-public:
-    explicit DefaultApi(const std::shared_ptr<Pistache::Rest::Router>& rtr);
-    ~DefaultApi() override = default;
-    void init() override;
-
-    static const std::string base;
-
-private:
-    void setupRoutes();
-
-    void cancel_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_azim_int_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_azim_int_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_dark_mask_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_dark_mask_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_detector_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_detector_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_file_writer_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_file_writer_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_image_format_conversion_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_image_format_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_image_format_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_image_format_raw_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_indexing_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_indexing_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_instrument_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_instrument_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_internal_generator_image_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_internal_generator_image_tiff_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_mask_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_mask_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_roi_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_roi_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_select_detector_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_select_detector_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_spot_finding_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_spot_finding_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_user_mask_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_user_mask_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_user_mask_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_user_mask_tiff_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_zeromq_metadata_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_zeromq_metadata_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_zeromq_preview_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void config_zeromq_preview_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void deactivate_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void detector_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void fpga_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void image_buffer_clear_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void image_buffer_image_cbor_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void image_buffer_image_jpeg_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void image_buffer_image_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void image_buffer_start_cbor_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void image_buffer_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void initialize_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void pedestal_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void preview_pedestal_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void preview_plot_bin_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void preview_plot_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void result_scan_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void start_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void statistics_calibration_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void statistics_data_collection_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void statistics_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void trigger_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void version_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void wait_till_done_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void xfel_event_code_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void xfel_pulse_id_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void default_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-
-    /// <summary>
-    /// Helper function to handle unexpected Exceptions during Parameter parsing and validation.
-    /// May be overridden to return custom error formats. This is called inside a catch block.
-    /// Important: When overriding, do not call `throw ex;`, but instead use `throw;`.
-    /// </summary>
-    virtual void handleParsingException(const std::exception& ex, Pistache::Http::ResponseWriter &response) const noexcept;
-
-    /// <summary>
-    /// Helper function to handle unexpected Exceptions during Parameter parsing and validation.
-    /// May be overridden to return custom error formats. This is called inside a catch block.
-    /// Important: When overriding, do not call `throw ex;`, but instead use `throw;`.
-    /// </summary>
-    virtual std::pair<Pistache::Http::Code, std::string> handleParsingException(const std::exception& ex) const noexcept;
-
-    /// <summary>
-    /// Helper function to handle unexpected Exceptions during processing of the request in handler functions.
-    /// May be overridden to return custom error formats. This is called inside a catch block.
-    /// Important: When overriding, do not call `throw ex;`, but instead use `throw;`.
-    /// </summary>
-    virtual void handleOperationException(const std::exception& ex, Pistache::Http::ResponseWriter &response) const noexcept;
-
-    /// <summary>
-    /// Helper function to handle unexpected Exceptions during processing of the request in handler functions.
-    /// May be overridden to return custom error formats. This is called inside a catch block.
-    /// Important: When overriding, do not call `throw ex;`, but instead use `throw;`.
-    /// </summary>
-    virtual std::pair<Pistache::Http::Code, std::string> handleOperationException(const std::exception& ex) const noexcept;
-
-    /// <summary>
-    /// Cancel running data collection
-    /// </summary>
-    /// <remarks>
-    /// Command will inform FPGA network card to stop pedestal or data collection at the current stage. Any frame that is currently being processed by CPU will be finished and sent to writer. Given the command is making sure to gracefully stop data acquisition and detector, it might take some time to switch back after command finished to &#x60;Idle&#x60; state.  If data collection is not running, the command has no effect. 
-    /// </remarks>
-    virtual void cancel_post( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get azimuthal integration configuration
-    /// </summary>
-    /// <remarks>
-    /// Can be done anytime
-    /// </remarks>
-    virtual void config_azim_int_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Configure azimuthal integration
-    /// </summary>
-    /// <remarks>
-    /// Can be done when detector is Inactive or Idle
-    /// </remarks>
-    /// <param name="azimIntSettings"> (optional)</param>
-    virtual void config_azim_int_put( const org::openapitools::server::model::Azim_int_settings &azimIntSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get settings for dark data collection to calculate mask
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void config_dark_mask_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Set configuration for dark data collection to calculate mask
-    /// </summary>
-    /// <remarks>
-    /// This is only possible when operating DECTRIS detectors at the moment; it will be also available for PSI EIGER at some point. This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. 
-    /// </remarks>
-    /// <param name="darkMaskSettings"> (optional)</param>
-    virtual void config_dark_mask_put( const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get detector configuration
-    /// </summary>
-    /// <remarks>
-    /// Can be done anytime
-    /// </remarks>
-    virtual void config_detector_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Change detector configuration
-    /// </summary>
-    /// <remarks>
-    /// Detector settings are ones that have effect on calibration, i.e., pedestal has to be collected again after changing these settings. This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. If detector is in &#x60;Idle&#x60; state , pedestal procedure will be executed automatically - there must be no X-rays on the detector during the operation. If detector is in &#x60;Inactive&#x60; or &#x60;Error&#x60; states, new settings will be saved, but no calibration will be executed. 
-    /// </remarks>
-    /// <param name="detectorSettings"> (optional)</param>
-    virtual void config_detector_put( const org::openapitools::server::model::Detector_settings &detectorSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get file writer settings
-    /// </summary>
-    /// <remarks>
-    /// Can be done anytime
-    /// </remarks>
-    virtual void config_file_writer_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Change file writer settings
-    /// </summary>
-    /// <remarks>
-    /// This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. 
-    /// </remarks>
-    /// <param name="fileWriterSettings"> (optional)</param>
-    virtual void config_file_writer_put( const org::openapitools::server::model::File_writer_settings &fileWriterSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Configure format for data collection with full conversion
-    /// </summary>
-    /// <remarks>
-    /// This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. 
-    /// </remarks>
-    virtual void config_image_format_conversion_post( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get image output format
-    /// </summary>
-    /// <remarks>
-    /// Can be done anytime
-    /// </remarks>
-    virtual void config_image_format_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Change image output format
-    /// </summary>
-    /// <remarks>
-    /// This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. 
-    /// </remarks>
-    /// <param name="imageFormatSettings"> (optional)</param>
-    virtual void config_image_format_put( const org::openapitools::server::model::Image_format_settings &imageFormatSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Configure format for raw data collection
-    /// </summary>
-    /// <remarks>
-    /// This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. 
-    /// </remarks>
-    virtual void config_image_format_raw_post( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get indexing configuration
-    /// </summary>
-    /// <remarks>
-    /// Can be done anytime
-    /// </remarks>
-    virtual void config_indexing_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Change indexing algorithm settings
-    /// </summary>
-    /// <remarks>
-    /// This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. 
-    /// </remarks>
-    /// <param name="indexingSettings"> (optional)</param>
-    virtual void config_indexing_put( const org::openapitools::server::model::Indexing_settings &indexingSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get instrument metadata
-    /// </summary>
-    /// <remarks>
-    /// Can be done anytime
-    /// </remarks>
-    virtual void config_instrument_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Change instrument metadata
-    /// </summary>
-    /// <remarks>
-    /// This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. 
-    /// </remarks>
-    /// <param name="instrumentMetadata"> (optional)</param>
-    virtual void config_instrument_put( const org::openapitools::server::model::Instrument_metadata &instrumentMetadata, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Load binary image for internal FPGA generator
-    /// </summary>
-    /// <remarks>
-    /// Load image for internal FPGA generator. This can only happen in Idle state of the detector. Requires binary blob with 16-bit integer numbers of size of detector in raw/converted coordinates  (depending on detector settings). 
-    /// </remarks>
-    virtual void config_internal_generator_image_put(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Load TIFF image for internal FPGA generator
-    /// </summary>
-    /// <remarks>
-    /// Load image for internal FPGA generator. This can only happen in Idle state of the detector. Requires TIFF with 16-bit integer numbers of size of detector in raw/converted coordinates  (depending on detector settings). 
-    /// </remarks>
-    virtual void config_internal_generator_image_tiff_put(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get mask of the detector (binary)
-    /// </summary>
-    /// <remarks>
-    /// Detector must be Initialized. Get full pixel mask of the detector. See NXmx standard for meaning of pixel values. 
-    /// </remarks>
-    virtual void config_mask_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get mask of the detector (TIFF)
-    /// </summary>
-    /// <remarks>
-    /// Should be in &#x60;Idle&#x60; state. Get full pixel mask of the detector See NXmx standard for meaning of pixel values 
-    /// </remarks>
-    virtual void config_mask_tiff_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get ROI definitions
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void config_roi_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Upload ROI definitions
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    /// <param name="roiDefinitions"> (optional)</param>
-    virtual void config_roi_put( const org::openapitools::server::model::Roi_definitions &roiDefinitions, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// List available detectors
-    /// </summary>
-    /// <remarks>
-    /// Configured detectors that can be selected by used
-    /// </remarks>
-    virtual void config_select_detector_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Select detector
-    /// </summary>
-    /// <remarks>
-    /// Jungfraujoch allows to control multiple detectors and/or region-of-interests. The command allows to choose one detector from the list (ID has to be consistent with one provided by GET response). Changing detector will set detector to &#x60;Inactive&#x60; state and will require reinitialization. 
-    /// </remarks>
-    /// <param name="detectorSelection"> (optional)</param>
-    virtual void config_select_detector_put( const org::openapitools::server::model::Detector_selection &detectorSelection, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get data processing configuration
-    /// </summary>
-    /// <remarks>
-    /// Can be done anytime
-    /// </remarks>
-    virtual void config_spot_finding_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Configure spot finding
-    /// </summary>
-    /// <remarks>
-    /// Can be done anytime, also while data collection is running
-    /// </remarks>
-    /// <param name="spotFindingSettings"> (optional)</param>
-    virtual void config_spot_finding_put( const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Detector must be Initialized. Get user mask of the detector (binary) 
-    /// </summary>
-    /// <remarks>
-    /// Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked
-    /// </remarks>
-    virtual void config_user_mask_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Upload user mask of the detector (binary)
-    /// </summary>
-    /// <remarks>
-    /// Should be in &#x60;Idle&#x60; state. Upload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions. If detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates. In the latter case - module gaps are ignored and don&#39;t need to be assigned value. Mask is expected as binary array (4-byte; unsigned). 0 - good pixel, other value - masked User mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration. 
-    /// </remarks>
-    virtual void config_user_mask_put(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Detector must be Initialized. Get user mask of the detector (TIFF) 
-    /// </summary>
-    /// <remarks>
-    /// Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked
-    /// </remarks>
-    virtual void config_user_mask_tiff_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Upload user mask of the detector
-    /// </summary>
-    /// <remarks>
-    /// Should be in &#x60;Idle&#x60; state. Upload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions. If detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates. In the latter case - module gaps are ignored and don&#39;t need to be assigned value. Mask is expected as TIFF (4-byte; unsigned). 0 - good pixel, other value - masked User mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration.  User mask is not automatically applied - i.e. pixels with user mask will have a valid pixel value in the images. 
-    /// </remarks>
-    virtual void config_user_mask_tiff_put(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get ZeroMQ metadata socket settings
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void config_zeromq_metadata_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Set ZeroMQ metadata settings
-    /// </summary>
-    /// <remarks>
-    /// Jungfraujoch can generate metadata message stream on ZeroMQ PUB socket. This stream covers all images. Here settings of the socket can be adjusted. While the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request. 
-    /// </remarks>
-    /// <param name="zeromqMetadataSettings"> (optional)</param>
-    virtual void config_zeromq_metadata_put( const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get ZeroMQ preview settings
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void config_zeromq_preview_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Set ZeroMQ preview settings
-    /// </summary>
-    /// <remarks>
-    /// Jungfraujoch can generate preview message stream on ZeroMQ SUB socket. Here settings of the socket can be adjusted. While the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request. Options set with this PUT request have no effect on HTTP based preview. 
-    /// </remarks>
-    /// <param name="zeromqPreviewSettings"> (optional)</param>
-    virtual void config_zeromq_preview_put( const org::openapitools::server::model::Zeromq_preview_settings &zeromqPreviewSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Prepare detector to turn off
-    /// </summary>
-    /// <remarks>
-    /// Should be in &#x60;Idle&#x60; or &#x60;Error&#x60; state. Command deactivates data acquisition and turns off detector high voltage and ASIC. Should be used always before turning off power from the detector. 
-    /// </remarks>
-    virtual void deactivate_post( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get detector status
-    /// </summary>
-    /// <remarks>
-    /// Status of the JUNGFRAU detector
-    /// </remarks>
-    virtual void detector_status_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get status of FPGA devices
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void fpga_status_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Clear image buffer
-    /// </summary>
-    /// <remarks>
-    /// Turns off image buffer for the last data collection. Can be only run when Jungfraujoch is not collecting data.
-    /// </remarks>
-    virtual void image_buffer_clear_post( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get image message in CBOR format
-    /// </summary>
-    /// <remarks>
-    /// Contains full image data and metadata. The image must come from the latest data collection.
-    /// </remarks>
-    /// <param name="id">Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L)</param>
-    virtual void image_buffer_image_cbor_get( const std::optional<int64_t> &id, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get preview image in JPEG format using custom settings
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    /// <param name="id">Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L)</param>
-    /// <param name="showUserMask">Show user mask (optional, default to false)</param>
-    /// <param name="showRoi">Show ROI areas on the image (optional, default to false)</param>
-    /// <param name="showSpots">Show spot finding results on the image (optional, default to true)</param>
-    /// <param name="showBeamCenter">Show beam center on the image (optional, default to true)</param>
-    /// <param name="saturation">Saturation value to set contrast in the preview image; if not provided, then autocontrast procedure is used (optional, default to 0.0f)</param>
-    /// <param name="jpegQuality">Quality of JPEG image (100 - highest; 0 - lowest) (optional, default to 100L)</param>
-    /// <param name="showResRing">Show resolution ring, provided in Angstrom (optional, default to 0.1f)</param>
-    /// <param name="color">Color scale for preview image (optional, default to &quot;indigo&quot;)</param>
-    /// <param name="showResEst">Show resolution estimation as a ring (optional, default to false)</param>
-    virtual void image_buffer_image_jpeg_get( const std::optional<int64_t> &id, const std::optional<bool> &showUserMask, const std::optional<bool> &showRoi, const std::optional<bool> &showSpots, const std::optional<bool> &showBeamCenter, const std::optional<float> &saturation, const std::optional<int64_t> &jpegQuality, const std::optional<float> &showResRing, const std::optional<std::string> &color, const std::optional<bool> &showResEst, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get preview image in TIFF format
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    /// <param name="id">Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L)</param>
-    virtual void image_buffer_image_tiff_get( const std::optional<int64_t> &id, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get Start message in CBOR format
-    /// </summary>
-    /// <remarks>
-    /// Contains metadata for a dataset (e.g., experimental geometry)
-    /// </remarks>
-    virtual void image_buffer_start_cbor_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get status of the image buffers
-    /// </summary>
-    /// <remarks>
-    /// Can be run at any stage of Jungfraujoch operation, including during data collection. The status of the image buffer is volatile during data collection - if data collection goes for more images than available buffer slots, then image might be replaced in the buffer between calling /images and /image.cbor. 
-    /// </remarks>
-    virtual void image_buffer_status_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Initialize detector and data acquisition
-    /// </summary>
-    /// <remarks>
-    /// Should be used in two cases:   - Detector is in &#x60;Inactive&#x60; state   - Detector is in &#x60;Error&#x60; state X-ray shutter must be closed.  This operation will reconfigure network interface of the detector.  During operation of the detector it is recommended to use the &#x60;POST /pedestal&#x60; operation instead. If storage cells are used, the execution time might be few minutes.  This is async function - one needs to use &#x60;POST /wait_till_done&#x60; to ensure operation is done. 
-    /// </remarks>
-    virtual void initialize_post( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Collect dark current for the detector
-    /// </summary>
-    /// <remarks>
-    /// Updates calibration of the JUNGFRAU detector. Must be in &#x60;Idle&#x60; state.  X-ray shutter must be closed. Recommended to run once per hour for long integration times (&gt; 100 us).  This is async function - one needs to use &#x60;POST /wait_till_done&#x60; to ensure operation is done. 
-    /// </remarks>
-    virtual void pedestal_post( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get pedestal in TIFF format
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    /// <param name="gainLevel">Gain level (0, 1, 2)</param>
-    /// <param name="sc">Storage cell number (optional, default to 0)</param>
-    virtual void preview_pedestal_tiff_get( const std::optional<int32_t> &gainLevel, const std::optional<int32_t> &sc, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate 1D plot from Jungfraujoch and send in raw binary format. Data are provided as (32-bit) float binary array. This format doesn&#39;t transmit information about X-axis, only values, so it is of limited use for azimuthal integration. 
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    /// <param name="type">Type of requested plot</param>
-    /// <param name="roi">Name of ROI for which plot is requested (optional, default to &quot;&quot;)</param>
-    virtual void preview_plot_bin_get( const std::optional<std::string> &type, const std::optional<std::string> &roi, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate 1D plot from Jungfraujoch
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    /// <param name="type">Type of requested plot</param>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 1)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to false)</param>
-    /// <param name="fill">Fill value for elements that were missed during data collection  (optional, default to 0.0f)</param>
-    /// <param name="experimentalCoord">If measurement has goniometer axis defined, plot X-axis will represent rotation angle If measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value For still measurement the number is ignored  (optional, default to false)</param>
-    /// <param name="azintUnit">Unit used for azim int.  (optional, default to &quot;Q_recipA&quot;)</param>
-    virtual void preview_plot_get( const std::optional<std::string> &type, const std::optional<int32_t> &binning, const std::optional<bool> &compression, const std::optional<float> &fill, const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get full scan result
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void result_scan_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Start detector
-    /// </summary>
-    /// <remarks>
-    /// Start data acquisition. Detector must be in &#x60;Idle&#x60; state. Doesn&#39;t run calibration procedure. When the function returns, detector is ready to accept soft/TTL triggers. 
-    /// </remarks>
-    /// <param name="datasetSettings"> (optional)</param>
-    virtual void start_post( const org::openapitools::server::model::Dataset_settings &datasetSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get calibration statistics
-    /// </summary>
-    /// <remarks>
-    /// Statistics are provided for each module/storage cell separately
-    /// </remarks>
-    virtual void statistics_calibration_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get data collection statistics
-    /// </summary>
-    /// <remarks>
-    /// Results of the last data collection
-    /// </remarks>
-    virtual void statistics_data_collection_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get general statistics
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to false)</param>
-    virtual void statistics_get( const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get Jungfraujoch status
-    /// </summary>
-    /// <remarks>
-    /// Status of the data acquisition
-    /// </remarks>
-    virtual void status_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Send soft trigger to the detector
-    /// </summary>
-    /// <remarks>
-    /// Generate soft trigger
-    /// </remarks>
-    virtual void trigger_post( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get Jungfraujoch version of jfjoch_broker
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void version_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Wait for acquisition done
-    /// </summary>
-    /// <remarks>
-    /// Block execution of external script till initialization, data collection or pedestal is finished. Running this command does not affect (cancel) running data collection, it is only to ensure synchronous execution of other software.  To not block web server for a indefinite period of time, the procedure is provided with a timeout. Extending timeout is possible, but requires to ensure safety that client will not close the connection and retry the connection. 
-    /// </remarks>
-    /// <param name="timeout">Timeout in seconds (0 &#x3D;&#x3D; immediate response) (optional, default to 60)</param>
-    virtual void wait_till_done_post( const std::optional<int32_t> &timeout, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Return XFEL event codes for the current data acquisition
-    /// </summary>
-    /// <remarks>
-    /// Return array of XFEL event codes
-    /// </remarks>
-    virtual void xfel_event_code_get( Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Return XFEL pulse IDs for the current data acquisition
-    /// </summary>
-    /// <remarks>
-    /// Return array of XFEL pulse IDs - (-1) if image not recorded
-    /// </remarks>
-    virtual void xfel_pulse_id_get( Pistache::Http::ResponseWriter &response) = 0;
-
-};
-
-} // namespace org::openapitools::server::api
-
-#endif /* DefaultApi_H_ */
-

broker/gen/model/Azim_int_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Azim_int_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Broker_status.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -30,6 +30,8 @@ Broker_status::Broker_status()
     m_Message_severityIsSet = false;
     m_Gpu_count = 0;
     m_Gpu_countIsSet = false;
+    m_Broker_version = "";
+    m_Broker_versionIsSet = false;
     
 }
 
@@ -71,7 +73,7 @@ bool Broker_status::validate(std::stringstream& msg, const std::string& pathPref
         }
 
     }
-                
+                    
     return success;
 }
 
@@ -93,7 +95,10 @@ bool Broker_status::operator==(const Broker_status& rhs) const
     ((!messageSeverityIsSet() && !rhs.messageSeverityIsSet()) || (messageSeverityIsSet() && rhs.messageSeverityIsSet() && getMessageSeverity() == rhs.getMessageSeverity())) &&
     
     
-    ((!gpuCountIsSet() && !rhs.gpuCountIsSet()) || (gpuCountIsSet() && rhs.gpuCountIsSet() && getGpuCount() == rhs.getGpuCount()))
+    ((!gpuCountIsSet() && !rhs.gpuCountIsSet()) || (gpuCountIsSet() && rhs.gpuCountIsSet() && getGpuCount() == rhs.getGpuCount())) &&
+    
+    
+    ((!brokerVersionIsSet() && !rhs.brokerVersionIsSet()) || (brokerVersionIsSet() && rhs.brokerVersionIsSet() && getBrokerVersion() == rhs.getBrokerVersion()))
     
     ;
 }
@@ -115,6 +120,8 @@ void to_json(nlohmann::json& j, const Broker_status& o)
         j["message_severity"] = o.m_Message_severity;
     if(o.gpuCountIsSet())
         j["gpu_count"] = o.m_Gpu_count;
+    if(o.brokerVersionIsSet())
+        j["broker_version"] = o.m_Broker_version;
     
 }
 
@@ -141,6 +148,11 @@ void from_json(const nlohmann::json& j, Broker_status& o)
         j.at("gpu_count").get_to(o.m_Gpu_count);
         o.m_Gpu_countIsSet = true;
     } 
+    if(j.find("broker_version") != j.end())
+    {
+        j.at("broker_version").get_to(o.m_Broker_version);
+        o.m_Broker_versionIsSet = true;
+    } 
     
 }
 
@@ -220,6 +232,23 @@ void Broker_status::unsetGpu_count()
 {
     m_Gpu_countIsSet = false;
 }
+std::string Broker_status::getBrokerVersion() const
+{
+    return m_Broker_version;
+}
+void Broker_status::setBrokerVersion(std::string const& value)
+{
+    m_Broker_version = value;
+    m_Broker_versionIsSet = true;
+}
+bool Broker_status::brokerVersionIsSet() const
+{
+    return m_Broker_versionIsSet;
+}
+void Broker_status::unsetBroker_version()
+{
+    m_Broker_versionIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Broker_status.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -91,6 +91,13 @@ public:
     void setGpuCount(int32_t const value);
     bool gpuCountIsSet() const;
     void unsetGpu_count();
+    /// <summary>
+    /// Version of the jfjoch_broker
+    /// </summary>
+    std::string getBrokerVersion() const;
+    void setBrokerVersion(std::string const& value);
+    bool brokerVersionIsSet() const;
+    void unsetBroker_version();
 
     friend  void to_json(nlohmann::json& j, const Broker_status& o);
     friend  void from_json(const nlohmann::json& j, Broker_status& o);
@@ -105,6 +112,8 @@ protected:
     bool m_Message_severityIsSet;
     int32_t m_Gpu_count;
     bool m_Gpu_countIsSet;
+    std::string m_Broker_version;
+    bool m_Broker_versionIsSet;
     
 };
 

broker/gen/model/Calibration_statistics_inner.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Calibration_statistics_inner.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dark_mask_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dark_mask_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dataset_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dataset_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_list.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_list.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_list_element.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_list_element.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module_direction.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module_direction.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_power_state.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_power_state.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_selection.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_selection.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_state.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_state.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_status.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_status.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_timing.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_timing.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_type.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_type.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Error_message.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Error_message.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/File_writer_format.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/File_writer_format.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/File_writer_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/File_writer_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Fpga_status_inner.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Fpga_status_inner.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Geom_refinement_algorithm.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Geom_refinement_algorithm.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Grid_scan.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Grid_scan.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Helpers.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Helpers.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_buffer_status.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_buffer_status.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_format_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_format_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_pusher_status.cpp

@@ -0,0 +1,292 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.133
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+
+#include "Image_pusher_status.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Image_pusher_status::Image_pusher_status()
+{
+    m_Connected_writers = 0L;
+    m_Images_written = 0L;
+    m_Images_writtenIsSet = false;
+    m_Images_write_error = 0L;
+    m_Images_write_errorIsSet = false;
+    m_Writer_fifo_utilizationIsSet = false;
+    
+}
+
+void Image_pusher_status::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Image_pusher_status::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Image_pusher_status::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Image_pusher_status" : pathPrefix;
+
+             
+    
+    /* Addr */ {
+        const std::vector<std::string>& value = m_Addr;
+        const std::string currentValuePath = _pathPrefix + ".addr";
+                
+        
+        { // Recursive validation of array elements
+            const std::string oldValuePath = currentValuePath;
+            int i = 0;
+            for (const std::string& value : value)
+            { 
+                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
+                        
+        
+ 
+                i++;
+            }
+        }
+
+    }
+         
+    
+    /* Connected_writers */ {
+        const int64_t& value = m_Connected_writers;
+        const std::string currentValuePath = _pathPrefix + ".connectedWriters";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+         
+    if (imagesWrittenIsSet())
+    {
+        const int64_t& value = m_Images_written;
+        const std::string currentValuePath = _pathPrefix + ".imagesWritten";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+         
+    if (imagesWriteErrorIsSet())
+    {
+        const int64_t& value = m_Images_write_error;
+        const std::string currentValuePath = _pathPrefix + ".imagesWriteError";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+         
+    if (writerFifoUtilizationIsSet())
+    {
+        const std::vector<int64_t>& value = m_Writer_fifo_utilization;
+        const std::string currentValuePath = _pathPrefix + ".writerFifoUtilization";
+                
+        
+        { // Recursive validation of array elements
+            const std::string oldValuePath = currentValuePath;
+            int i = 0;
+            for (const int64_t& value : value)
+            { 
+                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
+                        
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+ 
+                i++;
+            }
+        }
+
+    }
+    
+    return success;
+}
+
+bool Image_pusher_status::operator==(const Image_pusher_status& rhs) const
+{
+    return
+    
+    
+    (getPusherType() == rhs.getPusherType())
+     &&
+    
+    (getAddr() == rhs.getAddr())
+     &&
+    
+    (getConnectedWriters() == rhs.getConnectedWriters())
+     &&
+    
+    
+    ((!imagesWrittenIsSet() && !rhs.imagesWrittenIsSet()) || (imagesWrittenIsSet() && rhs.imagesWrittenIsSet() && getImagesWritten() == rhs.getImagesWritten())) &&
+    
+    
+    ((!imagesWriteErrorIsSet() && !rhs.imagesWriteErrorIsSet()) || (imagesWriteErrorIsSet() && rhs.imagesWriteErrorIsSet() && getImagesWriteError() == rhs.getImagesWriteError())) &&
+    
+    
+    ((!writerFifoUtilizationIsSet() && !rhs.writerFifoUtilizationIsSet()) || (writerFifoUtilizationIsSet() && rhs.writerFifoUtilizationIsSet() && getWriterFifoUtilization() == rhs.getWriterFifoUtilization()))
+    
+    ;
+}
+
+bool Image_pusher_status::operator!=(const Image_pusher_status& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Image_pusher_status& o)
+{
+    j = nlohmann::json::object();
+    j["pusher_type"] = o.m_Pusher_type;
+    j["addr"] = o.m_Addr;
+    j["connected_writers"] = o.m_Connected_writers;
+    if(o.imagesWrittenIsSet())
+        j["images_written"] = o.m_Images_written;
+    if(o.imagesWriteErrorIsSet())
+        j["images_write_error"] = o.m_Images_write_error;
+    if(o.writerFifoUtilizationIsSet() || !o.m_Writer_fifo_utilization.empty())
+        j["writer_fifo_utilization"] = o.m_Writer_fifo_utilization;
+    
+}
+
+void from_json(const nlohmann::json& j, Image_pusher_status& o)
+{
+    j.at("pusher_type").get_to(o.m_Pusher_type);
+    j.at("addr").get_to(o.m_Addr);
+    j.at("connected_writers").get_to(o.m_Connected_writers);
+    if(j.find("images_written") != j.end())
+    {
+        j.at("images_written").get_to(o.m_Images_written);
+        o.m_Images_writtenIsSet = true;
+    } 
+    if(j.find("images_write_error") != j.end())
+    {
+        j.at("images_write_error").get_to(o.m_Images_write_error);
+        o.m_Images_write_errorIsSet = true;
+    } 
+    if(j.find("writer_fifo_utilization") != j.end())
+    {
+        j.at("writer_fifo_utilization").get_to(o.m_Writer_fifo_utilization);
+        o.m_Writer_fifo_utilizationIsSet = true;
+    } 
+    
+}
+
+org::openapitools::server::model::Image_pusher_type Image_pusher_status::getPusherType() const
+{
+    return m_Pusher_type;
+}
+void Image_pusher_status::setPusherType(org::openapitools::server::model::Image_pusher_type const& value)
+{
+    m_Pusher_type = value;
+}
+std::vector<std::string> Image_pusher_status::getAddr() const
+{
+    return m_Addr;
+}
+void Image_pusher_status::setAddr(std::vector<std::string> const& value)
+{
+    m_Addr = value;
+}
+int64_t Image_pusher_status::getConnectedWriters() const
+{
+    return m_Connected_writers;
+}
+void Image_pusher_status::setConnectedWriters(int64_t const value)
+{
+    m_Connected_writers = value;
+}
+int64_t Image_pusher_status::getImagesWritten() const
+{
+    return m_Images_written;
+}
+void Image_pusher_status::setImagesWritten(int64_t const value)
+{
+    m_Images_written = value;
+    m_Images_writtenIsSet = true;
+}
+bool Image_pusher_status::imagesWrittenIsSet() const
+{
+    return m_Images_writtenIsSet;
+}
+void Image_pusher_status::unsetImages_written()
+{
+    m_Images_writtenIsSet = false;
+}
+int64_t Image_pusher_status::getImagesWriteError() const
+{
+    return m_Images_write_error;
+}
+void Image_pusher_status::setImagesWriteError(int64_t const value)
+{
+    m_Images_write_error = value;
+    m_Images_write_errorIsSet = true;
+}
+bool Image_pusher_status::imagesWriteErrorIsSet() const
+{
+    return m_Images_write_errorIsSet;
+}
+void Image_pusher_status::unsetImages_write_error()
+{
+    m_Images_write_errorIsSet = false;
+}
+std::vector<int64_t> Image_pusher_status::getWriterFifoUtilization() const
+{
+    return m_Writer_fifo_utilization;
+}
+void Image_pusher_status::setWriterFifoUtilization(std::vector<int64_t> const value)
+{
+    m_Writer_fifo_utilization = value;
+    m_Writer_fifo_utilizationIsSet = true;
+}
+bool Image_pusher_status::writerFifoUtilizationIsSet() const
+{
+    return m_Writer_fifo_utilizationIsSet;
+}
+void Image_pusher_status::unsetWriter_fifo_utilization()
+{
+    m_Writer_fifo_utilizationIsSet = false;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Image_pusher_status.h

@@ -0,0 +1,120 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.133
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * Image_pusher_status.h
+ *
+ * Informs about status of the image pusher. 
+ */
+
+#ifndef Image_pusher_status_H_
+#define Image_pusher_status_H_
+
+
+#include "Image_pusher_type.h"
+#include <string>
+#include <vector>
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// Informs about status of the image pusher. 
+/// </summary>
+class  Image_pusher_status
+{
+public:
+    Image_pusher_status();
+    virtual ~Image_pusher_status() = default;
+
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Image_pusher_status& rhs) const;
+    bool operator!=(const Image_pusher_status& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Image_pusher_status members
+
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Image_pusher_type getPusherType() const;
+    void setPusherType(org::openapitools::server::model::Image_pusher_type const& value);
+    /// <summary>
+    /// List of addresses of image pushers. For HDF5 socket - no addresses will be returned. For ZeroMQ - list of addresses for each socket will be provided. For TCP/IP - single address to connect all writers will be provided. 
+    /// </summary>
+    std::vector<std::string> getAddr() const;
+    void setAddr(std::vector<std::string> const& value);
+    /// <summary>
+    /// Number of connected writers  For ZeroMQ image socket: number is constant For TCP/IP image socket: number is updated live during operation 
+    /// </summary>
+    int64_t getConnectedWriters() const;
+    void setConnectedWriters(int64_t const value);
+    /// <summary>
+    /// Number of images written to the image socket. This number is updated live during operation for TCP/IP image socket and direct HDF5 writer. It is updated at the end of experiment for ZeroMQ image socket. 
+    /// </summary>
+    int64_t getImagesWritten() const;
+    void setImagesWritten(int64_t const value);
+    bool imagesWrittenIsSet() const;
+    void unsetImages_written();
+    /// <summary>
+    /// Number of images that could not be written to the image socket. This number is updated live during operation for TCP/IP image socket. No other socket use it. 
+    /// </summary>
+    int64_t getImagesWriteError() const;
+    void setImagesWriteError(int64_t const value);
+    bool imagesWriteErrorIsSet() const;
+    void unsetImages_write_error();
+    /// <summary>
+    /// Utilization of internal writer FIFO. This number is updated live during operation for TCP/IP image socket. No other socket use it. 
+    /// </summary>
+    std::vector<int64_t> getWriterFifoUtilization() const;
+    void setWriterFifoUtilization(std::vector<int64_t> const value);
+    bool writerFifoUtilizationIsSet() const;
+    void unsetWriter_fifo_utilization();
+
+    friend  void to_json(nlohmann::json& j, const Image_pusher_status& o);
+    friend  void from_json(const nlohmann::json& j, Image_pusher_status& o);
+protected:
+    org::openapitools::server::model::Image_pusher_type m_Pusher_type;
+
+    std::vector<std::string> m_Addr;
+
+    int64_t m_Connected_writers;
+
+    int64_t m_Images_written;
+    bool m_Images_writtenIsSet;
+    int64_t m_Images_write_error;
+    bool m_Images_write_errorIsSet;
+    std::vector<int64_t> m_Writer_fifo_utilization;
+    bool m_Writer_fifo_utilizationIsSet;
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Image_pusher_status_H_ */

broker/gen/model/Image_pusher_type.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_pusher_type.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Indexing_algorithm.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Indexing_algorithm.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Indexing_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Indexing_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Instrument_metadata.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Instrument_metadata.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Jfjoch_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -23,6 +23,7 @@ Jfjoch_settings::Jfjoch_settings()
 {
     m_PcieIsSet = false;
     m_ZeromqIsSet = false;
+    m_TcpIsSet = false;
     m_InstrumentIsSet = false;
     m_File_writerIsSet = false;
     m_IndexingIsSet = false;
@@ -38,7 +39,6 @@ Jfjoch_settings::Jfjoch_settings()
     m_Numa_policy = "";
     m_Numa_policyIsSet = false;
     m_Frontend_directory = "";
-    m_SslIsSet = false;
     m_Spot_findingIsSet = false;
     m_Zeromq_previewIsSet = false;
     m_Zeromq_metadataIsSet = false;
@@ -86,7 +86,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
-                     
+                         
     
     /* Detector */ {
         const std::vector<org::openapitools::server::model::Detector>& value = m_Detector;
@@ -140,7 +140,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
-                                    
+                                
     return success;
 }
 
@@ -156,6 +156,9 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
     ((!zeromqIsSet() && !rhs.zeromqIsSet()) || (zeromqIsSet() && rhs.zeromqIsSet() && getZeromq() == rhs.getZeromq())) &&
     
     
+    ((!tcpIsSet() && !rhs.tcpIsSet()) || (tcpIsSet() && rhs.tcpIsSet() && getTcp() == rhs.getTcp())) &&
+    
+    
     ((!instrumentIsSet() && !rhs.instrumentIsSet()) || (instrumentIsSet() && rhs.instrumentIsSet() && getInstrument() == rhs.getInstrument())) &&
     
     
@@ -192,9 +195,6 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
      &&
     
     
-    ((!sslIsSet() && !rhs.sslIsSet()) || (sslIsSet() && rhs.sslIsSet() && getSsl() == rhs.getSsl())) &&
-    
-    
     ((!spotFindingIsSet() && !rhs.spotFindingIsSet()) || (spotFindingIsSet() && rhs.spotFindingIsSet() && getSpotFinding() == rhs.getSpotFinding())) &&
     
     (getImagePusher() == rhs.getImagePusher())
@@ -224,6 +224,8 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o)
         j["pcie"] = o.m_Pcie;
     if(o.zeromqIsSet())
         j["zeromq"] = o.m_Zeromq;
+    if(o.tcpIsSet())
+        j["tcp"] = o.m_Tcp;
     if(o.instrumentIsSet())
         j["instrument"] = o.m_Instrument;
     if(o.fileWriterIsSet())
@@ -246,8 +248,6 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o)
     if(o.numaPolicyIsSet())
         j["numa_policy"] = o.m_Numa_policy;
     j["frontend_directory"] = o.m_Frontend_directory;
-    if(o.sslIsSet())
-        j["ssl"] = o.m_Ssl;
     if(o.spotFindingIsSet())
         j["spot_finding"] = o.m_Spot_finding;
     j["image_pusher"] = o.m_Image_pusher;
@@ -272,6 +272,11 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
         j.at("zeromq").get_to(o.m_Zeromq);
         o.m_ZeromqIsSet = true;
     } 
+    if(j.find("tcp") != j.end())
+    {
+        j.at("tcp").get_to(o.m_Tcp);
+        o.m_TcpIsSet = true;
+    } 
     if(j.find("instrument") != j.end())
     {
         j.at("instrument").get_to(o.m_Instrument);
@@ -324,11 +329,6 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
         o.m_Numa_policyIsSet = true;
     } 
     j.at("frontend_directory").get_to(o.m_Frontend_directory);
-    if(j.find("ssl") != j.end())
-    {
-        j.at("ssl").get_to(o.m_Ssl);
-        o.m_SslIsSet = true;
-    } 
     if(j.find("spot_finding") != j.end())
     {
         j.at("spot_finding").get_to(o.m_Spot_finding);
@@ -387,6 +387,23 @@ void Jfjoch_settings::unsetZeromq()
 {
     m_ZeromqIsSet = false;
 }
+org::openapitools::server::model::Tcp_settings Jfjoch_settings::getTcp() const
+{
+    return m_Tcp;
+}
+void Jfjoch_settings::setTcp(org::openapitools::server::model::Tcp_settings const& value)
+{
+    m_Tcp = value;
+    m_TcpIsSet = true;
+}
+bool Jfjoch_settings::tcpIsSet() const
+{
+    return m_TcpIsSet;
+}
+void Jfjoch_settings::unsetTcp()
+{
+    m_TcpIsSet = false;
+}
 org::openapitools::server::model::Instrument_metadata Jfjoch_settings::getInstrument() const
 {
     return m_Instrument;
@@ -573,23 +590,6 @@ void Jfjoch_settings::setFrontendDirectory(std::string const& value)
 {
     m_Frontend_directory = value;
 }
-org::openapitools::server::model::Jfjoch_settings_ssl Jfjoch_settings::getSsl() const
-{
-    return m_Ssl;
-}
-void Jfjoch_settings::setSsl(org::openapitools::server::model::Jfjoch_settings_ssl const& value)
-{
-    m_Ssl = value;
-    m_SslIsSet = true;
-}
-bool Jfjoch_settings::sslIsSet() const
-{
-    return m_SslIsSet;
-}
-void Jfjoch_settings::unsetSsl()
-{
-    m_SslIsSet = false;
-}
 org::openapitools::server::model::Spot_finding_settings Jfjoch_settings::getSpotFinding() const
 {
     return m_Spot_finding;

broker/gen/model/Jfjoch_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -19,6 +19,7 @@
 #define Jfjoch_settings_H_
 
 
+#include "Tcp_settings.h"
 #include "Spot_finding_settings.h"
 #include "Zeromq_preview_settings.h"
 #include "Dark_mask_settings.h"
@@ -35,7 +36,6 @@
 #include "Image_pusher_type.h"
 #include "Zeromq_settings.h"
 #include "Instrument_metadata.h"
-#include "Jfjoch_settings_ssl.h"
 #include <nlohmann/json.hpp>
 
 namespace org::openapitools::server::model
@@ -91,6 +91,13 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    org::openapitools::server::model::Tcp_settings getTcp() const;
+    void setTcp(org::openapitools::server::model::Tcp_settings const& value);
+    bool tcpIsSet() const;
+    void unsetTcp();
+    /// <summary>
+    /// 
+    /// </summary>
     org::openapitools::server::model::Instrument_metadata getInstrument() const;
     void setInstrument(org::openapitools::server::model::Instrument_metadata const& value);
     bool instrumentIsSet() const;
@@ -171,13 +178,6 @@ public:
     /// <summary>
     /// 
     /// </summary>
-    org::openapitools::server::model::Jfjoch_settings_ssl getSsl() const;
-    void setSsl(org::openapitools::server::model::Jfjoch_settings_ssl const& value);
-    bool sslIsSet() const;
-    void unsetSsl();
-    /// <summary>
-    /// 
-    /// </summary>
     org::openapitools::server::model::Spot_finding_settings getSpotFinding() const;
     void setSpotFinding(org::openapitools::server::model::Spot_finding_settings const& value);
     bool spotFindingIsSet() const;
@@ -216,6 +216,8 @@ protected:
     bool m_PcieIsSet;
     org::openapitools::server::model::Zeromq_settings m_Zeromq;
     bool m_ZeromqIsSet;
+    org::openapitools::server::model::Tcp_settings m_Tcp;
+    bool m_TcpIsSet;
     org::openapitools::server::model::Instrument_metadata m_Instrument;
     bool m_InstrumentIsSet;
     org::openapitools::server::model::File_writer_settings m_File_writer;
@@ -240,8 +242,6 @@ protected:
     bool m_Numa_policyIsSet;
     std::string m_Frontend_directory;
 
-    org::openapitools::server::model::Jfjoch_settings_ssl m_Ssl;
-    bool m_SslIsSet;
     org::openapitools::server::model::Spot_finding_settings m_Spot_finding;
     bool m_Spot_findingIsSet;
     org::openapitools::server::model::Image_pusher_type m_Image_pusher;

broker/gen/model/Jfjoch_settings_ssl.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Jfjoch_settings_ssl.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Jfjoch_statistics.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -40,6 +40,7 @@ Jfjoch_statistics::Jfjoch_statistics()
     m_Az_intIsSet = false;
     m_BufferIsSet = false;
     m_IndexingIsSet = false;
+    m_Image_pusherIsSet = false;
     
 }
 
@@ -104,7 +105,7 @@ bool Jfjoch_statistics::validate(std::stringstream& msg, const std::string& path
         }
 
     }
-                                    
+                                        
     return success;
 }
 
@@ -168,7 +169,10 @@ bool Jfjoch_statistics::operator==(const Jfjoch_statistics& rhs) const
     ((!bufferIsSet() && !rhs.bufferIsSet()) || (bufferIsSet() && rhs.bufferIsSet() && getBuffer() == rhs.getBuffer())) &&
     
     
-    ((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing()))
+    ((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing())) &&
+    
+    
+    ((!imagePusherIsSet() && !rhs.imagePusherIsSet()) || (imagePusherIsSet() && rhs.imagePusherIsSet() && getImagePusher() == rhs.getImagePusher()))
     
     ;
 }
@@ -219,6 +223,8 @@ void to_json(nlohmann::json& j, const Jfjoch_statistics& o)
         j["buffer"] = o.m_Buffer;
     if(o.indexingIsSet())
         j["indexing"] = o.m_Indexing;
+    if(o.imagePusherIsSet())
+        j["image_pusher"] = o.m_Image_pusher;
     
 }
 
@@ -319,6 +325,11 @@ void from_json(const nlohmann::json& j, Jfjoch_statistics& o)
         j.at("indexing").get_to(o.m_Indexing);
         o.m_IndexingIsSet = true;
     } 
+    if(j.find("image_pusher") != j.end())
+    {
+        j.at("image_pusher").get_to(o.m_Image_pusher);
+        o.m_Image_pusherIsSet = true;
+    } 
     
 }
 
@@ -645,6 +656,23 @@ void Jfjoch_statistics::unsetIndexing()
 {
     m_IndexingIsSet = false;
 }
+org::openapitools::server::model::Image_pusher_status Jfjoch_statistics::getImagePusher() const
+{
+    return m_Image_pusher;
+}
+void Jfjoch_statistics::setImagePusher(org::openapitools::server::model::Image_pusher_status const& value)
+{
+    m_Image_pusher = value;
+    m_Image_pusherIsSet = true;
+}
+bool Jfjoch_statistics::imagePusherIsSet() const
+{
+    return m_Image_pusherIsSet;
+}
+void Jfjoch_statistics::unsetImage_pusher()
+{
+    m_Image_pusherIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Jfjoch_statistics.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -35,6 +35,7 @@
 #include <vector>
 #include "Indexing_settings.h"
 #include "Detector_status.h"
+#include "Image_pusher_status.h"
 #include "Roi_definitions.h"
 #include "Fpga_status_inner.h"
 #include "Image_buffer_status.h"
@@ -210,6 +211,13 @@ public:
     void setIndexing(org::openapitools::server::model::Indexing_settings const& value);
     bool indexingIsSet() const;
     void unsetIndexing();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Image_pusher_status getImagePusher() const;
+    void setImagePusher(org::openapitools::server::model::Image_pusher_status const& value);
+    bool imagePusherIsSet() const;
+    void unsetImage_pusher();
 
     friend  void to_json(nlohmann::json& j, const Jfjoch_statistics& o);
     friend  void from_json(const nlohmann::json& j, Jfjoch_statistics& o);
@@ -252,6 +260,8 @@ protected:
     bool m_BufferIsSet;
     org::openapitools::server::model::Indexing_settings m_Indexing;
     bool m_IndexingIsSet;
+    org::openapitools::server::model::Image_pusher_status m_Image_pusher;
+    bool m_Image_pusherIsSet;
     
 };
 

broker/gen/model/Measurement_statistics.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -33,6 +33,8 @@ Measurement_statistics::Measurement_statistics()
     m_Images_collectedIsSet = false;
     m_Images_sent = 0L;
     m_Images_sentIsSet = false;
+    m_Images_written = 0L;
+    m_Images_writtenIsSet = false;
     m_Images_discarded_lossy_compression = 0L;
     m_Images_discarded_lossy_compressionIsSet = false;
     m_Max_image_number_sent = 0L;
@@ -87,7 +89,7 @@ bool Measurement_statistics::validate(std::stringstream& msg, const std::string&
     bool success = true;
     const std::string _pathPrefix = pathPrefix.empty() ? "Measurement_statistics" : pathPrefix;
 
-                                         
+                                             
     if (collectionEfficiencyIsSet())
     {
         const float& value = m_Collection_efficiency;
@@ -148,6 +150,9 @@ bool Measurement_statistics::operator==(const Measurement_statistics& rhs) const
     ((!imagesSentIsSet() && !rhs.imagesSentIsSet()) || (imagesSentIsSet() && rhs.imagesSentIsSet() && getImagesSent() == rhs.getImagesSent())) &&
     
     
+    ((!imagesWrittenIsSet() && !rhs.imagesWrittenIsSet()) || (imagesWrittenIsSet() && rhs.imagesWrittenIsSet() && getImagesWritten() == rhs.getImagesWritten())) &&
+    
+    
     ((!imagesDiscardedLossyCompressionIsSet() && !rhs.imagesDiscardedLossyCompressionIsSet()) || (imagesDiscardedLossyCompressionIsSet() && rhs.imagesDiscardedLossyCompressionIsSet() && getImagesDiscardedLossyCompression() == rhs.getImagesDiscardedLossyCompression())) &&
     
     
@@ -218,6 +223,8 @@ void to_json(nlohmann::json& j, const Measurement_statistics& o)
         j["images_collected"] = o.m_Images_collected;
     if(o.imagesSentIsSet())
         j["images_sent"] = o.m_Images_sent;
+    if(o.imagesWrittenIsSet())
+        j["images_written"] = o.m_Images_written;
     if(o.imagesDiscardedLossyCompressionIsSet())
         j["images_discarded_lossy_compression"] = o.m_Images_discarded_lossy_compression;
     if(o.maxImageNumberSentIsSet())
@@ -285,6 +292,11 @@ void from_json(const nlohmann::json& j, Measurement_statistics& o)
         j.at("images_sent").get_to(o.m_Images_sent);
         o.m_Images_sentIsSet = true;
     } 
+    if(j.find("images_written") != j.end())
+    {
+        j.at("images_written").get_to(o.m_Images_written);
+        o.m_Images_writtenIsSet = true;
+    } 
     if(j.find("images_discarded_lossy_compression") != j.end())
     {
         j.at("images_discarded_lossy_compression").get_to(o.m_Images_discarded_lossy_compression);
@@ -470,6 +482,23 @@ void Measurement_statistics::unsetImages_sent()
 {
     m_Images_sentIsSet = false;
 }
+int64_t Measurement_statistics::getImagesWritten() const
+{
+    return m_Images_written;
+}
+void Measurement_statistics::setImagesWritten(int64_t const value)
+{
+    m_Images_written = value;
+    m_Images_writtenIsSet = true;
+}
+bool Measurement_statistics::imagesWrittenIsSet() const
+{
+    return m_Images_writtenIsSet;
+}
+void Measurement_statistics::unsetImages_written()
+{
+    m_Images_writtenIsSet = false;
+}
 int64_t Measurement_statistics::getImagesDiscardedLossyCompression() const
 {
     return m_Images_discarded_lossy_compression;

broker/gen/model/Measurement_statistics.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -101,6 +101,13 @@ public:
     bool imagesSentIsSet() const;
     void unsetImages_sent();
     /// <summary>
+    /// Images successfully written to disk. The value is live updated for TCP/IP socket and direct HDF5 writer, while for ZeroMQ it is only updated at the end of experiment. 
+    /// </summary>
+    int64_t getImagesWritten() const;
+    void setImagesWritten(int64_t const value);
+    bool imagesWrittenIsSet() const;
+    void unsetImages_written();
+    /// <summary>
     /// Images discarded by the lossy compression filter
     /// </summary>
     int64_t getImagesDiscardedLossyCompression() const;
@@ -228,6 +235,8 @@ protected:
     bool m_Images_collectedIsSet;
     int64_t m_Images_sent;
     bool m_Images_sentIsSet;
+    int64_t m_Images_written;
+    bool m_Images_writtenIsSet;
     int64_t m_Images_discarded_lossy_compression;
     bool m_Images_discarded_lossy_compressionIsSet;
     int64_t m_Max_image_number_sent;

broker/gen/model/Pcie_devices_inner.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pcie_devices_inner.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pixel_mask_statistics.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pixel_mask_statistics.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plot.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plot.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plot_unit_x.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plot_unit_x.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plots.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plots.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Roi_azim_list.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.127
+* The version of the OpenAPI document: 1.0.0-rc.133
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).