@things-factory/integration-opc 8.0.0-beta.0 → 8.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-opc",
-  "version": "8.0.0-beta.0",
+  "version": "8.0.0-beta.2",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -23,8 +23,8 @@
     "clean": "npm run clean:server"
   },
   "dependencies": {
-    "@things-factory/integration-base": "^8.0.0-beta.0",
+    "@things-factory/integration-base": "^8.0.0-beta.2",
     "node-opcua": "^2.110.0"
   },
-  "gitHead": "add6fb8224b2cb19cbea47bed6a5ecb0424c9a28"
+  "gitHead": "f03431a09435511b2595515658f9cb8f78ba4ebb"
 }

package/server/engine/connector/index.ts

@@ -1,2 +0,0 @@
-import './opc-ua'
-import './opc-ua-server'

package/server/engine/connector/opc-ua-server.ts

@@ -1,145 +0,0 @@
-import { StatusCodes, OPCUAServer, Variant, DataType } from 'node-opcua'
-import { ConnectionManager, Connector, Connection } from '@things-factory/integration-base'
-
-export class OPCUAServerConnector implements Connector {
-  async ready(connectionConfigs) {
-    await Promise.all(connectionConfigs.map(this.connect))
-
-    ConnectionManager.logger.info('opc-ua-servers are ready')
-  }
-
-  async connect(config) {
-    var {
-      name: productName,
-      endpoint: port, // the port of the listening socket of the server
-      params: {
-        resourcePath, // this path will be added to the endpoint resource name
-        buildNumber,
-        buildDate
-      }
-    } = config
-
-    const server = new OPCUAServer({
-      port,
-      resourcePath,
-      buildInfo: {
-        productName,
-        buildNumber,
-        buildDate: buildDate ? new Date(buildDate) : new Date()
-      }
-    })
-
-    await server.initialize()
-    ConnectionManager.logger.info('initialized')
-
-    const addressSpace = server.engine.addressSpace
-    const namespace = addressSpace.getOwnNamespace()
-
-    // declare a new object
-    const device = namespace.addObject({
-      organizedBy: addressSpace.rootFolder.objects,
-      browseName: 'MyDevice'
-    })
-
-    // add some variables
-    // add a variable named MyVariable1 to the newly created folder "MyDevice"
-    let variable1 = 1
-
-    // emulate variable1 changing every 500 ms
-    setInterval(() => {
-      variable1 += 1
-    }, 500)
-
-    namespace.addVariable({
-      componentOf: device,
-      browseName: 'MyVariable1',
-      dataType: 'Double',
-      value: {
-        get: () => new Variant({ dataType: DataType.Double, value: variable1 })
-      }
-    })
-
-    // add a variable named MyVariable2 to the newly created folder "MyDevice"
-    let variable2 = 10.0
-
-    namespace.addVariable({
-      componentOf: device,
-      nodeId: 'ns=1;b=1020FFAA', // some opaque NodeId in namespace 4
-      browseName: 'MyVariable2',
-      dataType: 'Double',
-      minimumSamplingInterval: 1234, // we need to specify a minimumSamplingInterval when using a getter
-      value: {
-        get: () => new Variant({ dataType: DataType.Double, value: variable2 }),
-        set: variant => {
-          variable2 = parseFloat(variant.value)
-          return StatusCodes.Good
-        }
-      }
-    })
-    const os = require('os')
-    /**
-     * returns the percentage of free memory on the running machine
-     * @return {double}
-     */
-    function available_memory() {
-      // var value = process.memoryUsage().heapUsed / 1000000;
-      const percentageMemUsed = (os.freemem() / os.totalmem()) * 100.0
-      return percentageMemUsed
-    }
-    namespace.addVariable({
-      componentOf: device,
-
-      nodeId: 's=free_memory', // a string nodeID
-      browseName: 'FreeMemory',
-      dataType: 'Double',
-      value: {
-        get: () => new Variant({ dataType: DataType.Double, value: available_memory() })
-      }
-    })
-
-    server.start(function () {
-      ConnectionManager.logger.info('Server is now listening ... ( press CTRL+C to stop)')
-      ConnectionManager.logger.info('port ', server.endpoints[0].port)
-      const endpointUrl = server.endpoints[0].endpointDescriptions()[0].endpointUrl
-      ConnectionManager.logger.info(' the primary server endpoint url is ', endpointUrl)
-    })
-
-    ConnectionManager.addConnectionInstance(config, server)
-
-    ConnectionManager.logger.info(`opc-ua-server connection(${config.name}:${port}) is connected`)
-  }
-
-  async disconnect(connection: Connection) {
-    var server = ConnectionManager.removeConnectionInstance(connection)
-    server && server._server.close()
-
-    ConnectionManager.logger.info(`opc-ua-server connection(${connection.name}) is disconnected`)
-  }
-
-  get parameterSpec() {
-    return [
-      {
-        type: 'number',
-        name: 'port',
-        label: 'port'
-      },
-      {
-        type: 'string',
-        name: 'productName',
-        label: 'product-name'
-      },
-      {
-        type: 'string',
-        name: 'buildNumber',
-        label: 'build-number'
-      },
-      {
-        type: 'string',
-        name: 'buildDate',
-        label: 'build-date'
-      }
-    ]
-  }
-}
-
-ConnectionManager.registerConnector('opc-ua-server', new OPCUAServerConnector())

