OPCUAServer.h

/*
 * Copyright (c) 2023 Pavel Vainerman.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, version 2.1.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// -----------------------------------------------------------------------------
#ifndef _OPCUAServer_H_
#define _OPCUAServer_H_
// -----------------------------------------------------------------------------
#include <memory>
#include <atomic>
#include <regex>
#include <optional>
#include <unordered_map>
#include "open62541pp/open62541pp.hpp"
#include "UObject_SK.h"
#include "SMInterface.h"
#include "SharedMemory.h"
#include "ThreadCreator.h"
#include "Extensions.h"
#include "USingleProcess.h"
#include "LogServer.h"
// --------------------------------------------------------------------------
namespace uniset
{
    // -----------------------------------------------------------------------------
    // -----------------------------------------------------------------------------
    class OPCUAServer:
        private USingleProcess,
        public UObject_SK
    {
        public:
            OPCUAServer(uniset::ObjectId objId, xmlNode* cnode, uniset::ObjectId shmID,
                        const std::shared_ptr<SharedMemory>& ic = nullptr,
                        const std::string& prefix = "opcua");
 
            virtual ~OPCUAServer();
 
            virtual CORBA::Boolean exist() override;
 
            static std::shared_ptr<OPCUAServer> init_opcua_server(int argc, const char* const* argv,
                    uniset::ObjectId shmID,
                    const std::shared_ptr<SharedMemory>& ic = nullptr,
                    const std::string& prefix = "opcua");
 
            static void help_print();
 
            using DefaultValueType = int32_t;
            using DefaultValueUType = uint32_t;
            static const opcua::DataTypeId DefaultVariableType = { opcua::DataTypeId::Int32 };
 
            static uint8_t firstBit( DefaultValueUType mask );
            // offset = firstBit(mask)
            static DefaultValueUType getBits( DefaultValueUType value, DefaultValueUType mask, uint8_t offset );
            // if mask = 0 return value
            static DefaultValueUType setBits( DefaultValueUType value, DefaultValueUType set, DefaultValueUType mask, uint8_t offset );
            // if mask=0 return set
            static DefaultValueUType forceSetBits( DefaultValueUType value, DefaultValueUType set, DefaultValueUType mask, uint8_t offset );
 
            static UA_StatusCode UA_setValueMethod(UA_Server* server, const UA_NodeId* sessionId, void* sessionHandle,
                                                   const UA_NodeId* methodId, void* methodContext, const UA_NodeId* objectId,
                                                   void* objectContext, size_t inputSize, const UA_Variant* input, size_t outputSize, UA_Variant* output);
 
#ifndef DISABLE_REST_API
            // HTTP API
            virtual Poco::JSON::Object::Ptr httpHelp( const Poco::URI::QueryParameters& p ) override;
            virtual Poco::JSON::Object::Ptr httpRequest( const UHttp::HttpRequestContext& ctx ) override;
            virtual Poco::JSON::Object::Ptr httpGetMyInfo( Poco::JSON::Object::Ptr root ) override;
 
            // Public HTTP endpoints
            Poco::JSON::Object::Ptr httpSensors( const Poco::URI::QueryParameters& p );
            Poco::JSON::Object::Ptr httpGet( const Poco::URI::QueryParameters& p );
#endif
 
        protected:
            OPCUAServer();
 
            virtual void callback() noexcept override;
            virtual void sysCommand(const uniset::SystemMessage* sm) override;
            virtual bool deactivateObject() override;
            virtual void askSensors(UniversalIO::UIOCommand cmd) override;
            virtual void sensorInfo(const uniset::SensorMessage* sm) override;
            virtual std::string getMonitInfo() const override;
            void serverLoopTerminate();
            void serverLoop();
            void updateLoop();
            void update();
 
#ifndef DISABLE_REST_API
            // params
            virtual Poco::JSON::Object::Ptr httpGetParam( const Poco::URI::QueryParameters& p );
            virtual Poco::JSON::Object::Ptr httpSetParam( const Poco::URI::QueryParameters& p );
 
            // status
            Poco::JSON::Object::Ptr httpStatus();
            Poco::JSON::Object::Ptr buildLogServerInfo();
 
            // Защитный флаг: разрешить/запретить /setparam (по аналогии с MBExchange/MBSlave)
            bool httpEnabledSetParams { true };
#endif
            bool initVariable(UniXML::iterator& it);
            bool readItem(const std::shared_ptr<UniXML>& xml, UniXML::iterator& it, xmlNode* sec);
            void readConfiguration();
 
            std::shared_ptr<SMInterface> shm;
            std::unique_ptr<ThreadCreator<OPCUAServer>> serverThread;
            std::unique_ptr<ThreadCreator<OPCUAServer>> updateThread;
 
            struct IOVariable
            {
                IOVariable(const opcua::Node<opcua::Server>& n) : node(n) {};
                opcua::Node<opcua::Server> node;
                IOController::IOStateList::iterator it;
                UniversalIO::IOType stype = { UniversalIO::AO };
 
                uniset::uniset_rwmutex vmut;
                DefaultValueType value = { 0 };
                bool state = { false };
                DefaultValueUType mask = { 0 };
                uint8_t offset = { 0 };
                opcua::DataTypeId vtype = { DefaultVariableType };
                uint8_t precision = { 0 }; // only for float
            };
 
            std::unordered_map<ObjectId, IOVariable> variables;
            size_t writeCount = { 0 };
 
            struct IONode
            {
                opcua::Node<opcua::Server> node;
                IONode( const opcua::Node<opcua::Server>& n ):  node(n) {};
            };
 
            struct IOMethod
            {
                IOMethod( uniset::ObjectId _sid) : sid(_sid) {};
 
                IOController::IOStateList::iterator it;
                uniset::ObjectId sid = { DefaultObjectId };
                uint8_t precision = { 0 }; // only for float
            };
 
            std::unordered_map<uint32_t, IOMethod> methods;
            size_t methodCount = { 0 };
 
        private:
            opcua::Server opcServer;
            std::unique_ptr<IONode> ioNode = { nullptr };
            std::string prefix;
            std::string propPrefix;
            std::string s_field;
            std::string s_fvalue;
            std::optional<std::regex> s_fvalue_re;
            std::string namePrefix;
            uniset::timeout_t updateTime_msec = { 100 };
            std::atomic_bool firstUpdate = false;
            std::shared_ptr<LogServer> logserv;
            std::string logserv_host = {""};
            int logserv_port = {0};
 
            using folderMap  = std::unordered_map<std::string, std::unique_ptr<IONode>>;
            folderMap foldermap; // список тегов
            void initFolderMap( uniset::UniXML::iterator it, const std::string& parent_name, std::unique_ptr<IONode>& parent );
    };
    // --------------------------------------------------------------------------
    constexpr std::string_view getLogLevelName(opcua::LogLevel level)
    {
        switch (level)
        {
            case opcua::LogLevel::Trace:
                return "trace";
 
            case opcua::LogLevel::Debug:
                return "debug";
 
            case opcua::LogLevel::Info:
                return "info";
 
            case opcua::LogLevel::Warning:
                return "warning";
 
            case opcua::LogLevel::Error:
                return "error";
 
            case opcua::LogLevel::Fatal:
                return "fatal";
 
            default:
                return "unknown";
        }
    }
 
    constexpr std::string_view getLogCategoryName(opcua::LogCategory category)
    {
        switch (category)
        {
            case opcua::LogCategory::Network:
                return "network";
 
            case opcua::LogCategory::SecureChannel:
                return "channel";
 
            case opcua::LogCategory::Session:
                return "session";
 
            case opcua::LogCategory::Server:
                return "server";
 
            case opcua::LogCategory::Client:
                return "client";
 
            case opcua::LogCategory::Userland:
                return "userland";
 
            case opcua::LogCategory::SecurityPolicy:
                return "securitypolicy";
 
            default:
                return "unknown";
        }
    }
} // end of namespace uniset
// -----------------------------------------------------------------------------
#endif // _OPCUAServer_H_
// -----------------------------------------------------------------------------