opcua_main.cpp

Go to the documentation of this file.

#include "opcua_options.h"

#include <opc/ua/client/addon.h>
#include <opc/common/addons_core/addon_manager.h>
#include <opc/common/addons_core/config_file.h>
#include <opc/common/uri_facade.h>
#include <opc/ua/node.h>
#include <opc/ua/protocol/string_utils.h>
#include <opc/ua/protocol/variant_visitor.h>
#include <opc/ua/services/services.h>

#include <algorithm>
#include <iostream>
#include <stdexcept>

namespace
{

using namespace OpcUa;

struct Tabs
{
  Tabs(unsigned num = 0)
    : Num(num)
  {
  }
  unsigned Num;
};

std::ostream & operator <<(std::ostream & os, const Tabs & tabs)
{
  for (unsigned i = 0; i < tabs.Num; ++i)
    {
      os << " ";
    }

  return os;
}


std::string GetName(OpcUa::MessageSecurityMode mode)
{
  switch (mode)
    {
    case MessageSecurityMode::None:
      return "none";

    case MessageSecurityMode::Sign:
      return "sign";

    case MessageSecurityMode::SignAndEncrypt:
      return "sign and encrypt";

    default:
      return "unknown";
    }
}

std::string GetName(OpcUa::ApplicationType type)
{
  switch (type)
    {
    case OpcUa::ApplicationType::Server:
      return "server";

    case OpcUa::ApplicationType::Client:
      return "client";

    case OpcUa::ApplicationType::ClientAndServer:
      return "client and server";

    case OpcUa::ApplicationType::DiscoveryServer:
      return "discovery server";

    default:
      return "unknown";
    }
}

std::string GetName(OpcUa::UserTokenType type)
{
  switch (type)
    {
    case OpcUa::UserTokenType::Anonymous:
      return "anonymous";

    case OpcUa::UserTokenType::UserName:
      return "username";

    case OpcUa::UserTokenType::Certificate:
      return "x509v3 certificate";

    case OpcUa::UserTokenType::IssuedToken:
      return "WS_Security token";

    default:
      return "unknown";
    }
}

std::string GetNodeClassName(unsigned cls)
{
  std::string result;
  NodeClass nodeClass = static_cast<NodeClass>(cls);

  if (nodeClass == NodeClass::Object)
    {
      result += "object";
    }

  if (nodeClass == NodeClass::Variable)
    {
      if (!result.empty())
        {
          result += ", ";
        }

      result += "variable";
    }

  if (nodeClass == NodeClass::Method)
    {
      if (!result.empty())
        {
          result += ", ";
        }

      result += "method";
    }

  if (nodeClass == NodeClass::ObjectType)
    {
      if (!result.empty())
        {
          result += ", ";
        }

      result += "object type";
    }

  if (nodeClass == NodeClass::VariableType)
    {
      if (!result.empty())
        {
          result += ", ";
        }

      result += "variable type";
    }

  if (nodeClass == NodeClass::ReferenceType)
    {
      if (!result.empty())
        {
          result += ", ";
        }

      result += "reference type";
    }

  if (nodeClass == NodeClass::DataType)
    {
      if (!result.empty())
        {
          result += ", ";
        }

      result += "data type";
    }

  if (nodeClass == NodeClass::View)
    {
      if (!result.empty())
        {
          result += ", ";
        }

      result += "view";
    }

  return result;
}




void Print(const OpcUa::NodeId & nodeId, const Tabs & tabs)
{
  OpcUa::NodeIdEncoding encoding = static_cast<OpcUa::NodeIdEncoding>(nodeId.Encoding & OpcUa::NodeIdEncoding::EV_VALUE_MASK);

  const Tabs dataTabs(tabs.Num + 2);

  switch (encoding)
    {
    case OpcUa::NodeIdEncoding::EV_TWO_BYTE:
    {
      std::cout << tabs << "Two byte:" << std::endl;
      std::cout << dataTabs << "Identifier:" << (unsigned)nodeId.TwoByteData.Identifier << std::endl;
      break;
    }

    case OpcUa::NodeIdEncoding::EV_FOUR_BYTE:
    {
      std::cout << tabs << "Four byte:" << std::endl;
      std::cout << dataTabs << "NamespaceIndex:" << (unsigned)nodeId.FourByteData.NamespaceIndex << std::endl;
      std::cout << dataTabs << "Identifier" << (unsigned)nodeId.FourByteData.Identifier << std::endl;
      break;
    }

    case OpcUa::NodeIdEncoding::EV_NUMERIC:
    {
      std::cout << tabs << "Numeric:" << std::endl;
      std::cout << dataTabs << "NamespaceIndex" << (unsigned)nodeId.NumericData.NamespaceIndex << std::endl;
      std::cout << dataTabs << "Identifier" << (unsigned)nodeId.NumericData.Identifier << std::endl;
      break;
    }

    case OpcUa::NodeIdEncoding::EV_STRING:
    {
      std::cout << tabs << "String: " << std::endl;
      std::cout << dataTabs << "NamespaceIndex: " << (unsigned)nodeId.StringData.NamespaceIndex << std::endl;
      std::cout << dataTabs << "Identifier: " <<  nodeId.StringData.Identifier << std::endl;
      break;
    }

    case OpcUa::NodeIdEncoding::EV_BYTE_STRING:
    {
      std::cout << tabs << "Binary: " << std::endl;
      std::cout << dataTabs << "NamespaceIndex: " << (unsigned)nodeId.BinaryData.NamespaceIndex << std::endl;
      std::cout << dataTabs << "Identifier: ";

      for (auto val : nodeId.BinaryData.Identifier) {std::cout << (unsigned)val; }

      std::cout << std::endl;
      break;
    }

    case OpcUa::NodeIdEncoding::EV_GUId:
    {
      std::cout << tabs << "Guid: " << std::endl;
      std::cout << dataTabs << "Namespace Index: " << (unsigned)nodeId.GuidData.NamespaceIndex << std::endl;
      const OpcUa::Guid & guid = nodeId.GuidData.Identifier;
      std::cout << dataTabs << "Identifier: " << std::hex << guid.Data1 << "-" << guid.Data2 << "-" << guid.Data3;

      for (auto val : guid.Data4) {std::cout << (unsigned)val; }

      break;
    }

    default:
    {
      std::cout << tabs << "unknown id type:" << (unsigned)encoding << std::endl;
      break;
    }
    }

  if (nodeId.Encoding & OpcUa::NodeIdEncoding::EV_NAMESPACE_URI_FLAG)
    {
      std::cout << tabs << "Namespace URI: " << nodeId.NamespaceURI << std::endl;
    }

  if (nodeId.Encoding & OpcUa::NodeIdEncoding::EV_Server_INDEX_FLAG)
    {
      std::cout << tabs << "Server index: " << nodeId.ServerIndex << std::endl;
    }
}

void Print(const OpcUa::UserTokenPolicy & policy, const Tabs & tabs)
{
  std::cout << tabs << "Id: " << policy.PolicyId << std::endl;
  std::cout << tabs << "TokenType: " << GetName(policy.TokenType) << std::endl;
  std::cout << tabs << "IssuedTokenType: " << policy.IssuedTokenType  << std::endl;
  std::cout << tabs << "IssuerEndpointUrl: " << policy.IssuerEndpointUrl << std::endl;
  std::cout << tabs << "SecurityPolicyUri: " << policy.SecurityPolicyUri << std::endl;
}


void Print(const OpcUa::ApplicationDescription & desc, const Tabs & tab)
{
  std::cout << tab << "Name: " << desc.ApplicationName.Text << " (" << desc.ApplicationName.Locale << ")" << std::endl;
  std::cout << tab << "Type: " << GetName(desc.ApplicationType) << std::endl;
  std::cout << tab << "URI: " << desc.ApplicationUri << std::endl;
  std::cout << tab << "ProductURI: " << desc.ProductUri << std::endl;
  std::cout << tab << "GatewayServerURI: " << desc.GatewayServerUri << std::endl;
  std::cout << tab << "DiscoveryProfileURI: " << desc.DiscoveryProfileUri << std::endl;

  if (!desc.DiscoveryUrls.empty())
    {
      std::cout << tab << "DiscoveryProfileURLs: ";

      for (auto it = desc.DiscoveryUrls.begin(); it != desc.DiscoveryUrls.end(); ++it)
        {
          std::cout << "'" << *it << "' ";
        }

      std::cout << std::endl;
    }
}

void Print(const OpcUa::EndpointDescription & desc, const Tabs & tab)
{
  std::cout << tab << "URL: " << desc.EndpointUrl << std::endl;
  std::cout << tab << "SecurityPolicyUri: " << desc.SecurityPolicyUri << std::endl;
  std::cout << tab << "SecurityLevel: " << GetName(desc.SecurityMode) << " (" << (int)desc.SecurityMode << ")" << std::endl;
  std::cout << tab << "TransportProfileURI: " << desc.TransportProfileUri << std::endl;
  std::cout << tab << "SecurityLevel: " << (int)desc.SecurityLevel << std::endl;
  std::cout << tab << "Server description: " << std::endl;
  Print(desc.Server, Tabs(tab.Num + 2));

  if (!desc.UserIdentityTokens.empty())
    {
      std::cout << tab << "User identify tokens: " << std::endl;

      for (auto it = desc.UserIdentityTokens.begin(); it != desc.UserIdentityTokens.end(); ++it)
        {
          std::cout << Tabs(tab.Num + 2) << "token: " << std::endl;
          Print(*it, Tabs(tab.Num + 4));
        }

      std::cout << std::endl;
    }

//    CertificateData ServerCertificate;
//    std::vector<UserTokenPolicy> ;
}

void PrintEndpoints(OpcUa::Services & computer)
{
  std::shared_ptr<OpcUa::EndpointServices> service = computer.Endpoints();
  OpcUa::GetEndpointsParameters filter;
  std::vector<OpcUa::EndpointDescription> endpoints = service->GetEndpoints(filter);

  for (auto it = endpoints.begin(); it != endpoints.end(); ++it)
    {
      std::cout << "endpoint:" << std::endl;
      Print(*it, Tabs(2));
    }
}

void PrintServers(OpcUa::Services & computer)
{
  std::shared_ptr<OpcUa::EndpointServices> service = computer.Endpoints();
  OpcUa::FindServersParameters filter;
  std::vector<OpcUa::ApplicationDescription> applications = service->FindServers(filter);

  for (const OpcUa::ApplicationDescription & desc : applications)
    {
      std::cout << "Application:" << std::endl;
      Print(desc, Tabs(2));
    }
}

inline void PrintReference(const OpcUa::ReferenceDescription & desc, const Tabs & tabs)
{
  const Tabs tabs1(tabs.Num + 2);
  std::cout << tabs << "DisplayName: " << desc.DisplayName.Text << std::endl;
  std::cout << tabs << "Browse Name: " << desc.BrowseName.NamespaceIndex << ":" << desc.BrowseName.Name << std::endl;
  std::cout << tabs << "Is Forward: " << desc.IsForward << std::endl;

  std::cout << tabs << "Target Node class: " << GetNodeClassName(static_cast<unsigned>(desc.TargetNodeClass))  << std::endl;
  std::cout << tabs << "Target NodeId:" << std::endl;
  Print(desc.TargetNodeId, tabs1);

  std::cout << tabs << "TypeId:" << std::endl;
  Print(desc.ReferenceTypeId, tabs1);

  std::cout << tabs << "Type definition Id:" << std::endl;
  Print(desc.TargetNodeTypeDefinition, tabs1);
}

void Browse(OpcUa::ViewServices & view, OpcUa::NodeId nodeId)
{
  OpcUa::BrowseDescription description;
  description.NodeToBrowse = nodeId;
  description.Direction = OpcUa::BrowseDirection::Forward;
  description.IncludeSubtypes = true;
  description.NodeClasses = OpcUa::NodeClass::Unspecified;
  description.ResultMask = OpcUa::BrowseResultMask::All;

  OpcUa::NodesQuery query;
  query.View.Timestamp = OpcUa::DateTime::Current();
  query.NodesToBrowse.push_back(description);
  query.MaxReferenciesPerNode = 100;

  std::vector<OpcUa::BrowseResult> results = view.Browse(query);

  while (true)
    {
      if (results.empty())
        {
          return;
        }

      if (results[0].Referencies.empty())
        {
          break;
        }

      for (auto refIt : results[0].Referencies)
        {
          std::cout << "reference:" << std::endl;
          PrintReference(refIt, Tabs(2));
          std::cout << std::endl;
        }

      results = view.BrowseNext();
    }
}


struct VariantPrinter
{
  template <typename T>
  void PrintValue(const T & val)
  {
    std::cout << val;
  }

