pvxslibs 1.2.4a3__tar.gz → 1.3.0__tar.gz

{pvxslibs-1.2.4a3/python/pvxslibs.egg-info → pvxslibs-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pvxslibs
-Version: 1.2.4a3
+Version: 1.3.0
 Summary: PVXS libraries packaged for python
 Home-page: https://mdavidsaver.github.io/pvxs
 Author: Michael Davidsaver

{pvxslibs-1.2.4a3 → pvxslibs-1.3.0}/configure/CONFIG_PVXS_VERSION

@@ -1,6 +1,6 @@
 PVXS_MAJOR_VERSION = 1
-PVXS_MINOR_VERSION = 2
-PVXS_MAINTENANCE_VERSION = 4
+PVXS_MINOR_VERSION = 3
+PVXS_MAINTENANCE_VERSION = 0
 
 # Version range conditions in Makefiles
 #
@@ -12,7 +12,8 @@ PVXS_MAINTENANCE_VERSION = 4
 #
 # ifneq ($(PVXS_X_Y_Z),YES)   # PVXS != X.Y.Z
 #
-PVXS_1_2_4 = YES
+PVXS_1_3_0 = YES
+PVXS_1_2_4 = NO
 PVXS_1_2_3 = NO
 PVXS_1_2_2 = NO
 PVXS_1_2_1 = NO

{pvxslibs-1.2.4a3 → pvxslibs-1.3.0}/ioc/field.h

@@ -42,7 +42,7 @@ public:
     // points to storage in containing Group::fields
     std::vector<Field*> triggers;
 
-    // only for Meta mapping.  type infered from dbChannelFinalFieldType()
+    // only for Meta mapping.  type inferred from dbChannelFinalFieldType()
     Value anyType;
 
     Field(const FieldDefinition& def);

{pvxslibs-1.2.4a3 → pvxslibs-1.3.0}/ioc/groupsource.cpp

@@ -209,19 +209,27 @@ void subscriptionPost(GroupSourceSubscriptionCtx *pGroupCtx)
     // Make sure that the initial subscription update has occurred on all channels before replying
     // As we make two initial updates when opening a new subscription, for each field,
     // we need all updates for all fields to have completed before continuing
+    bool first = false;
     if (!pGroupCtx->eventsPrimed) {
         for (auto& fieldCtx: pGroupCtx->fieldSubscriptionContexts) {
             if (!fieldCtx.hadValueEvent || !fieldCtx.hadPropertyEvent) {
                 return;
             }
         }
-        pGroupCtx->eventsPrimed = true;
+        pGroupCtx->eventsPrimed = first = true;
     }
 
-    log_debug_printf(_logname, "%s : %s\n", __func__, pGroupCtx->group.name.c_str());
-
     auto& currentValue = pGroupCtx->currentValue;
 
+    bool empty(!currentValue.isMarked(false, true));
+
+    Level lvl = first && empty ? Level::Warn : Level::Debug;
+    log_printf(_logname, lvl, "%s%s%s : %s\n", __func__,
+               first ? " first" : "", empty ? " empty" : "",
+               pGroupCtx->group.name.c_str());
+    if(empty && !first)
+        return;
+
     // If events have been primed then return the value to the subscriber,
     // and unmark all accumulated changes
     pGroupCtx->subscriptionControl->post(currentValue.clone());
@@ -251,7 +259,8 @@ void GroupSource::onStartSubscription(const std::shared_ptr<GroupSourceSubscript
  * @param pDbFieldLog the database field log containing the changes being notified
  */
 static
-void subscriptionValueCallback(void* userArg, dbChannel* pChannel, int, struct db_field_log* pDbFieldLog) {
+void subscriptionValueCallback(void* userArg, dbChannel* pChannel,
+                               int, struct db_field_log* pDbFieldLog) noexcept {
     try {
         auto fieldSubscriptionCtx = (FieldSubscriptionCtx*)userArg;
         auto first = !fieldSubscriptionCtx->hadValueEvent;
@@ -299,7 +308,8 @@ void subscriptionValueCallback(void* userArg, dbChannel* pChannel, int, struct d
 }
 
 static
-void subscriptionPropertiesCallback(void* userArg, dbChannel* pChannel, int, struct db_field_log* pDbFieldLog) {
+void subscriptionPropertiesCallback(void* userArg, dbChannel* pChannel,
+                                    int, struct db_field_log* pDbFieldLog) noexcept {
     try {
         auto subscriptionContext = (FieldSubscriptionCtx*)userArg;
         bool first = subscriptionContext->hadPropertyEvent;

{pvxslibs-1.2.4a3 → pvxslibs-1.3.0}/ioc/groupsourcehooks.cpp

@@ -20,6 +20,7 @@
 #include <pvxs/source.h>
 #include <pvxs/iochooks.h>
 
+#include "qsrvpvt.h"
 #include "groupsource.h"
 #include "groupconfigprocessor.h"
 #include "iocshcommand.h"
@@ -161,66 +162,49 @@ long dbLoadGroup(const char* jsonFilename, const char* macros) {
     }
 }
 
-}
-} // namespace pvxs::ioc
 
-using namespace pvxs::ioc;
+void processGroups()
+{
+    GroupConfigProcessor processor;
+    epicsGuard<epicsMutex> G(processor.config.groupMapMutex);
 
-namespace {
-using namespace pvxs;
+    // Parse all info(Q:Group... records to configure groups
+    processor.loadConfigFromDb();
 
-/**
- * Initialise qsrv database group records by adding them as sources in our running pvxs server instance
- *
- * @param theInitHookState the initHook state - we only want to trigger on the initHookAfterIocBuilt state - ignore all others
- */
-void qsrvGroupSourceInit(initHookState theInitHookState) {
-    try {
-        if(!IOCSource::enabled())
-            return;
-        if (theInitHookState == initHookAfterInitDatabase) {
-            GroupConfigProcessor processor;
-            epicsGuard<epicsMutex> G(processor.config.groupMapMutex);
+    // Load group configuration files
+    processor.loadConfigFiles();
 
-            // Parse all info(Q:Group... records to configure groups
-            processor.loadConfigFromDb();
+    // checks on groupConfigMap
+    processor.validateGroups();
 
-            // Load group configuration files
-            processor.loadConfigFiles();
+    // Configure groups
+    processor.defineGroups();
 
-            // checks on groupConfigMap
-            processor.validateGroups();
+    // Resolve triggers
+    processor.resolveTriggerReferences();
 
-            // Configure groups
-            processor.defineGroups();
+    // Create Server Groups
+    processor.createGroups();
+}
 
-            // Resolve triggers
-            processor.resolveTriggerReferences();
+void addGroupSrc()
+{
+    pvxs::ioc::server()
+            .addSource("qsrvGroup", std::make_shared<pvxs::ioc::GroupSource>(), 1);
+}
 
-            // Create Server Groups
-            processor.createGroups();
-        } else if (theInitHookState == initHookAfterIocBuilt) {
-            // Load group configuration from parsed groups in iocServer
-            pvxs::ioc::server().addSource("qsrvGroup", std::make_shared<pvxs::ioc::GroupSource>(), 1);
-        }
-    } catch(std::exception& e) {
-        fprintf(stderr, "ERROR: Unhandled exception in %s(%d): %s\n",
-                __func__, theInitHookState, e.what());
-    }
+void resetGroups()
+{
+    auto& config(IOCGroupConfig::instance());
+
+    // server stopped at this point, but lock anyway
+    epicsGuard<epicsMutex> G(config.groupMapMutex);
+
+    config.groupMap.clear();
+    config.groupConfigFiles.clear();
 }
 
-/**
- * IOC pvxs Group Source registrar.  This implements the required registrar function that is called by xxxx_registerRecordDeviceDriver,
- * the auto-generated stub created for all IOC implementations.
- *<p>
- * It is registered by using the `epicsExportRegistrar()` macro.
- *<p>
- * 1. Register your hook handler to handle any state hooks that you want to implement.  Here we install
- * an `initHookState` handler connected to the `initHookAfterIocBuilt` state.  It  will add all of the
- * group record type sources defined so far.  Note that you can define sources up until the `iocInit()` call,
- * after which point the `initHookAfterIocBuilt` handlers are called and will register all the defined records.
- */
-void pvxsGroupSourceRegistrar() {
+void group_enable() {
     // Register commands to be available in the IOC shell
     IOCShCommand<int, const char*>("pvxgl", "[level, [pattern]]",
                                    "Group Sources list.\n"
@@ -232,14 +216,6 @@ void pvxsGroupSourceRegistrar() {
     IOCShCommand<const char*, const char*>("dbLoadGroup",
                                            "JSON file", "macros", dbLoadGroupMsg)
             .implementation<&dbLoadGroupCmd>();
-
-    initHookRegister(&qsrvGroupSourceInit);
 }
 
-} // namespace
-
-// in .dbd file
-//registrar(pvxsGroupSourceRegistrar)
-extern "C" {
-epicsExportRegistrar(pvxsGroupSourceRegistrar);
-}
+}} // namespace pvxs::ioc

{pvxslibs-1.2.4a3 → pvxslibs-1.3.0}/ioc/iochooks.cpp

@@ -18,8 +18,12 @@
 
 #include <epicsExport.h>
 #include <epicsExit.h>
+#include <epicsString.h>
 #include <initHooks.h>
 #include <iocsh.h>
+#include <dbAccess.h>
+#include <dbStaticLib.h>
+#include <registryDeviceSupport.h>
 
 #include <pvxs/iochooks.h>
 #include <pvxs/log.h>
@@ -28,14 +32,18 @@
 
 #include "iocshcommand.h"
 #include "utilpvt.h"
+#include "qsrvpvt.h"
+
+#ifdef USE_QSRV_SINGLE
+#  include <dbUnitTest.h>
+#endif
+#ifdef USE_PVA_LINKS
+#  include "pvalink.h"
+#endif
 
 // include last to avoid clash of #define printf with other headers
 #include <epicsStdio.h>
 
-#if EPICS_VERSION_INT >= VERSION_INT(7, 0, 4, 0)
-#  define USE_DEINIT_HOOKS
-#endif
-
 namespace pvxs {
 namespace ioc {
 
@@ -80,29 +88,24 @@ void initialisePvxsServer() {
     using namespace pvxs::server;
 
     Config conf = ::pvxs::impl::inUnitTest() ? Config::isolated() : Config::from_env();
-    Server newsrv(conf);
 
     threadOnce<&pvxServerInit>();
     Guard G(pvxServer->lock);
-    if(pvxServer->srv)
-        throw std::logic_error(SB()<<__func__<<" found existing server?!?");
-
-    pvxServer->srv = std::move(newsrv);
+    if(!pvxServer->srv) {
+        pvxServer->srv = Server(conf);
+    }
 }
 
-/**
- * The function to call when we exit the IOC process.  This is only installed as the callback function
- * after the database has been initialized.  This function will stop the pvxs server instance and destroy the
- * object.
- *
- * @param pep - The pointer to the exit parameter list - unused
- */
 static
-void pvxsAtExit(void*) noexcept {
+void pvxsExitBeforeIocShutdown(void*) noexcept
+{
     try {
+#ifdef USE_PVA_LINKS
+        linkGlobal_t::deinit();
+#endif
         Guard (pvxServer->lock);
         if(auto srv = std::move(pvxServer->srv)) {
-            pvxServer->srv = server::Server();
+            assert(!pvxServer->srv);
             srv.stop();
             IOCGroupConfigCleanup();
             log_debug_printf(_logname, "Stopped Server%s", "\n");
@@ -112,19 +115,56 @@ void pvxsAtExit(void*) noexcept {
     }
 }
 
+static
+void pvxsExitAfterIocShutdown(void*) noexcept
+{
+    try {
+#ifdef USE_PVA_LINKS
+        linkGlobal_t::dtor();
+#endif
+
+    } catch(std::exception& e) {
+        fprintf(stderr, "Error in %s : %s\n", __func__, e.what());
+    }
+}
+
+static
+void testPrepareImpl()
+{
+    initialisePvxsServer(); // re-create server for next test cycle
+}
+
 void testPrepare()
 {
-    if(pvxServer)
-        initialisePvxsServer(); // re-create server for next test cycle
+#ifndef USE_PREPARE_CLEANUP_HOOKS
+    testPrepareImpl();
+#endif
 }
 
 void testShutdown()
 {
 #ifndef USE_DEINIT_HOOKS
-    pvxsAtExit(nullptr);
+    pvxsExitBeforeIocShutdown(nullptr);
+#endif
+}
+
+void testAfterShutdown()
+{
+#ifndef USE_DEINIT_HOOKS
+    pvxsExitAfterIocShutdown(nullptr);
 #endif
 }
 
+void testCleanupPrepare()
+{
+    server::Server trash;
+    {
+        Guard G(pvxServer->lock);
+        trash = std::move(pvxServer->srv);
+    }
+    resetGroups();
+}
+
 ////////////////////////////////////
 // Two ioc shell commands for pvxs
 ////////////////////////////////////
@@ -165,6 +205,35 @@ void pvxsi() {
     printf("%s", capture.str().c_str());
 }
 
+#ifdef USE_QSRV_SINGLE
+TestIOC::TestIOC() {
+    testdbPrepare();
+    testPrepare();
+}
+
+void TestIOC::init() {
+    if(!isRunning) {
+        testIocInitOk();
+        isRunning = true;
+    }
+}
+
+void TestIOC::shutdown() {
+    if(isRunning) {
+        isRunning = false;
+        testShutdown();
+        testIocShutdownOk();
+        testAfterShutdown();
+    }
+}
+
+TestIOC::~TestIOC() {
+    shutdown();
+    testCleanupPrepare();
+    testdbCleanup();
+}
+#endif // USE_QSRV_SINGLE
+
 namespace {
 
 void pvxrefshow() {
@@ -236,26 +305,53 @@ void pvxrefdiff() {
 
 } // namespace
 
-/**
- * Initialise and control state of pvxs ioc server instance in response to iocInitHook events.
- * Installed on the initHookState hook this function will respond to the following events:
- *  - initHookAfterInitDatabase: 		Set the exit callback only when we have initialized the database
- *  - initHookAfterCaServerRunning: 	Start the pvxs server instance after the CA server starts running
- *  - initHookAfterCaServerPaused: 		Pause the pvxs server instance if the CA server pauses
- *
- * @param theInitHookState the initHook state to respond to
- */
 static
-void pvxsInitHook(initHookState theInitHookState) {
+void pvxsInitHook(initHookState theInitHookState) noexcept {
     switch(theInitHookState) {
+#ifdef USE_PREPARE_CLEANUP_HOOKS
+    case initHookAfterPrepareDatabase: // test only
+        testPrepareImpl();
+        break;
+#endif
+    case initHookAtBeginning:
+        dbRegisterQSRV2();
+        break;
+    case initHookAfterCaLinkInit:
+#ifdef USE_PVA_LINKS
+        linkGlobal_t::alloc();
+#endif
+#ifndef USE_DEINIT_HOOKS
+        // before epicsExit(exitDatabase),
+        // so hook registered here will be run after iocShutdown()
+    {
+        static bool installed = false;
+        if(!installed) {
+            epicsAtExit(&pvxsExitAfterIocShutdown, nullptr);
+            installed = true;
+        }
+    }
+#endif
+        break;
     case initHookAfterInitDatabase:
-        // when de-init hooks not available, register for later cleanup via atexit()
-        // function to run before exitDatabase
+        processGroups();
 #ifndef USE_DEINIT_HOOKS
-        epicsAtExit(&pvxsAtExit, nullptr);
+        // register for later cleanup before iocShutdown()
+    {
+        static bool installed = false;
+        if(!installed) {
+            epicsAtExit(&pvxsExitBeforeIocShutdown, nullptr);
+            installed = true;
+        }
+    }
 #endif
         break;
-    case initHookAfterCaServerRunning:
+    case initHookAfterIocBuilt:
+#ifdef USE_PVA_LINKS
+        linkGlobal_t::init();
+#endif
+        addSingleSrc();
+        addGroupSrc();
+        break;
     case initHookAfterIocRunning:
         if(auto srv = server()) {
             srv.start();
@@ -271,7 +367,15 @@ void pvxsInitHook(initHookState theInitHookState) {
 #ifdef USE_DEINIT_HOOKS
     // use de-init hook when available
     case initHookAtShutdown:
-        pvxsAtExit(nullptr);
+        pvxsExitBeforeIocShutdown(nullptr);
+        break;
+    case initHookAfterShutdown:
+        pvxsExitAfterIocShutdown(nullptr);
+        break;
+#endif
+#ifdef USE_PREPARE_CLEANUP_HOOKS
+    case initHookBeforeCleanupDatabase: // test only
+        testCleanupPrepare();
         break;
 #endif
     default:
@@ -286,6 +390,56 @@ using namespace pvxs::ioc;
 
 namespace {
 
+bool enable2() {
+    // detect if also linked with qsrv.dbd
+    const bool permit = !registryDeviceSupportFind("devWfPDBDemo");
+    bool request = permit;
+    bool quiet = false;
+
+    auto env_dis = getenv("EPICS_IOC_IGNORE_SERVERS");
+    auto env_ena = getenv("PVXS_QSRV_ENABLE");
+
+    if(env_dis && strstr(env_dis, "qsrv2")) {
+        request = false;
+        quiet = true;
+
+    } else if(env_ena && epicsStrCaseCmp(env_ena, "YES")==0) {
+        request = true;
+
+    } else if(env_ena && epicsStrCaseCmp(env_ena, "NO")==0) {
+        request = false;
+        quiet = true;
+
+    } else if(env_ena) {
+        // will be seen during initialization, print synchronously
+        fprintf(stderr, "ERROR: PVXS_QSRV_ENABLE=%s not YES/NO.  Defaulting to %s.\n",
+                env_ena,
+                request ? "YES" : "NO");
+    }
+
+    const bool enable = permit && request;
+
+    if(quiet) {
+        // shut up, I know what I'm doing...
+    } else if(request && !permit) {
+        fprintf(stderr,
+                "WARNING: QSRV1 detected, disabling QSRV2.\n"
+                "         If not intended, omit qsrv.dbd when including pvxsIoc.dbd\n");
+
+    } else {
+        printf("INFO: PVXS QSRV2 is loaded, %spermitted, and %s.\n",
+               permit ? "" : "NOT ",
+               enable ? "ENABLED" : "disabled");
+
+        if(!permit) {
+            printf("      Not permitted due to conflict with QSRV1.\n"
+                   "      Remove qsrv.dbd from IOC.\n");
+        }
+    }
+
+    return enable;
+}
+
 /**
  * IOC pvxs base registrar.  This implements the required registrar function that is called by xxxx_registerRecordDeviceDriver,
  * the auto-generated stub created for all IOC implementations.
@@ -296,11 +450,11 @@ namespace {
  * 2. Also make sure that you initialize your server implementation - PVXS in our case - so that it will be available for the shell.
  * 3. Lastly register your hook handler to handle any state hooks that you want to implement
  */
-void pvxsBaseRegistrar() {
+void pvxsBaseRegistrar() noexcept {
     try {
         pvxs::logger_config_env();
 
-        pvxServer = new pvxServer_t();
+        bool enableQ = enable2();
 
         IOCShCommand<int>("pvxsr", "[show_detailed_information?]", "PVXS Server Report.  "
                                                                    "Shows information about server config (level==0)\n"
@@ -320,6 +474,12 @@ void pvxsBaseRegistrar() {
 
         // Register our hook handler to intercept certain state changes
         initHookRegister(&pvxsInitHook);
+
+        if(enableQ) {
+            single_enable();
+            group_enable();
+            pvalink_enable();
+        }
     } catch (std::exception& e) {
         fprintf(stderr, "Error in %s : %s\n", __func__, e.what());
     }

{pvxslibs-1.2.4a3 → pvxslibs-1.3.0}/ioc/iocsource.cpp

@@ -36,46 +36,6 @@ DEFINE_LOGGER(_log, "pvxs.ioc.db");
 namespace pvxs {
 namespace ioc {
 
-
-bool IOCSource::enabled()
-{
-    /* -1 - disabled
-     *  0 - lazy init, check environment
-     *  1 - enabled
-     */
-    static std::atomic<int> ena{};
-
-    auto e = ena.load();
-    if(e==0) {
-        e = inUnitTest() ? 1 : -1; // default to disabled normally (not unittest)
-
-        auto env_dis = getenv("EPICS_IOC_IGNORE_SERVERS");
-        auto env_ena = getenv("PVXS_QSRV_ENABLE");
-
-        if(env_dis && strstr(env_dis, "qsrv2")) {
-            e = -1;
-
-        } else if(env_ena && epicsStrCaseCmp(env_ena, "YES")==0) {
-            e = 1;
-
-        } else if(env_ena && epicsStrCaseCmp(env_ena, "NO")==0) {
-            e = -1;
-
-        } else if(env_ena) {
-            // will be seen during initialization, print synchronously
-            fprintf(stderr, "ERROR: PVXS_QSRV_ENABLE=%s not YES/NO.  Defaulting to %s.\n",
-                    env_ena,
-                    e==1 ? "YES" : "NO");
-        }
-        printf("INFO: PVXS QSRV2 is loaded and %s\n",
-               e==1 ? "ENABLED." : "disabled.\n"
-               "      To enable set: epicsEnvSet(\"PVXS_QSRV_ENABLE\",\"YES\")\n"
-               "      and ensure that $EPICS_IOC_IGNORE_SERVERS does not contain \"qsrv2\".");
-        ena = e;
-    }
-    return e==1;
-}
-
 void IOCSource::initialize(Value& value, const MappingInfo &info, const Channel& chan)
 {
     if(info.type==MappingInfo::Scalar) {
@@ -315,9 +275,6 @@ void getProperties(dbChannel* pChannel, db_field_log *pfl, Value& node)
         if(auto units = node["display.units"])
             units = meta.units;
     }
-    if(options & DBR_PRECISION) {
-        // TODO: add in nt.cpp?
-    }
     if(options & DBR_ENUM_STRS) {
         if(auto choices = node["value.choices"]) {
             shared_array<std::string> arr(meta.no_str);
@@ -331,7 +288,9 @@ void getProperties(dbChannel* pChannel, db_field_log *pfl, Value& node)
         if(options & DBR_GR_DOUBLE) {
             dlL = meta.lower_disp_limit;
             node["display.limitHigh"] = meta.upper_disp_limit;
-            node["display.precision"] = meta.precision.dp;
+            if(options & DBR_PRECISION) {
+                node["display.precision"] = int32_t(meta.precision.dp);
+            }
         }
         if(options & DBR_CTRL_DOUBLE) {
             node["control.limitLow"] = meta.lower_ctrl_limit;
@@ -477,15 +436,31 @@ void IOCSource::doPostProcessing(dbChannel* pDbChannel, TriState forceProcessing
  * @param securityControlObject the security control object to update
  */
 void IOCSource::setForceProcessingFlag(const Value& pvRequest,
-        const std::shared_ptr<SecurityControlObject>& securityControlObject) {
-    pvRequest["record._options.process"]
-            .as<std::string>([&securityControlObject](const std::string& forceProcessingOption) {
-                if (forceProcessingOption == "true") {
-                    securityControlObject->forceProcessing = True;
-                } else if (forceProcessingOption == "false") {
-                    securityControlObject->forceProcessing = False;
-                }
-            });
+                                       const std::shared_ptr<SecurityControlObject>& securityControlObject)
+{
+    auto proc = pvRequest["record._options.process"];
+    switch(proc.type().code) {
+    case TypeCode::String: {
+        auto val(proc.as<std::string>());
+        if (val == "true") {
+            securityControlObject->forceProcessing = True;
+        } else if (val == "false") {
+            securityControlObject->forceProcessing = False;
+        } else if (val == "passive") {
+            securityControlObject->forceProcessing = Unset;
+        } else {
+            log_warn_printf(_log, "Ignoring unsupported record._options.process='%s'", val.c_str());
+        }
+        break;
+    }
+    case TypeCode::Bool:
+        securityControlObject->forceProcessing = proc.as<bool>() ? True : False;
+        break;
+    default:
+        log_warn_printf(_log, "Ignoring unsupported record._options.process type %s", proc.type().name());
+    case TypeCode::Null:
+        break;
+    }
 }
 
 static

{pvxslibs-1.2.4a3 → pvxslibs-1.3.0}/ioc/iocsource.h

@@ -43,8 +43,6 @@ enum type {
 
 class IOCSource {
 public:
-    static bool enabled();
-
     static void initialize(Value& value, const MappingInfo &info, const Channel &chan);
 
     static void get(Value& valuePrototype,