karabo.cpp 3.0.3__tar.gz → 3.0.7__tar.gz

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/CMakeLists.txt

@@ -37,7 +37,6 @@ install(DIRECTORY extern/build/include/
         PATTERN "boost/fusion"        EXCLUDE
         PATTERN "boost/geometry"      EXCLUDE
         PATTERN "boost/spirit"        EXCLUDE
-        PATTERN "boost/preprocessor"  EXCLUDE
         PATTERN "boost/wave"          EXCLUDE
         PATTERN "boost/beast"         EXCLUDE
         PATTERN "boost/qvm"           EXCLUDE

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karabo.cpp
-Version: 3.0.3
+Version: 3.0.7
 Summary: Karabo's C++ API and Python bindings thereof
 Keywords: Karabo,SCADA,async,control system
 Author-Email: European XFEL GmbH <opensource@xfel.eu>
@@ -13,7 +13,7 @@ Project-URL: Homepage, https://github.com/European-XFEL/Karabo
 Project-URL: Bug Reports, https://github.com/European-XFEL/Karabo/issues
 Project-URL: Source, https://github.com/European-XFEL/Karabo
 Requires-Python: ==3.12.*
-Requires-Dist: karabo-native==3.0.3
+Requires-Dist: karabo-native==3.0.7
 Description-Content-Type: text/markdown
 
 # Karabo SCADA Framework - C++ API and Service Devices

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/extern/build.sh

@@ -145,12 +145,6 @@ install_python() {
         safeRunCommandQuiet "conan remote update conancenter --url https://center2.conan.io"
     fi
 
-    # Some dependencies, like libpng specify minimum required versions of cmake to be older than
-    # "3.5" - starting with cmake "4.X", the minimum cmake version must be at least "3.5".
-    # Details at https://cmake.org/cmake/help/v4.0/release/4.0.html#id14
-    # Setting the environment variable below allows passing the cmake check.
-    export CMAKE_POLICY_VERSION_MINIMUM="3.5"
-
     safeRunCommandQuiet "conan install conanfile-bootstrap.txt $folder_opts $build_opts $profile_opts"
 
     # ensure that python can always find its libpython.so
@@ -283,6 +277,12 @@ else
    conan --version
 fi
 
+# Some dependencies, like libpng specify minimum required versions of cmake to be older than
+# "3.5" - starting with cmake "4.X", the minimum cmake version must be at least "3.5".
+# Details at https://cmake.org/cmake/help/v4.0/release/4.0.html#id14
+# Setting the environment variable below allows passing the cmake check.
+export CMAKE_POLICY_VERSION_MINIMUM="3.5"
+
 # python download and install to allow full bootstrap
 # install framework python dependencies via pip
 check_for $INSTALL_PREFIX/bin/python

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/extern/conanfile.txt

@@ -18,11 +18,11 @@ zeromq/4.3.2
 
 
 # patch-any
-libpng/1.6.37
+libpng/1.6.50
 libxslt/1.1.34
 libxml2/2.11.6
 patchelf/0.13
-pugixml/1.10
+pugixml/1.15
 
 # minor-any
 boost/1.88.0

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["scikit-build-core"]
 build-backend = "scikit_build_core.build"
 
 [project]
-version = "3.0.3"
+version = "3.0.7"
 name = "karabo.cpp"
 description = "Karabo's C++ API and Python bindings thereof"
 readme = "README.md"
@@ -38,7 +38,7 @@ classifiers = [
 # For an analysis of this field vs pip's requirements files see:
 # https://packaging.python.org/discussions/install-requires-vs-requirements/
 dependencies = [
-  "karabo-native==3.0.3",
+  "karabo-native==3.0.7",
   ]
 
 
@@ -130,5 +130,5 @@ before-build = "pip3 install conan==2.19.0 && pip3 install numpy==2.0.1 && pytho
 
 test-requires = ["pytest"]
 # these are minimally required for a C++ server to start
-before-test = "mkdir /karabo && mkdir /karabo/var && mkdir /karabo/var/data && mkdir /karabo/plugins && pip install karabo.native==3.0.3 --index-url 'https://gitlab-ci-token:glcbt-64_ywxqxzTszQXmxeVm8idj@git.xfel.eu/api/v4/projects/5003/packages/pypi/simple' --extra-index-url https://pypi.org"
+before-test = "mkdir /karabo && mkdir /karabo/var && mkdir /karabo/var/data && mkdir /karabo/plugins && pip install karabo.native==3.0.7 --index-url 'https://gitlab-ci-token:glcbt-64_rQzK5PzG5pw-grW5ESAR@git.xfel.eu/api/v4/projects/5003/packages/pypi/simple' --extra-index-url https://pypi.org"
 test-command = "KARABO=/karabo KARABO_BROKER=amqp://xfel:karabo@exfl-broker-1:5672 pytest {project}/wheel_tests"

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabind/PyUtilAlarmElement.cc

@@ -49,7 +49,8 @@ void exportPyUtilAlarmConditionElement(py::module_& m) {
 
     a.def("displayedName", &AlarmConditionElement::displayedName, py::return_value_policy::reference_internal);
 
-    a.def("key", &AlarmConditionElement::key, py::return_value_policy::reference_internal);
+    a.def("key", &AlarmConditionElement::key, py::arg("name"), py::arg("strict") = true,
+          py::return_value_policy::reference_internal);
 
     a.def("tags",
           (AlarmConditionElement & (AlarmConditionElement::*)(std::string const&, std::string const&)) &

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabind/PyUtilHash.cc

@@ -461,8 +461,8 @@ void exportPyUtilHash(py::module_& m) {
                 g = h.get('a.b')  # reference to Hash('c', 1)
                 g.set('c', 2)
                 assert(h.get('a.b.c') == 2)
-                del(h)        # delete whole tree
-                print(g)      # SEGFAULT: dangling reference
+                del h         # delete whole tree
+                print(g)      # inner Hash still valid
           )pbdoc");
 
     h.def(

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabind/PyUtilSchemaElement.cc

@@ -217,7 +217,8 @@ void exportPyUtilSchemaElement(py::module_& m) {
               .def("description", &NDArrayElement::description, py::return_value_policy::reference_internal)
               .def("displayedName", &NDArrayElement::displayedName, py::return_value_policy::reference_internal)
               .def("init", &NDArrayElement::init, py::return_value_policy::reference_internal)
-              .def("key", &NDArrayElement::key, py::return_value_policy::reference_internal)
+              .def("key", &NDArrayElement::key, py::arg("name"), py::arg("strict") = true,
+                   py::return_value_policy::reference_internal)
               .def("readOnly", &NDArrayElement::readOnly, py::return_value_policy::reference_internal)
               .def("reconfigurable", &NDArrayElement::reconfigurable, py::return_value_policy::reference_internal)
               .def("commit", &NDArrayElement::commit, py::return_value_policy::reference_internal);

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabind/PyUtilSchemaElement.hh

@@ -234,31 +234,31 @@ class CommonWrap {
                     KARABO_PYTHON_NUMERIC_ATTRIBUTES(T);                                                      \
     }
 
-#define KARABO_PYTHON_COMMON_ATTRIBUTES(T)                                                                    \
-    .def("observerAccess", &T::observerAccess, py::return_value_policy::reference_internal)                   \
-          .def("operatorAccess", &T::operatorAccess, py::return_value_policy::reference_internal)             \
-          .def("expertAccess", &T::expertAccess, py::return_value_policy::reference_internal)                 \
-          .def("allowedStates", &CommonWrap<T>::allowedStatesPy, py::return_value_policy::reference_internal) \
-          .def("assignmentInternal", &T::assignmentInternal, py::return_value_policy::reference_internal)     \
-          .def("assignmentMandatory", &T::assignmentMandatory, py::return_value_policy::reference_internal)   \
-          .def("assignmentOptional", &T::assignmentOptional, py::return_value_policy::reference_internal)     \
-          .def("alias", &AliasAttributeWrap<T>::aliasPy, py::return_value_policy::reference_internal)         \
-          .def("commit", &T::commit, py::return_value_policy::reference_internal)                             \
-          .def("commit", (T & (T::*)(karabo::data::Schema&))(&T::commit), py::arg("expected"),                \
-               py::return_value_policy::reference_internal)                                                   \
-          .def("description", &T::description, py::return_value_policy::reference_internal)                   \
-          .def("displayedName", &T::displayedName, py::return_value_policy::reference_internal)               \
-          .def("unit", &T::unit, py::return_value_policy::reference_internal)                                 \
-          .def("metricPrefix", &T::metricPrefix, py::return_value_policy::reference_internal)                 \
-          .def("init", &T::init, py::return_value_policy::reference_internal)                                 \
-          .def("key", &T::key, py::return_value_policy::reference_internal)                                   \
-          .def("setSpecialDisplayType", (T & (T::*)(std::string const&))(&T::setSpecialDisplayType),          \
-               py::arg("displayType"), py::return_value_policy::reference_internal)                           \
-          .def("readOnly", &T::readOnly, py::return_value_policy::reference_internal)                         \
-          .def("reconfigurable", &T::reconfigurable, py::return_value_policy::reference_internal)             \
-          .def("tags", (T & (T::*)(std::string const&, std::string const&))(&T::tags), py::arg("tags"),       \
-               py::arg("sep") = " ,;", py::return_value_policy::reference_internal)                           \
-          .def("tags", (T & (T::*)(std::vector<std::string> const&))(&T::tags), py::arg("tags"),              \
+#define KARABO_PYTHON_COMMON_ATTRIBUTES(T)                                                                             \
+    .def("observerAccess", &T::observerAccess, py::return_value_policy::reference_internal)                            \
+          .def("operatorAccess", &T::operatorAccess, py::return_value_policy::reference_internal)                      \
+          .def("expertAccess", &T::expertAccess, py::return_value_policy::reference_internal)                          \
+          .def("allowedStates", &CommonWrap<T>::allowedStatesPy, py::return_value_policy::reference_internal)          \
+          .def("assignmentInternal", &T::assignmentInternal, py::return_value_policy::reference_internal)              \
+          .def("assignmentMandatory", &T::assignmentMandatory, py::return_value_policy::reference_internal)            \
+          .def("assignmentOptional", &T::assignmentOptional, py::return_value_policy::reference_internal)              \
+          .def("alias", &AliasAttributeWrap<T>::aliasPy, py::return_value_policy::reference_internal)                  \
+          .def("commit", &T::commit, py::return_value_policy::reference_internal)                                      \
+          .def("commit", (T & (T::*)(karabo::data::Schema&))(&T::commit), py::arg("expected"),                         \
+               py::return_value_policy::reference_internal)                                                            \
+          .def("description", &T::description, py::return_value_policy::reference_internal)                            \
+          .def("displayedName", &T::displayedName, py::return_value_policy::reference_internal)                        \
+          .def("unit", &T::unit, py::return_value_policy::reference_internal)                                          \
+          .def("metricPrefix", &T::metricPrefix, py::return_value_policy::reference_internal)                          \
+          .def("init", &T::init, py::return_value_policy::reference_internal)                                          \
+          .def("key", &T::key, py::arg("name"), py::arg("strict") = true, py::return_value_policy::reference_internal) \
+          .def("setSpecialDisplayType", (T & (T::*)(std::string const&))(&T::setSpecialDisplayType),                   \
+               py::arg("displayType"), py::return_value_policy::reference_internal)                                    \
+          .def("readOnly", &T::readOnly, py::return_value_policy::reference_internal)                                  \
+          .def("reconfigurable", &T::reconfigurable, py::return_value_policy::reference_internal)                      \
+          .def("tags", (T & (T::*)(std::string const&, std::string const&))(&T::tags), py::arg("tags"),                \
+               py::arg("sep") = " ,;", py::return_value_policy::reference_internal)                                    \
+          .def("tags", (T & (T::*)(std::vector<std::string> const&))(&T::tags), py::arg("tags"),                       \
                py::return_value_policy::reference_internal)
 
 #define KARABO_PYTHON_OPTIONS_NONVECTOR(T)                                                              \
@@ -315,7 +315,8 @@ class CommonWrap {
     .def("observerAccess", &NameElem::observerAccess, py::return_value_policy::reference_internal)                    \
           .def("operatorAccess", &NameElem::operatorAccess, py::return_value_policy::reference_internal)              \
           .def("expertAccess", &NameElem::expertAccess, py::return_value_policy::reference_internal)                  \
-          .def("key", &NameElem::key, py::return_value_policy::reference_internal)                                    \
+          .def("key", &NameElem::key, py::arg("name"), py::arg("strict") = true,                                      \
+               py::return_value_policy::reference_internal)                                                           \
           .def("description", &NameElem::description, py::return_value_policy::reference_internal)                    \
           .def("displayedName", &NameElem::displayedName, py::return_value_policy::reference_internal)                \
           .def("alias", &AliasAttributeWrap<NameElem>::aliasPy, py::return_value_policy::reference_internal)          \

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabind/PyUtilSchemaTableElement.cc

@@ -125,7 +125,8 @@ void exportPyUtilSchemaTableElement(py::module_& m) {
               .def("description", &TableElement::description, py::return_value_policy::reference_internal)
               .def("displayedName", &TableElement::displayedName, py::return_value_policy::reference_internal)
               .def("init", &TableElement::init, py::return_value_policy::reference_internal)
-              .def("key", &TableElement::key, py::return_value_policy::reference_internal)
+              .def("key", &TableElement::key, py::arg("name"), py::arg("strict") = true,
+                   py::return_value_policy::reference_internal)
               .def("reconfigurable", &TableElement::reconfigurable, py::return_value_policy::reference_internal)
               .def("tags",
                    (TableElement & (TableElement::*)(std::string const&, std::string const&)) & TableElement::tags,

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabind/PyUtilStateElement.cc

@@ -47,7 +47,8 @@ void exportPyUtilStateElement(py::module_& m) {
 
     se.def("displayedName", &StateElement::displayedName, py::return_value_policy::reference_internal);
 
-    se.def("key", &StateElement::key, py::return_value_policy::reference_internal);
+    se.def("key", &StateElement::key, py::arg("name"), py::arg("strict") = true,
+           py::return_value_policy::reference_internal);
 
     se.def("tags", (StateElement & (StateElement::*)(std::string const&, std::string const&)) & StateElement::tags,
            py::arg("tags"), py::arg("sep") = " ,;", py::return_value_policy::reference_internal);

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabind/PyXmsImageDataElement.cc

@@ -210,7 +210,8 @@ void exportPyXmsImageDataElement(py::module_& m) {
 
         el.def(py::init<Schema&>(), py::arg("expected"));
 
-        el.def("key", &ImageDataElement::key, py::arg("key"), py::return_value_policy::reference_internal);
+        el.def("key", &ImageDataElement::key, py::arg("key"), py::arg("strict") = true,
+               py::return_value_policy::reference_internal);
 
         el.def("displayedName", &ImageDataElement::displayedName, py::arg("name"),
                py::return_value_policy::reference_internal);

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabind/PyXmsSlotElement.cc

@@ -85,7 +85,8 @@ void exportPyXmsSlotElement(py::module_& m) {
     sl.def("displayedName", &SlotElementBase<SLOT_ELEMENT>::displayedName, py::arg("displayedName"),
            py::return_value_policy::reference_internal);
 
-    sl.def("key", &SlotElementBase<SLOT_ELEMENT>::key, py::arg("name"), py::return_value_policy::reference_internal);
+    sl.def("key", &SlotElementBase<SLOT_ELEMENT>::key, py::arg("name"), py::arg("strict") = true,
+           py::return_value_policy::reference_internal);
 
     sl.def("alias", &wrapper::AliasAttributePy<SLOT_ELEMENT>::setAlias, py::return_value_policy::reference_internal);
 

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabo/CMakeLists.txt

@@ -66,10 +66,10 @@ endif()
 # Extracts KARABO_VERSION from the appropriate Git tag, writes to
 # a file to be used by the Karabo Framework at build time.
 message(STATUS "Resolving Karabo Version from Git repository")
-set(KARABO_VERSION "3.0.3")
+set(KARABO_VERSION "3.0.7")
 set(KARABO_VERSION_MAJOR "3")
 set(KARABO_VERSION_MINOR "0")
-set(KARABO_VERSION_PATCH "3")
+set(KARABO_VERSION_PATCH "7")
 message(STATUS "Karabo Version: ${KARABO_VERSION}")
 message(STATUS "Karabo Version Major: ${KARABO_VERSION_MAJOR}")
 message(STATUS "Karabo Version Minor: ${KARABO_VERSION_MINOR}")

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabo/core/Device.cc

@@ -158,10 +158,7 @@ namespace karabo {
             ALARM_ELEMENT(expected)
                   .key("alarmCondition")
                   .displayedName("Alarm condition")
-                  .description(
-                        "The current alarm condition of the device. "
-                        "Evaluates to the highest condition on any"
-                        " property if not set manually.")
+                  .description("The current alarm condition of the device.")
                   .initialValue(AlarmCondition::NONE)
                   .commit();
 
@@ -717,23 +714,53 @@ namespace karabo {
             onTimeTick(id, sec, frac, period);
         }
 
-
         void Device::appendSchemaMaxSize(const std::string& path, unsigned int value, bool emitFlag) {
+            internalAppendSchemaMultiMaxSize({path}, {value}, emitFlag);
+        }
+
+        void Device::appendSchemaMultiMaxSize(const std::vector<std::string>& paths,
+                                              const std::vector<unsigned int>& values) {
+            internalAppendSchemaMultiMaxSize(paths, values, true);
+        }
+
+        void Device::internalAppendSchemaMultiMaxSize(const std::vector<std::string>& paths,
+                                                      const std::vector<unsigned int>& values, bool emitFlag) {
             using karabo::data::OVERWRITE_ELEMENT;
+
+            if (paths.size() != values.size()) {
+                throw KARABO_PARAMETER_EXCEPTION("Number of paths and values differs.");
+            }
             std::lock_guard<std::mutex> lock(m_objectStateChangeMutex);
-            if (!m_fullSchema.has(path)) {
-                throw KARABO_PARAMETER_EXCEPTION("Path \"" + path + "\" not found in the device schema.");
+            for (const std::string& path : paths) {
+                if (!m_fullSchema.has(path)) {
+                    throw KARABO_PARAMETER_EXCEPTION("Path \"" + path + "\" not found in the device schema.");
+                }
             }
             m_stateDependentSchema.clear();
             // Do not touch static schema - that must be restorable via updateSchema(Schema())
             // OVERWRITE_ELEMENT checks whether max size attribute makes sense for path
-            OVERWRITE_ELEMENT(m_fullSchema).key(path).setNewMaxSize(value).commit();
-            if (m_injectedSchema.has(path)) {
-                OVERWRITE_ELEMENT(m_injectedSchema).key(path).setNewMaxSize(value).commit();
+            size_t index = 0;
+            for (const std::string& path : paths) {
+                const unsigned int value = values[index++]; // postfix!
+                OVERWRITE_ELEMENT(m_fullSchema).key(path).setNewMaxSize(value).commit();
+                if (m_injectedSchema.has(path)) {
+                    OVERWRITE_ELEMENT(m_injectedSchema).key(path).setNewMaxSize(value).commit();
+                }
             }
 
             // Notify the distributed system if needed
+            // (and, as in updateSchema and appendSchema, better before recreating output channels):
             if (emitFlag) emit("signalSchemaUpdated", m_fullSchema, m_deviceId);
+
+            // If the vector was part of an output channel schema, recreate the channel.
+            // The new incarnation of the channel receives the up-to-date schema for validation.
+            for (const std::string& output : getOutputChannelNames()) {
+                for (const std::string& path : paths) {
+                    if (path.starts_with(output)) {
+                        prepareOutputChannel(output);
+                    }
+                }
+            }
         }
 
 

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabo/core/Device.hh

@@ -811,20 +811,32 @@ namespace karabo {
                                       unsigned long long period) {}
 
             /**
-             * Append Schema to change/set maximum size information for path - if paths does not exist, throw exception
+             * Append Schema to change or set the maximum size for a vector or table property
              *
              * This is similar to the more general appendSchema, but dedicated to a common use case.
              *
-             * Caveat: This does not recreate an output channel if its schema is changed
+             * Use 'appendSchemaMultiMaxSize' if the maximum size of several properties should be changed.
              *
-             * @param path  indicates the parameter which should be a Vector- or TableElement
-             * @param value is the new maximum size of the parameter
+             * @param path  indicates the property which should be a Vector- or TableElement
+             * @param value is the new maximum size of the property
              * @param emitFlag indicates if others should be informed about this Schema update.
-             *                 If this method is called for a bunch of paths, it is recommended to
-             *                 set this to true only for the last call.
+             *                 Should only be set to false if followed by a call to appendSchema(..).
              */
             void appendSchemaMaxSize(const std::string& path, unsigned int value, bool emitFlag = true);
 
+            /**
+             * Append Schema to change or set the maximum size information for several properties
+             *
+             * @param paths  property names of Vector- or TableElements
+             * @param values the new maximum sizes of these properties (same order and length as 'paths')
+             */
+            void appendSchemaMultiMaxSize(const std::vector<std::string>& paths,
+                                          const std::vector<unsigned int>& values);
+
+           private:
+            void internalAppendSchemaMultiMaxSize(const std::vector<std::string>& paths,
+                                                  const std::vector<unsigned int>& values, bool emitFlag);
+
            protected: // Functions and Classes
             virtual void preReconfigure(karabo::data::Hash& incomingReconfiguration) {}
 

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabo/core/DeviceClient.cc

@@ -58,7 +58,6 @@ namespace karabo {
         // See also OutputChannel::initializeServerConnection(...)
         const int kMaxCompleteInitializationAttempts = 2500;
 
-        // TODO: Move this to a constant of ConfigurationManager device once it becomes part of the Framework.
         const std::string DEFAULT_CONFIG_MANAGER_ID("KaraboConfigurationManager");
 
         void DeviceClient::initServiceDeviceIds(const Hash& serviceDeviceIds) {
@@ -81,8 +80,7 @@ namespace karabo {
               m_internalTimeout(3000),
               m_topologyInitialized(false),
               m_ageingTimer(karabo::net::EventLoop::getIOService()),
-              m_getOlder(false) // Sic! To start aging in setAgeing below.
-              ,
+              m_getOlder(false), // Sic! To start aging in setAgeing below.
               m_signalsChangedTimer(karabo::net::EventLoop::getIOService()),
               m_runSignalsChangedTimer(false),
               m_signalsChangedInterval(-1),
@@ -119,8 +117,7 @@ namespace karabo {
               m_internalTimeout(2000),
               m_topologyInitialized(false),
               m_ageingTimer(karabo::net::EventLoop::getIOService()),
-              m_getOlder(false) // Sic! To start aging in setAgeing below.
-              ,
+              m_getOlder(false), // Sic! To start aging in setAgeing below.
               m_signalsChangedTimer(karabo::net::EventLoop::getIOService()),
               m_runSignalsChangedTimer(false),
               m_signalsChangedInterval(-1),
@@ -203,18 +200,15 @@ namespace karabo {
                   bind_weak(&karabo::core::DeviceClient::_slotClassSchema, this, _1, _2, _3), "_slotClassSchema");
             p->registerSlot<Schema, string>(bind_weak(&karabo::core::DeviceClient::_slotSchemaUpdated, this, _1, _2),
                                             "_slotSchemaUpdated");
+            // We hook our methods to the existing (in SignalSlotable) slots for instance monitoring
             p->registerSlot<string, Hash>(bind_weak(&karabo::core::DeviceClient::_slotInstanceNew, this, _1, _2),
-                                          "_slotInstanceNew");
+                                          "slotInstanceNew");
             p->registerSlot<string, Hash>(bind_weak(&karabo::core::DeviceClient::_slotInstanceGone, this, _1, _2),
-                                          "_slotInstanceGone");
+                                          "slotInstanceGone");
             p->registerSlot<string, Hash>(bind_weak(&karabo::core::DeviceClient::_slotInstanceUpdated, this, _1, _2),
-                                          "_slotInstanceUpdated");
+                                          "slotInstanceUpdated");
+            // A slot to follow logger map updates
             p->registerSlot<Hash>(bind_weak(&karabo::core::DeviceClient::_slotLoggerMap, this, _1), "_slotLoggerMap");
-
-            // No advantage from asyncConnect since connecting to one's own signal is just a call chain:
-            p->connect("", "signalInstanceNew", "_slotInstanceNew");
-            p->connect("", "signalInstanceGone", "_slotInstanceGone");
-            p->connect("", "signalInstanceUpdated", "_slotInstanceUpdated");
         }
 
 
@@ -380,11 +374,11 @@ namespace karabo {
                     //
                     // As a workaround, we try to clarify the situation:
                     // - Take care that we do not track the instance.
-                    // - Trigger a call to our slotPingAnswer that will then trigger "signalInstanceNew" (but only
+                    // - Trigger a call to our slotDiscoverAnswer that will then trigger "slotInstanceNew" (but only
                     //   if instance is untracked).
                     if (auto sigSlot = m_signalSlotable.lock()) {
                         const bool wasTracked = sigSlot->eraseTrackedInstance(instanceId);
-                        sigSlot->call(instanceId, "slotPing", 0);
+                        sigSlot->call(instanceId, "slotDiscover", getInstanceId());
                         KARABO_LOG_FRAMEWORK_WARN << getInstanceId() << ": Received instance update from '"
                                                   << instanceId << "' although it is not in runtime description"
                                                   << (wasTracked ? " (but was tracked!)" : "")

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabo/data/schema/BaseElement.cc

@@ -23,21 +23,33 @@
 #include "karabo/data/types/Exception.hh"
 #include "karabo/data/types/Hash.hh"
 
-void karabo::data::checkPropertyPath(const std::string& name) {
+void karabo::data::checkPropertyPath(const std::string& name, bool strict) {
     if (name.empty() || name.back() == Hash::k_defaultSep) {
         throw KARABO_PARAMETER_EXCEPTION(("Bad (sub-)key '" + name) += "': empty");
     }
     // '/' is special: only allowed for backward compatibility in metro devices of DA group
     constexpr char allowedCharacters[] =
-          ".0123456789_/"
+          ".0123456789_/" // In 3.1.X move '/' to tolerated characters?
           "abcdefghijklmnopqrstuvwxyz"
           "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     assert(allowedCharacters[0] == karabo::data::Hash::k_defaultSep);
 
-    const size_t pos = name.find_first_not_of(allowedCharacters);
-    if (pos != std::string::npos) {
-        std::string msg(("Bad (sub-)key '" + name) += "': illegal character at position ");
-        throw KARABO_PARAMETER_EXCEPTION(msg += toString(pos));
+    if (strict) {
+        const size_t pos = name.find_first_not_of(allowedCharacters);
+        if (pos != std::string::npos) {
+            std::string msg(("Bad (sub-)key '" + name) += "': illegal character at position ");
+            throw KARABO_PARAMETER_EXCEPTION(msg += toString(pos));
+        }
+    } else {
+        // If requested to be not strict, we tolerate some characters.
+        // Note we must not tolerate ',', '=', or space for sake of the influxDB line protocol!
+        const std::string toleratedCharacters("@-");
+        const std::string allAllowedCharacters(allowedCharacters + toleratedCharacters);
+        const size_t pos = name.find_first_not_of(allAllowedCharacters);
+        if (pos != std::string::npos) {
+            std::string msg(("Bad (sub-)key '" + name) += "': not tolerated character at position ");
+            throw KARABO_PARAMETER_EXCEPTION(msg += toString(pos));
+        }
     }
     // Now check that leading character of (last part of) name is not a digit
     // (non-last parts are checked when their nodes were added)

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabo/data/schema/BaseElement.hh

@@ -40,8 +40,9 @@ namespace karabo {
          * Nestes paths (i.e. paths with dots) are allowed.
          *
          * @param name the key to be checked
+         * @param strict specify whether to tolerate more than just letter, digits, underscore
          */
-        void checkPropertyPath(const std::string& name);
+        void checkPropertyPath(const std::string& name, bool strict);
 
         /**
          * The BaseElement class is a base class for various element types: simple, vector, choice, list
@@ -74,13 +75,13 @@ namespace karabo {
              *         .commit();
              * @endcode
              */
-            virtual Derived& key(const std::string& name) {
+            virtual Derived& key(const std::string& name, bool strict = true) {
                 // Check whether full path (that in fact has to be specified here!) or its last
                 // key is empty - empty non-last keys are caught elsewhere.
                 // Also ensure that keys are usable with MDL proxies, i.e. only letters, digits,
                 // underscores - and a digit not as first character.
 
-                checkPropertyPath(name); // throws if not OK
+                checkPropertyPath(name, strict); // throws if not OK
 
                 m_node->m_key = name;
                 return *(static_cast<Derived*>(this));

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabo/data/schema/CustomNodeElement.hh

@@ -92,6 +92,7 @@ namespace karabo {
             /**
              * The <b>key</b> method serves for setting up a unique name for the element.
              * @param name Unique name for the key
+             * @param strict keep as true to get the strongly recommended strict validation of characters in 'name'
              * @return reference to the Element (to allow method's chaining)
              *
              * <b>Example:</b>
@@ -102,10 +103,10 @@ namespace karabo {
              *         .commit();
              * @endcode
              */
-            Derived& key(const std::string& key) {
+            Derived& key(const std::string& key, bool strict = true) {
                 using namespace karabo::data;
                 m_key = key;
-                NODE_ELEMENT(m_schema).key(m_key).template appendParametersOf<Described>().commit();
+                NODE_ELEMENT(m_schema).key(m_key, strict).template appendParametersOf<Described>().commit();
 
                 return *(static_cast<Derived*>(this));
             }

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabo/devices/DataLoggerManager.cc

@@ -682,7 +682,7 @@ namespace karabo {
                 remote().enableInstanceTracking();
 
                 // Publish logger map read from disc. Do that as late as possible in the initialization procedure
-                // to give those interested the chance to register their slots after we sent signalInstanceNew.
+                // to give those interested the chance to register their slots after we sent slotInstanceNew.
                 {
                     std::lock_guard<std::mutex> lock(
                           m_loggerMapMutex); // m_loggerMap must not be changed while we process it

{karabo_cpp-3.0.3 → karabo_cpp-3.0.7}/src/karabo/net/AmqpClient.cc

@@ -570,11 +570,14 @@ namespace karabo::net {
                                           << static_cast<int>(m_channelStatus);
                 break;
             case ChannelStatus::CREATE_QUEUE: {
-                m_channel->declareQueue(m_queue, AMQP::autodelete, m_queueArgs)
+                // auto-delete: deleted when last consumer is finished using it
+                // exclusive: can be accessed only from our connection, deleted when that closes
+                m_channel->declareQueue(m_queue, AMQP::autodelete + AMQP::exclusive, m_queueArgs)
                       .onSuccess([wSelf](const std::string& name, int msgCount, int consumerCount) {
                           if (auto self = wSelf.lock()) {
                               if (consumerCount > 0) {
                                   // Queue already exists, but we need a unique one for us - attach timestamp
+                                  // (since queue is exclusive, happens only for same id using same connection)
                                   KARABO_LOG_FRAMEWORK_INFO_C("AmqpClient")
                                         << "Queue " << self->m_queue
                                         << " already has a consumer, append some bytes from clock and try again.";
@@ -601,15 +604,33 @@ namespace karabo::net {
                       }) // end of success handler
                       .onError([wSelf](const char* message) {
                           if (auto self = wSelf.lock()) {
-                              const std::string queue(self->m_instanceId == self->m_queue ? "" : self->m_queue + " ");
-                              KARABO_LOG_FRAMEWORK_WARN_C("AmqpClient")
-                                    << self->m_instanceId << ": Declaring queue " << queue << "failed: " << message;
-                              // reset channel
-                              self->m_channel.reset();
-                              self->m_channelStatus = ChannelStatus::REQUEST;
-                              AsyncHandler callback;
-                              callback.swap(self->m_channelPreparationCallback);
-                              callback(make_error_code(AmqpCppErrc::eCreateQueueError));
+                              const std::string_view msg(message);
+                              constexpr auto np = std::string::npos;
+                              if (msg.find("RESOURCE_LOCKED") != np && msg.find("cannot obtain exclusive") != np) {
+                                  KARABO_LOG_FRAMEWORK_INFO
+                                        << "Queue " << self->m_queue
+                                        << " already created, append some bytes from clock and try again. "
+                                        << "Will recreate channel (was " << (self->m_channel->usable() ? "" : "not ")
+                                        << "OK)."; // should be not OK
+                                  std::ostringstream oss;
+                                  oss << ":" << std::hex << std::chrono::steady_clock::now().time_since_epoch().count();
+                                  self->m_queue += oss.str();
+                                  self->m_channelStatus = ChannelStatus::CREATE;
+                                  AsyncHandler callback;
+                                  callback.swap(self->m_channelPreparationCallback);
+                                  self->asyncPrepareChannel(std::move(callback));
+                              } else {
+                                  const std::string queue(self->m_instanceId == self->m_queue ? ""
+                                                                                              : self->m_queue + " ");
+                                  KARABO_LOG_FRAMEWORK_WARN << self->m_instanceId << ": Declaring queue " << queue
+                                                            << "failed: " << message;
+                                  // reset channel
+                                  self->m_channel.reset();
+                                  self->m_channelStatus = ChannelStatus::REQUEST;
+                                  AsyncHandler callback;
+                                  callback.swap(self->m_channelPreparationCallback);
+                                  callback(make_error_code(AmqpCppErrc::eCreateQueueError));
+                              }
                           }
                       }); // end of failure handler
             } break;