@things-factory/integration-opc 6.1.120

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

@@ -0,0 +1,145 @@
+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.log('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.log('Server is now listening ... ( press CTRL+C to stop)')
+      ConnectionManager.logger.log('port ', server.endpoints[0].port)
+      const endpointUrl = server.endpoints[0].endpointDescriptions()[0].endpointUrl
+      ConnectionManager.logger.log(' 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

@@ -0,0 +1,206 @@
+import {
+  OPCUAClient,
+  BrowseResult,
+  ReferenceDescription,
+  AttributeIds,
+  StatusCodes,
+  TimestampsToReturn,
+  DataValue,
+  StatusCode,
+  ClientMonitoredItem
+} 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.log('retrying connection'))
+
+    await client.connect(endpoint)
+
+    const session = await client.createSession()
+
+    const browseResult: BrowseResult = (await session.browse('RootFolder')) as BrowseResult
+
+    ConnectionManager.logger.log(
+      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.log('subscription started - subscriptionId=', subscription.subscriptionId)
+      )
+      .on('keepalive', () => ConnectionManager.logger.log('keepalive'))
+      .on('terminated', () => ConnectionManager.logger.log('subscription terminated'))
+
+    try {
+      ConnectionManager.addConnectionInstance(config, {
+        read: async function (node, { logger }): Promise<DataValue> {
+          const dataValue = await session.read({ nodeId: node, attributeId: AttributeIds.Value })
+          if (dataValue.statusCode !== StatusCodes.Good) {
+            logger.log('Could not read ', node)
+          }
+          logger.log(` dataValue = ${dataValue.value.toString()}`)
+
+          return dataValue
+        },
+        write: async function (node, value, { logger }): Promise<StatusCode> {
+          const statusCode = await session.write({
+            nodeId: node,
+            attributeId: AttributeIds.Value,
+            value: {
+              statusCode: StatusCodes.Good,
+              sourceTimestamp: new Date(),
+              value
+            }
+          })
+
+          logger.log('statusCode = ', statusCode.toString())
+          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()
+        },
+        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

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

package/server/engine/task/index.ts

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

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

@@ -0,0 +1,33 @@
+import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
+
+async function OPCUARead(step, { logger, domain }) {
+  var {
+    connection,
+    params: { node }
+  } = 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 = await read(node, { logger })
+  return content
+}
+
+OPCUARead.parameterSpec = [
+  {
+    type: 'string',
+    name: 'node',
+    label: 'node'
+  }
+]
+
+OPCUARead.help = 'integration/task/opc-ua-read'
+
+TaskRegistry.registerTaskHandler('opc-ua-read', OPCUARead)

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

@@ -0,0 +1,57 @@
+import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
+import { DataValue } from 'node-opcua'
+
+async function OPCUAStartMonitor(step, { logger, domain, data }) {
+  var {
+    connection,
+    params: { node, samplingInterval, discardOldest, queueSize }
+  } = step
+
+  var client = ConnectionManager.getConnectionInstanceByName(domain, connection)
+  if (!client) {
+    throw new Error(`no connection : ${connection}`)
+  }
+
+  const callback = (dataValue: DataValue) => {
+    logger.log('monitored value: %s', dataValue)
+  }
+
+  var { startMonitor } = client
+  return await startMonitor(
+    node,
+    callback,
+    {
+      samplingInterval,
+      discardOldest,
+      queueSize
+    },
+    { logger }
+  )
+}
+
+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

@@ -0,0 +1,31 @@
+import { access } from '@things-factory/utils'
+import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
+
+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
+  return await stopMonitor(item, { logger })
+}
+
+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

@@ -0,0 +1,38 @@
+import { access } from '@things-factory/utils'
+import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
+
+async function OPCUAWrite(step, { logger, domain, data }) {
+  var {
+    connection,
+    params: { node, accessor }
+  } = 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 = await write(node, value, { logger })
+
+  return content
+}
+
+OPCUAWrite.parameterSpec = [
+  {
+    type: 'string',
+    name: 'node',
+    label: 'node'
+  },
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  }
+]
+
+OPCUAWrite.help = 'integration/task/opc-ua-write'
+
+TaskRegistry.registerTaskHandler('opc-ua-write', OPCUAWrite)

package/server/index.ts

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

package/things-factory.config.js

@@ -0,0 +1 @@
+export default {}

package/translations/en.json

@@ -0,0 +1,19 @@
+{
+  "label.max-retry": "max retry",
+  "label.initial-delay": "initial delay",
+  "label.max-delay": "max delay",
+  "label.requested-publishing-interval": "requested publishing interval",
+  "label.requested-lifetime-count": "requested lifetime count",
+  "label.requested-max-keep-alive-count": "requested max keep alive count",
+  "label.max-notifications-per-publish": "max notifications per publish",
+  "label.publishing-enabled": "publishing enabled",
+  "label.priority": "priority",
+  "label.sampling-interval": "sampling interval",
+  "label.discard-oldest": "discard oldest",
+  "label.queue-size": "queue size",
+  "label.node": "node",
+  "label.monitor-item": "monitor item",
+  "label.product-name": "product name",
+  "label.build-number": "build number",
+  "label.build-date": "build date"
+}

package/translations/ja.json

@@ -0,0 +1,19 @@
+{
+  "label.max-retry": "max retry",
+  "label.initial-delay": "initial delay",
+  "label.max-delay": "max delay",
+  "label.requested-publishing-interval": "requested publishing interval",
+  "label.requested-lifetime-count": "requested lifetime count",
+  "label.requested-max-keep-alive-count": "requested max keep alive count",
+  "label.max-notifications-per-publish": "max notifications per publish",
+  "label.publishing-enabled": "publishing enabled",
+  "label.priority": "priority",
+  "label.sampling-interval": "sampling interval",
+  "label.discard-oldest": "discard oldest",
+  "label.queue-size": "queue size",
+  "label.node": "node",
+  "label.monitor-item": "monitor item",
+  "label.product-name": "product name",
+  "label.build-number": "build number",
+  "label.build-date": "build date"
+}

package/translations/ko.json

@@ -0,0 +1,19 @@
+{
+  "label.max-retry": "max retry",
+  "label.initial-delay": "initial delay",
+  "label.max-delay": "max delay",
+  "label.requested-publishing-interval": "requested publishing interval",
+  "label.requested-lifetime-count": "requested lifetime count",
+  "label.requested-max-keep-alive-count": "requested max keep alive count",
+  "label.max-notifications-per-publish": "max notifications per publish",
+  "label.publishing-enabled": "publishing enabled",
+  "label.priority": "priority",
+  "label.sampling-interval": "sampling interval",
+  "label.discard-oldest": "discard oldest",
+  "label.queue-size": "queue size",
+  "label.node": "node",
+  "label.monitor-item": "monitor item",
+  "label.product-name": "product name",
+  "label.build-number": "build number",
+  "label.build-date": "build date"
+}

package/translations/ms.json

@@ -0,0 +1,19 @@
+{
+  "label.max-retry": "max retry",
+  "label.initial-delay": "initial delay",
+  "label.max-delay": "max delay",
+  "label.requested-publishing-interval": "requested publishing interval",
+  "label.requested-lifetime-count": "requested lifetime count",
+  "label.requested-max-keep-alive-count": "requested max keep alive count",
+  "label.max-notifications-per-publish": "max notifications per publish",
+  "label.publishing-enabled": "publishing enabled",
+  "label.priority": "priority",
+  "label.sampling-interval": "sampling interval",
+  "label.discard-oldest": "discard oldest",
+  "label.queue-size": "queue size",
+  "label.node": "node",
+  "label.monitor-item": "monitor item",
+  "label.product-name": "product name",
+  "label.build-number": "build number",
+  "label.build-date": "build date"
+}

package/translations/zh.json

@@ -0,0 +1,19 @@
+{
+  "label.max-retry": "max retry",
+  "label.initial-delay": "initial delay",
+  "label.max-delay": "max delay",
+  "label.requested-publishing-interval": "requested publishing interval",
+  "label.requested-lifetime-count": "requested lifetime count",
+  "label.requested-max-keep-alive-count": "requested max keep alive count",
+  "label.max-notifications-per-publish": "max notifications per publish",
+  "label.publishing-enabled": "publishing enabled",
+  "label.priority": "priority",
+  "label.sampling-interval": "sampling interval",
+  "label.discard-oldest": "discard oldest",
+  "label.queue-size": "queue size",
+  "label.node": "node",
+  "label.monitor-item": "monitor item",
+  "label.product-name": "product name",
+  "label.build-number": "build number",
+  "label.build-date": "build date"
+}