package/server/engine/connector/opc-ua.ts

@@ -1,212 +0,0 @@
-import {
-  OPCUAClient,
-  BrowseResult,
-  ReferenceDescription,
-  AttributeIds,
-  StatusCodes,
-  TimestampsToReturn,
-  DataValue,
-  DataType,
-  StatusCode,
-  ClientMonitoredItem,
-  Variant
-} from 'node-opcua'
-
-import { Connection, ConnectionManager, Connector } from '@things-factory/integration-base'
-
-export class OPCUAConnector implements Connector {
-  async ready(connectionConfigs) {
-    await Promise.all(connectionConfigs.map(this.connect))
-
-    ConnectionManager.logger.info('opc-ua connections are ready')
-  }
-
-  async connect(config) {
-    var {
-      name,
-      endpoint,
-      params: {
-        maxRetry = 2,
-        initialDelay = 2000,
-        maxDelay = 10 * 1000,
-        requestedPublishingInterval = 1000,
-        requestedLifetimeCount = 100,
-        requestedMaxKeepAliveCount = 20,
-        maxNotificationsPerPublish = 10,
-        publishingEnabled = true,
-        priority = 10
-      }
-    } = config
-
-    const client = OPCUAClient.create({
-      endpoint_must_exist: false,
-      connectionStrategy: {
-        maxRetry,
-        initialDelay,
-        maxDelay
-      }
-    })
-
-    client.on('backoff', () => ConnectionManager.logger.info('retrying connection'))
-
-    await client.connect(endpoint)
-
-    const session = await client.createSession()
-
-    const browseResult: BrowseResult = (await session.browse('RootFolder')) as BrowseResult
-
-    ConnectionManager.logger.info(
-      browseResult.references.map((r: ReferenceDescription) => r.browseName.toString()).join('\n')
-    )
-
-    const subscription = await session.createSubscription2({
-      requestedPublishingInterval,
-      requestedLifetimeCount,
-      requestedMaxKeepAliveCount,
-      maxNotificationsPerPublish,
-      publishingEnabled,
-      priority
-    })
-
-    subscription
-      .on('started', () =>
-        ConnectionManager.logger.info('subscription started - subscriptionId=', subscription.subscriptionId)
-      )
-      .on('keepalive', () => ConnectionManager.logger.info('keepalive'))
-      .on('terminated', () => ConnectionManager.logger.info('subscription terminated'))
-
-    try {
-      ConnectionManager.addConnectionInstance(config, {
-        read: async function (node, attribute, { logger }): Promise<DataValue> {
-          const dataValue = await session.read({ nodeId: node, attributeId: Number(attribute) })
-          if (dataValue.statusCode !== StatusCodes.Good) {
-            logger.info('Could not read ', node)
-          }
-          logger.info(` dataValue = ${dataValue.value.toString()}`)
-
-          return dataValue
-        },
-        write: async function (node, dataValue, dataType, { logger }): Promise<StatusCode> {
-          const resultVariant = new Variant({
-            dataType,
-            value: dataValue
-          })
-
-          const statusCode = await session.write({
-            nodeId: node,
-            attributeId: AttributeIds.Value,
-            value: {
-              value: resultVariant
-            }
-          })
-
-          logger.info('statusCode = ', statusCode.name)
-          return statusCode
-        },
-        startMonitor: async function (
-          node,
-          callback: (dataValue: DataValue) => void,
-          options: { samplingInterval: number; discardOldest: boolean; queueSize: number },
-          { logger }
-        ): Promise<ClientMonitoredItem> {
-          const { samplingInterval = 100, discardOldest = true, queueSize = 10 } = options || {}
-          const monitoredItem = await subscription.monitor(
-            {
-              nodeId: node,
-              attributeId: AttributeIds.Value
-            },
-            {
-              samplingInterval,
-              discardOldest,
-              queueSize
-            },
-            TimestampsToReturn.Both
-          )
-
-          monitoredItem.on('changed', callback)
-          return monitoredItem
-        },
-        stopMonitor: async function (monitoredItem, { logger }): Promise<void> {
-          await monitoredItem.terminate()
-          return monitoredItem
-        },
-        close: async function (): Promise<void> {
-          await subscription?.terminate()
-          await session?.close()
-          await client?.disconnect()
-        }
-      })
-
-      ConnectionManager.logger.info(`opc-ua connection(${name}:${endpoint}) is connected`)
-    } catch (error) {
-      ConnectionManager.logger.info(`opc-ua connection(${name}:${endpoint}) failed to connect`)
-    }
-  }
-
-  async disconnect(connection: Connection) {
-    var { close } = ConnectionManager.removeConnectionInstance(connection)
-    await close()
-
-    ConnectionManager.logger.info(`opc-ua connection(${connection.name}) is disconnected`)
-  }
-
-  get parameterSpec() {
-    return [
-      {
-        type: 'number',
-        name: 'maxRetry',
-        label: 'max-retry'
-      },
-      {
-        type: 'number',
-        name: 'initialDelay',
-        label: 'initial-delay'
-      },
-      {
-        type: 'number',
-        name: 'maxDelay',
-        label: 'max-delay'
-      },
-      {
-        type: 'number',
-        name: 'requestedPublishingInterval',
-        label: 'requested-publishing-interval'
-      },
-      {
-        type: 'number',
-        name: 'requestedLifetimeCount',
-        label: 'requested-lifetime-count'
-      },
-      {
-        type: 'number',
-        name: 'requestedMaxKeepAliveCount',
-        label: 'requested-max-keep-alive-count'
-      },
-      {
-        type: 'number',
-        name: 'maxNotificationsPerPublish',
-        label: 'max-notifications-per-publish'
-      },
-      {
-        type: 'boolean',
-        name: 'publishingEnabled',
-        label: 'publishing-enabled'
-      },
-      {
-        type: 'number',
-        name: 'priority',
-        label: 'priority'
-      }
-    ]
-  }
-
-  get taskPrefixes() {
-    return ['opc-ua']
-  }
-
-  get help() {
-    return 'integration/connector/opc-ua'
-  }
-}
-
-ConnectionManager.registerConnector('opc-ua', new OPCUAConnector())

