open62541.hpp

Go to the documentation of this file.

 
#ifndef CORE_PROTOCOL_OPEN62541_OPEN62541_HPP_
#define CORE_PROTOCOL_OPEN62541_OPEN62541_HPP_
 
// Deprecation notice for the whole ifw-core/protocol component.
//
// The protocol libraries (protocol/base and protocol/open62541) are deprecated:
// their OPC UA client functionality is now provided by uatools (the ualib
// library, ifw::fnd::defs::ICommAdapter over open62541). The protocol tree is
// kept for backwards compatibility only and will be removed in a future
// release. New code should use uatools/ualib instead.
//
// The notice is placed only in this strategic header (the main open62541 client
// header, included by every protocol consumer) so it fires once per translation
// unit rather than repeatedly across the many protocol headers. Compile-time
// message only; it does NOT affect build success or warning counts (safe under
// -Werror). To retire the component, delete this block along with the tree.
#pragma message("ifw-core/protocol is deprecated; migrate to uatools (ualib). " \
                "The protocol/base and protocol/open62541 libraries are kept " \
                "for compatibility only and will be removed in a future release.")
 
// System header files
#include <chrono>
#include <string>
#include <thread>
#include <mutex>
#include <atomic>
#include <optional>
 
// Third party headers
#include <log4cplus/logger.h>
#include <fmt/format.h>
 
// #ifdef UA_ENABLE_AMALGAMATION
// # include <open62541.h>
// #else
// # include <open62541/client.h>
// # include <open62541/common.h>
// #endif
 
#if __has_include(<open62541.h>)
#include <open62541.h>
#else
#include <open62541/server.h>
#include <open62541/plugin/log_stdout.h>
#endif
 
 
#include "ifw/core/protocol/base/dispatcher.hpp"
#include "ifw/core/protocol/base/iComm.hpp"
#include "ifw/core/protocol/open62541/iDataChangeHandler.hpp"
#include "ifw/core/protocol/open62541/monitoredItem.hpp"
#include "ifw/core/protocol/open62541/subscription.hpp"
 
 
using namespace std::literals::chrono_literals;
 
namespace ifw::core::protocol::opcua {
class IDataChangeHandler;

struct OpcuaConnection {
    UA_Client *m_client;
    std::atomic<bool> m_connected {false};
    std::atomic<bool> m_lost_connection {false};
 
    UA_UserNameIdentityToken* m_user_identity{nullptr};
    UA_ExtensionObject m_user_identity_ext_obj;
 
    UA_StatusCode m_last_error{0};
    UA_SecureChannelState m_last_channel_state{UA_SECURECHANNELSTATE_CLOSED};
    UA_SecureChannelState m_channel_state{UA_SECURECHANNELSTATE_CLOSED};
    UA_SessionState m_last_session_state{UA_SESSIONSTATE_CLOSED};
    UA_SessionState m_session_state{UA_SESSIONSTATE_CLOSED};
    UA_StatusCode m_last_connect_status{UA_STATUSCODE_BADCONNECTIONCLOSED};
    UA_StatusCode m_connect_status{UA_STATUSCODE_GOOD};
    std::mutex m_mutex;
};
 
 
struct ClientConfig {
 
    // TBD: std::string transport_protocol{"opc.tcp"};
    // TBD: std::string application_name{""};
    // TBD: std::string application_uri{""};
 
    bool use_anonymous_login{true};
    std::string username{""};
    std::string password{""};
 
    // Possible values: "None", "Basic256", "Basic256Sha256", etc.
    // TBD: std::string security_policy{"None"}; 
    // Possible values: "None", "Sign", "SignAndEncrypt"
    // TBD: std::string message_security_mode{"None"};
    int secure_channel_lifetime{86400000};
 
    std::string certificate_file{""};
    std::string private_key_file{""};
    bool validate_server_certificate{true};
 
    int timeout{30000};
 
    int session_timeout{30000}; // in ms
    // TBD: int watchdog_interval{5000}; // in ms
    int connectivity_check_interval{5000}; // in ms
 
    int outstanding_publish_requests{4};
 
    // TBD: int reconnect_attempts{5};
    // TBD: int reconnect_interval{2000}; // in ms
 
