CI: Disable sdk until DDS 2.6

Part of #185

.clang-tidy

@@ -0,0 +1,3 @@
+---
+Checks:          '*,-google-*,-fuchsia-*,-cert-*,-llvm-header-guard,-readability-named-parameter,-misc-non-private-member-variables-in-classes,-*-magic-numbers,-llvm-include-order,-hicpp-no-array-decay,-performance-unnecessary-value-param,-cppcoreguidelines-pro-bounds-array-to-pointer-decay'
+HeaderFilterRegex: '/(fairmq/|FairMQ)'

CMakeLists.txt

@@ -39,6 +39,7 @@ cmake_dependent_option(BUILD_OFI_TRANSPORT "Build experimental OFI transport." O
 cmake_dependent_option(BUILD_DDS_PLUGIN "Build DDS plugin." OFF "BUILD_FAIRMQ" OFF)
 cmake_dependent_option(BUILD_PMIX_PLUGIN "Build PMIx plugin." OFF "BUILD_FAIRMQ" OFF)
 cmake_dependent_option(BUILD_EXAMPLES "Build FairMQ examples." ON "BUILD_FAIRMQ" OFF)
+option(BUILD_SDK "Build the FairMQ controller SDK." OFF)
 option(BUILD_DOCS "Build FairMQ documentation." OFF)
 option(FAST_BUILD "Fast production build. Not recommended for development." OFF)
 ################################################################################
@@ -73,9 +74,14 @@ if(BUILD_NANOMSG_TRANSPORT)
   )
 endif()
 
-if(BUILD_DDS_PLUGIN)
+if(BUILD_SDK)
+  set(required_dds_version 2.5.22)
+else()
+  set(required_dds_version 2.4)
+endif()
+if(BUILD_DDS_PLUGIN OR BUILD_SDK)
   find_package2(PRIVATE DDS REQUIRED
-    VERSION 2.4
+    VERSION ${required_dds_version}
   )
   set(DDS_Boost_COMPONENTS system log log_setup)
   set(DDS_Boost_VERSION 1.67)
@@ -87,7 +93,7 @@ if(BUILD_PMIX_PLUGIN)
   )
 endif()
 
-if(BUILD_FAIRMQ)
+if(BUILD_FAIRMQ OR BUILD_SDK)
   find_package2(PUBLIC FairLogger REQUIRED
     VERSION 1.2.0
   )
@@ -113,6 +119,9 @@ if(BUILD_FAIRMQ)
     DDS
     FairLogger
   )
+endif()
+
+if(BUILD_FAIRMQ)
   find_package2(PRIVATE ZeroMQ REQUIRED
     VERSION 4.1.5
   )
@@ -135,12 +144,7 @@ endif()
 
 
 # Targets ######################################################################
-if(BUILD_FAIRMQ)
-  configure_file(${PROJECT_NAME_LOWER}/Version.h.in
-    ${CMAKE_BINARY_DIR}/${PROJECT_NAME_LOWER}/Version.h
-    @ONLY
-  )
-
+if(BUILD_FAIRMQ OR BUILD_SDK)
   add_subdirectory(fairmq)
 endif()
 
@@ -189,15 +193,14 @@ endif()
 if(BUILD_DOCS)
   list(APPEND PROJECT_PACKAGE_COMPONENTS docs)
 endif()
+if(BUILD_SDK)
+  list(APPEND PROJECT_PACKAGE_COMPONENTS sdk)
+endif()
 ################################################################################
 
 
 # Installation #################################################################
 if(BUILD_FAIRMQ)
-  install(FILES ${CMAKE_BINARY_DIR}/${PROJECT_NAME_LOWER}/Version.h
-    DESTINATION ${PROJECT_INSTALL_INCDIR}
-  )
-
   install(FILES cmake/FindZeroMQ.cmake
     DESTINATION ${PROJECT_INSTALL_CMAKEMODDIR}
   )
@@ -283,8 +286,7 @@ if(PROJECT_PACKAGE_DEPENDENCIES)
       get_target_property(nn_include nanomsg INTERFACE_INCLUDE_DIRECTORIES)
       get_filename_component(prefix ${nn_include}/.. ABSOLUTE)
     elseif(${dep} STREQUAL DDS)
-      get_target_property(dds_include DDS::dds_intercom_lib INTERFACE_INCLUDE_DIRECTORIES)
-      get_filename_component(prefix ${dds_include}/.. ABSOLUTE)
+      set(prefix "${DDS_INSTALL_PREFIX}")
     elseif(${dep} STREQUAL Boost)
       if(TARGET Boost::headers)
         get_target_property(boost_include Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
@@ -355,6 +357,12 @@ else()
   set(docs_summary "${BRed} NO${CR}    (default, enable with ${BMagenta}-DBUILD_DOCS=ON${CR})")
 endif()
 message(STATUS "  ${BWhite}docs${CR}               ${docs_summary}")
+if(BUILD_SDK)
+  set(sdk_summary "${BGreen}YES${CR}    EXPERIMENTAL (disable with ${BMagenta}-DBUILD_SDK=OFF${CR})")
+else()
+  set(sdk_summary "${BRed} NO${CR}    EXPERIMENTAL (default, enable with ${BMagenta}-DBUILD_SDK=ON${CR})")
+endif()
+message(STATUS "  ${BWhite}sdk${CR}                ${sdk_summary}")
 message(STATUS "  ")
 if(RUN_STATIC_ANALYSIS)
   list(LENGTH PROJECT_STATIC_ANALYSERS size)

COPYRIGHT

@@ -4,9 +4,9 @@ Upstream-Contact: Mohammad Al-Turany <m.al-turany@gsi.de>
 Source: https://github.com/FairRootGroup/FairMQ
 
 Files: *
-Copyright: 2012-2018, GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
-Copyright: 2012-2018, [see AUTHORS file]
-Copyright: 2012-2018, [see CONTRIBUTORS file]
+Copyright: 2012-2019, GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
+Copyright: 2012-2019, [see AUTHORS file]
+Copyright: 2012-2019, [see CONTRIBUTORS file]
 Comment: The copyright of individual contributors is documented in the
   Git history.
 License: LGPL-3.0-only

FairMQTest.cmake

@@ -29,6 +29,7 @@ Set(configure_options "${configure_options};-DCMAKE_PREFIX_PATH=$ENV{SIMPATH}")
 Set(configure_options "${configure_options};-DBUILD_NANOMSG_TRANSPORT=ON")
 # Set(configure_options "${configure_options};-DBUILD_OFI_TRANSPORT=ON")
 Set(configure_options "${configure_options};-DBUILD_DDS_PLUGIN=ON")
+Set(configure_options "${configure_options};-DBUILD_SDK=OFF")
 Set(configure_options "${configure_options};-DFAST_BUILD=ON")
 Set(configure_options "${configure_options};-DCOTIRE_MAXIMUM_NUMBER_OF_UNITY_INCLUDES=-j$ENV{number_of_processors}")
 
@@ -59,17 +60,9 @@ Ctest_Build(BUILD "${CTEST_BINARY_DIRECTORY}")
 
 Ctest_Test(BUILD "${CTEST_BINARY_DIRECTORY}" 
            # PARALLEL_LEVEL $ENV{number_of_processors}
-           PARALLEL_LEVEL 1
+           PARALLEL_LEVEL $ENV{number_of_processors}
            RETURN_VALUE _ctest_test_ret_val
           )
-If("$ENV{do_codecov_upload}")
-  ForEach(i RANGE 4)
-    # Gather statistics to catch time sensitive branches
-    Ctest_Test(BUILD "${CTEST_BINARY_DIRECTORY}" 
-               PARALLEL_LEVEL $ENV{number_of_processors}
-              )
-  EndForEach()
-EndIf()
 
 If(GCOV_COMMAND)
   Ctest_Coverage(BUILD "${CTEST_BINARY_DIRECTORY}" LABELS coverage)

cmake/FairMQConfig.cmake.in

@@ -13,12 +13,12 @@ set(@PROJECT_NAME@_VERSION @PROJECT_VERSION@)
 set(@PROJECT_NAME@_GIT_VERSION @PROJECT_GIT_VERSION@)
 set(@PROJECT_NAME@_GIT_DATE @PROJECT_GIT_DATE@)
 
-set_and_check(@PROJECT_NAME@_PREFIX @PACKAGE_CMAKE_INSTALL_PREFIX@)
-set_and_check(@PROJECT_NAME@_BINDIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@PROJECT_INSTALL_BINDIR@)
-set_and_check(@PROJECT_NAME@_INCDIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_INCLUDEDIR@)
-set_and_check(@PROJECT_NAME@_LIBDIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@PROJECT_INSTALL_LIBDIR@)
-set_and_check(@PROJECT_NAME@_DATADIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@PROJECT_INSTALL_DATADIR@)
-set_and_check(@PROJECT_NAME@_CMAKEMODDIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@PROJECT_INSTALL_CMAKEMODDIR@)
+set(@PROJECT_NAME@_PREFIX @PACKAGE_CMAKE_INSTALL_PREFIX@)
+set(@PROJECT_NAME@_BINDIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@PROJECT_INSTALL_BINDIR@)
+set(@PROJECT_NAME@_INCDIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_INCLUDEDIR@)
+set(@PROJECT_NAME@_LIBDIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@PROJECT_INSTALL_LIBDIR@)
+set(@PROJECT_NAME@_DATADIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@PROJECT_INSTALL_DATADIR@)
+set(@PROJECT_NAME@_CMAKEMODDIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@PROJECT_INSTALL_CMAKEMODDIR@)
 
 set(@PROJECT_NAME@_CXX_STANDARD_REQUIRED @CMAKE_CXX_STANDARD_REQUIRED@)
 set(@PROJECT_NAME@_CXX_STANDARD @CMAKE_CXX_STANDARD@)

cmake/FairMQLib.cmake

@@ -176,7 +176,7 @@ macro(set_fairmq_defaults)
     set(analyser "clang-tidy")
     find_program(${analyser}_FOUND "${analyser}")
     if(${analyser}_FOUND)
-      set(CMAKE_CXX_CLANG_TIDY "${${analyser}_FOUND}" "-color")
+      set(CMAKE_CXX_CLANG_TIDY "${${analyser}_FOUND}")
     endif()
     list(APPEND PROJECT_STATIC_ANALYSERS "${analyser}")
 
@@ -375,18 +375,18 @@ macro(find_package2 qualifier pkgname)
   if(${pkgname}_FOUND)
     if(${qualifier} STREQUAL PRIVATE)
       set(PROJECT_${pkgname}_VERSION ${__version__})
-      set(PROJECT_${pkgname}_COMPONENTS ${ARGS_COMPONENTS})
+      set(PROJECT_${pkgname}_COMPONENTS ${__components__})
       set(PROJECT_PACKAGE_DEPENDENCIES ${PROJECT_PACKAGE_DEPENDENCIES} ${pkgname})
     elseif(${qualifier} STREQUAL PUBLIC)
       set(PROJECT_${pkgname}_VERSION ${__version__})
-      set(PROJECT_${pkgname}_COMPONENTS ${ARGS_COMPONENTS})
+      set(PROJECT_${pkgname}_COMPONENTS ${__components__})
       set(PROJECT_PACKAGE_DEPENDENCIES ${PROJECT_PACKAGE_DEPENDENCIES} ${pkgname})
       set(PROJECT_INTERFACE_${pkgname}_VERSION ${__version__})
-      set(PROJECT_INTERFACE_${pkgname}_COMPONENTS ${ARGS_COMPONENTS})
+      set(PROJECT_INTERFACE_${pkgname}_COMPONENTS ${__components__})
       set(PROJECT_INTERFACE_PACKAGE_DEPENDENCIES ${PROJECT_INTERFACE_PACKAGE_DEPENDENCIES} ${pkgname})
     elseif(${qualifier} STREQUAL INTERFACE)
       set(PROJECT_INTERFACE_${pkgname}_VERSION ${__version__})
-      set(PROJECT_INTERFACE_${pkgname}_COMPONENTS ${ARGS_COMPONENTS})
+      set(PROJECT_INTERFACE_${pkgname}_COMPONENTS ${__components__})
       set(PROJECT_INTERFACE_PACKAGE_DEPENDENCIES ${PROJECT_INTERFACE_PACKAGE_DEPENDENCIES} ${pkgname})
     endif()
   endif()

docs/Configuration.md

@@ -4,7 +4,37 @@
 
 ## 3.1 Device Configuration
 
-Devices receive configuration primarily via provided command line options (that can be extended per device).
+Device Configuration is stored in configuration object - `fair::mq::ProgOptions`. It is accessible by the device, plugins or from DeviceRunner/main:
+
+Plugins <---read/write---> ProgOptions <---read/write---> Device
+
+Whenever a configuration property is set, it is set in ProgOptions. Device/Channels/User code read this value and apply it as necessary at different stages:
+ - apply it immidiately
+ - apply it in device/channels during InitializingDevice/Binding/Connecting states
+
+Here is an overview of the device/channel options and when they are applied:
+
+| Property | Applied in |
+| --- | --- |
+| `severity` | immidiately (if `fair::mq::DeviceRunner` is used (also the case when using `<runFairMQDevice.h>`)) |
+| `file-severity` | immidiately (if `fair::mq::DeviceRunner` is used (also the case when using `<runFairMQDevice.h>`)) |
+| `verbosity` | immidiately (if `fair::mq::DeviceRunner` is used (also the case when using `<runFairMQDevice.h>`)) |
+| `color` | immidiately (if `fair::mq::DeviceRunner` is used (also the case when using `<runFairMQDevice.h>`)) |
+| `log-to-file` | immidiately (if `fair::mq::DeviceRunner` is used (also the case when using `<runFairMQDevice.h>`)) |
+| `id` | at the end of `fair::mq::State::InitializingDevice` |
+| `io-threads` | at the end of `fair::mq::State::InitializingDevice` |
+| `transport` | at the end of `fair::mq::State::InitializingDevice` |
+| `network-interface` | at the end of `fair::mq::State::InitializingDevice` |
+| `init-timeout` | at the end of `fair::mq::State::InitializingDevice` |
+| `max-run-time` | at the end of `fair::mq::State::InitializingDevice` |
+| `shm-segment-size` | at the end of `fair::mq::State::InitializingDevice` |
+| `shm-monitor` | at the end of `fair::mq::State::InitializingDevice` |
+| `ofi-size-hint` | at the end of `fair::mq::State::InitializingDevice` |
+| `rate` | at the end of `fair::mq::State::InitializingDevice` |
+| `session` | at the end of `fair::mq::State::InitializingDevice` |
+| `chan.*` | at the end of `fair::mq::State::InitializingDevice` (channel addresses can be also applied during `fair::mq::State::Binding`/`fair::mq::State::Connecting`) |
+
+## 3.2 Configuration options
 
 ## 3.2 Communication Channels Configuration
 
@@ -32,6 +62,14 @@ This parser reads channel configuration from a JSON file. Example:
                                 "address": "tcp://*:5555",
                                 "sndBufSize": 1000,
                                 "rcvBufSize": 1000,
+                                "sndKernelSize" : 0,
+                                "rcvKernelSize" : 0,
+                                "transport": "shmem",
+                                "linger": "500",
+                                "portRangeMin": "22000",
+                                "portRangeMax": "23000",
+                                "autoBind": false,
+                                "numSockets": 0,
                                 "rateLogging": 1
                             }
                         ]
@@ -48,9 +86,7 @@ This parser reads channel configuration from a JSON file. Example:
                                 "type": "pull",
                                 "method": "connect",
                                 "address": "tcp://localhost:5555",
-                                "sndBufSize": 1000,
-                                "rcvBufSize": 1000,
-                                "rateLogging": 1
+                                "transport": "shmem"
                             }
                         ]
                     }

docs/Device.md

@@ -48,6 +48,6 @@ Without the interactive mode, for example for a run in background, two other con
 
 ## 1.4 Multiple devices in the same process
 
-Technically one can create two or more devices within the same process without any conflicts. However the configuration (FairMQProgOptions) currently assumes the supplied configuration values are for one device/process.
+Technically one can create two or more devices within the same process without any conflicts. However the configuration (fair::mq::ProgOptions) currently assumes the supplied configuration values are for one device/process.
 
 ← [Back](../README.md)

examples/1-1/Sampler.cxx

@@ -26,8 +26,8 @@ Sampler::Sampler()
 void Sampler::InitTask()
 {
     // Get the fText and fMaxIterations values from the command line options (via fConfig)
-    fText = fConfig->GetValue<string>("text");
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fText = fConfig->GetProperty<string>("text");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 bool Sampler::ConditionalRun()

examples/1-1/Sink.cxx

@@ -30,7 +30,7 @@ Sink::Sink()
 void Sink::InitTask()
 {
     // Get the fMaxIterations value from the command line options (via fConfig)
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 // handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)

examples/1-1/runSampler.cxx

@@ -18,7 +18,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_1_1::Sampler();
 }

examples/1-1/runSink.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_1_1::Sink();
 }

examples/1-n-1/Sampler.cxx

@@ -32,8 +32,8 @@ Sampler::Sampler()
 void Sampler::InitTask()
 {
     // Get the fText and fMaxIterations values from the command line options (via fConfig)
-    fText = fConfig->GetValue<string>("text");
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fText = fConfig->GetProperty<string>("text");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 bool Sampler::ConditionalRun()

examples/1-n-1/Sink.cxx

@@ -30,7 +30,7 @@ Sink::Sink()
 void Sink::InitTask()
 {
     // Get the fMaxIterations value from the command line options (via fConfig)
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 // handler is called whenever a message arrives on "data2", with a reference to the message and a sub-channel index (here 0)

examples/1-n-1/runProcessor.cxx

@@ -15,7 +15,7 @@ void addCustomOptions(bpo::options_description& /*options*/)
 {
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_1_n_1::Processor();
 }

examples/1-n-1/runSampler.cxx

@@ -18,7 +18,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_1_n_1::Sampler();
 }

examples/1-n-1/runSink.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_1_n_1::Sink();
 }

examples/copypush/Sampler.cxx

@@ -33,12 +33,11 @@ Sampler::Sampler()
 void Sampler::InitTask()
 {
     fNumDataChannels = fChannels.at("data").size();
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 bool Sampler::ConditionalRun()
 {
-
     // NewSimpleMessage creates a copy of the data and takes care of its destruction (after the transfer takes place).
     // Should only be used for small data because of the cost of an additional copy
     FairMQMessagePtr msg(NewSimpleMessage(fCounter++));

examples/copypush/Sink.cxx

@@ -27,7 +27,7 @@ Sink::Sink()
 void Sink::InitTask()
 {
     // Get the fMaxIterations value from the command line options (via fConfig)
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 bool Sink::HandleData(FairMQMessagePtr& msg, int /*index*/)

examples/copypush/runSampler.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_copypush::Sampler();
 }

examples/copypush/runSink.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_copypush::Sink();
 }

examples/dds/CMakeLists.txt

@@ -1,5 +1,5 @@
 ################################################################################
-#    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    #
+#  Copyright (C) 2014-2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH #
 #                                                                              #
 #              This software is distributed under the terms of the             #
 #              GNU Lesser General Public Licence (LGPL) version 3,             #
@@ -28,14 +28,21 @@ target_link_libraries(fairmq-ex-dds-sink PRIVATE ExampleDDSLib)
 
 add_custom_target(ExampleDDS DEPENDS fairmq-ex-dds-sampler fairmq-ex-dds-processor fairmq-ex-dds-sink)
 
-set(EX_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR})
-set(DDS_PLUGIN_LIB_DIR ${CMAKE_BINARY_DIR}/fairmq/plugins/DDS)
-set(FAIRMQ_BIN_DIR ${CMAKE_BINARY_DIR}/fairmq)
+set(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}:${CMAKE_BINARY_DIR}/fairmq/plugins/DDS)
+set(DATA_DIR ${CMAKE_CURRENT_BINARY_DIR})
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-dds-topology.xml ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-topology.xml @ONLY)
-
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-dds-topology-infinite.xml ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-topology-infinite.xml @ONLY)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-dds-hosts.cfg ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-hosts.cfg COPYONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-ex-dds-env.sh ${CMAKE_CURRENT_BINARY_DIR}/fairmq-ex-dds-env.sh @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-dds.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-dds.sh @ONLY)
 
 # test
+add_test(NAME Example.DDS.localhost COMMAND ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-dds.sh localhost)
+set_tests_properties(Example.DDS.localhost PROPERTIES
+  TIMEOUT 15
+  RUN_SERIAL true
+  PASS_REGULAR_EXPRESSION "Example successful"
+)
 
 # install
 
@@ -50,10 +57,12 @@ install(
 )
 
 # configure run script with different executable paths for build and for install directories
-set(EX_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR})
-set(DDS_PLUGIN_LIB_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_LIBDIR})
-set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
+set(BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR})
+set(DATA_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_DATADIR})
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-dds-topology.xml ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-topology.xml_install @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-dds-topology-infinite.xml ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-topology-infinite.xml_install @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-ex-dds-env.sh ${CMAKE_CURRENT_BINARY_DIR}/fairmq-ex-dds-env.sh_install @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-dds.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-dds.sh_install @ONLY)
 
 install(
     FILES ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-topology.xml_install
@@ -61,7 +70,25 @@ install(
     RENAME ex-dds-topology.xml
 )
 
+install(
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-topology-infinite.xml_install
+    DESTINATION ${PROJECT_INSTALL_DATADIR}
+    RENAME ex-dds-topology-infinite.xml
+)
+
 install(
     FILES ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-hosts.cfg
     DESTINATION ${PROJECT_INSTALL_DATADIR}
 )
+
+install(
+    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-ex-dds-env.sh_install
+    DESTINATION ${PROJECT_INSTALL_BINDIR}
+    RENAME fairmq-ex-dds-env.sh
+)
+
+install(
+    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-dds.sh_install
+    DESTINATION ${PROJECT_INSTALL_BINDIR}
+    RENAME fairmq-start-ex-dds.sh
+)

examples/dds/Sampler.cxx

@@ -26,10 +26,14 @@ Sampler::Sampler()
 {
 }
 
+void Sampler::InitTask()
+{
+    fIterations = fConfig->GetValue<uint64_t>("iterations");
+    fCounter = 0;
+}
+
 bool Sampler::ConditionalRun()
 {
-    std::this_thread::sleep_for(std::chrono::seconds(1));
-
     // NewSimpleMessage creates a copy of the data and takes care of its destruction (after the transfer takes place).
     // Should only be used for small data because of the cost of an additional copy
     FairMQMessagePtr msg(NewSimpleMessage("Data"));
@@ -38,11 +42,18 @@ bool Sampler::ConditionalRun()
 
     // in case of error or transfer interruption, return false to go to IDLE state
     // successfull transfer will return number of bytes transfered (can be 0 if sending an empty message).
-    if (Send(msg, "data1") < 0)
-    {
+    if (Send(msg, "data1") < 0) {
         return false;
     }
 
+    if (fIterations > 0) {
+        ++fCounter;
+        if (fCounter >= fIterations) {
+            LOG(info) << "Sent " << fCounter << " messages. Finished.";
+            return false;
+        }
+    }
+
     return true;
 }
 

examples/dds/Sampler.h

@@ -25,9 +25,14 @@ class Sampler : public FairMQDevice
   public:
     Sampler();
     virtual ~Sampler();
+    void InitTask() override;
 
   protected:
-    virtual bool ConditionalRun();
+    bool ConditionalRun() override;
+
+  private:
+    uint64_t fIterations;
+    uint64_t fCounter;
 };
 
 } // namespace example_dds

examples/dds/Sink.cxx

@@ -25,11 +25,24 @@ Sink::Sink()
     OnData("data2", &Sink::HandleData);
 }
 
+void Sink::InitTask()
+{
+    fIterations = fConfig->GetValue<uint64_t>("iterations");
+    fCounter = 0;
+}
+
 // handler is called whenever a message arrives on "data2", with a reference to the message and a sub-channel index (here 0)
 bool Sink::HandleData(FairMQMessagePtr& msg, int /*index*/)
 {
     LOG(info) << "Received: \"" << string(static_cast<char*>(msg->GetData()), msg->GetSize()) << "\"";
 
+    if (fIterations > 0) {
+        ++fCounter;
+        if (fCounter >= fIterations) {
+            LOG(info) << "Received " << fCounter << " messages. Finished.";
+            return false;
+        }
+    }
     // return true if want to be called again (otherwise go to IDLE state)
     return true;
 }

examples/dds/Sink.h

@@ -25,9 +25,14 @@ class Sink : public FairMQDevice
   public:
     Sink();
     virtual ~Sink();
+    void InitTask() override;
 
   protected:
     bool HandleData(FairMQMessagePtr&, int);
+
+  private:
+    uint64_t fIterations;
+    uint64_t fCounter;
 };
 
 } // namespace example_dds

examples/dds/ex-dds-hosts.cfg

@@ -1,7 +1,3 @@
-@bash_begin@
-# source setup.sh
-@bash_end@
-
-sampler, username@localhost, , /path/to/dds-work/, 1
-processor, username@localhost, , /path/to/dds-work/, 10
-sink, username@localhost, , /path/to/dds-work/, 1
+sampler, 127.0.0.1, , /tmp/fairmq-ex-dds, 1
+processor, 127.0.0.1, , /tmp/fairmq-ex-dds, 10
+sink, 127.0.0.1, , /tmp/fairmq-ex-dds, 1

examples/dds/ex-dds-topology-infinite.xml

@@ -0,0 +1,52 @@
+<topology name="ExampleDDS">
+
+    <property name="data1" />
+    <property name="data2" />
+
+    <declrequirement name="SamplerWorker" type="wnname" value="sampler"/>
+    <declrequirement name="ProcessorWorker" type="wnname" value="processor"/>
+    <declrequirement name="SinkWorker" type="wnname" value="sink"/>
+
+    <decltask name="Sampler">
+        <exe>fairmq-ex-dds-sampler --color false --channel-config name=data1,type=push,method=bind --rate 100 -P dds</exe>
+        <env reachable="false">fairmq-ex-dds-env.sh</env>
+        <requirements>
+            <name>SamplerWorker</name>
+        </requirements>
+        <properties>
+            <name access="write">data1</name>
+        </properties>
+    </decltask>
+
+    <decltask name="Processor">
+        <exe>fairmq-ex-dds-processor --color false --channel-config name=data1,type=pull,method=connect name=data2,type=push,method=connect -P dds</exe>
+        <env reachable="false">fairmq-ex-dds-env.sh</env>
+        <requirements>
+            <name>ProcessorWorker</name>
+        </requirements>
+        <properties>
+            <name access="read">data1</name>
+            <name access="read">data2</name>
+        </properties>
+    </decltask>
+
+    <decltask name="Sink">
+        <exe>fairmq-ex-dds-sink --color false --channel-config name=data2,type=pull,method=bind -P dds</exe>
+        <env reachable="false">fairmq-ex-dds-env.sh</env>
+        <requirements>
+            <name>SinkWorker</name>
+        </requirements>
+        <properties>
+            <name access="write">data2</name>
+        </properties>
+    </decltask>
+
+    <main name="main">
+        <task>Sampler</task>
+        <task>Sink</task>
+        <group name="ProcessorGroup" n="10">
+            <task>Processor</task>
+        </group>
+    </main>
+
+</topology>

examples/dds/ex-dds-topology.xml

@@ -8,7 +8,8 @@
     <declrequirement name="SinkWorker" type="wnname" value="sink"/>
 
     <decltask name="Sampler">
-        <exe reachable="true">@EX_BIN_DIR@/fairmq-ex-dds-sampler --id sampler --color false --channel-config name=data1,type=push,method=bind -S "&lt;@DDS_PLUGIN_LIB_DIR@/" -P dds</exe>
+        <exe>fairmq-ex-dds-sampler --color false --channel-config name=data1,type=push,method=bind -P dds --iterations 10</exe>
+        <env reachable="false">fairmq-ex-dds-env.sh</env>
         <requirements>
             <name>SamplerWorker</name>
         </requirements>
@@ -18,7 +19,8 @@
     </decltask>
 
     <decltask name="Processor">
-        <exe reachable="true">@EX_BIN_DIR@/fairmq-ex-dds-processor --id processor_%taskIndex% --config-key processor --color false --channel-config name=data1,type=pull,method=connect name=data2,type=push,method=connect -S "&lt;@DDS_PLUGIN_LIB_DIR@/" -P dds</exe>
+        <exe>fairmq-ex-dds-processor --color false --channel-config name=data1,type=pull,method=connect name=data2,type=push,method=connect -P dds</exe>
+        <env reachable="false">fairmq-ex-dds-env.sh</env>
         <requirements>
             <name>ProcessorWorker</name>
         </requirements>
@@ -29,7 +31,8 @@
     </decltask>
 
     <decltask name="Sink">
-        <exe reachable="true">@EX_BIN_DIR@/fairmq-ex-dds-sink --id sink --color false --channel-config name=data2,type=pull,method=bind -S "&lt;@DDS_PLUGIN_LIB_DIR@/" -P dds</exe>
+        <exe>fairmq-ex-dds-sink --color false --channel-config name=data2,type=pull,method=bind -P dds --iterations 10</exe>
+        <env reachable="false">fairmq-ex-dds-env.sh</env>
         <requirements>
             <name>SinkWorker</name>
         </requirements>

examples/dds/fairmq-ex-dds-env.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+################################################################################
+#    Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    #
+#                                                                              #
+#              This software is distributed under the terms of the             #
+#              GNU Lesser General Public Licence (LGPL) version 3,             #
+#                  copied verbatim in the file "LICENSE"                       #
+################################################################################
+
+export PATH=@BIN_DIR@:$PATH

examples/dds/fairmq-start-ex-dds.sh.in