package/server/engine/index.ts

@@ -1,2 +0,0 @@
-import './connector'
-import './task'

package/server/engine/task/index.ts

@@ -1,5 +0,0 @@
-import './opc-ua-read'
-import './opc-ua-write'
-import './opc-ua-start-monitor'
-//import './opc-ua-stop-monitor'
-import './utils'

package/server/engine/task/opc-ua-read.ts

@@ -1,77 +0,0 @@
-import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
-import { DataType, DataValue, AttributeIds } from 'node-opcua'
-import { DataTypeString } from './utils'
-
-async function OPCUARead(step, { logger, domain }) {
-  var {
-    connection,
-    params: { node, attribute }
-  } = step
-
-  var client = ConnectionManager.getConnectionInstanceByName(domain, connection)
-  if (!client) {
-    throw new Error(`no connection : ${connection}`)
-  }
-
-  if (!node) {
-    throw new Error('node parameter should be defined')
-  }
-
-  var { read } = client
-  var content: DataValue = await read(node, attribute, { logger })
-
-  return {
-    data: {
-      dataType: DataTypeString[content?.value.dataType],
-      value: content?.value.value
-    }
-  }
-}
-
-OPCUARead.parameterSpec = [
-  {
-    type: 'string',
-    name: 'node',
-    label: 'node'
-  },
-  {
-    type: 'select',
-    label: 'attribute',
-    name: 'attribute',
-    property: {
-      options: [
-        { display: 'Value', value: AttributeIds.Value },
-        { display: 'DataType', value: AttributeIds.DataType },
-        { display: 'NodeId', value: AttributeIds.NodeId },
-        { display: 'NodeClass', value: AttributeIds.NodeClass },
-        { display: 'BrowseName', value: AttributeIds.BrowseName },
-        { display: 'DisplayName', value: AttributeIds.DisplayName },
-        { display: 'Description', value: AttributeIds.Description },
-        { display: 'WriteMask', value: AttributeIds.WriteMask },
-        { display: 'UserWriteMask', value: AttributeIds.UserWriteMask },
-        { display: 'IsAbstract', value: AttributeIds.IsAbstract },
-        { display: 'Symmetric', value: AttributeIds.Symmetric },
-        { display: 'InverseName', value: AttributeIds.InverseName },
-        { display: 'ContainsNoLoops', value: AttributeIds.ContainsNoLoops },
-        { display: 'EventNotifier', value: AttributeIds.EventNotifier },
-        { display: 'ValueRank', value: AttributeIds.ValueRank },
-        { display: 'ArrayDimensions', value: AttributeIds.ArrayDimensions },
-        { display: 'AccessLevel', value: AttributeIds.AccessLevel },
-        { display: 'UserAccessLevel', value: AttributeIds.UserAccessLevel },
-        { display: 'MinimumSamplingInterval', value: AttributeIds.MinimumSamplingInterval },
-        { display: 'Historizing', value: AttributeIds.Historizing },
-        { display: 'Executable', value: AttributeIds.Executable },
-        { display: 'UserExecutable', value: AttributeIds.UserExecutable },
-        { display: 'DataTypeDefinition', value: AttributeIds.DataTypeDefinition },
-        { display: 'RolePermissions', value: AttributeIds.RolePermissions },
-        { display: 'UserRolePermissions', value: AttributeIds.UserRolePermissions },
-        { display: 'AccessRestrictions', value: AttributeIds.AccessRestrictions },
-        { display: 'AccessLevelEx', value: AttributeIds.AccessLevelEx }
-      ]
-    }
-  }
-]
-
-OPCUARead.help = 'integration/task/opc-ua-read'
-
-TaskRegistry.registerTaskHandler('opc-ua-read', OPCUARead)