  void PrintValue(const OpcUa::DiagnosticInfo & info)
  {
    std::cout << "!!!TODO!!!";
  }

  void PrintValue(const OpcUa::Variant & info)
  {
    std::cout << "!!!TODO!!!";
  }

  void PrintValue(const OpcUa::LocalizedText & text)
  {
    std::cout << text.Text << std::endl;
  }

  void PrintValue(const OpcUa::StatusCode & code)
  {
    std::cout << OpcUa::ToString(code) << std::endl;
  }

  template <typename T>
  void OnScalar(const T & val)
  {
    PrintValue(val);
    std::cout << std::endl;
  }

  template <typename T>
  void OnContainer(const std::vector<T> & vals)
  {
    typedef typename std::vector<T>::const_iterator Iterator;

    for (Iterator it = vals.begin(); it != vals.end(); ++it)
      {
        PrintValue(*it);
        std::cout << " ";
      }

    std::cout << std::endl;
  }
};

void Print(const OpcUa::Variant & var, const Tabs & tabs)
{
  VariantPrinter printer;
  TypedVisitor<VariantPrinter> visitor(printer);

  switch (var.Type())
    {
    case VariantType::BOOLEAN:
    {
      std::cout << tabs << "boolean: ";
      break;
    }

    case VariantType::SBYTE:
    {
      std::cout << tabs << "signed byte: ";
      break;
    }

    case VariantType::BYTE:
    {
      std::cout << tabs << "byte: ";
      break;
    }

    case VariantType::INT16:
    {
      std::cout << tabs << "int16: ";
      break;
    }

    case VariantType::UINT16:
    {
      std::cout << tabs << "unsigned int16: ";
      break;
    }

    case VariantType::INT32:
    {
      std::cout << tabs << "int32: ";
      break;
    }

    case VariantType::UINT32:
    {
      std::cout << tabs << "unsigned int32: ";
      break;
    }

    case VariantType::INT64:
    {
      std::cout << tabs << "int64: ";
      break;
    }


    case VariantType::UINT64:
    {
      std::cout << tabs << "unsigned int64: ";
      break;
    }


    case VariantType::FLOAT:
    {
      std::cout << tabs << "float: ";
      break;
    }


    case VariantType::DOUBLE:
    {
      std::cout << tabs << "double: ";
      break;
    }


    case VariantType::STRING:
    {
      std::cout << tabs << "string: ";
      break;
    }


    case VariantType::EXPANDED_NODE_Id:
    case VariantType::NODE_Id:
    {
      std::cout << tabs << "NodeId: " << std::endl;
      break;
    }

    case VariantType::QUALIFIED_NAME:
    {
      std::cout << tabs << "Name: ";
      break;
    }

    case VariantType::LOCALIZED_TEXT:
    {
      std::cout << tabs << "Text: ";
      break;
    }


    case VariantType::DATE_TIME:
    {
      std::cout << "DateTime: " << OpcUa::ToString(var.As<DateTime>()) << std::endl;
      break;
    }

    case VariantType::GUId:
    case VariantType::BYTE_STRING:
    case VariantType::XML_ELEMENT:
    case VariantType::STATUS_CODE:
    case VariantType::DIAGNOSTIC_INFO:
    case VariantType::VARIANT:
    case VariantType::DATA_VALUE:
    case VariantType::NUL:
    case VariantType::EXTENSION_OBJECT:
      break;

    default:
      throw std::logic_error("Unknown variant type.");
    }

  var.Visit(visitor);
  std::cout << std::endl;
}

void Print(const DataValue & value, const Tabs & tabs)
{
  const Tabs tabs1(tabs.Num + 2);

  if (value.Encoding & DATA_VALUE_STATUS_CODE)
    {
      std::cout << tabs << "Status code:" << std::endl;
      std::cout << tabs1 << "0x" << std::hex << static_cast<uint32_t>(value.Status) << std::endl;
    }

  if (value.Encoding & DATA_VALUE)
    {
      std::cout << tabs << "Value:" << std::endl;
      Print(value.Value, tabs1);
    }
}


void Read(OpcUa::AttributeServices & attributes, OpcUa::NodeId nodeId, OpcUa::AttributeId attributeId)
{
  ReadParameters params;
  ReadValueId attribute;
  attribute.NodeId = nodeId;
  attribute.AttributeId = attributeId;
  params.AttributesToRead.push_back(attribute);
  const std::vector<DataValue> values = attributes.Read(params);

  if (values.size() != 1)
    {
      std::cout << "Server returned " << values.size() << " instead of 1." << std::endl;
      return;
    }

  std::cout << "data value:" << std::endl;
  Print(values.front(), Tabs(2));
}

void Write(OpcUa::AttributeServices & attributes, OpcUa::NodeId nodeId, OpcUa::AttributeId attributeId, const OpcUa::Variant & value)
{
  OpcUa::WriteValue attribute;
  attribute.NodeId = nodeId;
  attribute.AttributeId = attributeId;
  attribute.Value = value;
  std::vector<StatusCode> statuses = attributes.Write(std::vector<OpcUa::WriteValue>(1, attribute));

  for (OpcUa::StatusCode status : statuses)
    {
      std::cout << "Status code: 0x" << std::hex << static_cast<uint32_t>(status) << std::endl;
    }
}

void CreateSubscription(OpcUa::SubscriptionServices & subscriptions)
{
  OpcUa::CreateSubscriptionRequest request;
  request.Parameters.MaxNotificationsPerPublish = 1;
  request.Parameters.Priority = 0;
  request.Parameters.PublishingEnabled = false;
  request.Parameters.RequestedLifetimeCount = 1;
  request.Parameters.RequestedMaxKeepAliveCount = 1;
  request.Parameters.RequestedPublishingInterval = 1000;
  const OpcUa::SubscriptionData data = subscriptions.CreateSubscription(request, [](PublishResult) {});
  std::cout << "Id: " << data.SubscriptionId << std::endl;
  std::cout << "RevisedPublishingInterval: " << data.RevisedPublishingInterval << std::endl;
  std::cout << "RevisedLifetimeCount: " << data.RevisedLifetimeCount << std::endl;
  std::cout << "RevisedMaxKeepAliveCount: " << data.RevisedMaxKeepAliveCount << std::endl;
}

void Process(OpcUa::CommandLine & cmd, const Common::AddonsManager & addons)
{
  const std::string serverURI = cmd.GetServerURI();
  const Common::Uri uri(serverURI);
  OpcUa::Client::Addon::SharedPtr addon = addons.GetAddon<OpcUa::Client::Addon>(uri.Scheme());
  std::shared_ptr<OpcUa::Services> computer = addon->Connect(serverURI);

  if (cmd.IsGetEndpointsOperation())
    {
      PrintEndpoints(*computer);
      return;
    }

  else if (cmd.IsFindServersOperation())
    {
      PrintServers(*computer);
    }

  OpcUa::RemoteSessionParameters session;
  session.ClientDescription.ApplicationUri = "https://github.com/treww/opc_layer.git";
  session.ClientDescription.ProductUri = "https://github.com/treww/opc_layer.git";
  session.ClientDescription.ApplicationName.Text = "opcua client";
  session.ClientDescription.ApplicationType = OpcUa::ApplicationType::Client;
  session.SessionName = "opua command line";
  session.EndpointUrl = serverURI;
  session.Timeout = 1200000;

  CreateSessionResponse resp = computer->CreateSession(session);
  ActivateSessionParameters session_parameters;
  computer->ActivateSession(session_parameters);

  if (cmd.IsBrowseOperation())
    {
      const OpcUa::NodeId nodeId = cmd.GetNodeId();
      Print(nodeId, Tabs(0));
      Browse(*computer->Views(), nodeId);
    }

  else if (cmd.IsReadOperation())
    {
      const OpcUa::NodeId nodeId = cmd.GetNodeId();
      const OpcUa::AttributeId attributeId = cmd.GetAttribute();
      Read(*computer->Attributes(), nodeId, attributeId);
    }

  else if (cmd.IsWriteOperation())
    {
      const OpcUa::NodeId nodeId = cmd.GetNodeId();
      const OpcUa::AttributeId attributeId = cmd.GetAttribute();
      const OpcUa::Variant value = cmd.GetValue();
      Write(*computer->Attributes(), nodeId, attributeId, value);
    }

  else if (cmd.IsCreateSubscriptionOperation())
    {
      CreateSubscription(*computer->Subscriptions());
    }

  else
    {
      std::cout << "nothing to do" << std::endl;
    }


  computer->CloseSession();
}

int RegisterNewModule(const OpcUa::CommandLine & cmd)
{
  std::cout << "Registering new module." << std::endl;
  const std::string & configDir = cmd.GetConfigDir();
  const std::string & addonId = cmd.GetModuleId();
  const std::string & modulePath = cmd.GetModulePath();

  std::cout << "Id: " << addonId << std::endl;
  std::cout << "Path: " << modulePath << std::endl;
  std::cout << "Configuration file: " << configDir << std::endl;

  Common::Configuration config = Common::ParseConfigurationFiles(configDir);
  const Common::ModulesConfiguration::const_iterator moduleIt = std::find_if(config.Modules.begin(), config.Modules.end(), [&addonId](const Common::ModuleConfiguration & config) {return config.Id == addonId;});

  if (moduleIt != config.Modules.end())
    {
      std::cerr << "Module already registered." << std::endl;
      return -1;
    }

  Common::ModuleConfiguration module;
  module.Id = addonId;
  module.Path = modulePath;

  config.Modules.push_back(module);
  Common::SaveConfiguration(config.Modules, configDir);
  std::cout << "Successfully registered." << std::endl;
  return 0;
}

int UnregisterModule(const OpcUa::CommandLine & cmd)
{
  const Common::AddonId addonId = cmd.GetModuleId();
  const std::string & configDir = cmd.GetConfigDir();
  std::cout << "Unregistering module." << std::endl;
  std::cout << "Id: " << addonId << std::endl;
  std::cout << "Configuration file: " << configDir << std::endl;

  Common::Configuration config = Common::ParseConfigurationFiles(configDir);
  Common::ModulesConfiguration::iterator moduleIt = std::find_if(config.Modules.begin(), config.Modules.end(), [&addonId](const Common::ModuleConfiguration & config) {return config.Id == addonId;});

  if (moduleIt == config.Modules.end())
    {
      std::cerr << "Module not found" << std::endl;
      return -1;
    }

  config.Modules.erase(moduleIt);
  Common::SaveConfiguration(config.Modules, configDir);

  std::cout << "Successfully unregistered." << std::endl;
  return 0;
}
}