@@ -0,0 +1,88 @@
+#!/bin/bash
+
+################################################################################
+#    Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    #
+#                                                                              #
+#              This software is distributed under the terms of the             #
+#              GNU Lesser General Public Licence (LGPL) version 3,             #
+#                  copied verbatim in the file "LICENSE"                       #
+################################################################################
+
+# fairmq-start-ex-dds.sh [localhost]   -> submit agents with localhost plugin
+# fairmq-start-ex-dds.sh ssh           -> submit agents with ssh plugin
+
+set -e
+
+cleanup() {
+  dds-session stop $1
+  echo "CLEANUP PERFORMED"
+}
+
+source @DDS_INSTALL_PREFIX@/DDS_env.sh
+export PATH=@BIN_DIR@:$PATH
+
+plugin=${1:-localhost}
+
+exec 5>&1
+output=$(dds-session start | tee >(cat - >&5))
+export DDS_SESSION_ID=$(echo ${output} | grep "DDS session ID: " | cut -d' ' -f4)
+echo "SESSION ID: ${DDS_SESSION_ID}"
+
+trap "cleanup ${DDS_SESSION_ID}" EXIT
+
+requiredNofAgents=12
+if [[ "$plugin" == "ssh" ]]; then
+  dds-submit -r ${plugin} -c @DATA_DIR@/ex-dds-hosts.cfg
+else
+  dds-submit -r ${plugin} -n ${requiredNofAgents}
+fi
+echo "...waiting for ${requiredNofAgents} idle agents..."
+dds-info --wait-for-idle-agents ${requiredNofAgents}
+
+topologyFile=@DATA_DIR@/ex-dds-topology.xml
+echo "TOPOLOGY FILE: ${topologyFile}"
+# TODO Uncomment once DDS 2.6 is released
+# echo "TOPOLOGY NAME: $(dds-topology --disable-validation --topology-name ${topologyFile})"
+
+# TODO Uncomment once DDS 2.6 is released
+# dds-info --active-topology
+dds-topology --activate ${topologyFile}
+# dds-info --active-topology
+# dds-info --wait-for-executing-agents ${requiredNofAgents}
+sleep 1
+
+echo "------------------------"
+echo "...waiting for Topology to finish..."
+# TODO Retrieve number of devices from DDS topology API instead of having the user pass it explicitely
+fairmq-dds-command-ui -w "IDLE" -n ${requiredNofAgents}
+fairmq-dds-command-ui -c i -w "INITIALIZING DEVICE" -n ${requiredNofAgents}
+fairmq-dds-command-ui -c k -w "INITIALIZED" -n ${requiredNofAgents}
+fairmq-dds-command-ui -c b -w "BOUND" -n ${requiredNofAgents}
+fairmq-dds-command-ui -c x -w "DEVICE READY" -n ${requiredNofAgents}
+fairmq-dds-command-ui -c j -w "READY" -n ${requiredNofAgents}
+fairmq-dds-command-ui -c r
+sampler_and_sink="main/(Sampler|Sink)"
+fairmq-dds-command-ui -p $sampler_and_sink -w "RUNNING->READY" -n 2
+echo "...$sampler_and_sink are READY, sending shutdown..."
+fairmq-dds-command-ui -c s -w "RUNNING->READY" -n ${requiredNofAgents}
+fairmq-dds-command-ui -c t -w "DEVICE READY" -n ${requiredNofAgents}
+fairmq-dds-command-ui -c d -w "IDLE" -n ${requiredNofAgents}
+fairmq-dds-command-ui -c q
+echo "...waiting for ${requiredNofAgents} idle agents..."
+dds-info --wait-for-idle-agents ${requiredNofAgents}
+echo "------------------------"
+
+# TODO Uncomment once DDS 2.6 is released
+# dds-info --active-topology
+dds-topology --stop
+# dds-info --active-topology
+
+dds-agent-cmd getlog -a
+logDir="${wrkDir}/logs"
+for file in $(find "${logDir}" -name "*.tar.gz"); do tar -xf ${file} -C "${logDir}" ; done
+echo "AGENT LOG FILES IN: ${logDir}"
+
+# This string is used by ctest to detect success
+echo "Example successful :)"
+
+# Cleanup function is called by EXIT trap

examples/dds/runProcessor.cxx

@@ -15,7 +15,7 @@ void addCustomOptions(bpo::options_description& /*options*/)
 {
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_dds::Processor();
 }

examples/dds/runSampler.cxx

@@ -11,11 +11,15 @@
 
 namespace bpo = boost::program_options;
 
-void addCustomOptions(bpo::options_description& /*options*/)
+void addCustomOptions(bpo::options_description& options)
 {
+    options.add_options()(
+        "iterations,i",
+        bpo::value<uint64_t>()->default_value(1000),
+        "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_dds::Sampler();
 }

examples/dds/runSink.cxx

@@ -11,11 +11,15 @@
 
 namespace bpo = boost::program_options;
 
-void addCustomOptions(bpo::options_description& /*options*/)
+void addCustomOptions(bpo::options_description& options)
 {
+    options.add_options()(
+        "iterations,i",
+        bpo::value<uint64_t>()->default_value(1000),
+        "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_dds::Sink();
 }

examples/multipart/Sampler.cxx

@@ -31,7 +31,7 @@ Sampler::Sampler()
 
 void Sampler::InitTask()
 {
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 bool Sampler::ConditionalRun()

examples/multipart/runSampler.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(5), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_multipart::Sampler();
 }

examples/multipart/runSink.cxx

@@ -15,7 +15,7 @@ void addCustomOptions(bpo::options_description& /*options*/)
 {
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_multipart::Sink();
 }

examples/multiple-channels/Sampler.cxx

@@ -33,8 +33,8 @@ Sampler::Sampler()
 
 void Sampler::InitTask()
 {
-    fText = fConfig->GetValue<string>("text");
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fText = fConfig->GetProperty<string>("text");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 void Sampler::Run()

examples/multiple-channels/Sink.cxx

@@ -31,7 +31,7 @@ Sink::Sink()
 
 void Sink::InitTask()
 {
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 bool Sink::HandleBroadcast(FairMQMessagePtr& msg, int /*index*/)

examples/multiple-channels/runBroadcaster.cxx

@@ -15,7 +15,7 @@ void addCustomOptions(bpo::options_description& /*options*/)
 {
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_multiple_channels::Broadcaster();
 }

examples/multiple-channels/runSampler.cxx

@@ -18,7 +18,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_multiple_channels::Sampler();
 }

examples/multiple-channels/runSink.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_multiple_channels::Sink();
 }

examples/multiple-transports/Sampler1.cxx

@@ -22,7 +22,7 @@ Sampler1::Sampler1()
 
 void Sampler1::InitTask()
 {
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 void Sampler1::PreRun()

examples/multiple-transports/Sampler2.cxx

@@ -21,7 +21,7 @@ Sampler2::Sampler2()
 
 void Sampler2::InitTask()
 {
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 bool Sampler2::ConditionalRun()

examples/multiple-transports/Sink.cxx

@@ -31,7 +31,7 @@ Sink::Sink()
 
 void Sink::InitTask()
 {
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 // handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)

examples/multiple-transports/runSampler1.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_multiple_transports::Sampler1();
 }

examples/multiple-transports/runSampler2.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_multiple_transports::Sampler2();
 }

examples/multiple-transports/runSink.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_multiple_transports::Sink();
 }

examples/readout/Builder.h

@@ -24,7 +24,7 @@ class Builder : public FairMQDevice
 
     void Init() override
     {
-        fOutputChannelName = fConfig->GetValue<std::string>("output-name");
+        fOutputChannelName = fConfig->GetProperty<std::string>("output-name");
         OnData("rb", &Builder::HandleData);
     }
 

examples/readout/Readout.h

@@ -31,8 +31,8 @@ class Readout : public FairMQDevice
   protected:
     void InitTask() override
     {
-        fMsgSize = fConfig->GetValue<int>("msg-size");
-        fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+        fMsgSize = fConfig->GetProperty<int>("msg-size");
+        fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 
         fRegion = FairMQUnmanagedRegionPtr(NewUnmanagedRegionFor("rb",
                                                                 0,

examples/readout/Receiver.h

@@ -25,7 +25,7 @@ class Receiver : public FairMQDevice
     void InitTask() override
     {
         // Get the fMaxIterations value from the command line options (via fConfig)
-        fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+        fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
     }
 
     void Run() override

examples/readout/Sender.h

@@ -24,7 +24,7 @@ class Sender : public FairMQDevice
 
     void Init() override
     {
-        fInputChannelName = fConfig->GetValue<std::string>("input-name");
+        fInputChannelName = fConfig->GetProperty<std::string>("input-name");
         OnData(fInputChannelName, &Sender::HandleData);
     }
 

examples/readout/runBuilder.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("output-name", bpo::value<std::string>()->default_value("bs"), "Output channel name");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_readout::Builder();
 }

examples/readout/runProcessor.cxx

@@ -14,7 +14,7 @@ namespace bpo = boost::program_options;
 void addCustomOptions(bpo::options_description& /* options */)
 {}
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_readout::Processor();
 }

examples/readout/runReadout.cxx

@@ -18,7 +18,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_readout::Readout();
 }

examples/readout/runReceiver.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_readout::Receiver();
 }

examples/readout/runSender.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("input-name", bpo::value<std::string>()->default_value("bs"), "Input channel name");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_readout::Sender();
 }

examples/region/Sampler.cxx