package/server/engine/task/opc-ua-start-monitor.ts

@@ -1,88 +0,0 @@
-import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
-import { DataValue } from 'node-opcua'
-import { sleep } from '@things-factory/utils'
-
-async function OPCUAStartMonitor(step, context) {
-  var {
-    connection,
-    params: { node, samplingInterval, discardOldest, queueSize }
-  } = step
-
-  const { logger, domain, closures, __opcua_moinitor } = context
-  if (!__opcua_moinitor) {
-    context.__opcua_moinitor = {}
-  }
-
-  var client = ConnectionManager.getConnectionInstanceByName(domain, connection)
-  if (!client) {
-    throw new Error(`no connection : ${connection}`)
-  }
-
-  if (!context.__opcua_moinitor[node]) {
-    var MONINTORED_VALUE
-    context.__opcua_moinitor[node] = async () => {
-      while (!MONINTORED_VALUE) {
-        await sleep(100)
-      }
-
-      var monitoringValue = MONINTORED_VALUE
-
-      MONINTORED_VALUE = null
-
-      return monitoringValue
-    }
-
-    var { startMonitor, stopMonitor } = client
-    var monitoredItem = await startMonitor(
-      node,
-      (dataValue: DataValue) => {
-        MONINTORED_VALUE = dataValue?.value.value
-      },
-      {
-        samplingInterval,
-        discardOldest,
-        queueSize
-      },
-      { logger }
-    )
-
-    closures.push(async () => {
-      try {
-        monitoredItem && (await stopMonitor(monitoredItem, { logger }))
-      } catch (e) {
-        logger.error(e)
-      }
-    })
-  }
-
-  var monitoringValue = await context.__opcua_moinitor[node]()
-
-  return { data: monitoringValue }
-}
-
-OPCUAStartMonitor.parameterSpec = [
-  {
-    type: 'string',
-    name: 'node',
-    label: 'node'
-  },
-  {
-    type: 'number',
-    name: 'samplingInterval',
-    label: 'sampling-interval'
-  },
-  {
-    type: 'boolean',
-    name: 'discardOldest',
-    label: 'discard-oldest'
-  },
-  {
-    type: 'number',
-    name: 'queueSize',
-    label: 'queue-size'
-  }
-]
-
-OPCUAStartMonitor.help = 'integration/task/opc-ua-start-monitor'
-
-TaskRegistry.registerTaskHandler('opc-ua-start-monitor', OPCUAStartMonitor)