int main(int argc, char ** argv)
{
  auto logger = spdlog::stderr_color_mt("client");
  logger->set_level(spdlog::level::info);

  try
    {
      OpcUa::CommandLine cmd(argc, argv);

      if (cmd.IsHelpOperation())
        {
          return 0;
        }

      if (cmd.IsRegisterModuleOperation())
        {
          return RegisterNewModule(cmd);
        }

      if (cmd.IsUnregisterModuleOperation())
        {
          return UnregisterModule(cmd);
        }

      const std::string configDir = cmd.GetConfigDir();
      const Common::Configuration & config = Common::ParseConfigurationFiles(configDir);

      std::vector<Common::AddonInformation> infos(config.Modules.size());
      std::transform(config.Modules.begin(), config.Modules.end(), infos.begin(), std::bind(&Common::GetAddonInfomation, std::placeholders::_1));

      Common::AddonsManager::UniquePtr manager = Common::CreateAddonsManager(logger);
      std::for_each(infos.begin(), infos.end(), [&manager](const Common::AddonInformation & addon)
      {
        manager->Register(addon);
      });
      manager->Start();
      Process(cmd, *manager);
      manager->Stop();
      return 0;
    }

  catch (const std::exception & exc)
    {
      std::cout << exc.what() << std::endl;
    }

  catch (...)
    {
      std::cout << "Unknown error." << std::endl;
    }

  return -1;
}