@@ -32,16 +32,15 @@ Sampler::Sampler()
 
 void Sampler::InitTask()
 {
-    fMsgSize = fConfig->GetValue<int>("msg-size");
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMsgSize = fConfig->GetProperty<int>("msg-size");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 
     fRegion = FairMQUnmanagedRegionPtr(NewUnmanagedRegionFor("data",
                                                              0,
                                                              10000000,
                                                              [this](void* /*data*/, size_t /*size*/, void* /*hint*/) { // callback to be called when message buffers no longer needed by transport
                                                                  --fNumUnackedMsgs;
-                                                                 if (fMaxIterations > 0)
-                                                                 {
+                                                                 if (fMaxIterations > 0) {
                                                                      LOG(debug) << "Received ack";
                                                                  }
                                                              }
@@ -58,12 +57,14 @@ bool Sampler::ConditionalRun()
                                         nullptr // hint
                                         ));
 
-    if (Send(msg, "data", 0) > 0)
-    {
+    // static_cast<char*>(fRegion->GetData())[3] = 97;
+    // LOG(info) << "check: " << static_cast<char*>(fRegion->GetData())[3];
+    // std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    if (Send(msg, "data", 0) > 0) {
         ++fNumUnackedMsgs;
 
-        if (fMaxIterations > 0 && ++fNumIterations >= fMaxIterations)
-        {
+        if (fMaxIterations > 0 && ++fNumIterations >= fMaxIterations) {
             LOG(info) << "Configured maximum number of iterations reached. Leaving RUNNING state.";
             return false;
         }
@@ -75,8 +76,7 @@ bool Sampler::ConditionalRun()
 void Sampler::ResetTask()
 {
     // if not all messages acknowledged, wait for a bit. But only once, since receiver could be already dead.
-    if (fNumUnackedMsgs != 0)
-    {
+    if (fNumUnackedMsgs != 0) {
         LOG(debug) << "waiting for all acknowledgements... (" << fNumUnackedMsgs << ")";
         this_thread::sleep_for(chrono::milliseconds(500));
         LOG(debug) << "done, still unacked: " << fNumUnackedMsgs;

examples/region/Sink.cxx

@@ -28,21 +28,22 @@ Sink::Sink()
 void Sink::InitTask()
 {
     // Get the fMaxIterations value from the command line options (via fConfig)
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 void Sink::Run()
 {
     FairMQChannel& dataInChannel = fChannels.at("data").at(0);
 
-    while (!NewStatePending())
-    {
+    while (!NewStatePending()) {
         FairMQMessagePtr msg(dataInChannel.Transport()->CreateMessage());
         dataInChannel.Receive(msg);
-        // void* ptr = msg->GetData();
 
-        if (fMaxIterations > 0 && ++fNumIterations >= fMaxIterations)
-        {
+        // void* ptr = msg->GetData();
+        // char* cptr = static_cast<char*>(ptr);
+        // LOG(info) << "check: " << cptr[3];
+
+        if (fMaxIterations > 0 && ++fNumIterations >= fMaxIterations) {
             LOG(info) << "Configured maximum number of iterations reached. Leaving RUNNING state.";
             break;
         }

examples/region/runSampler.cxx

@@ -18,7 +18,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_region::Sampler();
 }

examples/region/runSink.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_region::Sink();
 }

examples/req-rep/Client.cxx

@@ -31,8 +31,8 @@ Client::Client()
 
 void Client::InitTask()
 {
-    fText = fConfig->GetValue<string>("text");
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fText = fConfig->GetProperty<string>("text");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 bool Client::ConditionalRun()

examples/req-rep/Server.cxx

@@ -29,7 +29,7 @@ Server::Server()
 void Server::InitTask()
 {
     // Get the fMaxIterations value from the command line options (via fConfig)
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
 bool Server::HandleData(FairMQMessagePtr& req, int /*index*/)

examples/req-rep/runClient.cxx

@@ -18,7 +18,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_req_rep::Client();
 }

examples/req-rep/runServer.cxx

@@ -17,7 +17,7 @@ void addCustomOptions(bpo::options_description& options)
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)
+FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
 {
     return new example_req_rep::Server();
 }

fairmq/CMakeLists.txt

@@ -16,327 +16,450 @@ if(BUILD_PMIX_PLUGIN)
   add_subdirectory(plugins/PMIx)
 endif()
 
-
-##########################
-# libFairMQ header files #
-##########################
-set(FAIRMQ_PUBLIC_HEADER_FILES
-  DeviceRunner.h
-  EventManager.h
-  FairMQChannel.h
-  FairMQDevice.h
-  FairMQLogger.h
-  FairMQMessage.h
-  FairMQParts.h
-  FairMQPoller.h
-  FairMQUnmanagedRegion.h
-  FairMQSocket.h
-  StateMachine.h
-  FairMQTransportFactory.h
-  MemoryResources.h
-  MemoryResourceTools.h
-  Tools.h
-  Transports.h
-  options/FairMQProgOptions.h
-  options/FairProgOptions.h
-  Plugin.h
-  PluginManager.h
-  PluginServices.h
-  runFairMQDevice.h
-  tools/CppSTL.h
-  tools/Network.h
-  tools/Process.h
-  tools/RateLimit.h
-  tools/Strings.h
-  tools/Unique.h
-  tools/Version.h
-)
-
-set(FAIRMQ_PRIVATE_HEADER_FILES
-  devices/FairMQBenchmarkSampler.h
-  devices/FairMQMerger.h
-  devices/FairMQMultiplier.h
-  devices/FairMQProxy.h
-  devices/FairMQSink.h
-  devices/FairMQSplitter.h
-  options/FairMQParser.h
-  options/FairMQSuboptParser.h
-  options/FairProgOptionsHelper.h
-  plugins/Builtin.h
-  plugins/Control.h
-  shmem/FairMQMessageSHM.h
-  shmem/FairMQPollerSHM.h
-  shmem/FairMQUnmanagedRegionSHM.h
-  shmem/FairMQSocketSHM.h
-  shmem/FairMQTransportFactorySHM.h
-  shmem/Common.h
-  shmem/Manager.h
-  shmem/Region.h
-  zeromq/FairMQMessageZMQ.h
-  zeromq/FairMQPollerZMQ.h
-  zeromq/FairMQUnmanagedRegionZMQ.h
-  zeromq/FairMQSocketZMQ.h
-  zeromq/FairMQTransportFactoryZMQ.h
-)
-
-if(BUILD_NANOMSG_TRANSPORT)
-  set(FAIRMQ_PRIVATE_HEADER_FILES ${FAIRMQ_PRIVATE_HEADER_FILES}
-    nanomsg/FairMQMessageNN.h
-    nanomsg/FairMQPollerNN.h
-    nanomsg/FairMQUnmanagedRegionNN.h
-    nanomsg/FairMQSocketNN.h
-    nanomsg/FairMQTransportFactoryNN.h
+if(BUILD_FAIRMQ OR BUILD_SDK)
+  ###########
+  # Version #
+  ###########
+  configure_file(Version.h.in
+    ${CMAKE_BINARY_DIR}/${PROJECT_NAME_LOWER}/Version.h
+    @ONLY
   )
-endif()
-
-if(BUILD_OFI_TRANSPORT)
-  set(FAIRMQ_PRIVATE_HEADER_FILES ${FAIRMQ_PRIVATE_HEADER_FILES}
-    ofi/Context.h
-    ofi/Message.h
-    ofi/Poller.h
-    ofi/Socket.h
-    ofi/TransportFactory.h
+  install(FILES ${CMAKE_BINARY_DIR}/${PROJECT_NAME_LOWER}/Version.h
+    DESTINATION ${PROJECT_INSTALL_INCDIR}
   )
-endif()
 
-##########################
-# libFairMQ source files #
-##########################
-set(FAIRMQ_SOURCE_FILES
-  DeviceRunner.cxx
-  FairMQChannel.cxx
-  FairMQDevice.cxx
-  FairMQLogger.cxx
-  FairMQMessage.cxx
-  FairMQPoller.cxx
-  FairMQSocket.cxx
-  StateMachine.cxx
-  FairMQTransportFactory.cxx
-  devices/FairMQBenchmarkSampler.cxx
-  devices/FairMQMerger.cxx
-  devices/FairMQMultiplier.cxx
-  devices/FairMQProxy.cxx
-  devices/FairMQSplitter.cxx
-  options/FairMQParser.cxx
-  options/FairMQProgOptions.cxx
-  options/FairMQSuboptParser.cxx
-  Plugin.cxx
-  PluginManager.cxx
-  PluginServices.cxx
-  plugins/Control.cxx
-  shmem/FairMQMessageSHM.cxx
-  shmem/FairMQPollerSHM.cxx
-  shmem/FairMQUnmanagedRegionSHM.cxx
-  shmem/FairMQSocketSHM.cxx
-  shmem/FairMQTransportFactorySHM.cxx
-  shmem/Manager.cxx
-  shmem/Region.cxx
-  tools/Network.cxx
-  tools/Process.cxx
-  tools/Unique.cxx
-  zeromq/FairMQMessageZMQ.cxx
-  zeromq/FairMQPollerZMQ.cxx
-  zeromq/FairMQUnmanagedRegionZMQ.cxx
-  zeromq/FairMQSocketZMQ.cxx
-  zeromq/FairMQTransportFactoryZMQ.cxx
-  MemoryResources.cxx
-)
+  #########
+  # Tools #
+  #########
+  set(target Tools)
 
-if(BUILD_NANOMSG_TRANSPORT)
-  set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
-    nanomsg/FairMQMessageNN.cxx
-    nanomsg/FairMQPollerNN.cxx
-    nanomsg/FairMQUnmanagedRegionNN.cxx
-    nanomsg/FairMQSocketNN.cxx
-    nanomsg/FairMQTransportFactoryNN.cxx
+  set(TOOLS_PUBLIC_HEADER_FILES
+    tools/CppSTL.h
+    tools/InstanceLimit.h
+    tools/Network.h
+    tools/Process.h
+    tools/RateLimit.h
+    tools/Semaphore.h
+    tools/Strings.h
+    tools/Unique.h
+    tools/Version.h
+    Tools.h
   )
-endif()
 
-if(BUILD_OFI_TRANSPORT)
-  set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
-    ofi/Context.cxx
-    ofi/Message.cxx
-    ofi/Poller.cxx
-    ofi/Socket.cxx
-    ofi/TransportFactory.cxx
+  set(TOOLS_SOURCE_FILES
+    tools/Network.cxx
+    tools/Process.cxx
+    tools/Semaphore.cxx
+    tools/Unique.cxx
   )
+
+  add_library(${target}
+    ${TOOLS_SOURCE_FILES}
+    ${TOOLS_PUBLIC_HEADER_FILES}
+  )
+  target_compile_definitions(${target} PUBLIC BOOST_ERROR_CODE_HEADER_ONLY)
+  target_include_directories(${target}
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
+    $<INSTALL_INTERFACE:include>
+  )
+  target_link_libraries(${target}
+    PRIVATE
+    FairLogger::FairLogger
+    PUBLIC
+    Boost::boost
+  )
+  set_target_properties(${target} PROPERTIES
+    VERSION ${PROJECT_GIT_VERSION}
+    SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
+    OUTPUT_NAME FairMQ${target}
+  )
+  install(
+    TARGETS ${target}
+    EXPORT ${PROJECT_EXPORT_SET}
+    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  )
+  foreach(HEADER ${TOOLS_PUBLIC_HEADER_FILES})
+    get_filename_component(_path ${HEADER} DIRECTORY)
+    file(TO_CMAKE_PATH ${PROJECT_INSTALL_INCDIR}/${_path} _destination)
+    install(FILES ${HEADER}
+      DESTINATION ${_destination}
+    )
+  endforeach()
+
+  #################
+  # State Machine #
+  #################
+  set(target StateMachine)
+
+  set(FSM_PUBLIC_HEADER_FILES
+    StateMachine.h
+    States.h
+    StateQueue.h
+  )
+
+  set(FSM_SOURCE_FILES
+    StateMachine.cxx
+    States.cxx
+  )
+
+  add_library(${target}
+    ${FSM_SOURCE_FILES}
+    ${FSM_PUBLIC_HEADER_FILES}
+  )
+  target_compile_definitions(${target} PUBLIC BOOST_ERROR_CODE_HEADER_ONLY)
+  target_include_directories(${target}
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
+    $<INSTALL_INTERFACE:include>
+  )
+  target_link_libraries(${target}
+    PUBLIC
+    FairLogger::FairLogger
+
+    PRIVATE
+    Boost::boost
+    Tools
+  )
+  set_target_properties(${target} PROPERTIES
+    VERSION ${PROJECT_GIT_VERSION}
+    SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
+    OUTPUT_NAME FairMQ${target}
+  )
+  install(
+    TARGETS ${target}
+    EXPORT ${PROJECT_EXPORT_SET}
+    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  )
+  foreach(HEADER ${FSM_PUBLIC_HEADER_FILES})
+    get_filename_component(_path ${HEADER} DIRECTORY)
+    file(TO_CMAKE_PATH ${PROJECT_INSTALL_INCDIR}/${_path} _destination)
+    install(FILES ${HEADER}
+      DESTINATION ${_destination}
+    )
+  endforeach()
 endif()
 
+if(BUILD_FAIRMQ)
+  ##########################
+  # libFairMQ header files #
+  ##########################
+  set(FAIRMQ_PUBLIC_HEADER_FILES
+    DeviceRunner.h
+    EventManager.h
+    FairMQChannel.h
+    FairMQDevice.h
+    FairMQLogger.h
+    FairMQMessage.h
+    FairMQParts.h
+    FairMQPoller.h
+    FairMQUnmanagedRegion.h
+    FairMQSocket.h
+    FairMQTransportFactory.h
+    MemoryResources.h
+    MemoryResourceTools.h
+    Transports.h
+    options/FairMQProgOptions.h
+    JSONParser.h
+    ProgOptionsFwd.h
+    ProgOptions.h
+    Properties.h
+    PropertyOutput.h
+    SuboptParser.h
+    Plugin.h
+    PluginManager.h
+    PluginServices.h
+    runFairMQDevice.h
+  )
 
-###################
-# configure files #
-###################
-set(FAIRMQ_BIN_DIR ${CMAKE_BINARY_DIR}/fairmq)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/run/startMQBenchmark.sh.in ${CMAKE_CURRENT_BINARY_DIR}/startMQBenchmark.sh)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/options/startConfigExample.sh.in ${CMAKE_CURRENT_BINARY_DIR}/startConfigExample.sh)
+  set(FAIRMQ_PRIVATE_HEADER_FILES
+    devices/FairMQBenchmarkSampler.h
+    devices/FairMQMerger.h
+    devices/FairMQMultiplier.h
+    devices/FairMQProxy.h
+    devices/FairMQSink.h
+    devices/FairMQSplitter.h
+    plugins/Builtin.h
+    plugins/config/Config.h
+    plugins/Control.h
+    shmem/FairMQMessageSHM.h
+    shmem/FairMQPollerSHM.h
+    shmem/FairMQUnmanagedRegionSHM.h
+    shmem/FairMQSocketSHM.h
+    shmem/FairMQTransportFactorySHM.h
+    shmem/Common.h
+    shmem/Manager.h
+    shmem/Region.h
+    zeromq/FairMQMessageZMQ.h
+    zeromq/FairMQPollerZMQ.h
+    zeromq/FairMQUnmanagedRegionZMQ.h
+    zeromq/FairMQSocketZMQ.h
+    zeromq/FairMQTransportFactoryZMQ.h
+  )
+
+  if(BUILD_NANOMSG_TRANSPORT)
+    set(FAIRMQ_PRIVATE_HEADER_FILES ${FAIRMQ_PRIVATE_HEADER_FILES}
+      nanomsg/FairMQMessageNN.h
+      nanomsg/FairMQPollerNN.h
+      nanomsg/FairMQUnmanagedRegionNN.h
+      nanomsg/FairMQSocketNN.h
+      nanomsg/FairMQTransportFactoryNN.h
+    )
+  endif()
+
+  if(BUILD_OFI_TRANSPORT)
+    set(FAIRMQ_PRIVATE_HEADER_FILES ${FAIRMQ_PRIVATE_HEADER_FILES}
+      ofi/Context.h
+      ofi/Message.h
+      ofi/Poller.h
+      ofi/Socket.h
+      ofi/TransportFactory.h
+    )
+  endif()
+
+  ##########################
+  # libFairMQ source files #
+  ##########################
+  set(FAIRMQ_SOURCE_FILES
+    DeviceRunner.cxx
+    FairMQChannel.cxx
+    FairMQDevice.cxx
+    FairMQLogger.cxx
+    FairMQMessage.cxx
+    FairMQPoller.cxx
+    FairMQSocket.cxx
+    FairMQTransportFactory.cxx
+    devices/FairMQBenchmarkSampler.cxx
+    devices/FairMQMerger.cxx
+    devices/FairMQMultiplier.cxx
+    devices/FairMQProxy.cxx
+    devices/FairMQSplitter.cxx
+    Plugin.cxx
+    PluginManager.cxx
+    PluginServices.cxx
+    ProgOptions.cxx
+    JSONParser.cxx
+    Properties.cxx
+    SuboptParser.cxx
+    plugins/config/Config.cxx
+    plugins/Control.cxx
+    shmem/FairMQMessageSHM.cxx
+    shmem/FairMQPollerSHM.cxx
+    shmem/FairMQUnmanagedRegionSHM.cxx
+    shmem/FairMQSocketSHM.cxx
+    shmem/FairMQTransportFactorySHM.cxx
+    shmem/Manager.cxx
+    shmem/Region.cxx
+    zeromq/FairMQMessageZMQ.cxx
+    zeromq/FairMQPollerZMQ.cxx
+    zeromq/FairMQUnmanagedRegionZMQ.cxx
+    zeromq/FairMQSocketZMQ.cxx
+    zeromq/FairMQTransportFactoryZMQ.cxx
+    MemoryResources.cxx
+  )
+
+  if(BUILD_NANOMSG_TRANSPORT)
+    set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
+      nanomsg/FairMQMessageNN.cxx
+      nanomsg/FairMQPollerNN.cxx
+      nanomsg/FairMQUnmanagedRegionNN.cxx
+      nanomsg/FairMQSocketNN.cxx
+      nanomsg/FairMQTransportFactoryNN.cxx
+    )
+  endif()
+
+  if(BUILD_OFI_TRANSPORT)
+    set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
+      ofi/Context.cxx
+      ofi/Message.cxx
+      ofi/Poller.cxx
+      ofi/Socket.cxx
+      ofi/TransportFactory.cxx
+    )
+  endif()
 
 
-#################################
-# define libFairMQ build target #
-#################################
-if(FAST_BUILD)
-  set(_target FairMQ_)
-else()
-  set(_target FairMQ)
-endif()
-add_library(${_target}
-  ${FAIRMQ_SOURCE_FILES}
-  ${FAIRMQ_PUBLIC_HEADER_FILES} # for IDE integration
-  ${FAIRMQ_PRIVATE_HEADER_FILES} # for IDE integration
-)
-set_target_properties(${_target} PROPERTIES LABELS coverage)
-if(FAST_BUILD)
-  set_target_properties(${_target} PROPERTIES OUTPUT_NAME FairMQ)
-endif()
+  ###################
+  # configure files #
+  ###################
+  set(FAIRMQ_BIN_DIR ${CMAKE_BINARY_DIR}/fairmq)
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/run/startMQBenchmark.sh.in ${CMAKE_CURRENT_BINARY_DIR}/startMQBenchmark.sh)
+
+  #################################
+  # define libFairMQ build target #
+  #################################
+  if(FAST_BUILD)
+    set(_target FairMQ_)
+  else()
+    set(_target FairMQ)
+  endif()
+  add_library(${_target}
+    ${FAIRMQ_SOURCE_FILES}
+    ${FAIRMQ_PUBLIC_HEADER_FILES} # for IDE integration
+    ${FAIRMQ_PRIVATE_HEADER_FILES} # for IDE integration
+  )
+  set_target_properties(${_target} PROPERTIES LABELS coverage)
+  if(FAST_BUILD)
+    set_target_properties(${_target} PROPERTIES OUTPUT_NAME FairMQ)
+  endif()
 
 
-############################
-# preprocessor definitions #
-############################
-target_compile_definitions(${_target} PUBLIC BOOST_ERROR_CODE_HEADER_ONLY)
-if(BUILD_NANOMSG_TRANSPORT)
-  target_compile_definitions(${_target} PRIVATE BUILD_NANOMSG_TRANSPORT)
-endif()
-if(BUILD_OFI_TRANSPORT)
-  target_compile_definitions(${_target} PRIVATE BUILD_OFI_TRANSPORT)
-endif()
+  ############################
+  # preprocessor definitions #
+  ############################
+  target_compile_definitions(${_target} PUBLIC BOOST_ERROR_CODE_HEADER_ONLY)
+  if(BUILD_NANOMSG_TRANSPORT)
+    target_compile_definitions(${_target} PRIVATE BUILD_NANOMSG_TRANSPORT)
+  endif()
+  if(BUILD_OFI_TRANSPORT)
+    target_compile_definitions(${_target} PRIVATE BUILD_OFI_TRANSPORT)
+  endif()
 
 
-#######################
-# include directories #
-#######################
-target_include_directories(${_target}
-  PUBLIC # consumers inherit public include directories
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-  $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
-  $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}>
-  $<INSTALL_INTERFACE:include/fairmq>
-  $<INSTALL_INTERFACE:include>
-)
+  #######################
+  # include directories #
+  #######################
+  target_include_directories(${_target}
+    PUBLIC # consumers inherit public include directories
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}>
+    $<INSTALL_INTERFACE:include/fairmq>
+    $<INSTALL_INTERFACE:include>
+  )
 
-##################
-# link libraries #
-##################
-if(BUILD_NANOMSG_TRANSPORT)
-  set(NANOMSG_DEPS nanomsg msgpackc-cxx)
-endif()
-if(BUILD_OFI_TRANSPORT)
-  set(OFI_DEPS
-    asiofi::asiofi
+  ##################
+  # link libraries #
+  ##################
+  if(BUILD_NANOMSG_TRANSPORT)
+    set(NANOMSG_DEPS nanomsg msgpackc-cxx)
+  endif()
+  if(BUILD_OFI_TRANSPORT)
+    set(OFI_DEPS
+      asiofi::asiofi
+      Boost::container
+    )
+  endif()
+  set(optional_deps ${NANOMSG_DEPS} ${OFI_DEPS})
+  if(optional_deps)
+    list(REMOVE_DUPLICATES optional_deps)
+  endif()
+
+  target_link_libraries(${_target}
+    INTERFACE # only consumers link against interface dependencies
     Boost::container
+
+    PUBLIC # libFairMQ AND consumers of libFairMQ link aginst public dependencies
+    Threads::Threads
+    dl
+    $<$<PLATFORM_ID:Linux>:rt>
+    Boost::boost
+    Boost::program_options
+    Boost::filesystem
+    Boost::regex
+    FairLogger::FairLogger
+    Tools
+    StateMachine
+
+    PRIVATE # only libFairMQ links against private dependencies
+    libzmq
+    ${NANOMSG_DEPS}
+    ${OFI_DEPS}
   )
-endif()
-set(optional_deps ${NANOMSG_DEPS} ${OFI_DEPS})
-if(optional_deps)
-  list(REMOVE_DUPLICATES optional_deps)
-endif()
-
-target_link_libraries(${_target}
-  INTERFACE # only consumers link against interface dependencies
-  Boost::container
-
-  PUBLIC # libFairMQ AND consumers of libFairMQ link aginst public dependencies
-  Threads::Threads
-  dl
-  $<$<PLATFORM_ID:Linux>:rt>
-  Boost::boost
-  Boost::program_options
-  Boost::filesystem
-  Boost::regex
-  FairLogger::FairLogger
-
-  PRIVATE # only libFairMQ links against private dependencies
-  libzmq
-  ${NANOMSG_DEPS}
-  ${OFI_DEPS}
-)
-set_target_properties(${_target} PROPERTIES
-  VERSION ${PROJECT_GIT_VERSION}
-  SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
-)
-
-
-##############
-# fast build #
-##############
-if(FAST_BUILD)
   set_target_properties(${_target} PROPERTIES
-    COTIRE_UNITY_TARGET_NAME "FairMQ"
-    # COTIRE_ENABLE_PRECOMPILED_HEADER FALSE
-    EXCLUDE_FROM_ALL TRUE
+    VERSION ${PROJECT_GIT_VERSION}
+    SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
   )
-  cotire(${_target})
-  set_target_properties(FairMQ PROPERTIES EXCLUDE_FROM_ALL FALSE)
-  set_target_properties(FairMQ PROPERTIES LABELS coverage)
+
+
+  ##############
+  # fast build #
+  ##############
+  if(FAST_BUILD)
+    set_target_properties(${_target} PROPERTIES
+      COTIRE_UNITY_TARGET_NAME "FairMQ"
+      # COTIRE_ENABLE_PRECOMPILED_HEADER FALSE
+      EXCLUDE_FROM_ALL TRUE
+    )
+    cotire(${_target})
+    set_target_properties(FairMQ PROPERTIES EXCLUDE_FROM_ALL FALSE)
+    set_target_properties(FairMQ PROPERTIES LABELS coverage)
+  endif()
+
+
+  ###############
+  # executables #
+  ###############
+  add_executable(fairmq-bsampler run/runBenchmarkSampler.cxx)
+  target_link_libraries(fairmq-bsampler FairMQ)
+
+  add_executable(fairmq-merger run/runMerger.cxx)
+  target_link_libraries(fairmq-merger FairMQ)
+
+  add_executable(fairmq-multiplier run/runMultiplier.cxx)
+  target_link_libraries(fairmq-multiplier FairMQ)
+
+  add_executable(fairmq-proxy run/runProxy.cxx)
+  target_link_libraries(fairmq-proxy FairMQ)
+
+  add_executable(fairmq-sink run/runSink.cxx)
+  target_link_libraries(fairmq-sink FairMQ)
+
+  add_executable(fairmq-splitter run/runSplitter.cxx)
+  target_link_libraries(fairmq-splitter FairMQ)
+
+  add_executable(fairmq-shmmonitor shmem/Monitor.cxx shmem/Monitor.h shmem/runMonitor.cxx)
+  target_compile_definitions(fairmq-shmmonitor PUBLIC BOOST_ERROR_CODE_HEADER_ONLY)
+  target_link_libraries(fairmq-shmmonitor PUBLIC
+    Threads::Threads
+    $<$<PLATFORM_ID:Linux>:rt>
+    Boost::boost
+    Boost::date_time
+    Boost::program_options
+  )
+  target_include_directories(fairmq-shmmonitor PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
+  )
+
+  add_executable(fairmq-uuid-gen run/runUuidGenerator.cxx)
+  target_link_libraries(fairmq-uuid-gen FairMQ)
+
+
+  ###########
+  # install #
+  ###########
+  install(
+    TARGETS
+    FairMQ
+    fairmq-bsampler
+    fairmq-merger
+    fairmq-multiplier
+    fairmq-proxy
+    fairmq-sink
+    fairmq-splitter
+    fairmq-shmmonitor
+    fairmq-uuid-gen
+
+    EXPORT ${PROJECT_EXPORT_SET}
+    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  )
+
+  # preserve relative path and prepend fairmq
+  foreach(HEADER ${FAIRMQ_PUBLIC_HEADER_FILES})
+    get_filename_component(_path ${HEADER} DIRECTORY)
+    file(TO_CMAKE_PATH ${PROJECT_INSTALL_INCDIR}/${_path} _destination)
+    install(FILES ${HEADER}
+      DESTINATION ${_destination}
+    )
+  endforeach()
 endif()
 
-
-###############
-# executables #
-###############
-add_executable(fairmq-bsampler run/runBenchmarkSampler.cxx)
-target_link_libraries(fairmq-bsampler FairMQ)
-
-add_executable(fairmq-merger run/runMerger.cxx)
-target_link_libraries(fairmq-merger FairMQ)
-
-add_executable(fairmq-multiplier run/runMultiplier.cxx)
-target_link_libraries(fairmq-multiplier FairMQ)
-
-add_executable(fairmq-proxy run/runProxy.cxx)
-target_link_libraries(fairmq-proxy FairMQ)
-
-add_executable(fairmq-sink run/runSink.cxx)
-target_link_libraries(fairmq-sink FairMQ)
-
-add_executable(fairmq-splitter run/runSplitter.cxx)
-target_link_libraries(fairmq-splitter FairMQ)
-
-add_executable(runConfigExample options/runConfigEx.cxx)
-target_link_libraries(runConfigExample FairMQ)
-
-add_executable(fairmq-shmmonitor shmem/Monitor.cxx shmem/Monitor.h shmem/runMonitor.cxx)
-target_link_libraries(fairmq-shmmonitor PUBLIC
-  Threads::Threads
-  $<$<PLATFORM_ID:Linux>:rt>
-  Boost::boost
-  Boost::date_time
-  Boost::program_options
-)
-target_include_directories(fairmq-shmmonitor PUBLIC
-  $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
-)
-
-add_executable(fairmq-uuid-gen run/runUuidGenerator.cxx)
-target_link_libraries(fairmq-uuid-gen FairMQ)
-
-
-###########
-# install #
-###########
-install(
-  TARGETS
-  FairMQ
-  fairmq-bsampler
-  fairmq-merger
-  fairmq-multiplier
-  fairmq-proxy
-  fairmq-sink
-  fairmq-splitter
-  fairmq-shmmonitor
-  fairmq-uuid-gen
-
-  EXPORT ${PROJECT_EXPORT_SET}
-  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
-  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-  ARCHIVE DESTINATION ${PROJECT_INSTALL_LIBDIR}
-)
-
-# preserve relative path and prepend fairmq
-foreach(HEADER ${FAIRMQ_PUBLIC_HEADER_FILES})
-  get_filename_component(_path ${HEADER} DIRECTORY)
-  file(TO_CMAKE_PATH ${PROJECT_INSTALL_INCDIR}/${_path} _destination)
-  install(FILES ${HEADER}
-    DESTINATION ${_destination}
-  )
-endforeach()
+if(BUILD_SDK)
+  add_subdirectory(sdk)
+endif()

fairmq/DeviceRunner.cxx

@@ -12,9 +12,10 @@
 #include <fairmq/Tools.h>
 #include <fairmq/Version.h>
 
+using namespace std;
 using namespace fair::mq;
 
-DeviceRunner::DeviceRunner(int argc, char* const argv[], bool printLogo)
+DeviceRunner::DeviceRunner(int argc, char*const* argv, bool printLogo)
     : fRawCmdLineArgs(tools::ToStrVector(argc, argv, false))
     , fConfig()
     , fDevice(nullptr)
@@ -23,8 +24,80 @@ DeviceRunner::DeviceRunner(int argc, char* const argv[], bool printLogo)
     , fEvents()
 {}
 
+bool DeviceRunner::HandleGeneralOptions(const fair::mq::ProgOptions& config, bool printLogo)
+{
+    if (config.Count("help")) {
+        config.PrintHelp();
+        return false;
+    }
+
+    if (config.Count("print-options")) {
+        config.PrintOptionsRaw();
+        return false;
+    }
+
+    if (config.Count("print-channels") || config.Count("version")) {
+        fair::Logger::SetConsoleSeverity("nolog");
+    } else {
+        string severity = config.GetProperty<string>("severity");
+        string logFile = config.GetProperty<string>("log-to-file");
+        string logFileSeverity = config.GetProperty<string>("file-severity");
+        bool color = config.GetProperty<bool>("color");
+
+        string verbosity = config.GetProperty<string>("verbosity");
+        fair::Logger::SetVerbosity(verbosity);
+
+        if (logFile != "") {
+            fair::Logger::InitFileSink(logFileSeverity, logFile);
+            fair::Logger::SetConsoleSeverity("nolog");
+        } else {
+            fair::Logger::SetConsoleColor(color);
+            fair::Logger::SetConsoleSeverity(severity);
+        }
+
+        if (printLogo) {
+            LOG(info) << endl
+                << "      ______      _    _______  _________ " << endl
+                << "     / ____/___ _(_)_______   |/  /_  __ \\    version " << FAIRMQ_GIT_VERSION << endl
+                << "    / /_  / __ `/ / ___/__  /|_/ /_  / / /    build " << FAIRMQ_BUILD_TYPE << endl
+                << "   / __/ / /_/ / / /    _  /  / / / /_/ /     " << FAIRMQ_REPO_URL << endl
+                << "  /_/    \\__,_/_/_/     /_/  /_/  \\___\\_\\     " << FAIRMQ_LICENSE << "  © " << FAIRMQ_COPYRIGHT << endl;
+        }
+    }
+
+    return true;
+}
+
+void DeviceRunner::SubscribeForConfigChange()
+{
+    fConfig.Subscribe<bool>("device-runner", [](const std::string& key, const bool val) {
+        if (key == "color") {
+            fair::Logger::SetConsoleColor(val);
+        }
+    });
+    fConfig.Subscribe<string>("device-runner", [&](const std::string& key, const std::string val) {
+        if (key == "severity") {
+            fair::Logger::SetConsoleSeverity(val);
+        } else if (key == "file-severity") {
+            fair::Logger::SetFileSeverity(val);
+        } else if (key == "verbosity") {
+            fair::Logger::SetVerbosity(val);
+        } else if (key == "log-to-file") {
+            string fileSeverity = fConfig.GetProperty<string>("file-severity");
+            fair::Logger::InitFileSink(fileSeverity, val);
+        }
+    });
+}
+void DeviceRunner::UnsubscribeFromConfigChange()
+{
+    fConfig.Unsubscribe<bool>("device-runner");
+    fConfig.Unsubscribe<string>("device-runner");
+}
+
 auto DeviceRunner::Run() -> int
 {
+    fPluginManager.LoadPlugin("s:config");
+
     ////// CALL HOOK ///////
     fEvents.Emit<hooks::LoadPlugins>(*this);
     ////////////////////////
@@ -36,28 +109,25 @@ auto DeviceRunner::Run() -> int
     fEvents.Emit<hooks::SetCustomCmdLineOptions>(*this);
     ////////////////////////
 
-    fPluginManager.ForEachPluginProgOptions(
-        [&](boost::program_options::options_description options) {
-            fConfig.AddToCmdLineOptions(options);
-        });
+    fPluginManager.ForEachPluginProgOptions([&](boost::program_options::options_description options) {
+        fConfig.AddToCmdLineOptions(options);
+    });
     fConfig.AddToCmdLineOptions(fPluginManager.ProgramOptions());
 
     ////// CALL HOOK ///////
     fEvents.Emit<hooks::ModifyRawCmdLineArgs>(*this);
     ////////////////////////
 
-    if (fConfig.ParseAll(fRawCmdLineArgs, true)) {
+    fConfig.ParseAll(fRawCmdLineArgs, true);
+
+    if (!HandleGeneralOptions(fConfig)) {
         return 0;
     }
 
-    if (fPrintLogo) {
-        LOG(info) << std::endl
-                  << "      ______      _    _______  _________ " << std::endl
-                  << "     / ____/___ _(_)_______   |/  /_  __ \\    version " << FAIRMQ_GIT_VERSION << std::endl
-                  << "    / /_  / __ `/ / ___/__  /|_/ /_  / / /    build " << FAIRMQ_BUILD_TYPE << std::endl
-                  << "   / __/ / /_/ / / /    _  /  / / / /_/ /     " << FAIRMQ_REPO_URL << std::endl
-                  << "  /_/    \\__,_/_/_/     /_/  /_/  \\___\\_\\     " << FAIRMQ_LICENSE << "  © " << FAIRMQ_COPYRIGHT << std::endl;
-    }
+    fConfig.Notify();
+
+    // handle configuration updates (for general options)
+    SubscribeForConfigChange();
 
     ////// CALL HOOK ///////
     fEvents.Emit<hooks::InstantiateDevice>(*this);
@@ -80,7 +150,8 @@ auto DeviceRunner::Run() -> int
 
     // Handle --version
     if (fConfig.Count("version")) {
-        std::cout << "User device version: " << fDevice->GetVersion() << std::endl;
+        cout << "FairMQ version: " << FAIRMQ_GIT_VERSION << endl;
+        cout << "User device version: " << fDevice->GetVersion() << endl;
         fDevice->ChangeState(fair::mq::Transition::End);
         return 0;
     }
@@ -96,12 +167,18 @@ auto DeviceRunner::Run() -> int
     // Instantiate and run plugins
     fPluginManager.InstantiatePlugins();
 
+    // Log IDLE configuration
+    fConfig.PrintOptions();
+
     // Run the device
     fDevice->RunStateMachine();
 
     // Wait for control plugin to release device control
     fPluginManager.WaitForPluginsToReleaseDeviceControl();
 
+    // stop handling configuration updates (for general options)
+    UnsubscribeFromConfigChange();
+
     return 0;
 }
 
@@ -109,7 +186,7 @@ auto DeviceRunner::RunWithExceptionHandlers() -> int
 {
     try {
         return Run();
-    } catch (std::exception& e) {
+    } catch (exception& e) {
         LOG(error) << "Uncaught exception reached the top of DeviceRunner: " << e.what();
         return 1;
     } catch (...) {

fairmq/DeviceRunner.h

@@ -11,9 +11,9 @@
 
 #include <fairmq/EventManager.h>
 #include <fairmq/PluginManager.h>
+#include <fairmq/ProgOptions.h>
 #include <FairMQDevice.h>
 #include <FairMQLogger.h>
-#include <options/FairMQProgOptions.h>
 
 #include <functional>
 #include <memory>
@@ -51,11 +51,16 @@ namespace mq {
 class DeviceRunner
 {
   public:
-    DeviceRunner(int argc, char* const argv[], bool printLogo = true);
+    DeviceRunner(int argc, char*const* argv, bool printLogo = true);
 
     auto Run() -> int;
     auto RunWithExceptionHandlers() -> int;
 
+    static bool HandleGeneralOptions(const fair::mq::ProgOptions& config, bool printLogo = true);
+
+    void SubscribeForConfigChange();
+    void UnsubscribeFromConfigChange();
+
     template<typename H>
     auto AddHook(std::function<void(DeviceRunner&)> hook) -> void
     {
@@ -68,7 +73,7 @@ class DeviceRunner
     }
 
     std::vector<std::string> fRawCmdLineArgs;
-    FairMQProgOptions fConfig;
+    fair::mq::ProgOptions fConfig;
     std::unique_ptr<FairMQDevice> fDevice;
     PluginManager fPluginManager;
     const bool fPrintLogo;

fairmq/FairMQChannel.cxx

@@ -5,64 +5,113 @@
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
-/**
- * FairMQChannel.cxx
- *
- * @since 2015-06-02
- * @author A. Rybalchenko
- */
 
 #include "FairMQChannel.h"
 #include <fairmq/Tools.h>
 
 #include <boost/algorithm/string.hpp> // join/split
 
+#include <regex>
 #include <set>
 #include <random>
 
 using namespace std;
+using namespace fair::mq;
 
-mutex FairMQChannel::fChannelMutex;
+template<typename T>
+T GetPropertyOrDefault(const fair::mq::Properties& m, const string& k, const T& ifNotFound) noexcept
+{
+    if (m.count(k)) {
+        return boost::any_cast<T>(m.at(k));
+    }
+    return ifNotFound;
+}
+
+constexpr fair::mq::Transport FairMQChannel::DefaultTransportType;
+constexpr const char* FairMQChannel::DefaultTransportName;
+constexpr const char* FairMQChannel::DefaultName;
+constexpr const char* FairMQChannel::DefaultType;
+constexpr const char* FairMQChannel::DefaultMethod;
+constexpr const char* FairMQChannel::DefaultAddress;
+constexpr int FairMQChannel::DefaultSndBufSize;
+constexpr int FairMQChannel::DefaultRcvBufSize;
+constexpr int FairMQChannel::DefaultSndKernelSize;
+constexpr int FairMQChannel::DefaultRcvKernelSize;
+constexpr int FairMQChannel::DefaultLinger;
+constexpr int FairMQChannel::DefaultRateLogging;
+constexpr int FairMQChannel::DefaultPortRangeMin;
+constexpr int FairMQChannel::DefaultPortRangeMax;
+constexpr bool FairMQChannel::DefaultAutoBind;
 
 FairMQChannel::FairMQChannel()
-    : FairMQChannel("", "unspecified", "unspecified", "unspecified", nullptr)
+    : FairMQChannel(DefaultName, DefaultType, DefaultMethod, DefaultAddress, nullptr)
+{}
+
+FairMQChannel::FairMQChannel(const string& name)
+    : FairMQChannel(name, DefaultType, DefaultMethod, DefaultAddress, nullptr)
 {}
 
 FairMQChannel::FairMQChannel(const string& type, const string& method, const string& address)
-    : FairMQChannel("", type, method, address, nullptr)
+    : FairMQChannel(DefaultName, type, method, address, nullptr)
 {}
 
 FairMQChannel::FairMQChannel(const string& name, const string& type, shared_ptr<FairMQTransportFactory> factory)
-    : FairMQChannel(name, type, "unspecified", "unspecified", factory)
+    : FairMQChannel(name, type, DefaultMethod, DefaultAddress, factory)
 {}
 
 FairMQChannel::FairMQChannel(const string& name, const string& type, const string& method, const string& address, shared_ptr<FairMQTransportFactory> factory)
     : fTransportFactory(factory)
-    , fTransportType(factory ? factory->GetType() : fair::mq::Transport::DEFAULT)
+    , fTransportType(factory ? factory->GetType() : DefaultTransportType)
     , fSocket(factory ? factory->CreateSocket(type, name) : nullptr)
+    , fName(name)
     , fType(type)
     , fMethod(method)
     , fAddress(address)
-    , fSndBufSize(1000)
-    , fRcvBufSize(1000)
-    , fSndKernelSize(0)
-    , fRcvKernelSize(0)
-    , fLinger(500)
-    , fRateLogging(1)
-    , fPortRangeMin(22000)
-    , fPortRangeMax(23000)
-    , fAutoBind(true)
-    , fName(name)
+    , fSndBufSize(DefaultSndBufSize)
+    , fRcvBufSize(DefaultRcvBufSize)
+    , fSndKernelSize(DefaultSndKernelSize)
+    , fRcvKernelSize(DefaultRcvKernelSize)
+    , fLinger(DefaultLinger)
+    , fRateLogging(DefaultRateLogging)
+    , fPortRangeMin(DefaultPortRangeMin)
+    , fPortRangeMax(DefaultPortRangeMax)
+    , fAutoBind(DefaultAutoBind)
     , fIsValid(false)
     , fMultipart(false)
     , fModified(true)
     , fReset(false)
+    , fMtx()
 {}
 
+FairMQChannel::FairMQChannel(const string& name, int index, const fair::mq::Properties& properties)
+    : FairMQChannel(tools::ToString(name, "[", index, "]"), "unspecified", "unspecified", "unspecified", nullptr)
+{
+    string prefix(tools::ToString("chans.", name, ".", index, "."));
+
+    fType = GetPropertyOrDefault(properties, string(prefix + "type"), fType);
+    fMethod = GetPropertyOrDefault(properties, string(prefix + "method"), fMethod);
+    fAddress = GetPropertyOrDefault(properties, string(prefix + "address"), fAddress);
+    fTransportType = TransportTypes.at(GetPropertyOrDefault(properties, string(prefix + "transport"), TransportNames.at(fTransportType)));
+    fSndBufSize = GetPropertyOrDefault(properties, string(prefix + "sndBufSize"), fSndBufSize);
+    fRcvBufSize = GetPropertyOrDefault(properties, string(prefix + "rcvBufSize"), fRcvBufSize);
+    fSndKernelSize = GetPropertyOrDefault(properties, string(prefix + "sndKernelSize"), fSndKernelSize);
+    fRcvKernelSize = GetPropertyOrDefault(properties, string(prefix + "rcvKernelSize"), fRcvKernelSize);
+    fLinger = GetPropertyOrDefault(properties, string(prefix + "linger"), fLinger);
+    fRateLogging = GetPropertyOrDefault(properties, string(prefix + "rateLogging"), fRateLogging);
+    fPortRangeMin = GetPropertyOrDefault(properties, string(prefix + "portRangeMin"), fPortRangeMin);
+    fPortRangeMax = GetPropertyOrDefault(properties, string(prefix + "portRangeMax"), fPortRangeMax);
+    fAutoBind = GetPropertyOrDefault(properties, string(prefix + "autoBind"), fAutoBind);
+}
+
 FairMQChannel::FairMQChannel(const FairMQChannel& chan)
+    : FairMQChannel(chan, chan.fName)
+{}
+
+FairMQChannel::FairMQChannel(const FairMQChannel& chan, const string& newName)
     : fTransportFactory(nullptr)
     , fTransportType(chan.fTransportType)
     , fSocket(nullptr)
+    , fName(newName)
     , fType(chan.fType)
     , fMethod(chan.fMethod)
     , fAddress(chan.fAddress)
@@ -75,7 +124,6 @@ FairMQChannel::FairMQChannel(const FairMQChannel& chan)
     , fPortRangeMin(chan.fPortRangeMin)
     , fPortRangeMax(chan.fPortRangeMax)
     , fAutoBind(chan.fAutoBind)
-    , fName(chan.fName)
     , fIsValid(false)
     , fMultipart(chan.fMultipart)
     , fModified(chan.fModified)
@@ -87,6 +135,7 @@ FairMQChannel& FairMQChannel::operator=(const FairMQChannel& chan)
     fTransportFactory = nullptr;
     fTransportType = chan.fTransportType;
     fSocket = nullptr;
+    fName = chan.fName;
     fType = chan.fType;
     fMethod = chan.fMethod;
     fAddress = chan.fAddress;
@@ -99,7 +148,6 @@ FairMQChannel& FairMQChannel::operator=(const FairMQChannel& chan)
     fPortRangeMin = chan.fPortRangeMin;
     fPortRangeMax = chan.fPortRangeMax;
     fAutoBind = chan.fAutoBind;
-    fName = chan.fName;
     fIsValid = false;
     fMultipart = chan.fMultipart;
     fModified = chan.fModified;
@@ -116,13 +164,13 @@ FairMQSocket & FairMQChannel::GetSocket() const
 
 string FairMQChannel::GetName() const
 {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fName;
 }
 
 string FairMQChannel::GetPrefix() const
 {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     string prefix = fName;
     prefix = prefix.erase(fName.rfind('['));
     return prefix;
@@ -130,7 +178,7 @@ string FairMQChannel::GetPrefix() const
 
 string FairMQChannel::GetIndex() const
 {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     string indexStr = fName;
     indexStr.erase(indexStr.rfind(']'));
     indexStr.erase(0, indexStr.rfind('[') + 1);
@@ -139,296 +187,306 @@ string FairMQChannel::GetIndex() const
 
 string FairMQChannel::GetType() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fType;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetType: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 string FairMQChannel::GetMethod() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fMethod;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetMethod: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 string FairMQChannel::GetAddress() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fAddress;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetAddress: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 string FairMQChannel::GetTransportName() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
-    return fair::mq::TransportNames.at(fTransportType);
+    lock_guard<mutex> lock(fMtx);
+    return TransportNames.at(fTransportType);
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetTransportName: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
+Transport FairMQChannel::GetTransportType() const
+try {
+    lock_guard<mutex> lock(fMtx);
+    return fTransportType;
+} catch (exception& e) {
+    LOG(error) << "Exception caught in FairMQChannel::GetTransportType: " << e.what();
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
+}
+
+
 int FairMQChannel::GetSndBufSize() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fSndBufSize;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetSndBufSize: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 int FairMQChannel::GetRcvBufSize() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fRcvBufSize;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetRcvBufSize: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 int FairMQChannel::GetSndKernelSize() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fSndKernelSize;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetSndKernelSize: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 int FairMQChannel::GetRcvKernelSize() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fRcvKernelSize;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetRcvKernelSize: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 int FairMQChannel::GetLinger() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fLinger;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetLinger: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 int FairMQChannel::GetRateLogging() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fRateLogging;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetRateLogging: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 int FairMQChannel::GetPortRangeMin() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fPortRangeMin;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetPortRangeMin: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 int FairMQChannel::GetPortRangeMax() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fPortRangeMax;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetPortRangeMax: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 bool FairMQChannel::GetAutoBind() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fAutoBind;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::GetAutoBind: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateType(const string& type)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fType = type;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateType: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateMethod(const string& method)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fMethod = method;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateMethod: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateAddress(const string& address)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fAddress = address;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateAddress: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateTransport(const string& transport)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
-    fTransportType = fair::mq::TransportTypes.at(transport);
+    fTransportType = TransportTypes.at(transport);
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateTransport: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateSndBufSize(const int sndBufSize)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fSndBufSize = sndBufSize;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateSndBufSize: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateRcvBufSize(const int rcvBufSize)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fRcvBufSize = rcvBufSize;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateRcvBufSize: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateSndKernelSize(const int sndKernelSize)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fSndKernelSize = sndKernelSize;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateSndKernelSize: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateRcvKernelSize(const int rcvKernelSize)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fRcvKernelSize = rcvKernelSize;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateRcvKernelSize: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateLinger(const int duration)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fLinger = duration;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateLinger: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateRateLogging(const int rateLogging)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fRateLogging = rateLogging;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateRateLogging: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdatePortRangeMin(const int minPort)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fPortRangeMin = minPort;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdatePortRangeMin: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdatePortRangeMax(const int maxPort)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fPortRangeMax = maxPort;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdatePortRangeMax: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateAutoBind(const bool autobind)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fAutoBind = autobind;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateAutoBind: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 auto FairMQChannel::SetModified(const bool modified) -> void
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fModified = modified;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::SetModified: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 void FairMQChannel::UpdateName(const string& name)
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     fName = name;
     fModified = true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::UpdateName: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 bool FairMQChannel::IsValid() const
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     return fIsValid;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::IsValid: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString("failed to acquire lock: ", e.what()));
+    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
 }
 
 bool FairMQChannel::Validate()
 try {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     stringstream ss;
     ss << "Validating channel '" << fName << "'... ";
 
@@ -438,13 +496,22 @@ try {
         return true;
     }
 
+    // validate channel name
+    smatch m;
+    if (regex_search(fName, m, regex("[^a-zA-Z0-9\\-_\\[\\]#]"))) {
+        ss << "INVALID";
+        LOG(debug) << ss.str();
+        LOG(error) << "channel name contains illegal character: '" << m.str(0) << "', allowed characters are: a-z, A-Z, 0-9, -, _, [, ], #";
+        return false;
+    }
+
     // validate socket type
     const set<string> socketTypes{ "sub", "pub", "pull", "push", "req", "rep", "xsub", "xpub", "dealer", "router", "pair" };
     if (socketTypes.find(fType) == socketTypes.end()) {
         ss << "INVALID";
         LOG(debug) << ss.str();
         LOG(error) << "Invalid channel type: '" << fType << "'";
-        throw ChannelConfigurationError(fair::mq::tools::ToString("Invalid channel type: '", fType, "'"));
+        throw ChannelConfigurationError(tools::ToString("Invalid channel type: '", fType, "'"));
     }
 
     // validate socket address
@@ -467,7 +534,7 @@ try {
                     ss << "INVALID";
                     LOG(debug) << ss.str();
                     LOG(error) << "Invalid endpoint connection method: '" << fMethod << "' for " << endpoint;
-                    throw ChannelConfigurationError(fair::mq::tools::ToString("Invalid endpoint connection method: '", fMethod, "' for ", endpoint));
+                    throw ChannelConfigurationError(tools::ToString("Invalid endpoint connection method: '", fMethod, "' for ", endpoint));
                 }
                 address = endpoint;
             }
@@ -523,7 +590,7 @@ try {
         ss << "INVALID";
         LOG(debug) << ss.str();
         LOG(error) << "invalid channel send buffer size (cannot be negative): '" << fSndBufSize << "'";
-        throw ChannelConfigurationError(fair::mq::tools::ToString("invalid channel send buffer size (cannot be negative): '", fSndBufSize, "'"));
+        throw ChannelConfigurationError(tools::ToString("invalid channel send buffer size (cannot be negative): '", fSndBufSize, "'"));
     }
 
     // validate socket buffer size for receiving
@@ -531,7 +598,7 @@ try {
         ss << "INVALID";
         LOG(debug) << ss.str();
         LOG(error) << "invalid channel receive buffer size (cannot be negative): '" << fRcvBufSize << "'";
-        throw ChannelConfigurationError(fair::mq::tools::ToString("invalid channel receive buffer size (cannot be negative): '", fRcvBufSize, "'"));
+        throw ChannelConfigurationError(tools::ToString("invalid channel receive buffer size (cannot be negative): '", fRcvBufSize, "'"));
     }
 
     // validate socket kernel transmit size for sending
@@ -539,7 +606,7 @@ try {
         ss << "INVALID";
         LOG(debug) << ss.str();
         LOG(error) << "invalid channel send kernel transmit size (cannot be negative): '" << fSndKernelSize << "'";
-        throw ChannelConfigurationError(fair::mq::tools::ToString("invalid channel send kernel transmit size (cannot be negative): '", fSndKernelSize, "'"));
+        throw ChannelConfigurationError(tools::ToString("invalid channel send kernel transmit size (cannot be negative): '", fSndKernelSize, "'"));
     }
 
     // validate socket kernel transmit size for receiving
@@ -547,7 +614,7 @@ try {
         ss << "INVALID";
         LOG(debug) << ss.str();
         LOG(error) << "invalid channel receive kernel transmit size (cannot be negative): '" << fRcvKernelSize << "'";
-        throw ChannelConfigurationError(fair::mq::tools::ToString("invalid channel receive kernel transmit size (cannot be negative): '", fRcvKernelSize, "'"));
+        throw ChannelConfigurationError(tools::ToString("invalid channel receive kernel transmit size (cannot be negative): '", fRcvKernelSize, "'"));
     }
 
     // validate socket rate logging interval
@@ -555,7 +622,7 @@ try {
         ss << "INVALID";
         LOG(debug) << ss.str();
         LOG(error) << "invalid socket rate logging interval (cannot be negative): '" << fRateLogging << "'";
-        throw ChannelConfigurationError(fair::mq::tools::ToString("invalid socket rate logging interval (cannot be negative): '", fRateLogging, "'"));
+        throw ChannelConfigurationError(tools::ToString("invalid socket rate logging interval (cannot be negative): '", fRateLogging, "'"));
     }
 
     fIsValid = true;
@@ -564,12 +631,12 @@ try {
     return true;
 } catch (exception& e) {
     LOG(error) << "Exception caught in FairMQChannel::ValidateChannel: " << e.what();
-    throw ChannelConfigurationError(fair::mq::tools::ToString(e.what()));
+    throw ChannelConfigurationError(tools::ToString(e.what()));
 }
 
 void FairMQChannel::Init()
 {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
 
     fSocket = fTransportFactory->CreateSocket(fType, fName);
 
@@ -591,14 +658,14 @@ void FairMQChannel::Init()
 
 bool FairMQChannel::ConnectEndpoint(const string& endpoint)
 {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
 
     return fSocket->Connect(endpoint);
 }
 
 bool FairMQChannel::BindEndpoint(string& endpoint)
 {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
 
     // try to bind to the configured port. If it fails, try random one (if AutoBind is on).
     if (fSocket->Bind(endpoint)) {
@@ -623,7 +690,7 @@ bool FairMQChannel::BindEndpoint(string& endpoint)
                 }
 
                 size_t pos = endpoint.rfind(':');
-                endpoint = endpoint.substr(0, pos + 1) + fair::mq::tools::ToString(static_cast<int>(randomPort(generator)));
+                endpoint = endpoint.substr(0, pos + 1) + tools::ToString(static_cast<int>(randomPort(generator)));
             } while (!fSocket->Bind(endpoint));
 
             return true;
@@ -636,7 +703,7 @@ bool FairMQChannel::BindEndpoint(string& endpoint)
 
 void FairMQChannel::ResetChannel()
 {
-    lock_guard<mutex> lock(fChannelMutex);
+    lock_guard<mutex> lock(fMtx);
     fIsValid = false;
     // TODO: implement channel resetting
 }

fairmq/FairMQChannel.h

@@ -9,6 +9,16 @@
 #ifndef FAIRMQCHANNEL_H_
 #define FAIRMQCHANNEL_H_
 
+#include <FairMQTransportFactory.h>
+#include <FairMQSocket.h>
+#include <fairmq/Transports.h>
+#include <FairMQLogger.h>
+#include <FairMQParts.h>
+#include <fairmq/Properties.h>
+#include <FairMQMessage.h>
+
+#include <boost/any.hpp>
+
 #include <string>
 #include <memory> // unique_ptr, shared_ptr
 #include <vector>
@@ -17,13 +27,6 @@
 #include <stdexcept>
 #include <utility> // std::move
 
-#include <FairMQTransportFactory.h>
-#include <FairMQSocket.h>
-#include <fairmq/Transports.h>
-#include <FairMQLogger.h>
-#include <FairMQParts.h>
-#include <FairMQMessage.h>
-
 class FairMQChannel
 {
     friend class FairMQDevice;
@@ -32,6 +35,10 @@ class FairMQChannel
     /// Default constructor
     FairMQChannel();
 
+    /// Constructor
+    /// @param name Channel name
+    FairMQChannel(const std::string& name);
+
     /// Constructor
     /// @param type Socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
     /// @param method Socket method (bind/connect)
@@ -52,14 +59,28 @@ class FairMQChannel
     /// @param factory TransportFactory
     FairMQChannel(const std::string& name, const std::string& type, const std::string& method, const std::string& address, std::shared_ptr<FairMQTransportFactory> factory);
 
+    FairMQChannel(const std::string& name, int index, const fair::mq::Properties& properties);
+
     /// Copy Constructor
     FairMQChannel(const FairMQChannel&);
 
+    /// Copy Constructor (with new name)
+    FairMQChannel(const FairMQChannel&, const std::string& name);
+
+    /// Move constructor
+    FairMQChannel(FairMQChannel&&) = default;
+
     /// Assignment operator
     FairMQChannel& operator=(const FairMQChannel&);
 
-    /// Default destructor
-    virtual ~FairMQChannel() {}
+    /// Move assignment operator
+    FairMQChannel& operator=(FairMQChannel&&) = default;
+
+    /// Destructor
+    virtual ~FairMQChannel()
+    {
+        // LOG(debug) << "Destroying channel " << fName;
+    }
 
     struct ChannelConfigurationError : std::runtime_error { using std::runtime_error::runtime_error; };
 
@@ -81,17 +102,17 @@ class FairMQChannel
 
     /// Get channel name
     /// @return Returns full channel name (e.g. "data[0]")
-    std::string GetChannelName() const { return GetName(); } // TODO: deprecate this in favor of following
-    std::string GetName() const;
+    std::string GetChannelName() const __attribute__((deprecated("Use GetName()"))) { return GetName(); }
+    std::string GetName() const ;
 
     /// Get channel prefix
     /// @return Returns channel prefix (e.g. "data" in "data[0]")
-    std::string GetChannelPrefix() const { return GetPrefix(); } // TODO: deprecate this in favor of following
+    std::string GetChannelPrefix() const  __attribute__((deprecated("Use GetPrefix()"))) { return GetPrefix(); }
     std::string GetPrefix() const;
 
     /// Get channel index
     /// @return Returns channel index (e.g. 0 in "data[0]")
-    std::string GetChannelIndex() const { return GetIndex(); } // TODO: deprecate this in favor of following
+    std::string GetChannelIndex() const __attribute__((deprecated("Use GetIndex()"))) { return GetIndex(); }
     std::string GetIndex() const;
 
     /// Get socket type
@@ -106,10 +127,14 @@ class FairMQChannel
     /// @return Returns socket address (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
     std::string GetAddress() const;
 
-    /// Get channel transport ("default", "zeromq", "nanomsg" or "shmem")
-    /// @return Returns channel transport (e.g. "default", "zeromq", "nanomsg" or "shmem")
+    /// Get channel transport name ("default", "zeromq", "nanomsg" or "shmem")
+    /// @return Returns channel transport name (e.g. "default", "zeromq", "nanomsg" or "shmem")
     std::string GetTransportName() const;
 
+    /// Get channel transport type
+    /// @return Returns channel transport type
+    fair::mq::Transport GetTransportType() const;
+
     /// Get socket send buffer size (in number of messages)
     /// @return Returns socket send buffer size (in number of messages)
     int GetSndBufSize() const;
@@ -200,7 +225,7 @@ class FairMQChannel
 
     /// Set channel name
     /// @param name Arbitrary channel name
-    void UpdateChannelName(const std::string& name) { UpdateName(name); } // TODO: deprecate this in favor of following
+    void UpdateChannelName(const std::string& name) __attribute__((deprecated("Use UpdateName()"))) { UpdateName(name); }
     void UpdateName(const std::string& name);
 
     /// Checks if the configured channel settings are valid (checks the validity parameter, without running full validation (as oposed to ValidateChannel()))
@@ -209,10 +234,7 @@ class FairMQChannel
 
     /// Validates channel configuration
     /// @return true if channel settings are valid, false otherwise.
-    bool ValidateChannel() // TODO: deprecate this
-    {
-        return Validate();
-    }
+    bool ValidateChannel() __attribute__((deprecated("Use Validate()"))) { return Validate(); }
 
     /// Validates channel configuration
     /// @return true if channel settings are valid, false otherwise.
@@ -247,17 +269,6 @@ class FairMQChannel
         return fSocket->Receive(msg, rcvTimeoutInMs);
     }
 
-    int SendAsync(FairMQMessagePtr& msg) __attribute__((deprecated("For non-blocking Send, use timeout version with timeout of 0: Send(msg, timeout);")))
-    {
-        CheckSendCompatibility(msg);
-        return fSocket->Send(msg, 0);
-    }
-    int ReceiveAsync(FairMQMessagePtr& msg) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(msg, timeout);")))
-    {
-        CheckReceiveCompatibility(msg);
-        return fSocket->Receive(msg, 0);
-    }
-
     /// Send a vector of messages
     /// @param msgVec message vector reference
     /// @param sndTimeoutInMs send timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
@@ -278,17 +289,6 @@ class FairMQChannel
         return fSocket->Receive(msgVec, rcvTimeoutInMs);
     }
 
-    int64_t SendAsync(std::vector<FairMQMessagePtr>& msgVec) __attribute__((deprecated("For non-blocking Send, use timeout version with timeout of 0: Send(msgVec, timeout);")))
-    {
-        CheckSendCompatibility(msgVec);
-        return fSocket->Send(msgVec, 0);
-    }
-    int64_t ReceiveAsync(std::vector<FairMQMessagePtr>& msgVec) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(msgVec, timeout);")))
-    {
-        CheckReceiveCompatibility(msgVec);
-        return fSocket->Receive(msgVec, 0);
-    }
-
     /// Send FairMQParts
     /// @param parts FairMQParts reference
     /// @param sndTimeoutInMs send timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
@@ -307,16 +307,6 @@ class FairMQChannel
         return Receive(parts.fParts, rcvTimeoutInMs);
     }
 
-    int64_t SendAsync(FairMQParts& parts) __attribute__((deprecated("For non-blocking Send, use timeout version with timeout of 0: Send(parts, timeout);")))
-    {
-        return Send(parts.fParts, 0);
-    }
-
-    int64_t ReceiveAsync(FairMQParts& parts) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(parts, timeout);")))
-    {
-        return Receive(parts.fParts, 0);
-    }
-
     unsigned long GetBytesTx() const { return fSocket->GetBytesTx(); }
     unsigned long GetBytesRx() const { return fSocket->GetBytesRx(); }
     unsigned long GetMessagesTx() const { return fSocket->GetMessagesTx(); }
@@ -345,16 +335,33 @@ class FairMQChannel
         return Transport()->NewStaticMessage(data);
     }
 
-    FairMQUnmanagedRegionPtr NewUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr)
+    FairMQUnmanagedRegionPtr NewUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0)
     {
-        return Transport()->CreateUnmanagedRegion(size, callback);
+        return Transport()->CreateUnmanagedRegion(size, callback, path, flags);
     }
 
+    static constexpr fair::mq::Transport DefaultTransportType = fair::mq::Transport::DEFAULT;
+    static constexpr const char* DefaultTransportName = "default";
+    static constexpr const char* DefaultName = "";
+    static constexpr const char* DefaultType = "unspecified";
+    static constexpr const char* DefaultMethod = "unspecified";
+    static constexpr const char* DefaultAddress = "unspecified";
+    static constexpr int DefaultSndBufSize = 1000;
+    static constexpr int DefaultRcvBufSize = 1000;
+    static constexpr int DefaultSndKernelSize = 0;
+    static constexpr int DefaultRcvKernelSize = 0;
+    static constexpr int DefaultLinger = 500;
+    static constexpr int DefaultRateLogging = 1;
+    static constexpr int DefaultPortRangeMin = 22000;
+    static constexpr int DefaultPortRangeMax = 23000;
+    static constexpr bool DefaultAutoBind = true;
+
   private:
     std::shared_ptr<FairMQTransportFactory> fTransportFactory;
     fair::mq::Transport fTransportType;
     std::unique_ptr<FairMQSocket> fSocket;
 
+    std::string fName;
     std::string fType;
     std::string fMethod;
     std::string fAddress;
@@ -368,23 +375,17 @@ class FairMQChannel
     int fPortRangeMax;
     bool fAutoBind;
 
-    std::string fName;
-    std::atomic<bool> fIsValid;
-
-    // use static mutex to make the class easily copyable
-    // implication: same mutex is used for all instances of the class
-    // this does not hurt much, because mutex is used only during initialization with very low contention
-    // possible TODO: improve this
-    static std::mutex fChannelMutex;
+    bool fIsValid;
 
     bool fMultipart;
     bool fModified;
     bool fReset;
 
+    mutable std::mutex fMtx;
+
     void CheckSendCompatibility(FairMQMessagePtr& msg)
     {
         if (fTransportType != msg->GetType()) {
-            // LOG(debug) << "Channel type does not match message type. Creating wrapper";
             FairMQMessagePtr msgWrapper(NewMessage(
                 msg->GetData(),
                 msg->GetSize(),
@@ -400,7 +401,7 @@ class FairMQChannel
     {
         for (auto& msg : msgVec) {
             if (fTransportType != msg->GetType()) {
-                // LOG(debug) << "Channel type does not match message type. Creating wrapper";
+
                 FairMQMessagePtr msgWrapper(NewMessage(
                     msg->GetData(),
                     msg->GetSize(),
@@ -416,7 +417,6 @@ class FairMQChannel
     void CheckReceiveCompatibility(FairMQMessagePtr& msg)
     {
         if (fTransportType != msg->GetType()) {
-            // LOG(debug) << "Channel type does not match message type. Creating wrapper";
             FairMQMessagePtr newMsg(NewMessage());
             msg = move(newMsg);
         }
@@ -426,7 +426,7 @@ class FairMQChannel
     {
         for (auto& msg : msgVec) {
             if (fTransportType != msg->GetType()) {
-                // LOG(debug) << "Channel type does not match message type. Creating wrapper";
+
                 FairMQMessagePtr newMsg(NewMessage());
                 msg = move(newMsg);
             }
@@ -438,6 +438,7 @@ class FairMQChannel
         fTransportFactory = factory;
         fTransportType = factory->GetType();
     }
+
     auto SetModified(const bool modified) -> void;
 };
 

fairmq/FairMQDevice.cxx

@@ -56,34 +56,61 @@ static map<int, Transition> backwardsCompatibilityChangeStateHelper =
     { FairMQDevice::Event::ERROR_FOUND,           Transition::ErrorFound }
 };
 
+constexpr const char* FairMQDevice::DefaultId;
+constexpr int FairMQDevice::DefaultIOThreads;
+constexpr const char* FairMQDevice::DefaultTransportName;
+constexpr fair::mq::Transport FairMQDevice::DefaultTransportType;
+constexpr const char* FairMQDevice::DefaultNetworkInterface;
+constexpr int FairMQDevice::DefaultInitTimeout;
+constexpr uint64_t FairMQDevice::DefaultMaxRunTime;
+constexpr float FairMQDevice::DefaultRate;
+constexpr const char* FairMQDevice::DefaultSession;
+
+struct StateSubscription
+{
+    fair::mq::StateMachine& fStateMachine;
+    fair::mq::StateQueue& fStateQueue;
+    string fId;
+
+    explicit StateSubscription(const string& id, fair::mq::StateMachine& stateMachine, fair::mq::StateQueue& stateQueue)
+        : fStateMachine(stateMachine)
+        , fStateQueue(stateQueue)
+        , fId(id)
+    {
+        fStateMachine.SubscribeToStateChange(fId, [&](fair::mq::State state) {
+            fStateQueue.Push(state);
+        });
+    }
+
+    ~StateSubscription() {
+        fStateMachine.UnsubscribeFromStateChange(fId);
+    }
+};
+
 FairMQDevice::FairMQDevice()
     : FairMQDevice(nullptr, {0, 0, 0})
-{
-}
+{}
 
-FairMQDevice::FairMQDevice(FairMQProgOptions& config)
+FairMQDevice::FairMQDevice(ProgOptions& config)
     : FairMQDevice(&config, {0, 0, 0})
-{
-}
+{}
 
 FairMQDevice::FairMQDevice(const tools::Version version)
     : FairMQDevice(nullptr, version)
-{
-}
+{}
 
-FairMQDevice::FairMQDevice(FairMQProgOptions& config, const tools::Version version)
+FairMQDevice::FairMQDevice(ProgOptions& config, const tools::Version version)
     : FairMQDevice(&config, version)
-{
-}
+{}
 
-FairMQDevice::FairMQDevice(FairMQProgOptions* config, const tools::Version version)
+FairMQDevice::FairMQDevice(ProgOptions* config, const tools::Version version)
     : fTransportFactory(nullptr)
     , fTransports()
     , fChannels()
-    , fInternalConfig(config ? nullptr : tools::make_unique<FairMQProgOptions>())
+    , fInternalConfig(config ? nullptr : tools::make_unique<ProgOptions>())
     , fConfig(config ? config : fInternalConfig.get())
-    , fId()
-    , fDefaultTransportType(fair::mq::Transport::ZMQ)
+    , fId(DefaultId)
+    , fDefaultTransportType(DefaultTransportType)
     , fStateMachine()
     , fUninitializedBindingChannels()
     , fUninitializedConnectingChannels()
@@ -96,9 +123,12 @@ FairMQDevice::FairMQDevice(FairMQProgOptions* config, const tools::Version versi
     , fMultitransportMutex()
     , fMultitransportProceed(false)
     , fVersion(version)
-    , fRate(0.)
-    , fMaxRunRuntimeInS(0)
+    , fRate(DefaultRate)
+    , fMaxRunRuntimeInS(DefaultMaxRunTime)
+    , fInitializationTimeoutInS(DefaultInitTimeout)
     , fRawCmdLineArgs()
+    , fTransitionMtx()
+    , fTransitioning(false)
 {
     SubscribeToNewTransition("device", [&](Transition transition) {
         LOG(trace) << "device notified on new transition: " << transition;
@@ -115,11 +145,7 @@ FairMQDevice::FairMQDevice(FairMQProgOptions* config, const tools::Version versi
     fStateMachine.HandleStates([&](fair::mq::State state) {
         LOG(trace) << "device notified on new state: " << state;
 
-        {
-            lock_guard<mutex> lock(fStatesMtx);
-            fStates.push(state);
-        }
-        fStatesCV.notify_all();
+        fStateQueue.Push(state);
 
         switch (state) {
             case fair::mq::State::InitializingDevice:
@@ -155,27 +181,71 @@ FairMQDevice::FairMQDevice(FairMQProgOptions* config, const tools::Version versi
     fStateMachine.Start();
 }
 
-fair::mq::State FairMQDevice::WaitForNextState()
+void FairMQDevice::TransitionTo(const fair::mq::State s)
 {
-    unique_lock<mutex> lock(fStatesMtx);
-    while (fStates.empty()) {
-        fStatesCV.wait_for(lock, chrono::milliseconds(50));
+    {
+        lock_guard<mutex> lock(fTransitionMtx);
+        if (fTransitioning) {
+            LOG(debug) << "Attempting a transition with TransitionTo() while another one is already in progress";
+            throw OngoingTransition("Attempting a transition with TransitionTo() while another one is already in progress");
+        }
+        fTransitioning = true;
     }
 
-    auto result = fStates.front();
+    using fair::mq::State;
 
-    if (result == fair::mq::State::Error) {
-        throw DeviceStateError("Device transitioned to error state.");
+    StateQueue sq;
+    StateSubscription ss(tools::ToString(fId, ".TransitionTo"), fStateMachine, sq);
+
+    State currentState = GetCurrentState();
+
+    while (s != currentState) {
+        switch (currentState) {
+            case State::Idle:
+                if (s == State::Exiting) { ChangeState(Transition::End); }
+                else { ChangeState(Transition::InitDevice); }
+            break;
+            case State::InitializingDevice:
+                ChangeState(Transition::CompleteInit);
+            break;
+            case State::Initialized:
+                if (s == State::Exiting || s == State::Idle) { ChangeState(Transition::ResetDevice); }
+                else { ChangeState(Transition::Bind); }
+            break;
+            case State::Bound:
+                if (s == State::DeviceReady || s == State::Ready || s == State::Running) { ChangeState(Transition::Connect); }
+                else { ChangeState(Transition::ResetDevice); }
+            break;
+            case State::DeviceReady:
+                if (s == State::Running || s == State::Ready) { ChangeState(Transition::InitTask); }
+                else { ChangeState(Transition::ResetDevice); }
+            break;
+            case State::Ready:
+                if (s == State::Running) { ChangeState(Transition::Run); }
+                else { ChangeState(Transition::ResetTask); }
+            break;
+            case State::Running:
+                ChangeState(Transition::Stop);
+            break;
+            case State::Binding:
+            case State::Connecting:
+            case State::InitializingTask:
+            case State::ResettingDevice:
+            case State::ResettingTask:
+                LOG(debug) << "TransitionTo ignoring state: " << currentState << " (expected, automatic transition).";
+            break;
+            default:
+                LOG(debug) << "TransitionTo ignoring state: " << currentState;
+            break;
+        }
+
+        currentState = sq.WaitForNext();
     }
 
-    fStates.pop();
-
-    return result;
-}
-
-void FairMQDevice::WaitForState(fair::mq::State state)
-{
-    while (WaitForNextState() != state) {}
+    {
+        lock_guard<mutex> lock(fTransitionMtx);
+        fTransitioning = false;
+    }
 }
 
 bool FairMQDevice::ChangeState(const int transition)
@@ -190,69 +260,65 @@ void FairMQDevice::WaitForEndOfState(Transition transition)
 
 void FairMQDevice::InitWrapper()
 {
+    // run initialization once CompleteInit transition is requested
     fStateMachine.WaitForPendingState();
 
-    fId = fConfig->GetValue<string>("id");
+    fId = fConfig->GetProperty<string>("id", DefaultId);
 
     Init();
 
-    fRate = fConfig->GetValue<float>("rate");
-    fMaxRunRuntimeInS = fConfig->GetValue<uint64_t>("max-run-time");
+    fRate = fConfig->GetProperty<float>("rate", DefaultRate);
+    fMaxRunRuntimeInS = fConfig->GetProperty<uint64_t>("max-run-time", DefaultMaxRunTime);
+    fInitializationTimeoutInS = fConfig->GetProperty<int>("init-timeout", DefaultInitTimeout);
 
     try {
-        fDefaultTransportType = fair::mq::TransportTypes.at(fConfig->GetValue<string>("transport"));
+        fDefaultTransportType = fair::mq::TransportTypes.at(fConfig->GetProperty<string>("transport", DefaultTransportName));
     } catch (const exception& e) {
         LOG(error) << "exception: " << e.what();
-        LOG(error) << "invalid transport type provided: " << fConfig->GetValue<string>("transport");
+        LOG(error) << "invalid transport type provided: " << fConfig->GetProperty<string>("transport", "not provided");
         throw;
     }
 
-    for (auto& c : fConfig->GetFairMQMap()) {
-        if (fChannels.find(c.first) == fChannels.end()) {
-            LOG(debug) << "Inserting new device channel from config: " << c.first;
-            fChannels.insert(c);
-        } else {
-            LOG(debug) << "Updating existing device channel from config: " << c.first;
-            fChannels[c.first] = c.second;
+    unordered_map<string, int> infos = fConfig->GetChannelInfo();
+    for (const auto& info : infos) {
+        for (int i = 0; i < info.second; ++i) {
+            fChannels[info.first].emplace_back(info.first, i, fConfig->GetPropertiesStartingWith(tools::ToString("chans.", info.first, ".", i, ".")));
         }
     }
 
     LOG(debug) << "Setting '" << fair::mq::TransportNames.at(fDefaultTransportType) << "' as default transport for the device";
     fTransportFactory = AddTransport(fDefaultTransportType);
 
-    string networkInterface = fConfig->GetValue<string>("network-interface");
+    string networkInterface = fConfig->GetProperty<string>("network-interface", DefaultNetworkInterface);
 
     // Fill the uninitialized channel containers
-    for (auto& mi : fChannels) {
+    for (auto& channel : fChannels) {
         int subChannelIndex = 0;
-        for (auto& vi : mi.second) {
-            // set channel name: name + vector index
-            vi.fName = tools::ToString(mi.first, "[", subChannelIndex, "]");
-
+        for (auto& subChannel : channel.second) {
             // set channel transport
-            LOG(debug) << "Initializing transport for channel " << vi.fName << ": " << fair::mq::TransportNames.at(vi.fTransportType);
-            vi.InitTransport(AddTransport(vi.fTransportType));
+            LOG(debug) << "Initializing transport for channel " << subChannel.fName << ": " << fair::mq::TransportNames.at(subChannel.fTransportType);
+            subChannel.InitTransport(AddTransport(subChannel.fTransportType));
 
-            if (vi.fMethod == "bind") {
+            if (subChannel.fMethod == "bind") {
                 // if binding address is not specified, try getting it from the configured network interface
-                if (vi.fAddress == "unspecified" || vi.fAddress == "") {
+                if (subChannel.fAddress == "unspecified" || subChannel.fAddress == "") {
                     // if the configured network interface is default, get its name from the default route
                     if (networkInterface == "default") {
                         networkInterface = tools::getDefaultRouteNetworkInterface();
                     }
-                    vi.fAddress = "tcp://" + tools::getInterfaceIP(networkInterface) + ":1";
+                    subChannel.fAddress = "tcp://" + tools::getInterfaceIP(networkInterface) + ":1";
                 }
                 // fill the uninitialized list
-                fUninitializedBindingChannels.push_back(&vi);
-            } else if (vi.fMethod == "connect") {
+                fUninitializedBindingChannels.push_back(&subChannel);
+            } else if (subChannel.fMethod == "connect") {
                 // fill the uninitialized list
-                fUninitializedConnectingChannels.push_back(&vi);
-            } else if (vi.fAddress.find_first_of("@+>") != string::npos) {
+                fUninitializedConnectingChannels.push_back(&subChannel);
+            } else if (subChannel.fAddress.find_first_of("@+>") != string::npos) {
                 // fill the uninitialized list
-                fUninitializedConnectingChannels.push_back(&vi);
+                fUninitializedConnectingChannels.push_back(&subChannel);
             } else {
-                LOG(error) << "Cannot update configuration. Socket method (bind/connect) for channel '" << vi.fName << "' not specified.";
-                throw runtime_error(tools::ToString("Cannot update configuration. Socket method (bind/connect) for channel ", vi.fName, " not specified."));
+                LOG(error) << "Cannot update configuration. Socket method (bind/connect) for channel '" << subChannel.fName << "' not specified.";
+                throw runtime_error(tools::ToString("Cannot update configuration. Socket method (bind/connect) for channel ", subChannel.fName, " not specified."));
             }
 
             subChannelIndex++;
@@ -280,12 +346,10 @@ void FairMQDevice::BindWrapper()
 
 void FairMQDevice::ConnectWrapper()
 {
-    int initializationTimeoutInS = fConfig->GetValue<int>("initialization-timeout");
-
     // go over the list of channels until all are initialized (and removed from the uninitialized list)
     int numAttempts = 1;
     auto sleepTimeInMS = 50;
-    auto maxAttempts = initializationTimeoutInS * 1000 / sleepTimeInMS;
+    auto maxAttempts = fInitializationTimeoutInS * 1000 / sleepTimeInMS;
     // first attempt
     AttachChannels(fUninitializedConnectingChannels);
     // if not all channels could be connected, update their address values from config and retry
@@ -293,16 +357,16 @@ void FairMQDevice::ConnectWrapper()
         this_thread::sleep_for(chrono::milliseconds(sleepTimeInMS));
 
         for (auto& chan : fUninitializedConnectingChannels) {
-            string key{"chans." + chan->GetChannelPrefix() + "." + chan->GetChannelIndex() + ".address"};
-            string newAddress = fConfig->GetValue<string>(key);
+            string key{"chans." + chan->GetPrefix() + "." + chan->GetIndex() + ".address"};
+            string newAddress = fConfig->GetProperty<string>(key);
             if (newAddress != chan->GetAddress()) {
                 chan->UpdateAddress(newAddress);
             }
         }
 
         if (numAttempts++ > maxAttempts) {
-            LOG(error) << "could not connect all channels after " << initializationTimeoutInS << " attempts";
-            throw runtime_error(tools::ToString("could not connect all channels after ", initializationTimeoutInS, " attempts"));
+            LOG(error) << "could not connect all channels after " << fInitializationTimeoutInS << " attempts";
+            throw runtime_error(tools::ToString("could not connect all channels after ", fInitializationTimeoutInS, " attempts"));
         }
 
         AttachChannels(fUninitializedConnectingChannels);
@@ -322,7 +386,7 @@ void FairMQDevice::AttachChannels(vector<FairMQChannel*>& chans)
     auto itr = chans.begin();
 
     while (itr != chans.end()) {
-        if ((*itr)->ValidateChannel()) {
+        if ((*itr)->Validate()) {
             (*itr)->Init();
             if (AttachChannel(**itr)) {
                 (*itr)->SetModified(false);
@@ -405,7 +469,7 @@ bool FairMQDevice::AttachChannel(FairMQChannel& chan)
         chan.UpdateAddress(newAddress);
 
         // update address in the config, it could have been modified during binding
-        fConfig->SetValue({"chans." + chan.GetPrefix() + "." + chan.GetIndex() + ".address"}, newAddress);
+        fConfig->SetProperty({"chans." + chan.GetPrefix() + "." + chan.GetIndex() + ".address"}, newAddress);
     }
 
     return true;
@@ -716,7 +780,7 @@ shared_ptr<FairMQTransportFactory> FairMQDevice::AddTransport(fair::mq::Transpor
     }
 }
 
-void FairMQDevice::SetConfig(FairMQProgOptions& config)
+void FairMQDevice::SetConfig(ProgOptions& config)
 {
     fInternalConfig.reset();
     fConfig = &config;
@@ -724,7 +788,7 @@ void FairMQDevice::SetConfig(FairMQProgOptions& config)
 
 void FairMQDevice::LogSocketRates()
 {
-    vector<FairMQSocket*> filteredSockets;
+    vector<FairMQChannel*> filteredChannels;
     vector<string> filteredChannelNames;
     vector<int> logIntervals;
     vector<int> intervalCounters;
@@ -732,40 +796,40 @@ void FairMQDevice::LogSocketRates()
     size_t chanNameLen = 0;
 
     // iterate over the channels map
-    for (const auto& mi : fChannels) {
+    for (auto& channel : fChannels) {
         // iterate over the channels vector
-        for (auto vi = (mi.second).begin(); vi != (mi.second).end(); ++vi) {
-            if (vi->fRateLogging > 0) {
-                filteredSockets.push_back(vi->fSocket.get());
-                logIntervals.push_back(vi->fRateLogging);
+        for (auto& subChannel : channel.second) {
+            if (subChannel.fRateLogging > 0) {
+                filteredChannels.push_back(&subChannel);
+                logIntervals.push_back(subChannel.fRateLogging);
                 intervalCounters.push_back(0);
-                filteredChannelNames.push_back(tools::ToString(mi.first, "[", vi - (mi.second).begin(), "]"));
+                filteredChannelNames.push_back(subChannel.GetName());
                 chanNameLen = max(chanNameLen, filteredChannelNames.back().length());
             }
         }
     }
 
-    vector<unsigned long> bytesIn(filteredSockets.size());
-    vector<unsigned long> msgIn(filteredSockets.size());
-    vector<unsigned long> bytesOut(filteredSockets.size());
-    vector<unsigned long> msgOut(filteredSockets.size());
+    vector<unsigned long> bytesIn(filteredChannels.size());
+    vector<unsigned long> msgIn(filteredChannels.size());
+    vector<unsigned long> bytesOut(filteredChannels.size());
+    vector<unsigned long> msgOut(filteredChannels.size());
 
-    vector<unsigned long> bytesInNew(filteredSockets.size());
-    vector<unsigned long> msgInNew(filteredSockets.size());
-    vector<unsigned long> bytesOutNew(filteredSockets.size());
-    vector<unsigned long> msgOutNew(filteredSockets.size());
+    vector<unsigned long> bytesInNew(filteredChannels.size());
+    vector<unsigned long> msgInNew(filteredChannels.size());
+    vector<unsigned long> bytesOutNew(filteredChannels.size());
+    vector<unsigned long> msgOutNew(filteredChannels.size());
 
-    vector<double> mbPerSecIn(filteredSockets.size());
-    vector<double> msgPerSecIn(filteredSockets.size());
-    vector<double> mbPerSecOut(filteredSockets.size());
-    vector<double> msgPerSecOut(filteredSockets.size());
+    vector<double> mbPerSecIn(filteredChannels.size());
+    vector<double> msgPerSecIn(filteredChannels.size());
+    vector<double> mbPerSecOut(filteredChannels.size());
+    vector<double> msgPerSecOut(filteredChannels.size());
 
     int i = 0;
-    for (const auto& vi : filteredSockets) {
-        bytesIn.at(i) = vi->GetBytesRx();
-        bytesOut.at(i) = vi->GetBytesTx();
-        msgIn.at(i) = vi->GetMessagesRx();
-        msgOut.at(i) = vi->GetMessagesTx();
+    for (const auto& channel : filteredChannels) {
+        bytesIn.at(i) = channel->GetBytesRx();
+        bytesOut.at(i) = channel->GetBytesTx();
+        msgIn.at(i) = channel->GetMessagesRx();
+        msgOut.at(i) = channel->GetMessagesTx();
         ++i;
     }
 
@@ -782,17 +846,17 @@ void FairMQDevice::LogSocketRates()
 
         i = 0;
 
-        for (const auto& vi : filteredSockets) {
+        for (const auto& channel : filteredChannels) {
             intervalCounters.at(i)++;
 
             if (intervalCounters.at(i) == logIntervals.at(i)) {
                 intervalCounters.at(i) = 0;
 
                 if (msSinceLastLog > 0) {
-                    bytesInNew.at(i) = vi->GetBytesRx();
-                    msgInNew.at(i) = vi->GetMessagesRx();
-                    bytesOutNew.at(i) = vi->GetBytesTx();
-                    msgOutNew.at(i) = vi->GetMessagesTx();
+                    bytesInNew.at(i) = channel->GetBytesRx();
+                    msgInNew.at(i) = channel->GetMessagesRx();
+                    bytesOutNew.at(i) = channel->GetBytesTx();
+                    msgOutNew.at(i) = channel->GetMessagesTx();
 
                     mbPerSecIn.at(i) = (static_cast<double>(bytesInNew.at(i) - bytesIn.at(i)) / (1000. * 1000.)) / static_cast<double>(msSinceLastLog) * 1000.;
                     msgPerSecIn.at(i) = static_cast<double>(msgInNew.at(i) - msgIn.at(i)) / static_cast<double>(msSinceLastLog) * 1000.;
@@ -822,8 +886,8 @@ void FairMQDevice::LogSocketRates()
 
 void FairMQDevice::UnblockTransports()
 {
-    for (auto& t : fTransports) {
-        t.second->Interrupt();
+    for (auto& transport : fTransports) {
+        transport.second->Interrupt();
     }
 }
 
@@ -836,21 +900,15 @@ void FairMQDevice::ResetTaskWrapper()
 
 void FairMQDevice::ResetWrapper()
 {
-    for (auto& t : fTransports) {
-        t.second->Reset();
-    }
-
-    // iterate over the channels map
-    for (auto& mi : fChannels) {
-        // iterate over the channels vector
-        for (auto& vi : mi.second) {
-            // vi.fReset = true;
-            vi.fSocket.reset(); // destroy FairMQSocket
-        }
+    for (auto& transport : fTransports) {
+        transport.second->Reset();
     }
 
     Reset();
 
+    fChannels.clear();
+    fTransports.clear();
+    fTransportFactory.reset();
     ChangeState(Transition::Auto);
 }
 

fairmq/FairMQDevice.h

@@ -12,6 +12,7 @@
 #include <StateMachine.h>
 #include <FairMQTransportFactory.h>
 #include <fairmq/Transports.h>
+#include <fairmq/StateQueue.h>
 
 #include <FairMQSocket.h>
 #include <FairMQChannel.h>
@@ -19,7 +20,7 @@
 #include <FairMQParts.h>
 #include <FairMQUnmanagedRegion.h>
 #include <FairMQLogger.h>
-#include <options/FairMQProgOptions.h>
+#include <fairmq/ProgOptions.h>
 
 #include <vector>
 #include <memory> // unique_ptr
@@ -44,6 +45,14 @@ using FairMQChannelMap = std::unordered_map<std::string, std::vector<FairMQChann
 using InputMsgCallback = std::function<bool(FairMQMessagePtr&, int)>;
 using InputMultipartCallback = std::function<bool(FairMQParts&, int)>;
 
+namespace fair
+{
+namespace mq
+{
+struct OngoingTransition : std::runtime_error { using std::runtime_error::runtime_error; };
+}
+}
+
 class FairMQDevice
 {
     friend class FairMQChannel;
@@ -83,17 +92,17 @@ class FairMQDevice
 
     /// Default constructor
     FairMQDevice();
-    /// Constructor with external FairMQProgOptions
-    FairMQDevice(FairMQProgOptions& config);
+    /// Constructor with external fair::mq::ProgOptions
+    FairMQDevice(fair::mq::ProgOptions& config);
 
     /// Constructor that sets the version
     FairMQDevice(const fair::mq::tools::Version version);
 
-    /// Constructor that sets the version and external FairMQProgOptions
-    FairMQDevice(FairMQProgOptions& config, const fair::mq::tools::Version version);
+    /// Constructor that sets the version and external fair::mq::ProgOptions
+    FairMQDevice(fair::mq::ProgOptions& config, const fair::mq::tools::Version version);
 
   private:
-    FairMQDevice(FairMQProgOptions* config, const fair::mq::tools::Version version);
+    FairMQDevice(fair::mq::ProgOptions* config, const fair::mq::tools::Version version);
 
   public:
     /// Copy constructor (disabled)
@@ -240,9 +249,9 @@ class FairMQDevice
     }
 
     // creates unmanaged region with the transport of the specified channel
-    FairMQUnmanagedRegionPtr NewUnmanagedRegionFor(const std::string& channel, int index, const size_t size, FairMQRegionCallback callback = nullptr)
+    FairMQUnmanagedRegionPtr NewUnmanagedRegionFor(const std::string& channel, int index, const size_t size, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0)
     {
-        return GetChannel(channel, index).NewUnmanagedRegion(size, callback);
+        return GetChannel(channel, index).NewUnmanagedRegion(size, callback, path, flags);
     }
 
     template<typename ...Ts>
@@ -296,9 +305,9 @@ class FairMQDevice
     std::shared_ptr<FairMQTransportFactory> AddTransport(const fair::mq::Transport transport);
 
     /// Assigns config to the device
-    void SetConfig(FairMQProgOptions& config);
+    void SetConfig(fair::mq::ProgOptions& config);
     /// Get pointer to the config
-    FairMQProgOptions* GetConfig() const
+    fair::mq::ProgOptions* GetConfig() const
     {
         return fConfig;
     }
@@ -399,23 +408,23 @@ class FairMQDevice
 
     const fair::mq::tools::Version GetVersion() const { return fVersion; }
 
-    void SetNumIoThreads(int numIoThreads) { fConfig->SetValue<int>("io-threads", numIoThreads);}
-    int GetNumIoThreads() const { return fConfig->GetValue<int>("io-threads"); }
+    void SetNumIoThreads(int numIoThreads) { fConfig->SetProperty("io-threads", numIoThreads);}
+    int GetNumIoThreads() const { return fConfig->GetProperty<int>("io-threads", DefaultIOThreads); }
 
-    void SetNetworkInterface(const std::string& networkInterface) { fConfig->SetValue<std::string>("network-interface", networkInterface); }
-    std::string GetNetworkInterface() const { return fConfig->GetValue<std::string>("network-interface"); }
+    void SetNetworkInterface(const std::string& networkInterface) { fConfig->SetProperty("network-interface", networkInterface); }
+    std::string GetNetworkInterface() const { return fConfig->GetProperty<std::string>("network-interface", DefaultNetworkInterface); }
 
-    void SetDefaultTransport(const std::string& name) { fConfig->SetValue<std::string>("transport", name); }
-    std::string GetDefaultTransport() const { return fConfig->GetValue<std::string>("transport"); }
+    void SetDefaultTransport(const std::string& name) { fConfig->SetProperty("transport", name); }
+    std::string GetDefaultTransport() const { return fConfig->GetProperty<std::string>("transport", DefaultTransportName); }
 
-    void SetInitializationTimeoutInS(int initializationTimeoutInS) { fConfig->SetValue<int>("initialization-timeout", initializationTimeoutInS); }
-    int GetInitializationTimeoutInS() const { return fConfig->GetValue<int>("initialization-timeout"); }
+    void SetInitTimeoutInS(int initTimeoutInS) { fConfig->SetProperty("init-timeout", initTimeoutInS); }
+    int GetInitTimeoutInS() const { return fConfig->GetProperty<int>("init-timeout", DefaultInitTimeout); }
 
     /// Sets the default transport for the device
     /// @param transport  Transport string ("zeromq"/"nanomsg"/"shmem")
-    void SetTransport(const std::string& transport) { fConfig->SetValue<std::string>("transport", transport); }
+    void SetTransport(const std::string& transport) { fConfig->SetProperty("transport", transport); }
     /// Gets the default transport name
-    std::string GetTransportName() const { return fConfig->GetValue<std::string>("transport"); }
+    std::string GetTransportName() const { return fConfig->GetProperty<std::string>("transport", DefaultTransportName); }
 
     void SetRawCmdLineArgs(const std::vector<std::string>& args) { fRawCmdLineArgs = args; }
     std::vector<std::string> GetRawCmdLineArgs() const { return fRawCmdLineArgs; }
@@ -428,7 +437,7 @@ class FairMQDevice
     /// Wait for the supplied amount of time or for interruption.
     /// If interrupted, returns false, otherwise true.
     /// @param duration wait duration
-    template<class Rep, class Period>
+    template<typename Rep, typename Period>
     bool WaitFor(std::chrono::duration<Rep, Period> const& duration)
     {
         return !fStateMachine.WaitForPendingStateFor(std::chrono::duration_cast<std::chrono::milliseconds>(duration).count());
@@ -440,12 +449,12 @@ class FairMQDevice
 
   public:
     std::unordered_map<std::string, std::vector<FairMQChannel>> fChannels; ///< Device channels
-    std::unique_ptr<FairMQProgOptions> fInternalConfig; ///< Internal program options configuration
-    FairMQProgOptions* fConfig; ///< Pointer to config (internal or external)
+    std::unique_ptr<fair::mq::ProgOptions> fInternalConfig; ///< Internal program options configuration
+    fair::mq::ProgOptions* fConfig; ///< Pointer to config (internal or external)
 
-    void AddChannel(const std::string& channelName, const FairMQChannel& channel)
+    void AddChannel(const std::string& name, FairMQChannel&& channel)
     {
-        fConfig->AddChannel(channelName, channel);
+        fConfig->AddChannel(name, channel);
     }
 
   protected:
@@ -483,16 +492,18 @@ class FairMQDevice
 
   public:
     bool ChangeState(const fair::mq::Transition transition) { return fStateMachine.ChangeState(transition); }
-    bool ChangeState(const std::string& transition) { return fStateMachine.ChangeState(fair::mq::StateMachine::GetTransition(transition)); }
+    bool ChangeState(const std::string& transition) { return fStateMachine.ChangeState(fair::mq::GetTransition(transition)); }
 
     bool ChangeState(const int transition) __attribute__((deprecated("Use ChangeState(const fair::mq::Transition transition).")));
 
     void WaitForEndOfState(const fair::mq::Transition transition) __attribute__((deprecated("Use WaitForState(fair::mq::State expectedState).")));
     void WaitForEndOfState(const std::string& transition) __attribute__((deprecated("Use WaitForState(fair::mq::State expectedState)."))) { WaitForState(transition); }
 
-    fair::mq::State WaitForNextState();
-    void WaitForState(fair::mq::State state);
-    void WaitForState(const std::string& state) { fair::mq::StateMachine::GetState(state); }
+    fair::mq::State WaitForNextState() { return fStateQueue.WaitForNext(); }
+    void WaitForState(fair::mq::State state) { fStateQueue.WaitForState(state); }
+    void WaitForState(const std::string& state) { WaitForState(fair::mq::GetState(state)); }
+
+    void TransitionTo(const fair::mq::State state);
 
     void SubscribeToStateChange(const std::string& key, std::function<void(const fair::mq::State)> callback) { fStateMachine.SubscribeToStateChange(key, callback); }
     void UnsubscribeFromStateChange(const std::string& key) { fStateMachine.UnsubscribeFromStateChange(key); }
@@ -509,10 +520,18 @@ class FairMQDevice
     fair::mq::State GetCurrentState() const { return fStateMachine.GetCurrentState(); }
     std::string GetCurrentStateName() const { return fStateMachine.GetCurrentStateName(); }
 
-    static std::string GetStateName(const fair::mq::State state) { return fair::mq::StateMachine::GetStateName(state); }
-    static std::string GetTransitionName(const fair::mq::Transition transition) { return fair::mq::StateMachine::GetTransitionName(transition); }
+    static std::string GetStateName(const fair::mq::State state) { return fair::mq::GetStateName(state); }
+    static std::string GetTransitionName(const fair::mq::Transition transition) { return fair::mq::GetTransitionName(transition); }
 
-    struct DeviceStateError : std::runtime_error { using std::runtime_error::runtime_error; };
+    static constexpr const char* DefaultId = "";
+    static constexpr int DefaultIOThreads = 1;
+    static constexpr const char* DefaultTransportName = "zeromq";
+    static constexpr fair::mq::Transport DefaultTransportType = fair::mq::Transport::ZMQ;
+    static constexpr const char* DefaultNetworkInterface = "default";
+    static constexpr int DefaultInitTimeout = 120;
+    static constexpr uint64_t DefaultMaxRunTime = 0;
+    static constexpr float DefaultRate = 0.;
+    static constexpr const char* DefaultSession = "default";
 
   private:
     fair::mq::Transport fDefaultTransportType; ///< Default transport for the device
@@ -566,11 +585,13 @@ class FairMQDevice
     const fair::mq::tools::Version fVersion;
     float fRate; ///< Rate limiting for ConditionalRun
     uint64_t fMaxRunRuntimeInS; ///< Maximum runtime for the Running state handler, after which state will change to Ready (in seconds, 0 for no limit).
+    int fInitializationTimeoutInS;
     std::vector<std::string> fRawCmdLineArgs;
 
-    std::queue<fair::mq::State> fStates;
-    std::mutex fStatesMtx;
-    std::condition_variable fStatesCV;
+    fair::mq::StateQueue fStateQueue;
+
+    std::mutex fTransitionMtx;
+    bool fTransitioning;
 };
 
 #endif /* FAIRMQDEVICE_H_ */

fairmq/FairMQTransportFactory.cxx

@@ -27,7 +27,7 @@ FairMQTransportFactory::FairMQTransportFactory(const std::string& id)
 {
 }
 
-auto FairMQTransportFactory::CreateTransportFactory(const std::string& type, const std::string& id, const FairMQProgOptions* config) -> std::shared_ptr<FairMQTransportFactory>
+auto FairMQTransportFactory::CreateTransportFactory(const std::string& type, const std::string& id, const fair::mq::ProgOptions* config) -> std::shared_ptr<FairMQTransportFactory>
 {
     using namespace std;
 

fairmq/FairMQTransportFactory.h

@@ -12,6 +12,7 @@
 #include <FairMQLogger.h>
 #include <FairMQMessage.h>
 #include <FairMQPoller.h>
+#include <fairmq/ProgOptionsFwd.h>
 #include <FairMQSocket.h>
 #include <FairMQUnmanagedRegion.h>
 #include <fairmq/MemoryResources.h>
@@ -23,7 +24,6 @@
 #include <unordered_map>
 
 class FairMQChannel;
-class FairMQProgOptions;
 
 class FairMQTransportFactory
 {
@@ -72,7 +72,7 @@ class FairMQTransportFactory
     /// Create a poller for specific channels (all subchannels)
     virtual FairMQPollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const = 0;
 
-    virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr) const = 0;
+    virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0) const = 0;
 
     /// Get transport type
     virtual fair::mq::Transport GetType() const = 0;
@@ -83,7 +83,7 @@ class FairMQTransportFactory
 
     virtual ~FairMQTransportFactory() {};
 
-    static auto CreateTransportFactory(const std::string& type, const std::string& id = "", const FairMQProgOptions* config = nullptr) -> std::shared_ptr<FairMQTransportFactory>;
+    static auto CreateTransportFactory(const std::string& type, const std::string& id = "", const fair::mq::ProgOptions* config = nullptr) -> std::shared_ptr<FairMQTransportFactory>;
 
     static void FairMQNoCleanup(void* /*data*/, void* /*obj*/)
     {

fairmq/JSONParser.cxx

@@ -0,0 +1,187 @@
+/********************************************************************************
+ * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+/*
+ * File:   JSONParser.cxx
+ * Author: winckler
+ *
+ * Created on May 14, 2015, 5:01 PM
+ */
+
+#include <fairmq/PropertyOutput.h>
+#include "JSONParser.h"
+#include "FairMQLogger.h"
+#include <fairmq/Tools.h>
+
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/any.hpp>
+
+#include <ios>
+
+using namespace std;
+using namespace fair::mq;
+using namespace fair::mq::tools;
+using namespace boost::property_tree;
+
+namespace fair
+{
+namespace mq
+{
+
+fair::mq::Properties PtreeParser(const ptree& pt, const string& id)
+{
+    if (id == "") {
+        throw ParserError("no device ID provided. Provide with `--id` cmd option");
+    }
+
+    // json_parser::write_json(cout, pt);
+
+    return helper::DeviceParser(pt.get_child("fairMQOptions"), id);
+}
+
+fair::mq::Properties JSONParser(const string& filename, const string& deviceId)
+{
+    ptree pt;
+    LOG(debug) << "Parsing JSON from " << filename << " ...";
+    read_json(filename, pt);
+    return PtreeParser(pt, deviceId);
+}
+
+namespace helper
+{
+
+fair::mq::Properties DeviceParser(const ptree& fairMQOptions, const string& deviceId)
+{
+    fair::mq::Properties properties;
+
+    for (const auto& node : fairMQOptions) {
+        if (node.first == "devices") {
+            for (const auto& device : node.second) {
+                // check if key is provided, otherwise use id
+                string deviceIdKey = device.second.get<string>("key", device.second.get<string>("id", ""));
+
+                // if not correct device id, do not fill MQMap
+                if (deviceId != deviceIdKey) {
+                    continue;
+                }
+
+                LOG(trace) << "Found following channels for device ID '" << deviceId << "' :";
+                ChannelParser(device.second, properties);
+            }
+        }
+    }
+
+    return properties;
+}
+
+void ChannelParser(const ptree& tree, fair::mq::Properties& properties)
+{
+    for (const auto& node : tree) {
+        if (node.first == "channels") {
+            for (const auto& cn : node.second) {
+                fair::mq::Properties commonProperties;
+                commonProperties.emplace("type", cn.second.get<string>("type", FairMQChannel::DefaultType));
+                commonProperties.emplace("method", cn.second.get<string>("method", FairMQChannel::DefaultMethod));
+                commonProperties.emplace("address", cn.second.get<string>("address", FairMQChannel::DefaultAddress));
+                commonProperties.emplace("transport", cn.second.get<string>("transport", FairMQChannel::DefaultTransportName));
+                commonProperties.emplace("sndBufSize", cn.second.get<int>("sndBufSize", FairMQChannel::DefaultSndBufSize));
+                commonProperties.emplace("rcvBufSize", cn.second.get<int>("rcvBufSize", FairMQChannel::DefaultRcvBufSize));
+                commonProperties.emplace("sndKernelSize", cn.second.get<int>("sndKernelSize", FairMQChannel::DefaultSndKernelSize));
+                commonProperties.emplace("rcvKernelSize", cn.second.get<int>("rcvKernelSize", FairMQChannel::DefaultRcvKernelSize));
+                commonProperties.emplace("linger", cn.second.get<int>("linger", FairMQChannel::DefaultLinger));
+                commonProperties.emplace("rateLogging", cn.second.get<int>("rateLogging", FairMQChannel::DefaultRateLogging));
+                commonProperties.emplace("portRangeMin", cn.second.get<int>("portRangeMin", FairMQChannel::DefaultPortRangeMin));
+                commonProperties.emplace("portRangeMax", cn.second.get<int>("portRangeMax", FairMQChannel::DefaultPortRangeMax));
+                commonProperties.emplace("autoBind", cn.second.get<bool>("autoBind", FairMQChannel::DefaultAutoBind));
+
+                string name = cn.second.get<string>("name");
+                int numSockets = cn.second.get<int>("numSockets", 0);
+
+                if (numSockets > 0) {
+                    LOG(trace) << name << ":";
+                    LOG(trace) << "\tnumSockets of " << numSockets << " specified, applying common settings to each:";
+
+                    for (auto& p : commonProperties) {
+                        LOG(trace) << "\t" << setw(13) << left << p.first << " : " << p.second;
+                    }
+
+                    for (int i = 0; i < numSockets; ++i) {
+                        for (const auto& p : commonProperties) {
+                            properties.emplace(ToString("chans.", name, ".", i, ".", p.first), p.second);
+                        }
+                    }
+                } else {
+                    SubChannelParser(cn.second.get_child(""), properties, name, commonProperties);
+                }
+            }
+        }
+    }
+}
+
+void SubChannelParser(const ptree& channelTree, fair::mq::Properties& properties, const string& channelName, const fair::mq::Properties& commonProperties)
+{
+    // for each socket in channel
+    int i = 0;
+
+    for (const auto& node : channelTree) {
+        if (node.first == "sockets") {
+            for (const auto& sn : node.second) {
+                // a sub-channel inherits relevant properties from the common channel ...
+                fair::mq::Properties newProperties(commonProperties);
+
+                // ... and adds/overwrites its own properties
+                newProperties["type"] = sn.second.get<string>("type", boost::any_cast<string>(commonProperties.at("type")));
+                newProperties["method"] = sn.second.get<string>("method", boost::any_cast<string>(commonProperties.at("method")));
+                newProperties["address"] = sn.second.get<string>("address", boost::any_cast<string>(commonProperties.at("address")));
+                newProperties["transport"] = sn.second.get<string>("transport", boost::any_cast<string>(commonProperties.at("transport")));
+                newProperties["sndBufSize"] = sn.second.get<int>("sndBufSize", boost::any_cast<int>(commonProperties.at("sndBufSize")));
+                newProperties["rcvBufSize"] = sn.second.get<int>("rcvBufSize", boost::any_cast<int>(commonProperties.at("rcvBufSize")));
+                newProperties["sndKernelSize"] = sn.second.get<int>("sndKernelSize", boost::any_cast<int>(commonProperties.at("sndKernelSize")));
+                newProperties["rcvKernelSize"] = sn.second.get<int>("rcvKernelSize", boost::any_cast<int>(commonProperties.at("rcvKernelSize")));
+                newProperties["linger"] = sn.second.get<int>("linger", boost::any_cast<int>(commonProperties.at("linger")));
+                newProperties["rateLogging"] = sn.second.get<int>("rateLogging", boost::any_cast<int>(commonProperties.at("rateLogging")));
+                newProperties["portRangeMin"] = sn.second.get<int>("portRangeMin", boost::any_cast<int>(commonProperties.at("portRangeMin")));
+                newProperties["portRangeMax"] = sn.second.get<int>("portRangeMax", boost::any_cast<int>(commonProperties.at("portRangeMax")));
+                newProperties["autoBind"] = sn.second.get<bool>("autoBind", boost::any_cast<bool>(commonProperties.at("autoBind")));
+
+                LOG(trace) << "" << channelName << "[" << i << "]:";
+                for (auto& p : newProperties) {
+                    LOG(trace) << "\t" << setw(13) << left << p.first << " : " << p.second;
+                }
+
+                for (const auto& p : newProperties) {
+                    properties.emplace(ToString("chans.", channelName, ".", i, ".", p.first), p.second);
+                }
+                ++i;
+            }
+        }
+    }
+
+    if (i > 0) {
+        LOG(trace) << "Found " << i << " socket(s) in channel.";
+    } else {
+        // if no sockets are specified, apply common channel properties
+        LOG(trace) << "" << channelName << ":";
+        LOG(trace) << "\tNo sockets specified,";
+        LOG(trace) << "\tapplying common settings to the channel:";
+
+        fair::mq::Properties newProperties(commonProperties);
+
+        for (auto& p : newProperties) {
+            LOG(trace) << "\t" << setw(13) << left << p.first << " : " << p.second;
+        }
+
+        for (const auto& p : newProperties) {
+            properties.emplace(ToString("chans.", channelName, ".0.", p.first), p.second);
+        }
+    }
+}
+
+} // helper namespace
+} // namespace mq
+} // namespace fair

fairmq/JSONParser.h

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+/*
+ * File:   FairMQParser.h
+ * Author: winckler
+ *
+ * Created on May 14, 2015, 5:01 PM
+ */
+
+#ifndef FAIR_MQ_JSONPARSER_H
+#define FAIR_MQ_JSONPARSER_H
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <exception>
+
+#include <boost/property_tree/ptree_fwd.hpp>
+
+#include "FairMQChannel.h"
+#include <fairmq/Properties.h>
+
+namespace fair
+{
+namespace mq
+{
+
+struct ParserError : std::runtime_error { using std::runtime_error::runtime_error; };
+
+fair::mq::Properties PtreeParser(const boost::property_tree::ptree& pt, const std::string& deviceId);
+
+fair::mq::Properties JSONParser(const std::string& filename, const std::string& deviceId);
+
+namespace helper
+{
+
+fair::mq::Properties DeviceParser(const boost::property_tree::ptree& tree, const std::string& deviceId);
+void ChannelParser(const boost::property_tree::ptree& tree, fair::mq::Properties& properties);
+void SubChannelParser(const boost::property_tree::ptree& tree, fair::mq::Properties& properties, const std::string& channelName, const fair::mq::Properties& commonProperties);
+
+} // helper namespace
+
+} // namespace mq
+} // namespace fair
+
+#endif /* FAIR_MQ_JSONPARSER_H */

fairmq/Plugin.h

@@ -79,19 +79,37 @@ class Plugin
     auto StealDeviceControl() -> void { fPluginServices->StealDeviceControl(fkName); };
     auto ReleaseDeviceControl() -> void { fPluginServices->ReleaseDeviceControl(fkName); };
     auto ChangeDeviceState(const DeviceStateTransition next) -> bool { return fPluginServices->ChangeDeviceState(fkName, next); }
+    void TransitionDeviceStateTo(const DeviceState state) { return fPluginServices->TransitionDeviceStateTo(fkName, state); }
     auto SubscribeToDeviceStateChange(std::function<void(DeviceState)> callback) -> void { fPluginServices->SubscribeToDeviceStateChange(fkName, callback); }
     auto UnsubscribeFromDeviceStateChange() -> void { fPluginServices->UnsubscribeFromDeviceStateChange(fkName); }
 
     // device config API
     // see <fairmq/PluginServices.h> for docs
     auto PropertyExists(const std::string& key) -> int { return fPluginServices->PropertyExists(key); }
+
     template<typename T>
-    auto SetProperty(const std::string& key, T val) -> void { fPluginServices->SetProperty(key, val); }
+    T GetProperty(const std::string& key) const { return fPluginServices->GetProperty<T>(key); }
     template<typename T>
-    auto GetProperty(const std::string& key) const -> T { return fPluginServices->GetProperty<T>(key); }
-    auto GetPropertyAsString(const std::string& key) const -> std::string { return fPluginServices->GetPropertyAsString(key); }
+    T GetProperty(const std::string& key, const T& ifNotFound) const { return fPluginServices->GetProperty(key, ifNotFound); }
+    std::string GetPropertyAsString(const std::string& key) const { return fPluginServices->GetPropertyAsString(key); }
+    std::string GetPropertyAsString(const std::string& key, const std::string& ifNotFound) const  { return fPluginServices->GetPropertyAsString(key, ifNotFound); }
+    fair::mq::Properties GetProperties(const std::string& q) const { return fPluginServices->GetProperties(q); }
+    fair::mq::Properties GetPropertiesStartingWith(const std::string& q) const { return fPluginServices->GetPropertiesStartingWith(q); };
+    std::map<std::string, std::string> GetPropertiesAsString(const std::string& q) const { return fPluginServices->GetPropertiesAsString(q); }
+    std::map<std::string, std::string> GetPropertiesAsStringStartingWith(const std::string& q) const { return fPluginServices->GetPropertiesAsStringStartingWith(q); };
+
     auto GetChannelInfo() const -> std::unordered_map<std::string, int> { return fPluginServices->GetChannelInfo(); }
     auto GetPropertyKeys() const -> std::vector<std::string> { return fPluginServices->GetPropertyKeys(); }
+
+    template<typename T>
+    auto SetProperty(const std::string& key, T val) -> void { fPluginServices->SetProperty(key, val); }
+    void SetProperties(const fair::mq::Properties& props) { fPluginServices->SetProperties(props); }
+    template<typename T>
+    bool UpdateProperty(const std::string& key, T val) { return fPluginServices->UpdateProperty(key, val); }
+    bool UpdateProperties(const fair::mq::Properties& input) { return fPluginServices->UpdateProperties(input); }
+
+    void DeleteProperty(const std::string& key) { fPluginServices->DeleteProperty(key); }
+
     template<typename T>
     auto SubscribeToPropertyChange(std::function<void(const std::string& key, T newValue)> callback) -> void { fPluginServices->SubscribeToPropertyChange<T>(fkName, callback); }
     template<typename T>

fairmq/PluginManager.cxx

@@ -49,13 +49,11 @@ fair::mq::PluginManager::PluginManager(const vector<string> args)
     // Parse command line options
     auto options = ProgramOptions();
     auto vm = po::variables_map{};
-    try
-    {
+    try {
         auto parsed = po::command_line_parser(args).options(options).allow_unregistered().run();
         po::store(parsed, vm);
         po::notify(vm);
-    } catch (const po::error& e)
-    {
+    } catch (const po::error& e) {
         throw ProgramOptionsParseError{ToString("Error occured while parsing the 'Plugin Manager' program options: ", e.what())};
     }
 
@@ -63,10 +61,8 @@ fair::mq::PluginManager::PluginManager(const vector<string> args)
     auto append = vector<fs::path>{};
     auto prepend = vector<fs::path>{};
     auto searchPaths = vector<fs::path>{};
-    if (vm.count("plugin-search-path"))
-    {
-        for (const auto& path : vm["plugin-search-path"].as<vector<string>>())
-        {
+    if (vm.count("plugin-search-path")) {
+        for (const auto& path : vm["plugin-search-path"].as<vector<string>>()) {
             if      (path.substr(0, 1) == "<") { prepend.emplace_back(path.substr(1)); }
             else if (path.substr(0, 1) == ">") { append.emplace_back(path.substr(1)); }
             else                               { searchPaths.emplace_back(path); }
@@ -126,23 +122,16 @@ auto fair::mq::PluginManager::ProgramOptions() -> po::options_description
 
 auto fair::mq::PluginManager::LoadPlugin(const string& pluginName) -> void
 {
-    if (pluginName.substr(0,2) == "p:")
-    {
+    if (pluginName.substr(0,2) == "p:") {
         // Mechanism A: prelinked dynamic
         LoadPluginPrelinkedDynamic(pluginName.substr(2));
-    }
-    else if (pluginName.substr(0,2) == "d:")
-    {
+    } else if (pluginName.substr(0,2) == "d:") {
         // Mechanism B: dynamic
         LoadPluginDynamic(pluginName.substr(2));
-    }
-    else if (pluginName.substr(0,2) == "s:")
-    {
+    } else if (pluginName.substr(0,2) == "s:") {
         // Mechanism C: static (builtin)
         LoadPluginStatic(pluginName.substr(2));
-    }
-    else
-    {
+    } else {
         // Mechanism B: dynamic (default)
         LoadPluginDynamic(pluginName);
     }
@@ -151,15 +140,11 @@ auto fair::mq::PluginManager::LoadPlugin(const string& pluginName) -> void
 auto fair::mq::PluginManager::LoadPluginPrelinkedDynamic(const string& pluginName) -> void
 {
     // Load symbol
-    if (fPluginFactories.find(pluginName) == fPluginFactories.end())
-    {
-        try
-        {
+    if (fPluginFactories.find(pluginName) == fPluginFactories.end()) {
+        try {
             LoadSymbols(pluginName, dll::program_location());
             fPluginOrder.push_back(pluginName);
-        }
-        catch (boost::system::system_error& e)
-        {
+        } catch (boost::system::system_error& e) {
             throw PluginLoadError(ToString("An error occurred while loading prelinked dynamic plugin ", pluginName, ": ", e.what()));
         }
     }
@@ -168,13 +153,11 @@ auto fair::mq::PluginManager::LoadPluginPrelinkedDynamic(const string& pluginNam
 auto fair::mq::PluginManager::LoadPluginDynamic(const string& pluginName) -> void
 {
     // Search plugin and load, if found
-    if (fPluginFactories.find(pluginName) == fPluginFactories.end())
-    {
+    if (fPluginFactories.find(pluginName) == fPluginFactories.end()) {
         auto success = false;
         for (const auto& searchPath : SearchPaths()) {
             try {
-                LoadSymbols(pluginName,
-                            searchPath / ToString(LibPrefix(), pluginName),
+                LoadSymbols(pluginName, searchPath / ToString(LibPrefix(), pluginName),
                             dll::load_mode::append_decorations | dll::load_mode::rtld_global);
                 fPluginOrder.push_back(pluginName);
                 success = true;
@@ -213,15 +196,11 @@ auto fair::mq::PluginManager::LoadPluginDynamic(const string& pluginName) -> voi
 auto fair::mq::PluginManager::LoadPluginStatic(const string& pluginName) -> void
 {
     // Load symbol
-    if (fPluginFactories.find(pluginName) == fPluginFactories.end())
-    {
-        try
-        {
+    if (fPluginFactories.find(pluginName) == fPluginFactories.end()) {
+        try {
             LoadSymbols(pluginName, dll::program_location());
             fPluginOrder.push_back(pluginName);
-        }
-        catch (boost::system::system_error& e)
-        {
+        } catch (boost::system::system_error& e) {
             throw PluginLoadError(ToString("An error occurred while loading static plugin ", pluginName, ": ", e.what()));
         }
     }
@@ -229,22 +208,17 @@ auto fair::mq::PluginManager::LoadPluginStatic(const string& pluginName) -> void
 
 auto fair::mq::PluginManager::InstantiatePlugin(const string& pluginName) -> void
 {
-    if (fPlugins.find(pluginName) == fPlugins.end())
-    {
+    if (fPlugins.find(pluginName) == fPlugins.end()) {
         fPlugins[pluginName] = fPluginFactories[pluginName](*fPluginServices);
     }
 }
 
 auto fair::mq::PluginManager::InstantiatePlugins() -> void
 {
-    for(const auto& pluginName : fPluginOrder)
-    {
-        try
-        {
+    for(const auto& pluginName : fPluginOrder) {
+        try {
             InstantiatePlugin(pluginName);
-        }
-        catch (std::exception& e)
-        {
+        } catch (std::exception& e) {
             throw PluginInstantiationError(ToString("An error occurred while instantiating plugin ", pluginName, ": ", e.what()));
         }
     }

fairmq/PluginServices.cxx

@@ -11,134 +11,47 @@
 using namespace fair::mq;
 using namespace std;
 
-const std::unordered_map<std::string, PluginServices::DeviceState> PluginServices::fkDeviceStateStrMap = {
-    {"OK",                  DeviceState::Ok},
-    {"ERROR",               DeviceState::Error},
-    {"IDLE",                DeviceState::Idle},
-    {"INITIALIZING DEVICE", DeviceState::InitializingDevice},
-    {"INITIALIZED",         DeviceState::Initialized},
-    {"BINDING",             DeviceState::Binding},
-    {"BOUND",               DeviceState::Bound},
-    {"CONNECTING",          DeviceState::Connecting},
-    {"DEVICE READY",        DeviceState::DeviceReady},
-    {"INITIALIZING TASK",   DeviceState::InitializingTask},
-    {"READY",               DeviceState::Ready},
-    {"RUNNING",             DeviceState::Running},
-    {"RESETTING TASK",      DeviceState::ResettingTask},
-    {"RESETTING DEVICE",    DeviceState::ResettingDevice},
-    {"EXITING",             DeviceState::Exiting}
-};
-const std::unordered_map<PluginServices::DeviceState, std::string, tools::HashEnum<PluginServices::DeviceState>> PluginServices::fkStrDeviceStateMap = {
-    {DeviceState::Ok,                 "OK"},
-    {DeviceState::Error,              "ERROR"},
-    {DeviceState::Idle,               "IDLE"},
-    {DeviceState::InitializingDevice, "INITIALIZING DEVICE"},
-    {DeviceState::Initialized,        "INITIALIZED"},
-    {DeviceState::Binding,            "BINDING"},
-    {DeviceState::Bound,              "BOUND"},
-    {DeviceState::Connecting,         "CONNECTING"},
-    {DeviceState::DeviceReady,        "DEVICE READY"},
-    {DeviceState::InitializingTask,   "INITIALIZING TASK"},
-    {DeviceState::Ready,              "READY"},
-    {DeviceState::Running,            "RUNNING"},
-    {DeviceState::ResettingTask,      "RESETTING TASK"},
-    {DeviceState::ResettingDevice,    "RESETTING DEVICE"},
-    {DeviceState::Exiting,            "EXITING"}
-};
-const std::unordered_map<std::string, PluginServices::DeviceStateTransition> PluginServices::fkDeviceStateTransitionStrMap = {
-    {"AUTO",          DeviceStateTransition::Auto},
-    {"INIT DEVICE",   DeviceStateTransition::InitDevice},
-    {"COMPLETE INIT", DeviceStateTransition::CompleteInit},
-    {"BIND",          DeviceStateTransition::Bind},
-    {"CONNECT",       DeviceStateTransition::Connect},
-    {"INIT TASK",     DeviceStateTransition::InitTask},
-    {"RUN",           DeviceStateTransition::Run},
-    {"STOP",          DeviceStateTransition::Stop},
-    {"RESET TASK",    DeviceStateTransition::ResetTask},
-    {"RESET DEVICE",  DeviceStateTransition::ResetDevice},
-    {"END",           DeviceStateTransition::End},
-    {"ERROR FOUND",   DeviceStateTransition::ErrorFound},
-};
-const std::unordered_map<PluginServices::DeviceStateTransition, std::string, tools::HashEnum<PluginServices::DeviceStateTransition>> PluginServices::fkStrDeviceStateTransitionMap = {
-    {DeviceStateTransition::Auto,         "Auto"},
-    {DeviceStateTransition::InitDevice,   "INIT DEVICE"},
-    {DeviceStateTransition::CompleteInit, "COMPLETE INIT"},
-    {DeviceStateTransition::Bind,         "BIND"},
-    {DeviceStateTransition::Connect,      "CONNECT"},
-    {DeviceStateTransition::InitTask,     "INIT TASK"},
-    {DeviceStateTransition::Run,          "RUN"},
-    {DeviceStateTransition::Stop,         "STOP"},
-    {DeviceStateTransition::ResetTask,    "RESET TASK"},
-    {DeviceStateTransition::ResetDevice,  "RESET DEVICE"},
-    {DeviceStateTransition::End,          "END"},
-    {DeviceStateTransition::ErrorFound,   "ERROR FOUND"},
-};
-const std::unordered_map<fair::mq::State, PluginServices::DeviceState, fair::mq::tools::HashEnum<fair::mq::State>> PluginServices::fkDeviceStateMap = {
-    {fair::mq::State::Ok,                 DeviceState::Ok},
-    {fair::mq::State::Error,              DeviceState::Error},
-    {fair::mq::State::Idle,               DeviceState::Idle},
-    {fair::mq::State::InitializingDevice, DeviceState::InitializingDevice},
-    {fair::mq::State::Initialized,        DeviceState::Initialized},
-    {fair::mq::State::Binding,            DeviceState::Binding},
-    {fair::mq::State::Bound,              DeviceState::Bound},
-    {fair::mq::State::Connecting,         DeviceState::Connecting},
-    {fair::mq::State::DeviceReady,        DeviceState::DeviceReady},
-    {fair::mq::State::InitializingTask,   DeviceState::InitializingTask},
-    {fair::mq::State::Ready,              DeviceState::Ready},
-    {fair::mq::State::Running,            DeviceState::Running},
-    {fair::mq::State::ResettingTask,      DeviceState::ResettingTask},
-    {fair::mq::State::ResettingDevice,    DeviceState::ResettingDevice},
-    {fair::mq::State::Exiting,            DeviceState::Exiting}
-};
-const std::unordered_map<PluginServices::DeviceStateTransition, fair::mq::Transition, tools::HashEnum<PluginServices::DeviceStateTransition>> PluginServices::fkDeviceStateTransitionMap = {
-    {DeviceStateTransition::Auto,         fair::mq::Transition::Auto},
-    {DeviceStateTransition::InitDevice,   fair::mq::Transition::InitDevice},
-    {DeviceStateTransition::CompleteInit, fair::mq::Transition::CompleteInit},
-    {DeviceStateTransition::Bind,         fair::mq::Transition::Bind},
-    {DeviceStateTransition::Connect,      fair::mq::Transition::Connect},
-    {DeviceStateTransition::InitTask,     fair::mq::Transition::InitTask},
-    {DeviceStateTransition::Run,          fair::mq::Transition::Run},
-    {DeviceStateTransition::Stop,         fair::mq::Transition::Stop},
-    {DeviceStateTransition::ResetTask,    fair::mq::Transition::ResetTask},
-    {DeviceStateTransition::ResetDevice,  fair::mq::Transition::ResetDevice},
-    {DeviceStateTransition::End,          fair::mq::Transition::End},
-    {DeviceStateTransition::ErrorFound,   fair::mq::Transition::ErrorFound}
-};
-
-auto PluginServices::ChangeDeviceState(const std::string& controller, const DeviceStateTransition next) -> bool
+auto PluginServices::ChangeDeviceState(const string& controller, const DeviceStateTransition next) -> bool
 {
     lock_guard<mutex> lock{fDeviceControllerMutex};
 
     if (!fDeviceController) fDeviceController = controller;
 
-    bool result = false;
-
     if (fDeviceController == controller) {
-        result = fDevice.ChangeState(fkDeviceStateTransitionMap.at(next));
+        return fDevice.ChangeState(next);
     } else {
         throw DeviceControlError{tools::ToString(
             "Plugin '", controller, "' is not allowed to change device states. ",
             "Currently, plugin '", *fDeviceController, "' has taken control."
         )};
     }
-
-    return result;
 }
 
-auto PluginServices::TakeDeviceControl(const std::string& controller) -> void
+void PluginServices::TransitionDeviceStateTo(const std::string& controller, DeviceState state)
 {
     lock_guard<mutex> lock{fDeviceControllerMutex};
 
-    if (!fDeviceController)
-    {
+    if (!fDeviceController) fDeviceController = controller;
+
+    if (fDeviceController == controller) {
+        fDevice.TransitionTo(state);
+    } else {
+        throw DeviceControlError{tools::ToString(
+            "Plugin '", controller, "' is not allowed to change device states. ",
+            "Currently, plugin '", *fDeviceController, "' has taken control."
+        )};
+    }
+}
+
+auto PluginServices::TakeDeviceControl(const string& controller) -> void
+{
+    lock_guard<mutex> lock{fDeviceControllerMutex};
+
+    if (!fDeviceController) {
         fDeviceController = controller;
-    }
-    else if (fDeviceController == controller)
-    {
+    } else if (fDeviceController == controller) {
         // nothing to do
-    }
-    else
-    {
+    } else {
         throw DeviceControlError{tools::ToString(
             "Plugin '", controller, "' is not allowed to take over control. ",
             "Currently, plugin '", *fDeviceController, "' has taken control."
@@ -146,32 +59,30 @@ auto PluginServices::TakeDeviceControl(const std::string& controller) -> void
     }
 }
 
-auto PluginServices::StealDeviceControl(const std::string& controller) -> void
+auto PluginServices::StealDeviceControl(const string& controller) -> void
 {
     lock_guard<mutex> lock{fDeviceControllerMutex};
 
     fDeviceController = controller;
 }
 
-auto PluginServices::ReleaseDeviceControl(const std::string& controller) -> void
+auto PluginServices::ReleaseDeviceControl(const string& controller) -> void
 {
     {
         lock_guard<mutex> lock{fDeviceControllerMutex};
 
-        if (fDeviceController == controller)
-        {
+        if (fDeviceController == controller) {
             fDeviceController = boost::none;
-        }
-        else
-        {
-            throw DeviceControlError{tools::ToString("Plugin '", controller, "' cannot release control because it has not taken over control.")};
+        } else {
+            LOG(debug) << "Plugin '" << controller << "' cannot release control "
+                       << "because it has no control.";
         }
     }
 
     fReleaseDeviceControlCondition.notify_one();
 }
 
-auto PluginServices::GetDeviceController() const -> boost::optional<std::string>
+auto PluginServices::GetDeviceController() const -> boost::optional<string>
 {
     lock_guard<mutex> lock{fDeviceControllerMutex};
 
@@ -182,8 +93,7 @@ auto PluginServices::WaitForReleaseDeviceControl() -> void
 {
     unique_lock<mutex> lock{fDeviceControllerMutex};
 
-    while (fDeviceController)
-    {
+    while (fDeviceController) {
         fReleaseDeviceControlCondition.wait(lock);
     }
 }

fairmq/PluginServices.h

@@ -10,8 +10,10 @@
 #define FAIR_MQ_PLUGINSERVICES_H
 
 #include <fairmq/Tools.h>
+#include <fairmq/States.h>
 #include <FairMQDevice.h>
-#include <options/FairMQProgOptions.h>
+#include <fairmq/ProgOptions.h>
+#include <fairmq/Properties.h>
 
 #include <boost/optional.hpp>
 #include <boost/optional/optional_io.hpp>
@@ -20,6 +22,7 @@
 #include <string>
 #include <unordered_map>
 #include <mutex>
+#include <map>
 #include <condition_variable>
 #include <stdexcept>
 
@@ -39,7 +42,7 @@ class PluginServices
 {
   public:
     PluginServices() = delete;
-    PluginServices(FairMQProgOptions& config, FairMQDevice& device)
+    PluginServices(ProgOptions& config, FairMQDevice& device)
         : fConfig(config)
         , fDevice(device)
         , fDeviceController()
@@ -56,41 +59,8 @@ class PluginServices
     PluginServices(const PluginServices&) = delete;
     PluginServices operator=(const PluginServices&) = delete;
 
-    /// See https://github.com/FairRootGroup/FairRoot/blob/dev/fairmq/docs/Device.md#13-state-machine
-    enum class DeviceState : int
-    {
-        Ok,
-        Error,
-        Idle,
-        InitializingDevice,
-        Initialized,
-        Binding,
-        Bound,
-        Connecting,
-        DeviceReady,
-        InitializingTask,
-        Ready,
-        Running,
-        ResettingTask,
-        ResettingDevice,
-        Exiting
-    };
-
-    enum class DeviceStateTransition : int // transition event between DeviceStates
-    {
-        Auto,
-        InitDevice,
-        CompleteInit,
-        Bind,
-        Connect,
-        InitTask,
-        Run,
-        Stop,
-        ResetTask,
-        ResetDevice,
-        End,
-        ErrorFound
-    };
+    using DeviceState = fair::mq::State;
+    using DeviceStateTransition = fair::mq::Transition;
 
     // Control API
 
@@ -98,29 +68,26 @@ class PluginServices
     /// @param state to convert
     /// @return DeviceState enum entry
     /// @throw std::out_of_range if a string cannot be resolved to a DeviceState
-    static auto ToDeviceState(const std::string& state) -> DeviceState { return fkDeviceStateStrMap.at(state); }
+    static auto ToDeviceState(const std::string& state) -> DeviceState { return GetState(state); }
 
     /// @brief Convert string to DeviceStateTransition
     /// @param transition to convert
     /// @return DeviceStateTransition enum entry
     /// @throw std::out_of_range if a string cannot be resolved to a DeviceStateTransition
-    static auto ToDeviceStateTransition(const std::string& transition) -> DeviceStateTransition { return fkDeviceStateTransitionStrMap.at(transition); }
+    static auto ToDeviceStateTransition(const std::string& transition) -> DeviceStateTransition { return GetTransition(transition); }
 
     /// @brief Convert DeviceState to string
     /// @param state to convert
     /// @return string representation of DeviceState enum entry
-    static auto ToStr(DeviceState state) -> std::string { return fkStrDeviceStateMap.at(state); }
+    static auto ToStr(DeviceState state) -> std::string { return GetStateName(state); }
 
     /// @brief Convert DeviceStateTransition to string
     /// @param transition to convert
     /// @return string representation of DeviceStateTransition enum entry
-    static auto ToStr(DeviceStateTransition transition) -> std::string { return fkStrDeviceStateTransitionMap.at(transition); }
-
-    friend auto operator<<(std::ostream& os, const DeviceState& state) -> std::ostream& { return os << ToStr(state); }
-    friend auto operator<<(std::ostream& os, const DeviceStateTransition& transition) -> std::ostream& { return os << ToStr(transition); }
+    static auto ToStr(DeviceStateTransition transition) -> std::string { return GetTransitionName(transition); }
 
     /// @return current device state
-    auto GetCurrentDeviceState() const -> DeviceState { return fkDeviceStateMap.at(static_cast<fair::mq::State>(fDevice.GetCurrentState())); }
+    auto GetCurrentDeviceState() const -> DeviceState { return fDevice.GetCurrentState(); }
 
     /// @brief Become device controller
     /// @param controller id
@@ -158,6 +125,8 @@ class PluginServices
     /// If the device control role has not been taken yet, calling this function will take over control implicitely.
     auto ChangeDeviceState(const std::string& controller, const DeviceStateTransition next) -> bool;
 
+    void TransitionDeviceStateTo(const std::string& controller, DeviceState state);
+
     /// @brief Subscribe with a callback to device state changes
     /// @param subscriber id
     /// @param callback
@@ -167,7 +136,7 @@ class PluginServices
     auto SubscribeToDeviceStateChange(const std::string& subscriber, std::function<void(DeviceState /*newState*/)> callback) -> void
     {
         fDevice.SubscribeToStateChange(subscriber, [&,callback](fair::mq::State newState){
-            callback(fkDeviceStateMap.at(newState));
+            callback(newState);
         });
     }
 
@@ -176,63 +145,91 @@ class PluginServices
     auto UnsubscribeFromDeviceStateChange(const std::string& subscriber) -> void { fDevice.UnsubscribeFromStateChange(subscriber); }
 
     // Config API
-    struct PropertyNotFoundError : std::runtime_error { using std::runtime_error::runtime_error; };
 
+    /// @brief Checks a property with the given key exist in the configuration
+    /// @param key
+    /// @return true if it exists, false otherwise
     auto PropertyExists(const std::string& key) const -> bool { return fConfig.Count(key) > 0; }
 
     /// @brief Set config property
     /// @param key
     /// @param val
-    /// @throws fair::mq::PluginServices::InvalidStateError if method is called in unsupported device states
     ///
     /// Setting a config property will store the value in the FairMQ internal config store and notify any subscribers about the update.
     /// It is property dependent, if the call to this method will have an immediate, delayed or any effect at all.
     template<typename T>
-    auto SetProperty(const std::string& key, T val) -> void
-    {
-        auto currentState = GetCurrentDeviceState();
-        if (   (currentState == DeviceState::InitializingDevice)
-            || (currentState == DeviceState::Initialized)
-            || (currentState == DeviceState::Binding)
-            || (currentState == DeviceState::Bound)
-            || (currentState == DeviceState::Connecting)
-            || (currentState == DeviceState::Ready)
-            || (currentState == DeviceState::Idle && key == "channel-config")) {
-            fConfig.SetValue(key, val);
-        } else {
-            throw InvalidStateError{
-                tools::ToString("PluginServices::SetProperty is not supported in device state ", currentState, ". ",
-                                "Supported state is ", DeviceState::InitializingDevice, ".")};
-        }
-    }
-    struct InvalidStateError : std::runtime_error { using std::runtime_error::runtime_error; };
-
-    /// @brief Read config property
+    auto SetProperty(const std::string& key, T val) -> void { fConfig.SetProperty(key, val); }
+    /// @brief Set multiple config properties
+    /// @param props fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any
+    void SetProperties(const fair::mq::Properties& props) { fConfig.SetProperties(props); }
+    /// @brief Updates an existing config property (or fails if it doesn't exist)
     /// @param key
-    /// @return config property value
-    ///
-    /// TODO Currently, if a non-existing key is requested and a default constructed object is returned.
-    /// This behaviour will be changed in the future to throw an exception in that case to provide a proper sentinel.
+    /// @param val
     template<typename T>
-    auto GetProperty(const std::string& key) const -> T {
-        if (PropertyExists(key)) {
-            return fConfig.GetValue<T>(key);
-        }
-        throw PropertyNotFoundError(fair::mq::tools::ToString("Config has no key: ", key));
-    }
+    bool UpdateProperty(const std::string& key, T val) { return fConfig.UpdateProperty(key, val); }
+    /// @brief Updates multiple existing config properties (or fails of any of then do not exist, leaving property store unchanged)
+    /// @param props (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    bool UpdateProperties(const fair::mq::Properties& input) { return fConfig.UpdateProperties(input); }
 
-    /// @brief Read config property as string
+    /// @brief Deletes a property with the given key from the config store
     /// @param key
-    /// @return config property value converted to string
-    ///
-    /// If a type is not supported, the user can provide support by overloading the ostream operator for this type
-    auto GetPropertyAsString(const std::string& key) const -> std::string {
-        if (PropertyExists(key)) {
-            return fConfig.GetStringValue(key);
-        }
-        throw PropertyNotFoundError(fair::mq::tools::ToString("Config has no key: ", key));
-    }
+    void DeleteProperty(const std::string& key) { fConfig.DeleteProperty(key); }
 
+    /// @brief Read config property, throw if no property with this key exists
+    /// @param key
+    /// @return config property
+    template<typename T>
+    auto GetProperty(const std::string& key) const -> T { return fConfig.GetProperty<T>(key); }
+
+    /// @brief Read config property, return provided value if no property with this key exists
+    /// @param key
+    /// @param ifNotFound value to return if key is not found
+    /// @return config property
+    template<typename T>
+    T GetProperty(const std::string& key, const T& ifNotFound) const { return fConfig.GetProperty(key, ifNotFound); }
+
+    /// @brief Read config property as string, throw if no property with this key exists
+    /// @param key
+    /// @return config property converted to string
+    ///
+    /// Supports conversion to string for a fixed set of types,
+    /// for custom/unsupported types add them via `fair::mq::PropertyHelper::AddType<MyType>("optional label")`
+    /// the provided type must then be convertible to string via operator<<
+    auto GetPropertyAsString(const std::string& key) const -> std::string { return fConfig.GetPropertyAsString(key); }
+
+    /// @brief Read config property, return provided value if no property with this key exists
+    /// @param key
+    /// @param ifNotFound value to return if key is not found
+    /// @return config property converted to string
+    ///
+    /// Supports conversion to string for a fixed set of types,
+    /// for custom/unsupported types add them via `fair::mq::PropertyHelper::AddType<MyType>("optional label")`
+    /// the provided type must then be convertible to string via operator<<
+    auto GetPropertyAsString(const std::string& key, const std::string& ifNotFound) const -> std::string { return fConfig.GetPropertyAsString(key, ifNotFound); }
+
+    /// @brief Read several config properties whose keys match the provided regular expression
+    /// @param q regex string to match for
+    /// @return container with properties (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    fair::mq::Properties GetProperties(const std::string& q) const { return fConfig.GetProperties(q); }
+    /// @brief Read several config properties whose keys start with the provided string
+    /// @param q string to match for
+    /// @return container with properties (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    ///
+    /// Typically more performant than GetProperties with regex
+    fair::mq::Properties GetPropertiesStartingWith(const std::string& q) const { return fConfig.GetPropertiesStartingWith(q); }
+    /// @brief Read several config properties as string whose keys match the provided regular expression
+    /// @param q regex string to match for
+    /// @return container with properties (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    std::map<std::string, std::string> GetPropertiesAsString(const std::string& q) const { return fConfig.GetPropertiesAsString(q); }
+    /// @brief Read several config properties as string whose keys start with the provided string
+    /// @param q string to match for
+    /// @return container with properties (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    ///
+    /// Typically more performant than GetPropertiesAsString with regex
+    std::map<std::string, std::string> GetPropertiesAsStringStartingWith(const std::string& q) const { return fConfig.GetPropertiesAsStringStartingWith(q); }
+
+    /// @brief Retrieve current channel information
+    /// @return a map of <channel name, number of subchannels>
     auto GetChannelInfo() const -> std::unordered_map<std::string, int> { return fConfig.GetChannelInfo(); }
 
     /// @brief Discover the list of property keys
@@ -269,20 +266,17 @@ class PluginServices
     /// @param subscriber
     auto UnsubscribeFromPropertyChangeAsString(const std::string& subscriber) -> void { fConfig.UnsubscribeAsString(subscriber); }
 
+    /// @brief Increases console logging severity, or sets it to lowest if it is already highest
     auto CycleLogConsoleSeverityUp() -> void { Logger::CycleConsoleSeverityUp(); }
+    /// @brief Decreases console logging severity, or sets it to highest if it is already lowest
     auto CycleLogConsoleSeverityDown() -> void { Logger::CycleConsoleSeverityDown(); }
+    /// @brief Increases logging verbosity, or sets it to lowest if it is already highest
     auto CycleLogVerbosityUp() -> void { Logger::CycleVerbosityUp(); }
+    /// @brief Decreases logging verbosity, or sets it to highest if it is already lowest
     auto CycleLogVerbosityDown() -> void { Logger::CycleVerbosityDown(); }
 
-    static const std::unordered_map<std::string, DeviceState> fkDeviceStateStrMap;
-    static const std::unordered_map<DeviceState, std::string, tools::HashEnum<DeviceState>> fkStrDeviceStateMap;
-    static const std::unordered_map<std::string, DeviceStateTransition> fkDeviceStateTransitionStrMap;
-    static const std::unordered_map<DeviceStateTransition, std::string, tools::HashEnum<DeviceStateTransition>> fkStrDeviceStateTransitionMap;
-    static const std::unordered_map<fair::mq::State, DeviceState, tools::HashEnum<fair::mq::State>> fkDeviceStateMap;
-    static const std::unordered_map<DeviceStateTransition, fair::mq::Transition, tools::HashEnum<DeviceStateTransition>> fkDeviceStateTransitionMap;
-
   private:
-    FairMQProgOptions& fConfig;
+    fair::mq::ProgOptions& fConfig;
     FairMQDevice& fDevice;
     boost::optional<std::string> fDeviceController;
     mutable std::mutex fDeviceControllerMutex;

fairmq/ProgOptions.cxx

@@ -0,0 +1,446 @@
+/********************************************************************************
+ * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+/*
+ * File:   ProgOptions.cxx
+ * Author: winckler
+ *
+ * Created on March 11, 2015, 10:20 PM
+ */
+
+#include "FairMQLogger.h"
+#include <fairmq/ProgOptions.h>
+
+#include "tools/Unique.h"
+
+#include <boost/any.hpp>
+#include <boost/regex.hpp>
+
+#include <algorithm>
+#include <exception>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <utility> // pair
+
+using namespace std;
+using namespace fair::mq;
+
+namespace po = boost::program_options;
+
+struct ValInfo
+{
+    string value;
+    string type;
+    string origin;
+};
+
+namespace fair
+{
+namespace mq
+{
+
+ValInfo ConvertVarValToValInfo(const po::variable_value& v)
+{
+    string origin;
+
+    if (v.defaulted()) {
+        origin = "[default]";
+    } else if (v.empty()) {
+        origin = "[empty]";
+    } else {
+        origin = "[provided]";
+    }
+
+    try {
+        pair<string, string> info = PropertyHelper::GetPropertyInfo(v.value());
+        return {info.first, info.second, origin};
+    } catch (out_of_range& oor) {
+        return {string("[unidentified_type]"), string("[unidentified_type]"), origin};
+    }
+};
+
+string ConvertVarValToString(const po::variable_value& v)
+{
+    return ConvertVarValToValInfo(v).value;
+}
+
+ProgOptions::ProgOptions()
+    : fVarMap()
+    , fAllOptions("FairMQ Command Line Options")
+    , fUnregisteredOptions()
+    , fEvents()
+    , fMtx()
+{
+    fAllOptions.add_options()
+        ("help,h",                                                      "Print help")
+        ("version,v",                                                   "Print version")
+        ("severity",      po::value<string>()->default_value("debug"),  "Log severity level (console): trace, debug, info, state, warn, error, fatal, nolog")
+        ("file-severity", po::value<string>()->default_value("debug"),  "Log severity level (file): trace, debug, info, state, warn, error, fatal, nolog")
+        ("verbosity",     po::value<string>()->default_value("medium"), "Log verbosity level: veryhigh, high, medium, low")
+        ("color",         po::value<bool  >()->default_value(true),     "Log color (true/false)")
+        ("log-to-file",   po::value<string>()->default_value(""),       "Log output to a file.")
+        ("print-options", po::value<bool  >()->implicit_value(true),    "Print options in machine-readable format (<option>:<computed-value>:<type>:<description>)");
+
+    ParseDefaults();
+}
+
+void ProgOptions::ParseDefaults()
+{
+    vector<string> emptyArgs = {"dummy"};
+
+    vector<const char*> argv(emptyArgs.size());
+
+    transform(emptyArgs.begin(), emptyArgs.end(), argv.begin(), [](const string& str) {
+        return str.c_str();
+    });
+
+    po::store(po::parse_command_line(argv.size(), const_cast<char**>(argv.data()), fAllOptions), fVarMap);
+}
+
+void ProgOptions::ParseAll(const vector<string>& cmdArgs, bool allowUnregistered)
+{
+    vector<const char*> argv(cmdArgs.size());
+    transform(cmdArgs.begin(), cmdArgs.end(), argv.begin(), [](const string& str) {
+        return str.c_str();
+    });
+    ParseAll(argv.size(), const_cast<char**>(argv.data()), allowUnregistered);
+}
+
+void ProgOptions::ParseAll(const int argc, char const* const* argv, bool allowUnregistered)
+{
+    lock_guard<mutex> lock(fMtx);
+    // clear the container because it was filled with default values and subsequent calls to store() do not overwrite the existing values
+    fVarMap.clear();
+
+    if (allowUnregistered) {
+        po::command_line_parser parser(argc, argv);
+        parser.options(fAllOptions).allow_unregistered();
+        po::parsed_options parsed = parser.run();
+        fUnregisteredOptions = po::collect_unrecognized(parsed.options, po::include_positional);
+
+        po::store(parsed, fVarMap);
+    } else {
+        po::store(po::parse_command_line(argc, argv, fAllOptions), fVarMap);
+    }
+}
+
+void ProgOptions::Notify()
+{
+    lock_guard<mutex> lock(fMtx);
+    po::notify(fVarMap);
+}
+
+void ProgOptions::AddToCmdLineOptions(const po::options_description optDesc, bool /* visible */)
+{
+    lock_guard<mutex> lock(fMtx);
+    fAllOptions.add(optDesc);
+}
+
+po::options_description& ProgOptions::GetCmdLineOptions()
+{
+    return fAllOptions;
+}
+
+int ProgOptions::Count(const string& key) const
+{
+    lock_guard<mutex> lock(fMtx);
+    return fVarMap.count(key);
+}
+
+unordered_map<string, int> ProgOptions::GetChannelInfo() const
+{
+    lock_guard<mutex> lock(fMtx);
+    return GetChannelInfoImpl();
+}
+
+unordered_map<string, int> ProgOptions::GetChannelInfoImpl() const
+{
+    unordered_map<string, int> info;
+
+    boost::regex re("chans\\..*\\.type");
+    for (const auto& m : fVarMap) {
+        if (boost::regex_match(m.first, re)) {
+            string chan = m.first.substr(6);
+            string::size_type n = chan.find(".");
+            string chanName = chan.substr(0, n);
+
+            if (info.find(chanName) == info.end()) {
+                info.emplace(chanName, 1);
+            } else {
+                info[chanName] = info[chanName] + 1;
+            }
+        }
+    }
+
+    return info;
+}
+
+vector<string> ProgOptions::GetPropertyKeys() const
+{
+    lock_guard<mutex> lock(fMtx);
+
+    vector<string> keys;
+
+    for (const auto& it : fVarMap) {
+        keys.push_back(it.first.c_str());
+    }
+
+    return keys;
+}
+
+string ProgOptions::GetPropertyAsString(const string& key) const
+{
+    lock_guard<mutex> lock(fMtx);
+
+    if (fVarMap.count(key)) {
+        return ConvertVarValToString(fVarMap.at(key));
+    } else {
+        throw PropertyNotFoundError(fair::mq::tools::ToString("Config has no key: ", key));
+    }
+}
+
+string ProgOptions::GetStringValue(const string& key) const
+{
+    lock_guard<mutex> lock(fMtx);
+
+    if (fVarMap.count(key)) {
+        return ConvertVarValToString(fVarMap.at(key));
+    } else {
+        LOG(warn) << "Config has no key: " << key << ". Returning default constructed object.";
+        return string();
+    }
+}
+
+string ProgOptions::GetPropertyAsString(const string& key, const string& ifNotFound) const
+{
+    lock_guard<mutex> lock(fMtx);
+
+    if (fVarMap.count(key)) {
+        return ConvertVarValToString(fVarMap.at(key));
+    }
+
+    return ifNotFound;
+}
+
+Properties ProgOptions::GetProperties(const string& q) const
+{
+    boost::regex re(q);
+    Properties properties;
+
+    lock_guard<mutex> lock(fMtx);
+
+    for (const auto& m : fVarMap) {
+        if (boost::regex_match(m.first, re)) {
+            properties.emplace(m.first, m.second.value());
+        }
+    }
+
+    if (properties.size() == 0) {
+        LOG(warn) << "could not find anything with \"" << q << "\"";
+    }
+
+    return properties;
+}
+
+Properties ProgOptions::GetPropertiesStartingWith(const string& q) const
+{
+    Properties properties;
+
+    lock_guard<mutex> lock(fMtx);
+
+    for (const auto& m : fVarMap) {
+        if (m.first.compare(0, q.length(), q) == 0) {
+            properties.emplace(m.first, m.second.value());
+        }
+    }
+
+    return properties;
+}
+
+map<string, string> ProgOptions::GetPropertiesAsString(const string& q) const
+{
+    boost::regex re(q);
+    map<string, string> properties;
+
+    lock_guard<mutex> lock(fMtx);
+
+    for (const auto& m : fVarMap) {
+        if (boost::regex_match(m.first, re)) {
+            properties.emplace(m.first, PropertyHelper::ConvertPropertyToString(m.second.value()));
+        }
+    }
+
+    if (properties.size() == 0) {
+        LOG(warn) << "could not find anything with \"" << q << "\"";
+    }
+
+    return properties;
+}
+
+map<string, string> ProgOptions::GetPropertiesAsStringStartingWith(const string& q) const
+{
+    map<string, string> properties;
+
+    lock_guard<mutex> lock(fMtx);
+
+    for (const auto& m : fVarMap) {
+        if (m.first.compare(0, q.length(), q) == 0) {
+            properties.emplace(m.first, PropertyHelper::ConvertPropertyToString(m.second.value()));
+        }
+    }
+
+    return properties;
+}
+
+void ProgOptions::SetProperties(const Properties& input)
+{
+    unique_lock<mutex> lock(fMtx);
+
+    map<string, boost::program_options::variable_value>& vm = fVarMap;
+    for (const auto& m : input) {
+        vm[m.first].value() = m.second;
+    }
+
+    lock.unlock();
+
+    for (const auto& m : input) {
+        PropertyHelper::fEventEmitters.at(m.second.type())(fEvents, m.first, m.second);
+        fEvents.Emit<PropertyChangeAsString, string>(m.first, PropertyHelper::ConvertPropertyToString(m.second));
+    }
+}
+
+bool ProgOptions::UpdateProperties(const Properties& input)
+{
+    unique_lock<mutex> lock(fMtx);
+
+    for (const auto& m : input) {
+        if (fVarMap.count(m.first) == 0) {
+            LOG(debug) << "UpdateProperties failed, no property found with key '" << m.first << "'";
+            return false;
+        }
+    }
+
+    map<string, boost::program_options::variable_value>& vm = fVarMap;
+    for (const auto& m : input) {
+        vm[m.first].value() = m.second;
+    }
+
+    lock.unlock();
+
+    for (const auto& m : input) {
+        PropertyHelper::fEventEmitters.at(m.second.type())(fEvents, m.first, m.second);
+        fEvents.Emit<PropertyChangeAsString, string>(m.first, PropertyHelper::ConvertPropertyToString(m.second));
+    }
+
+    return true;
+}
+
+void ProgOptions::DeleteProperty(const string& key)
+{
+    lock_guard<mutex> lock(fMtx);
+
+    map<string, boost::program_options::variable_value>& vm = fVarMap;
+    vm.erase(key);
+}
+
+void ProgOptions::AddChannel(const string& name, const FairMQChannel& channel)
+{
+    lock_guard<mutex> lock(fMtx);
+    unordered_map<string, int> existingChannels = GetChannelInfoImpl();
+    int index = 0;
+    if (existingChannels.count(name) > 0) {
+        index = existingChannels.at(name);
+    }
+
+    string prefix = fair::mq::tools::ToString("chans.", name, ".", index, ".");
+
+    SetVarMapValue<string>(string(prefix + "type"), channel.GetType());
+    SetVarMapValue<string>(string(prefix + "method"), channel.GetMethod());
+    SetVarMapValue<string>(string(prefix + "address"), channel.GetAddress());
+    SetVarMapValue<string>(string(prefix + "transport"), channel.GetTransportName());
+    SetVarMapValue<int>(string(prefix + "sndBufSize"), channel.GetSndBufSize());
+    SetVarMapValue<int>(string(prefix + "rcvBufSize"), channel.GetRcvBufSize());
+    SetVarMapValue<int>(string(prefix + "sndKernelSize"), channel.GetSndKernelSize());
+    SetVarMapValue<int>(string(prefix + "rcvKernelSize"), channel.GetRcvKernelSize());
+    SetVarMapValue<int>(string(prefix + "linger"), channel.GetLinger());
+    SetVarMapValue<int>(string(prefix + "rateLogging"), channel.GetRateLogging());
+    SetVarMapValue<int>(string(prefix + "portRangeMin"), channel.GetPortRangeMin());
+    SetVarMapValue<int>(string(prefix + "portRangeMax"), channel.GetPortRangeMax());
+    SetVarMapValue<bool>(string(prefix + "autoBind"), channel.GetAutoBind());
+}
+
+void ProgOptions::PrintHelp() const
+{
+    cout << fAllOptions << endl;
+}
+
+void ProgOptions::PrintOptions() const
+{
+    map<string, ValInfo> mapinfo;
+
+    int maxLenKey = 0;
+    int maxLenValue = 0;
+    int maxLenType = 0;
+    int maxLenDefault = 0;
+
+    for (const auto& m : fVarMap) {
+        maxLenKey = max(maxLenKey, static_cast<int>(m.first.length()));
+
+        ValInfo valinfo = ConvertVarValToValInfo(m.second);
+        mapinfo[m.first] = valinfo;
+
+        maxLenValue = max(maxLenValue, static_cast<int>(valinfo.value.length()));
+        maxLenType = max(maxLenType, static_cast<int>(valinfo.type.length()));
+        maxLenDefault = max(maxLenDefault, static_cast<int>(valinfo.origin.length()));
+    }
+
+    if (maxLenValue > 100) {
+        maxLenValue = 100;
+    }
+
+    for (const auto& o : fUnregisteredOptions) {
+        LOG(debug) << "detected unregistered option: " << o;
+    }
+
+    stringstream ss;
+    ss << "Configuration: \n";
+
+    for (const auto& p : mapinfo) {
+        string type("<" + p.second.type + ">");
+        ss << setfill(' ') << left
+           << setw(maxLenKey) << p.first << " = "
+           << setw(maxLenValue) << p.second.value << " "
+           << setw(maxLenType + 2) << type << " "
+           << setw(maxLenDefault) << p.second.origin
+           << "\n";
+    }
+
+    LOG(debug) << ss.str();
+}
+
+void ProgOptions::PrintOptionsRaw() const
+{
+    const vector<boost::shared_ptr<po::option_description>>& options = fAllOptions.options();
+
+    for (const auto& o : options) {
+        ValInfo value;
+        if (fVarMap.count(o->canonical_display_name())) {
+            value = ConvertVarValToValInfo(fVarMap[o->canonical_display_name()]);
+        }
+
+        string description = o->description();
+
+        replace(description.begin(), description.end(), '\n', ' ');
+
+        cout << o->long_name() << ":" << value.value << ":" << (value.type == "" ? "<unknown>" : value.type) << ":" << description << endl;
+    }
+}
+
+
+} // namespace mq
+} // namespace fair

fairmq/ProgOptions.h

@@ -0,0 +1,276 @@
+/********************************************************************************
+ * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_PROGOPTIONS_H
+#define FAIR_MQ_PROGOPTIONS_H
+
+#include "FairMQChannel.h"
+#include "FairMQLogger.h"
+#include <fairmq/EventManager.h>
+#include <fairmq/ProgOptionsFwd.h>
+#include <fairmq/Properties.h>
+#include <fairmq/Tools.h>
+
+#include <boost/program_options.hpp>
+
+#include <functional>
+#include <map>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <stdexcept>
+
+namespace fair
+{
+namespace mq
+{
+
+struct PropertyNotFoundError : std::runtime_error { using std::runtime_error::runtime_error; };
+
+class ProgOptions
+{
+  public:
+    ProgOptions();
+    virtual ~ProgOptions() {}
+
+    void ParseAll(const std::vector<std::string>& cmdArgs, bool allowUnregistered);
+    void ParseAll(const int argc, char const* const* argv, bool allowUnregistered = true);
+    void Notify();
+
+    void AddToCmdLineOptions(const boost::program_options::options_description optDesc, bool visible = true);
+    boost::program_options::options_description& GetCmdLineOptions();
+
+    /// @brief Checks a property with the given key exist in the configuration
+    /// @param key
+    /// @return 1 if it exists, 0 otherwise
+    int Count(const std::string& key) const;
+
+    /// @brief Retrieve current channel information
+    /// @return a map of <channel name, number of subchannels>
+    std::unordered_map<std::string, int> GetChannelInfo() const;
+    /// @brief Discover the list of property keys
+    /// @return list of property keys
+    std::vector<std::string> GetPropertyKeys() const;
+
+    /// @brief Read config property, throw if no property with this key exists
+    /// @param key
+    /// @return config property
+    template<typename T>
+    T GetProperty(const std::string& key) const
+    {
+        std::lock_guard<std::mutex> lock(fMtx);
+        if (fVarMap.count(key)) {
+            return fVarMap[key].as<T>();
+        } else {
+            throw PropertyNotFoundError(fair::mq::tools::ToString("Config has no key: ", key));
+        }
+    }
+
+    /// @brief Read config property, return provided value if no property with this key exists
+    /// @param key
+    /// @param ifNotFound value to return if key is not found
+    /// @return config property
+    template<typename T>
+    T GetProperty(const std::string& key, const T& ifNotFound) const
+    {
+        std::lock_guard<std::mutex> lock(fMtx);
+        if (fVarMap.count(key)) {
+            return fVarMap[key].as<T>();
+        }
+        return ifNotFound;
+    }
+
+    /// @brief Read config property as string, throw if no property with this key exists
+    /// @param key
+    /// @return config property converted to string
+    ///
+    /// Supports conversion to string for a fixed set of types,
+    /// for custom/unsupported types add them via `fair::mq::PropertyHelper::AddType<MyType>("optional label")`
+    /// the provided type must then be convertible to string via operator<<
+    std::string GetPropertyAsString(const std::string& key) const;
+    /// @brief Read config property, return provided value if no property with this key exists
+    /// @param key
+    /// @param ifNotFound value to return if key is not found
+    /// @return config property converted to string
+    ///
+    /// Supports conversion to string for a fixed set of types,
+    /// for custom/unsupported types add them via `fair::mq::PropertyHelper::AddType<MyType>("optional label")`
+    /// the provided type must then be convertible to string via operator<<
+    std::string GetPropertyAsString(const std::string& key, const std::string& ifNotFound) const;
+
+    /// @brief Read several config properties whose keys match the provided regular expression
+    /// @param q regex string to match for
+    /// @return container with properties (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    fair::mq::Properties GetProperties(const std::string& q) const;
+    /// @brief Read several config properties whose keys start with the provided string
+    /// @param q string to match for
+    /// @return container with properties (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    ///
+    /// Typically more performant than GetProperties with regex
+    fair::mq::Properties GetPropertiesStartingWith(const std::string& q) const;
+    /// @brief Read several config properties as string whose keys match the provided regular expression
+    /// @param q regex string to match for
+    /// @return container with properties (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    std::map<std::string, std::string> GetPropertiesAsString(const std::string& q) const;
+    /// @brief Read several config properties as string whose keys start with the provided string
+    /// @param q string to match for
+    /// @return container with properties (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    ///
+    /// Typically more performant than GetPropertiesAsString with regex
+    std::map<std::string, std::string> GetPropertiesAsStringStartingWith(const std::string& q) const;
+
+    /// @brief Set config property
+    /// @param key
+    /// @param val
+    template<typename T>
+    void SetProperty(const std::string& key, T val)
+    {
+        std::unique_lock<std::mutex> lock(fMtx);
+
+        SetVarMapValue<typename std::decay<T>::type>(key, val);
+
+        lock.unlock();
+
+        fEvents.Emit<fair::mq::PropertyChange, typename std::decay<T>::type>(key, val);
+        fEvents.Emit<fair::mq::PropertyChangeAsString, std::string>(key, GetPropertyAsString(key));
+    }
+
+    /// @brief Updates an existing config property (or fails if it doesn't exist)
+    /// @param key
+    /// @param val
+    template<typename T>
+    bool UpdateProperty(const std::string& key, T val)
+    {
+        std::unique_lock<std::mutex> lock(fMtx);
+
+        if (fVarMap.count(key)) {
+            SetVarMapValue<typename std::decay<T>::type>(key, val);
+
+            lock.unlock();
+
+            fEvents.Emit<fair::mq::PropertyChange, typename std::decay<T>::type>(key, val);
+            fEvents.Emit<fair::mq::PropertyChangeAsString, std::string>(key, GetPropertyAsString(key));
+            return true;
+        } else {
+            LOG(debug) << "UpdateProperty failed, no property found with key '" << key << "'";
+            return false;
+        }
+    }
+
+    /// @brief Set multiple config properties
+    /// @param props fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any
+    void SetProperties(const fair::mq::Properties& input);
+    /// @brief Updates multiple existing config properties (or fails of any of then do not exist, leaving property store unchanged)
+    /// @param props (fair::mq::Properties as an alias for std::map<std::string, Property>, where property is boost::any)
+    bool UpdateProperties(const fair::mq::Properties& input);
+    /// @brief Deletes a property with the given key from the config store
+    /// @param key
+    void DeleteProperty(const std::string& key);
+
+    /// @brief Takes the provided channel and creates properties based on it
+    /// @param name channel name
+    /// @param channel FairMQChannel reference
+    void AddChannel(const std::string& name, const FairMQChannel& channel);
+
+    /// @brief Subscribe to property updates of type T
+    /// @param subscriber
+    /// @param callback function
+    ///
+    /// Subscribe to property changes with a callback to monitor property changes in an event based fashion.
+    template<typename T>
+    void Subscribe(const std::string& subscriber, std::function<void(typename fair::mq::PropertyChange::KeyType, T)> func) const
+    {
+        std::lock_guard<std::mutex> lock(fMtx);
+        static_assert(!std::is_same<T,const char*>::value || !std::is_same<T, char*>::value,
+            "In template member ProgOptions::Subscribe<T>(key,Lambda) the types const char* or char* for the calback signatures are not supported.");
+        fEvents.Subscribe<fair::mq::PropertyChange, T>(subscriber, func);
+    }
+
+    /// @brief Unsubscribe from property updates of type T
+    /// @param subscriber
+    template<typename T>
+    void Unsubscribe(const std::string& subscriber) const
+    {
+        std::lock_guard<std::mutex> lock(fMtx);
+        fEvents.Unsubscribe<fair::mq::PropertyChange, T>(subscriber);
+    }
+
+    /// @brief Subscribe to property updates, with values converted to string
+    /// @param subscriber
+    /// @param callback function
+    ///
+    /// Subscribe to property changes with a callback to monitor property changes in an event based fashion. Will convert the property to string.
+    void SubscribeAsString(const std::string& subscriber, std::function<void(typename fair::mq::PropertyChange::KeyType, std::string)> func) const
+    {
+        std::lock_guard<std::mutex> lock(fMtx);
+        fEvents.Subscribe<fair::mq::PropertyChangeAsString, std::string>(subscriber, func);
+    }
+
+    /// @brief Unsubscribe from property updates that convert to string
+    /// @param subscriber
+    void UnsubscribeAsString(const std::string& subscriber) const
+    {
+        std::lock_guard<std::mutex> lock(fMtx);
+        fEvents.Unsubscribe<fair::mq::PropertyChangeAsString, std::string>(subscriber);
+    }
+
+    /// @brief prints full options description
+    void PrintHelp() const;
+    /// @brief prints properties stored in the property container
+    void PrintOptions() const;
+    /// @brief prints full options description in a compact machine-readable format
+    void PrintOptionsRaw() const;
+
+    /// @brief returns the property container
+    const boost::program_options::variables_map& GetVarMap() const { return fVarMap; }
+
+    /// @brief Read config property, return default-constructed object if key doesn't exist
+    /// @param key
+    /// @return config property
+    template<typename T>
+    T GetValue(const std::string& key) const /* TODO: deprecate this */
+    {
+        std::lock_guard<std::mutex> lock(fMtx);
+        if (fVarMap.count(key)) {
+            return fVarMap[key].as<T>();
+        } else {
+            LOG(warn) << "Config has no key: " << key << ". Returning default constructed object.";
+            return T();
+        }
+    }
+    template<typename T>
+    int SetValue(const std::string& key, T val) /* TODO: deprecate this */ { SetProperty(key, val); return 0; }
+    /// @brief Read config property as string, return default-constructed object if key doesn't exist
+    /// @param key
+    /// @return config property
+    std::string GetStringValue(const std::string& key) const; /* TODO: deprecate this */
+
+  private:
+    void ParseDefaults();
+    std::unordered_map<std::string, int> GetChannelInfoImpl() const;
+
+    template<typename T>
+    void SetVarMapValue(const std::string& key, const T& val)
+    {
+        std::map<std::string, boost::program_options::variable_value>& vm = fVarMap;
+        vm[key].value() = boost::any(val);
+    }
+
+    boost::program_options::variables_map fVarMap; ///< options container
+    boost::program_options::options_description fAllOptions; ///< all options descriptions
+    std::vector<std::string> fUnregisteredOptions; ///< container with unregistered options
+
+    mutable fair::mq::EventManager fEvents;
+    mutable std::mutex fMtx;
+};
+
+} // namespace mq
+} // namespace fair
+
+#endif /* FAIR_MQ_PROGOPTIONS_H */

fairmq/ProgOptionsFwd.h

@@ -0,0 +1,22 @@
+/********************************************************************************
+ *    Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_PROGOPTIONSFWD_H
+#define FAIR_MQ_PROGOPTIONSFWD_H
+
+namespace fair
+{
+namespace mq
+{
+class ProgOptions;
+}
+}
+
+using FairMQProgOptions = fair::mq::ProgOptions;
+
+#endif /* FAIR_MQ_PROGOPTIONSFWD_H */

fairmq/Properties.cxx

@@ -0,0 +1,141 @@
+/********************************************************************************
+ * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#include <fairmq/Properties.h>
+#include <fairmq/Tools.h>
+
+#include <boost/filesystem.hpp>
+
+using namespace std;
+using namespace fair::mq::tools;
+using boost::any_cast;
+
+namespace fair
+{
+namespace mq
+{
+
+template<class T>
+ostream& operator<<(ostream& os, const vector<T>& v)
+{
+    for (unsigned int i = 0; i < v.size(); ++i) {
+        os << v[i];
+        if (i != v.size() - 1) {
+            os << ", ";
+        }
+    }
+    return os;
+}
+
+ostream& operator<<(ostream& os, const vector<signed char>& v)
+{
+    for (unsigned int i = 0; i < v.size(); ++i) {
+        os << to_string(v[i]);
+        if (i != v.size() - 1) {
+            os << ", ";
+        }
+    }
+    return os;
+}
+
+ostream& operator<<(ostream& os, const vector<unsigned char>& v)
+{
+    for (unsigned int i = 0; i < v.size(); ++i) {
+        os << to_string(v[i]);
+        if (i != v.size() - 1) {
+            os << ", ";
+        }
+    }
+    return os;
+}
+
+template<typename T>
+pair<string, string> getString(const boost::any& v, const string& label)
+{
+    return { to_string(any_cast<T>(v)), label };
+}
+
+
+template<typename T>
+pair<string, string> getStringPair(const boost::any& v, const string& label)
+{
+    stringstream ss;
+    ss << any_cast<T>(v);
+    return { ss.str(), label };
+}
+
+unordered_map<type_index, function<pair<string, string>(const Property&)>> PropertyHelper::fTypeInfos = {
+    { type_index(typeid(char)),                            [](const Property& p) { return pair<string, string>{ string(1, any_cast<char>(p)), "char" }; } },
+    { type_index(typeid(signed char)),                     [](const Property& p) { return getString<signed char>(p, "signed char"); } },
+    { type_index(typeid(unsigned char)),                   [](const Property& p) { return getString<unsigned char>(p, "unsigned char"); } },
+    { type_index(typeid(const char*)),                     [](const Property& p) { return pair<string, string>{ string(any_cast<const char*>(p)), "string" }; } },
+    { type_index(typeid(string)),                          [](const Property& p) { return pair<string, string>{ any_cast<string>(p), "string" }; } },
+    { type_index(typeid(int)),                             [](const Property& p) { return getString<int>(p, "int"); } },
+    { type_index(typeid(long)),                            [](const Property& p) { return getString<long>(p, "long"); } },
+    { type_index(typeid(long long)),                       [](const Property& p) { return getString<long long>(p, "long long"); } },
+    { type_index(typeid(unsigned)),                        [](const Property& p) { return getString<unsigned>(p, "unsigned"); } },
+    { type_index(typeid(unsigned long)),                   [](const Property& p) { return getString<unsigned long>(p, "unsigned long"); } },
+    { type_index(typeid(unsigned long long)),              [](const Property& p) { return getString<unsigned long long>(p, "unsigned long long"); } },
+    { type_index(typeid(float)),                           [](const Property& p) { return getStringPair<float>(p, "float"); } },
+    { type_index(typeid(double)),                          [](const Property& p) { return getStringPair<double>(p, "double"); } },
+    { type_index(typeid(long double)),                     [](const Property& p) { return getStringPair<long double>(p, "long double"); } },
+    { type_index(typeid(bool)),                            [](const Property& p) { stringstream ss; ss << boolalpha << any_cast<bool>(p); return pair<string, string>{ ss.str(), "bool" }; } },
+    { type_index(typeid(vector<bool>)),                    [](const Property& p) { stringstream ss; ss << boolalpha << any_cast<vector<bool>>(p); return pair<string, string>{ ss.str(), "vector<bool>>" }; } },
+    { type_index(typeid(boost::filesystem::path)),         [](const Property& p) { return getStringPair<boost::filesystem::path>(p, "boost::filesystem::path"); } },
+    { type_index(typeid(vector<char>)),                    [](const Property& p) { return getStringPair<vector<char>>(p, "vector<char>"); } },
+    { type_index(typeid(vector<signed char>)),             [](const Property& p) { return getStringPair<vector<signed char>>(p, "vector<signed char>"); } },
+    { type_index(typeid(vector<unsigned char>)),           [](const Property& p) { return getStringPair<vector<unsigned char>>(p, "vector<unsigned char>"); } },
+    { type_index(typeid(vector<string>)),                  [](const Property& p) { return getStringPair<vector<string>>(p, "vector<string>"); } },
+    { type_index(typeid(vector<int>)),                     [](const Property& p) { return getStringPair<vector<int>>(p, "vector<int>"); } },
+    { type_index(typeid(vector<long>)),                    [](const Property& p) { return getStringPair<vector<long>>(p, "vector<long>"); } },
+    { type_index(typeid(vector<long long>)),               [](const Property& p) { return getStringPair<vector<long long>>(p, "vector<long long>"); } },
+    { type_index(typeid(vector<unsigned>)),                [](const Property& p) { return getStringPair<vector<unsigned>>(p, "vector<unsigned>"); } },
+    { type_index(typeid(vector<unsigned long>)),           [](const Property& p) { return getStringPair<vector<unsigned long>>(p, "vector<unsigned long>"); } },
+    { type_index(typeid(vector<unsigned long long>)),      [](const Property& p) { return getStringPair<vector<unsigned long long>>(p, "vector<unsigned long long>"); } },
+    { type_index(typeid(vector<float>)),                   [](const Property& p) { return getStringPair<vector<float>>(p, "vector<float>"); } },
+    { type_index(typeid(vector<double>)),                  [](const Property& p) { return getStringPair<vector<double>>(p, "vector<double>"); } },
+    { type_index(typeid(vector<long double>)),             [](const Property& p) { return getStringPair<vector<long double>>(p, "vector<long double>"); } },
+    { type_index(typeid(vector<boost::filesystem::path>)), [](const Property& p) { return getStringPair<vector<boost::filesystem::path>>(p, "vector<boost::filesystem::path>"); } },
+};
+
+unordered_map<type_index, void(*)(const EventManager&, const string&, const Property&)> PropertyHelper::fEventEmitters = {
+    { type_index(typeid(char)),                            [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, char>(k, any_cast<char>(p)); } },
+    { type_index(typeid(signed char)),                     [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, signed char>(k, any_cast<signed char>(p)); } },
+    { type_index(typeid(unsigned char)),                   [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned char>(k, any_cast<unsigned char>(p)); } },
+    { type_index(typeid(const char*)),                     [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, string>(k, string(any_cast<const char*>(p))); } },
+    { type_index(typeid(string)),                          [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, string>(k, any_cast<string>(p)); } },
+    { type_index(typeid(int)),                             [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, int>(k, any_cast<int>(p)); } },
+    { type_index(typeid(long)),                            [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, long>(k, any_cast<long>(p)); } },
+    { type_index(typeid(long long)),                       [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, long long>(k, any_cast<long long>(p)); } },
+    { type_index(typeid(unsigned)),                        [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned>(k, any_cast<unsigned>(p)); } },
+    { type_index(typeid(unsigned long)),                   [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned long>(k, any_cast<unsigned long>(p)); } },
+    { type_index(typeid(unsigned long long)),              [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned long long>(k, any_cast<unsigned long long>(p)); } },
+    { type_index(typeid(float)),                           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, float>(k, any_cast<float>(p)); } },
+    { type_index(typeid(double)),                          [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, double>(k, any_cast<double>(p)); } },
+    { type_index(typeid(long double)),                     [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, long double>(k, any_cast<long double>(p)); } },
+    { type_index(typeid(bool)),                            [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, bool>(k, any_cast<bool>(p)); } },
+    { type_index(typeid(vector<bool>)),                    [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<bool>>(k, any_cast<vector<bool>>(p)); } },
+    { type_index(typeid(boost::filesystem::path)),         [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, boost::filesystem::path>(k, any_cast<boost::filesystem::path>(p)); } },
+    { type_index(typeid(vector<char>)),                    [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<char>>(k, any_cast<vector<char>>(p)); } },
+    { type_index(typeid(vector<signed char>)),             [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<signed char>>(k, any_cast<vector<signed char>>(p)); } },
+    { type_index(typeid(vector<unsigned char>)),           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned char>>(k, any_cast<vector<unsigned char>>(p)); } },
+    { type_index(typeid(vector<string>)),                  [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<string>>(k, any_cast<vector<string>>(p)); } },
+    { type_index(typeid(vector<int>)),                     [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<int>>(k, any_cast<vector<int>>(p)); } },
+    { type_index(typeid(vector<long>)),                    [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<long>>(k, any_cast<vector<long>>(p)); } },
+    { type_index(typeid(vector<long long>)),               [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<long long>>(k, any_cast<vector<long long>>(p)); } },
+    { type_index(typeid(vector<unsigned>)),                [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned>>(k, any_cast<vector<unsigned>>(p)); } },
+    { type_index(typeid(vector<unsigned long>)),           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned long>>(k, any_cast<vector<unsigned long>>(p)); } },
+    { type_index(typeid(vector<unsigned long long>)),      [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned long long>>(k, any_cast<vector<unsigned long long>>(p)); } },
+    { type_index(typeid(vector<float>)),                   [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<float>>(k, any_cast<vector<float>>(p)); } },
+    { type_index(typeid(vector<double>)),                  [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<double>>(k, any_cast<vector<double>>(p)); } },
+    { type_index(typeid(vector<long double>)),             [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<long double>>(k, any_cast<vector<long double>>(p)); } },
+    { type_index(typeid(vector<boost::filesystem::path>)), [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<boost::filesystem::path>>(k, any_cast<vector<boost::filesystem::path>>(p)); } },
+};
+
+} // namespace mq
+} // namespace fair

fairmq/Properties.h

@@ -0,0 +1,77 @@
+/********************************************************************************
+ * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+#ifndef FAIR_MQ_PROPERTIES_H
+#define FAIR_MQ_PROPERTIES_H
+
+#include <fairmq/EventManager.h>
+
+#include <boost/any.hpp>
+#include <boost/core/demangle.hpp>
+
+#include <functional>
+#include <map>
+#include <unordered_map>
+#include <string>
+#include <typeindex>
+#include <typeinfo>
+#include <utility> // pair
+
+namespace fair
+{
+namespace mq
+{
+
+using Property = boost::any;
+using Properties = std::map<std::string, Property>;
+
+struct PropertyChange : Event<std::string> {};
+struct PropertyChangeAsString : Event<std::string> {};
+
+class PropertyHelper
+{
+  public:
+    template<typename T>
+    static void AddType(std::string label = "")
+    {
+        if (label == "") {
+            label = boost::core::demangle(typeid(T).name());
+        }
+        fTypeInfos[std::type_index(typeid(T))] = [label](const Property& p) {
+            std::stringstream ss;
+            ss << boost::any_cast<T>(p);
+            return std::pair<std::string, std::string>{ss.str(), label};
+        };
+        fEventEmitters[std::type_index(typeid(T))] = [](const fair::mq::EventManager& em, const std::string& k, const Property& p) {
+            em.Emit<PropertyChange, T>(k, boost::any_cast<T>(p));
+        };
+    }
+
+    static std::string ConvertPropertyToString(const Property& p)
+    {
+        return fTypeInfos.at(p.type())(p).first;
+    }
+
+    // returns <valueAsString, typenameAsString>
+    static std::pair<std::string, std::string> GetPropertyInfo(const Property& p)
+    {
+        try {
+            return fTypeInfos.at(p.type())(p);
+        } catch (std::out_of_range& oor) {
+            return {"[unidentified_type]", "[unidentified_type]"};
+        }
+    }
+
+    static std::unordered_map<std::type_index, void(*)(const fair::mq::EventManager&, const std::string&, const Property&)> fEventEmitters;
+  private:
+    static std::unordered_map<std::type_index, std::function<std::pair<std::string, std::string>(const Property&)>> fTypeInfos;
+};
+
+}
+}
+
+#endif /* FAIR_MQ_PROPERTIES_H */

fairmq/PropertyOutput.h

@@ -0,0 +1,23 @@
+/********************************************************************************
+ *    Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+#ifndef FAIR_MQ_PROPERTYOUT_H
+#define FAIR_MQ_PROPERTYOUT_H
+
+#include <fairmq/Properties.h>
+
+namespace boost
+{
+
+inline std::ostream& operator<<(std::ostream& os, const boost::any& p)
+{
+    return os << fair::mq::PropertyHelper::GetPropertyInfo(p).first;
+}
+
+}
+
+#endif /* FAIR_MQ_PROPERTYOUT_H */

fairmq/SDK.h

@@ -0,0 +1,20 @@
+/********************************************************************************
+ *    Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_SDK_H
+#define FAIR_MQ_SDK_H
+
+// IWYU pragma: begin_exports
+#include <fairmq/sdk/DDSInfo.h>
+#include <fairmq/sdk/DDSEnvironment.h>
+#include <fairmq/sdk/DDSSession.h>
+#include <fairmq/sdk/DDSTopology.h>
+#include <fairmq/sdk/Topology.h>
+// IWYU pragma: end_exports
+
+#endif // FAIR_MQ_SDK_H

fairmq/StateMachine.cxx

@@ -6,7 +6,7 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include "StateMachine.h"
+#include <fairmq/StateMachine.h>
 #include <fairmq/Tools.h>
 
 // Increase maximum number of boost::msm states (default is 10)
@@ -25,10 +25,8 @@
 #include <atomic>
 #include <condition_variable>
 #include <chrono>
-#include <array>
 #include <unordered_map>
 #include <mutex>
-#include <stdexcept>
 
 using namespace std;
 using namespace boost::msm;
@@ -36,17 +34,6 @@ using namespace boost::msm::front;
 using namespace boost::msm::back;
 namespace bmpl = boost::mpl;
 
-namespace std
-{
-
-template<>
-struct hash<fair::mq::Transition> : fair::mq::tools::HashEnum<fair::mq::Transition> {};
-
-template<>
-struct hash<fair::mq::State> : fair::mq::tools::HashEnum<fair::mq::State> {};
-
-} /* namespace std */
-
 namespace fair
 {
 namespace mq
@@ -87,80 +74,6 @@ struct RESET_DEVICE_E  { static string Name() { return "RESET_DEVICE"; }  static
 struct END_E           { static string Name() { return "END"; }           static Transition Type() { return Transition::End; } };
 struct ERROR_FOUND_E   { static string Name() { return "ERROR_FOUND"; }   static Transition Type() { return Transition::ErrorFound; } };
 
-static array<string, 15> stateNames =
-{
-    {
-        "OK",
-        "Error",
-        "IDLE",
-        "INITIALIZING_DEVICE",
-        "INITIALIZED",
-        "BINDING",
-        "BOUND",
-        "CONNECTING",
-        "DEVICE_READY",
-        "INITIALIZING_TASK",
-        "READY",
-        "RUNNING",
-        "RESETTING_TASK",
-        "RESETTING_DEVICE",
-        "EXITING"
-    }
-};
-
-static array<string, 12> transitionNames =
-{
-    {
-        "AUTO",
-        "INIT_DEVICE",
-        "COMPLETE_INIT",
-        "BIND",
-        "CONNECT",
-        "INIT_TASK",
-        "RUN",
-        "STOP",
-        "RESET_TASK",
-        "RESET_DEVICE",
-        "END",
-        "ERROR_FOUND"
-    }
-};
-
-static map<string, State> stateNumbers =
-{
-    { "OK",                  State::Ok },
-    { "Error",               State::Error },
-    { "IDLE",                State::Idle },
-    { "INITIALIZING_DEVICE", State::InitializingDevice },
-    { "INITIALIZED",         State::Initialized },
-    { "BINDING",             State::Binding },
-    { "BOUND",               State::Bound },
-    { "CONNECTING",          State::Connecting },
-    { "DEVICE_READY",        State::DeviceReady },
-    { "INITIALIZING_TASK",   State::InitializingTask },
-    { "READY",               State::Ready },
-    { "RUNNING",             State::Running },
-    { "RESETTING_TASK",      State::ResettingTask },
-    { "RESETTING_DEVICE",    State::ResettingDevice },
-    { "EXITING",             State::Exiting }
-};
-
-static map<string, Transition> transitionNumbers =
-{
-    { "AUTO",          Transition::Auto },
-    { "INIT_DEVICE",   Transition::InitDevice },
-    { "COMPLETE_INIT", Transition::CompleteInit },
-    { "BIND",          Transition::Bind },
-    { "CONNECT",       Transition::Connect },
-    { "INIT_TASK",     Transition::InitTask },
-    { "RUN",           Transition::Run },
-    { "STOP",          Transition::Stop },
-    { "RESET_TASK",    Transition::ResetTask },
-    { "RESET_DEVICE",  Transition::ResetDevice },
-    { "END",           Transition::End },
-    { "ERROR_FOUND",   Transition::ErrorFound }
-};
-
 // defining the boost MSM state machine
 struct Machine_ : public state_machine_def<Machine_>
 {
@@ -228,7 +141,7 @@ struct Machine_ : public state_machine_def<Machine_>
         Row<RESETTING_TASK_S,      AUTO_E,          DEVICE_READY_S,        DefaultFct, none>,
         Row<RESETTING_DEVICE_S,    AUTO_E,          IDLE_S,                DefaultFct, none>,
 
-        Row<OK_S,                  ERROR_FOUND_E,   ERROR_S,               DefaultFct,   none>> {};
+        Row<OK_S,                  ERROR_FOUND_E,   ERROR_S,               DefaultFct, none>> {};
 
     void CallStateChangeCallbacks(const State state) const
     {
@@ -380,7 +293,7 @@ try {
                 return false;
              }
     } else {
-        LOG(state) << "Transition " << transitionNames.at(static_cast<int>(transition)) << " incoming, but another state transition is already ongoing.";
+        LOG(state) << "Transition " << GetTransitionName(transition) << " incoming, but another state transition is already ongoing.";
         return false;
     }
 } catch (exception& e) {
@@ -472,9 +385,3 @@ void StateMachine::ProcessWork()
         throw;
     }
 }
-
-string StateMachine::GetStateName(const State state) { return stateNames.at(static_cast<int>(state)); }
-string StateMachine::GetTransitionName(const Transition transition) { return transitionNames.at(static_cast<int>(transition)); }
-State StateMachine::GetState(const string& state) { return stateNumbers.at(state); }
-Transition StateMachine::GetTransition(const string& transition) { return transitionNumbers.at(transition); }
-

fairmq/StateMachine.h

@@ -9,15 +9,13 @@
 #ifndef FAIRMQSTATEMACHINE_H_
 #define FAIRMQSTATEMACHINE_H_
 
-#include "FairMQLogger.h"
+#include <fairmq/States.h>
+
+#include <fairlogger/Logger.h>
 
 #include <string>
 #include <memory>
 #include <functional>
-#include <condition_variable>
-#include <ostream>
-#include <queue>
-#include <mutex>
 #include <stdexcept>
 
 namespace fair
@@ -25,41 +23,6 @@ namespace fair
 namespace mq
 {
 
-enum class State : int
-{
-    Ok,
-    Error,
-    Idle,
-    InitializingDevice,
-    Initialized,
-    Binding,
-    Bound,
-    Connecting,
-    DeviceReady,
-    InitializingTask,
-    Ready,
-    Running,
-    ResettingTask,
-    ResettingDevice,
-    Exiting
-};
-
-enum class Transition : int
-{
-    Auto,
-    InitDevice,
-    CompleteInit,
-    Bind,
-    Connect,
-    InitTask,
-    Run,
-    Stop,
-    ResetTask,
-    ResetDevice,
-    End,
-    ErrorFound
-};
-
 class StateMachine
 {
   public:
@@ -89,20 +52,12 @@ class StateMachine
 
     void ProcessWork();
 
-    static std::string GetStateName(const State);
-    static std::string GetTransitionName(const Transition);
-    static State GetState(const std::string& state);
-    static Transition GetTransition(const std::string& transition);
-
     struct ErrorStateException : std::runtime_error { using std::runtime_error::runtime_error; };
 
   private:
     std::shared_ptr<void> fFsm;
 };
 
-inline std::ostream& operator<<(std::ostream& os, const State& state) { return os << StateMachine::GetStateName(state); }
-inline std::ostream& operator<<(std::ostream& os, const Transition& transition) { return os << StateMachine::GetTransitionName(transition); }
-
 } // namespace mq
 } // namespace fair
 

fairmq/StateQueue.h

@@ -0,0 +1,94 @@
+/********************************************************************************
+ *    Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIRMQSTATEQUEUE_H_
+#define FAIRMQSTATEQUEUE_H_
+
+#include <fairmq/States.h>
+
+#include <queue>
+#include <mutex>
+#include <chrono>
+#include <utility> // pair
+#include <condition_variable>
+
+namespace fair
+{
+namespace mq
+{
+
+class StateQueue
+{
+  public:
+    StateQueue() {}
+    ~StateQueue() {}
+
+    fair::mq::State WaitForNext()
+    {
+        std::unique_lock<std::mutex> lock(fMtx);
+        while (fStates.empty()) {
+            fCV.wait_for(lock, std::chrono::milliseconds(50));
+        }
+
+        fair::mq::State state = fStates.front();
+
+        if (state == fair::mq::State::Error) {
+            throw DeviceErrorState("Controlled device transitioned to error state.");
+        }
+
+        fStates.pop();
+        return state;
+    }
+
+    template<typename Rep, typename Period>
+    std::pair<bool, fair::mq::State> WaitForNext(std::chrono::duration<Rep, Period> const& duration)
+    {
+        std::unique_lock<std::mutex> lock(fMtx);
+        fCV.wait_for(lock, duration);
+
+        if (fStates.empty()) {
+            return { false, fair::mq::State::Ok };
+        }
+
+        fair::mq::State state = fStates.front();
+
+        if (state == fair::mq::State::Error) {
+            throw DeviceErrorState("Controlled device transitioned to error state.");
+        }
+
+        fStates.pop();
+        return { true, state };
+    }
+
+    void WaitForState(fair::mq::State state) { while (WaitForNext() != state) {} }
+
+    void Push(fair::mq::State state)
+    {
+        {
+            std::lock_guard<std::mutex> lock(fMtx);
+            fStates.push(state);
+        }
+        fCV.notify_all();
+    }
+
+    void Clear()
+    {
+        std::lock_guard<std::mutex> lock(fMtx);
+        fStates = std::queue<fair::mq::State>();
+    }
+
+  private:
+    std::queue<fair::mq::State> fStates;
+    std::mutex fMtx;
+    std::condition_variable fCV;
+};
+
+} // namespace mq
+} // namespace fair
+
+#endif /* FAIRMQSTATEQUEUE_H_ */

fairmq/States.cxx

@@ -0,0 +1,116 @@
+/********************************************************************************
+ *    Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#include <fairmq/States.h>
+
+#include <array>
+#include <unordered_map>
+
+using namespace std;
+
+namespace fair
+{
+namespace mq
+{
+
+array<string, 15> stateNames =
+{
+    {
+        "OK",
+        "ERROR",
+        "IDLE",
+        "INITIALIZING DEVICE",
+        "INITIALIZED",
+        "BINDING",
+        "BOUND",
+        "CONNECTING",
+        "DEVICE READY",
+        "INITIALIZING TASK",
+        "READY",
+        "RUNNING",
+        "RESETTING TASK",
+        "RESETTING DEVICE",
+        "EXITING"
+    }
+};
+
+unordered_map<string, State> states =
+{
+    { "OK",                  State::Ok },
+    { "ERROR",               State::Error },
+    { "IDLE",                State::Idle },
+    { "INITIALIZING DEVICE", State::InitializingDevice },
+    { "INITIALIZED",         State::Initialized },
+    { "BINDING",             State::Binding },
+    { "BOUND",               State::Bound },
+    { "CONNECTING",          State::Connecting },
+    { "DEVICE READY",        State::DeviceReady },
+    { "INITIALIZING TASK",   State::InitializingTask },
+    { "READY",               State::Ready },
+    { "RUNNING",             State::Running },
+    { "RESETTING TASK",      State::ResettingTask },
+    { "RESETTING DEVICE",    State::ResettingDevice },
+    { "EXITING",             State::Exiting }
+};
+
+array<string, 12> transitionNames =
+{
+    {
+        "AUTO",
+        "INIT DEVICE",
+        "COMPLETE INIT",
+        "BIND",
+        "CONNECT",
+        "INIT TASK",
+        "RUN",
+        "STOP",
+        "RESET TASK",
+        "RESET DEVICE",
+        "END",
+        "ERROR FOUND"
+    }
+};
+
+unordered_map<string, Transition> transitions =
+{
+    { "AUTO",          Transition::Auto },
+    { "INIT DEVICE",   Transition::InitDevice },
+    { "COMPLETE INIT", Transition::CompleteInit },
+    { "BIND",          Transition::Bind },
+    { "CONNECT",       Transition::Connect },
+    { "INIT TASK",     Transition::InitTask },
+    { "RUN",           Transition::Run },
+    { "STOP",          Transition::Stop },
+    { "RESET TASK",    Transition::ResetTask },
+    { "RESET DEVICE",  Transition::ResetDevice },
+    { "END",           Transition::End },
+    { "ERROR FOUND",   Transition::ErrorFound }
+};
+
+string GetStateName(const State state)
+{
+    return stateNames.at(static_cast<int>(state));
+}
+
+string GetTransitionName(const Transition transition)
+{
+    return transitionNames.at(static_cast<int>(transition));
+}
+
+State GetState(const string& state)
+{
+    return states.at(state);
+}
+
+Transition GetTransition(const string& transition)
+{
+    return transitions.at(transition);
+}
+
+} // namespace mq
+} // namespace fair

fairmq/States.h

@@ -0,0 +1,69 @@
+/********************************************************************************
+ *    Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIRMQSTATES_H_
+#define FAIRMQSTATES_H_
+
+#include <string>
+#include <ostream>
+#include <stdexcept>
+
+namespace fair
+{
+namespace mq
+{
+
+enum class State : int
+{
+    Ok,
+    Error,
+    Idle,
+    InitializingDevice,
+    Initialized,
+    Binding,
+    Bound,
+    Connecting,
+    DeviceReady,
+    InitializingTask,
+    Ready,
+    Running,
+    ResettingTask,
+    ResettingDevice,
+    Exiting
+};
+
+enum class Transition : int
+{
+    Auto,
+    InitDevice,
+    CompleteInit,
+    Bind,
+    Connect,
+    InitTask,
+    Run,
+    Stop,
+    ResetTask,
+    ResetDevice,
+    End,
+    ErrorFound
+};
+
+std::string GetStateName(State);
+std::string GetTransitionName(Transition);
+State GetState(const std::string& state);
+Transition GetTransition(const std::string& transition);
+
+struct DeviceErrorState : std::runtime_error { using std::runtime_error::runtime_error; };
+
+inline std::ostream& operator<<(std::ostream& os, const State& state) { return os << GetStateName(state); }
+inline std::ostream& operator<<(std::ostream& os, const Transition& transition) { return os << GetTransitionName(transition); }
+
+} // namespace mq
+} // namespace fair
+
+#endif /* FAIRMQSTATES_H_ */

fairmq/SuboptParser.cxx

@@ -6,12 +6,12 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-/// @file   FairMQSuboptParser.cxx
+/// @file   SuboptParser.cxx
 /// @author Matthias.Richter@scieq.net
 /// @since  2017-03-30
 /// @brief  Parser implementation for key-value subopt format
 
-#include "FairMQSuboptParser.h"
+#include <fairmq/SuboptParser.h>
 
 #include <boost/property_tree/ptree.hpp>
 #include <cstring>
@@ -24,12 +24,47 @@ namespace fair
 {
 namespace mq
 {
-namespace parser
+
+enum channelOptionKeyIds
 {
+    NAME = 0,       // name of the channel
+    TYPE,           // push, pull, publish, subscribe, etc
+    METHOD,         // bind or connect
+    ADDRESS,        // host, protocol and port address
+    TRANSPORT,      //
+    SNDBUFSIZE,     // size of the send queue
+    RCVBUFSIZE,     // size of the receive queue
+    SNDKERNELSIZE,
+    RCVKERNELSIZE,
+    LINGER,
+    RATELOGGING,    // logging rate
+    PORTRANGEMIN,
+    PORTRANGEMAX,
+    AUTOBIND,
+    NUMSOCKETS,
+    lastsocketkey
+};
 
-constexpr const char* SUBOPT::channelOptionKeys[];
+constexpr static const char* channelOptionKeys[] = {
+    /*[NAME]          = */ "name",
+    /*[TYPE]          = */ "type",
+    /*[METHOD]        = */ "method",
+    /*[ADDRESS]       = */ "address",
+    /*[TRANSPORT]     = */ "transport",
+    /*[SNDBUFSIZE]    = */ "sndBufSize",
+    /*[RCVBUFSIZE]    = */ "rcvBufSize",
+    /*[SNDKERNELSIZE] = */ "sndKernelSize",
+    /*[RCVKERNELSIZE] = */ "rcvKernelSize",
+    /*[LINGER]        = */ "linger",
+    /*[RATELOGGING]   = */ "rateLogging",
+    /*[PORTRANGEMIN]  = */ "portRangeMin",
+    /*[PORTRANGEMAX]  = */ "portRangeMax",
+    /*[AUTOBIND]      = */ "autoBind",
+    /*[NUMSOCKETS]    = */ "numSockets",
+    nullptr
+};
 
-FairMQChannelMap SUBOPT::UserParser(const vector<string>& channelConfig, const string& deviceId, const string& rootNode)
+Properties SuboptParser(const vector<string>& channelConfig, const string& deviceId)
 {
     ptree pt;
 
@@ -38,8 +73,7 @@ FairMQChannelMap SUBOPT::UserParser(const vector<string>& channelConfig, const s
 
     ptree channelsArray;
 
-    for (auto token : channelConfig)
-    {
+    for (auto token : channelConfig) {
         string channelName;
         ptree channelProperties;
 
@@ -48,32 +82,23 @@ FairMQChannelMap SUBOPT::UserParser(const vector<string>& channelConfig, const s
         string argString(token);
         char* subopts = &argString[0];
         char* value = nullptr;
-        while (subopts && *subopts != 0 && *subopts != ' ')
-        {
+        while (subopts && *subopts != 0 && *subopts != ' ') {
             int subopt = getsubopt(&subopts, (char**)channelOptionKeys, &value);
-            if (subopt == NAME)
-            {
+            if (subopt == NAME) {
                 channelName = value;
                 channelProperties.put("name", channelName);
-            }
-            else if (subopt == ADDRESS)
-            {
+            } else if (subopt == ADDRESS) {
                 ptree socketProperties;
                 socketProperties.put(channelOptionKeys[subopt], value);
                 socketsArray.push_back(make_pair("", socketProperties));
-            }
-            else if (subopt >= 0 && value != nullptr)
-            {
+            } else if (subopt >= 0 && value != nullptr) {
                 channelProperties.put(channelOptionKeys[subopt], value);
             }
         }
 
-        if (channelName != "")
-        {
+        if (channelName != "") {
             channelProperties.add_child("sockets", socketsArray);
-        }
-        else
-        {
+        } else {
             // TODO: what is the error policy here, should we abort?
             LOG(error) << "missing channel name in argument of option --channel-config";
         }
@@ -88,9 +113,8 @@ FairMQChannelMap SUBOPT::UserParser(const vector<string>& channelConfig, const s
 
     pt.add_child("fairMQOptions.devices", devicesArray);
 
-    return ptreeToMQMap(pt, deviceId, rootNode);
+    return PtreeParser(pt, deviceId);
 }
 
 }
 }
-}

fairmq/SuboptParser.h

@@ -0,0 +1,49 @@
+/********************************************************************************
+ *    Copyright (C) 2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public License (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+/// @file   FairMQSuboptParser.h
+/// @author Matthias.Richter@scieq.net
+/// @since  2017-03-30
+/// @brief  Parser implementation for key-value subopt format
+
+#ifndef FAIR_MQ_SUBOPTPARSER_H
+#define FAIR_MQ_SUBOPTPARSER_H
+
+#include <fairmq/JSONParser.h>
+
+#include <vector>
+#include <string>
+
+namespace fair
+{
+namespace mq
+{
+
+/**
+ * A parser implementation for FairMQ channel properties.
+ * The parser handles a comma separated key=value list format by using the
+ * getsubopt function of the standard library.
+ *
+ * The option key '--channel-config' can be used with the list of key/value
+ * pairs like e.g.
+ * <pre>
+ * --channel-config name=output,type=push,method=bind
+ * </pre>
+ *
+ * The FairMQ option parser defines a 'UserParser' function for different
+ * formats. Currently it is strictly parsing channel options, but in general
+ * the concept is extensible by renaming UserParser to ChannelPropertyParser
+ * and introducing additional parser functions.
+ */
+
+Properties SuboptParser(const std::vector<std::string>& channelConfig, const std::string& deviceId);
+
+}
+}
+
+#endif /* FAIR_MQ_SUBOPTPARSER_H */

fairmq/Tools.h

@@ -11,9 +11,11 @@
 
 // IWYU pragma: begin_exports
 #include <fairmq/tools/CppSTL.h>
+#include <fairmq/tools/InstanceLimit.h>
 #include <fairmq/tools/Network.h>
 #include <fairmq/tools/Process.h>
 #include <fairmq/tools/RateLimit.h>
+#include <fairmq/tools/Semaphore.h>
 #include <fairmq/tools/Strings.h>
 #include <fairmq/tools/Unique.h>
 #include <fairmq/tools/Version.h>

fairmq/devices/FairMQBenchmarkSampler.cxx

@@ -10,7 +10,6 @@
 
 #include <fairmq/Tools.h>
 #include "../FairMQLogger.h"
-#include "../options/FairMQProgOptions.h"
 
 #include <vector>
 #include <chrono>
@@ -34,12 +33,12 @@ FairMQBenchmarkSampler::~FairMQBenchmarkSampler()
 
 void FairMQBenchmarkSampler::InitTask()
 {
-    fMultipart = fConfig->GetValue<bool>("multipart");
-    fNumParts = fConfig->GetValue<size_t>("num-parts");
-    fMsgSize = fConfig->GetValue<size_t>("msg-size");
-    fMsgRate = fConfig->GetValue<float>("msg-rate");
-    fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
-    fOutChannelName = fConfig->GetValue<string>("out-channel");
+    fMultipart = fConfig->GetProperty<bool>("multipart");
+    fNumParts = fConfig->GetProperty<size_t>("num-parts");
+    fMsgSize = fConfig->GetProperty<size_t>("msg-size");
+    fMsgRate = fConfig->GetProperty<float>("msg-rate");
+    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
+    fOutChannelName = fConfig->GetProperty<string>("out-channel");
 }
 
 void FairMQBenchmarkSampler::Run()

fairmq/devices/FairMQMerger.cxx

@@ -15,7 +15,6 @@
 #include "FairMQMerger.h"
 #include "../FairMQLogger.h"
 #include "../FairMQPoller.h"
-#include "../options/FairMQProgOptions.h"
 
 using namespace std;
 
@@ -40,9 +39,9 @@ FairMQMerger::~FairMQMerger()
 
 void FairMQMerger::InitTask()
 {
-    fMultipart = fConfig->GetValue<bool>("multipart");
-    fInChannelName = fConfig->GetValue<string>("in-channel");
-    fOutChannelName = fConfig->GetValue<string>("out-channel");
+    fMultipart = fConfig->GetProperty<bool>("multipart");
+    fInChannelName = fConfig->GetProperty<string>("in-channel");
+    fOutChannelName = fConfig->GetProperty<string>("out-channel");
 }
 
 void FairMQMerger::Run()

fairmq/devices/FairMQMultiplier.cxx

@@ -9,7 +9,6 @@
 #include "FairMQMultiplier.h"
 
 #include "../FairMQLogger.h"
-#include "../options/FairMQProgOptions.h"
 
 using namespace std;
 
@@ -27,9 +26,9 @@ FairMQMultiplier::~FairMQMultiplier()
 
 void FairMQMultiplier::InitTask()
 {
-    fMultipart = fConfig->GetValue<bool>("multipart");
-    fInChannelName = fConfig->GetValue<string>("in-channel");
-    fOutChannelNames = fConfig->GetValue<vector<string>>("out-channel");
+    fMultipart = fConfig->GetProperty<bool>("multipart");
+    fInChannelName = fConfig->GetProperty<string>("in-channel");
+    fOutChannelNames = fConfig->GetProperty<vector<string>>("out-channel");
     fNumOutputs = fChannels.at(fOutChannelNames.at(0)).size();
 
     if (fMultipart)

fairmq/devices/FairMQProxy.cxx

@@ -15,7 +15,6 @@
 #include "FairMQProxy.h"
 
 #include "../FairMQLogger.h"
-#include "../options/FairMQProgOptions.h"
 
 using namespace std;
 
@@ -32,9 +31,9 @@ FairMQProxy::~FairMQProxy()
 
 void FairMQProxy::InitTask()
 {
-    fMultipart = fConfig->GetValue<bool>("multipart");
-    fInChannelName = fConfig->GetValue<string>("in-channel");
-    fOutChannelName = fConfig->GetValue<string>("out-channel");
+    fMultipart = fConfig->GetProperty<bool>("multipart");
+    fInChannelName = fConfig->GetProperty<string>("in-channel");
+    fOutChannelName = fConfig->GetProperty<string>("out-channel");
 }
 
 void FairMQProxy::Run()

fairmq/devices/FairMQSink.h

@@ -20,7 +20,6 @@
 
 #include "../FairMQDevice.h"
 #include "../FairMQLogger.h"
-#include "../options/FairMQProgOptions.h"
 
 // template<typename OutputPolicy>
 class FairMQSink : public FairMQDevice//, public OutputPolicy
@@ -44,9 +43,9 @@ class FairMQSink : public FairMQDevice//, public OutputPolicy
 
     virtual void InitTask()
     {
-        fMultipart = fConfig->GetValue<bool>("multipart");
-        fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
-        fInChannelName = fConfig->GetValue<std::string>("in-channel");
+        fMultipart = fConfig->GetProperty<bool>("multipart");
+        fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
+        fInChannelName = fConfig->GetProperty<std::string>("in-channel");
     }
 
     virtual void Run()