package/server/engine/task/opc-ua-stop-monitor.ts

@@ -1,37 +0,0 @@
-import { access } from '@things-factory/utils'
-import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
-
-import { ClientMonitoredItem } from 'node-opcua'
-
-async function OPCUAStopMonitor(step, { logger, domain, data }) {
-  var {
-    connection,
-    params: { monitorItem }
-  } = step
-
-  var client = ConnectionManager.getConnectionInstanceByName(domain, connection)
-  if (!client) {
-    throw new Error(`no connection : ${connection}`)
-  }
-
-  const item = access(monitorItem, data)
-
-  var { stopMonitor } = client
-  var monitoredItem: ClientMonitoredItem = await stopMonitor(item, { logger })
-
-  return {
-    data: monitoredItem.statusCode
-  }
-}
-
-OPCUAStopMonitor.parameterSpec = [
-  {
-    type: 'scenario-step-input',
-    name: 'monitorItem',
-    label: 'monitor-item'
-  }
-]
-
-OPCUAStopMonitor.help = 'integration/task/opc-ua-stop-monitor'
-
-TaskRegistry.registerTaskHandler('opc-ua-stop-monitor', OPCUAStopMonitor)

package/server/engine/task/opc-ua-write.ts

@@ -1,80 +0,0 @@
-import { access } from '@things-factory/utils'
-import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
-import { StatusCode, DataType } from 'node-opcua'
-
-async function OPCUAWrite(step, { logger, domain, data }) {
-  var {
-    connection,
-    params: { node, accessor, type }
-  } = step
-
-  var client = ConnectionManager.getConnectionInstanceByName(domain, connection)
-  if (!client) {
-    throw new Error(`no connection : ${connection}`)
-  }
-
-  const value = access(accessor, data)
-
-  var { write } = client
-  var content: StatusCode = await write(node, value, type, { logger })
-
-  return {
-    data: {
-      name: content.name,
-      description: content.description,
-      result: content.isGood()
-    }
-  }
-}
-
-OPCUAWrite.parameterSpec = [
-  {
-    type: 'string',
-    name: 'node',
-    label: 'node'
-  },
-  {
-    type: 'scenario-step-input',
-    name: 'accessor',
-    label: 'accessor'
-  },
-  {
-    type: 'select',
-    label: 'type',
-    name: 'type',
-    property: {
-      options: [
-        { display: 'Null', value: DataType.Null },
-        { display: 'Boolean', value: DataType.Boolean },
-        { display: 'SByte', value: DataType.SByte },
-        { display: 'Byte', value: DataType.Byte },
-        { display: 'Int16', value: DataType.Int16 },
-        { display: 'UInt16', value: DataType.UInt16 },
-        { display: 'Int32', value: DataType.Int32 },
-        { display: 'UInt32', value: DataType.UInt32 },
-        { display: 'Int64', value: DataType.Int64 },
-        { display: 'UInt64', value: DataType.UInt64 },
-        { display: 'Float', value: DataType.Float },
-        { display: 'Double', value: DataType.Double },
-        { display: 'String', value: DataType.String },
-        { display: 'DateTime', value: DataType.DateTime },
-        { display: 'Guid', value: DataType.Guid },
-        { display: 'ByteString', value: DataType.ByteString },
-        { display: 'XmlElement', value: DataType.XmlElement },
-        { display: 'NodeId', value: DataType.NodeId },
-        { display: 'ExpandedNodeId', value: DataType.ExpandedNodeId },
-        { display: 'StatusCode', value: DataType.StatusCode },
-        { display: 'QualifiedName', value: DataType.QualifiedName },
-        { display: 'LocalizedText', value: DataType.LocalizedText },
-        { display: 'ExtensionObject', value: DataType.ExtensionObject },
-        { display: 'Variant', value: DataType.Variant },
-        { display: 'DataValue', value: DataType.DataValue },
-        { display: 'DiagnosticInfo', value: DataType.DiagnosticInfo }
-      ]
-    }
-  }
-]
-
-OPCUAWrite.help = 'integration/task/opc-ua-write'
-
-TaskRegistry.registerTaskHandler('opc-ua-write', OPCUAWrite)