    // TBD: int subscription_lifetime{60000}; // in ms
    // TBD: int max_keep_alive_count{10};
    // TBD: int publishing_interval{1000}; // in ms
    // TBD: int priority{0};
 
    // TBD: bool auto_create_subscription{true};
    // TBD: bool auto_recover_subscription{true};
 
    // TBD: int max_response_message_size{65536};
 
    // ClientConfig& operator=(const protocol::base::ClientConfig& config) {
    //     return *this;
    // }
 
    virtual std::string ToString() const {
        return fmt::format("OPC UA config: use_anonymous_login={}, username={}, "
            "secure_channel_lifetime={}, certificate_file={}, private_key_file={}, "
            "validate_server_certificate={}, timeout={}, session_timeout={}, "
            "connectivity_check_interval={}, outstanding_publish_requests={}",
            use_anonymous_login, username, secure_channel_lifetime, certificate_file,
            private_key_file, validate_server_certificate, timeout, session_timeout,
            connectivity_check_interval, outstanding_publish_requests);
    }
};
 

class Open62541 : public ifw::core::protocol::base::IComm, public IDataChangeHandler {
 
    static constexpr std::chrono::milliseconds NETWORK_TIMEOUT = 2000ms;
 
  public:
    Open62541(const std::optional<std::string> opcua_config_file = std::nullopt);
    virtual ~Open62541();

    virtual void Connect(const std::string& device,
                         const std::string& address);

    virtual void Read(protocol::base::VectorVariant& params) override;

    virtual void Write(const protocol::base::VectorVariant& params) override;

    virtual void Rpc(const std::string& obj,
                     const std::string& proc,
                     const protocol::base::VectorVariant& params,
                     protocol::base::Variant& result) override;

    UA_StatusCode ResumeSubscriptions();

    virtual void StartMonitorItem(const std::string& item) override;

    virtual void StartMonitorItems(const std::vector<std::string>& item_vector) override;

    virtual void StopMonitorItem(const std::string& item) override;

    virtual void Disconnect();

    virtual void
    RegisterCB(protocol::base::Dispatcher<protocol::base::VectorVariant &>& dispatcher,
               protocol::base::Dispatcher<>& failure,
               protocol::base::Dispatcher<>& normal);

    void SetEndpoint(const std::string& endpoint);

    std::string GetEndpoint() const;

    virtual void HandleDataChange(const std::shared_ptr<MonitoredItem> monitor_item,
                                  UA_DataValue* value);

    virtual void HandleSessionChanges(bool status);

    void UpdateState(UA_SecureChannelState channel_state,
                     UA_SessionState session_state,
                     UA_StatusCode recovery_status);

    bool IsServerReady(UA_Client* client);

    inline static std::map<std::string, std::shared_ptr<OpcuaConnection>> m_connection_map;
 
  private:

    bool IsConnected(const std::string& address);

    void InactivityAcions();

    UA_StatusCode CreateSubscription(bool renew_monitor_items = false);

    void RemoveSubscription();

    void GetNodeId(std::string value, int& ns, std::string& name);

    static void InactivityCallback(UA_Client* client);

    static void StateCallback(UA_Client* client,
                              UA_SecureChannelState channelState,
                              UA_SessionState sessionState,
                              UA_StatusCode recoveryStatus);
 
    void LoadOpcuaConfig();

    SubscriptionPtr m_subscription;

    std::string m_endpoint;
 
    bool m_monitoring;

    inline static std::map<std::string, std::pair<std::string, Open62541*>> m_registration_map;

    std::string m_device;

    std::map<std::string, MonitoredItemPtr> m_map_monitor_items;

    protocol::base::Dispatcher<protocol::base::VectorVariant &> m_dispatcher;

    protocol::base::Dispatcher<> m_failure;

    protocol::base::Dispatcher<> m_normal;

    std::string  m_opcua_config_file;
    ClientConfig m_opua_config;

    log4cplus::Logger m_logger;

    inline static std::mutex m_connection_map_mutex;
 
    static std::shared_ptr<OpcuaConnection> GetConnection(const std::string& address);
};
 
} // namespace ifw::core::protocol::opcua
 
#endif // CORE_PROTOCOL_OPEN62541_OPEN62541_HPP_