package/server/engine/task/utils.ts

@@ -1,30 +0,0 @@
-import { DataType } from 'node-opcua'
-
-export const DataTypeString = {
-  [DataType.Null]: 'Null',
-  [DataType.Boolean]: 'Boolean',
-  [DataType.SByte]: 'SByte',
-  [DataType.Byte]: 'Byte',
-  [DataType.Int16]: 'Int16',
-  [DataType.UInt16]: 'UInt16',
-  [DataType.Int32]: 'Int32',
-  [DataType.UInt32]: 'UInt32',
-  [DataType.Int64]: 'Int64',
-  [DataType.UInt64]: 'UInt64',
-  [DataType.Float]: 'Float',
-  [DataType.Double]: 'Double',
-  [DataType.String]: 'String',
-  [DataType.DateTime]: 'DateTime',
-  [DataType.Guid]: 'Guid',
-  [DataType.ByteString]: 'ByteString',
-  [DataType.XmlElement]: 'XmlElement',
-  [DataType.NodeId]: 'NodeId',
-  [DataType.ExpandedNodeId]: 'ExpandedNodeId',
-  [DataType.StatusCode]: 'StatusCode',
-  [DataType.QualifiedName]: 'QualifiedName',
-  [DataType.LocalizedText]: 'LocalizedText',
-  [DataType.ExtensionObject]: 'ExtensionObject',
-  [DataType.DataValue]: 'DataValue',
-  [DataType.Variant]: 'Variant',
-  [DataType.DiagnosticInfo]: 'DiagnosticInfo'
-}

package/server/index.ts

@@ -1,2 +0,0 @@
-import './engine'
-import './engine'