Prosys OPC UA SDK for Java

  private PubSubVariableDataSetConf addPublishedVariableDataSet(PubSubSystemConf.Builder conf, UaNodeId variableId) {
    PubSubVariableDataSetConf.Builder builder = PubSubVariableDataSetConf.builder();
    // The Dataset is identified by it's unique name
    builder.setName(SAMPLE_VARIABLE_DATASET_NAME);

    /*
     * By default, the dataset will monitor the Value attribute of the variable. It will by default
     * use data from the node for the metadata of the Field and the name part of the BrowseName
     * Attribute for the field's name.
     */
    builder.addPublishedVariables(variableId);

    // This example shows how to monitor the DisplayName attribute
    PubSubPublishedVariableConf.Builder variableConfBuilder = PubSubPublishedVariableConf.builder();
    variableConfBuilder.setPublishedVariable(variableId);
    variableConfBuilder.setAttributeId(Attributes.DisplayName);
    /*
     * You can also override the name and description if the ones of the node are not suitable. For
     * non-Value Attributes by default the name of the Attribute is appended to the name part of the
     * BrowseName.
     */
    variableConfBuilder.setName("MySecondPublishedField");
    variableConfBuilder.setDescription(new LocalizedText("Description for second field"));

    builder.addPublishedVariables(variableConfBuilder.build());

    PubSubVariableDataSetConf r = builder.build();
    conf.addOrReplaceDataSet(r);
    return r;
  }

public static final String SAMPLE_NAMESPACE = "http://www.prosysopc.com/OPCUA/SampleAddressSpace";
UaNodeId variableId = UaNodeId.from(SAMPLE_NAMESPACE, "MyLevel");

 private PubSubEventDataSetConf addPublishedEventDataSet(PubSubSystemConf.Builder conf, UaNodeId eventNotifierId) {
    PubSubEventDataSetConf.Builder builder = PubSubEventDataSetConf.builder();
    // The Dataset is identified by it's unique name
    builder.setName(SAMPLE_EVENT_DATASET_NAME);

    builder.setEventNotifier(eventNotifierId);

    // The SelecteClauses define which event fields are added to the Dataset
    builder.addSelectClauses(UaSimpleAttributeOperand
        .from(UaBrowseNamePath.from(Ids.BaseEventType, UaQualifiedName.standard("Message")), Attributes.Value));
    builder.addSelectClauses(UaSimpleAttributeOperand
        .from(UaBrowseNamePath.from(Ids.BaseEventType, UaQualifiedName.standard("EventId")), Attributes.Value));

    PubSubEventDataSetConf r = builder.build();
    conf.addOrReplaceDataSet(r);
    return r;
  }

UaNodeId SERVER_NODE_ID = UaNodeId.fromStandard(ObjectIdentifiers.Server);

  private void addWriterGroup(PubSubConnectionConf.Builder<?> connection) {
    PubSubWriterGroupConf.Builder<?> builder = connection.getTransportProfile().createWriterGroupConfBuilder();
    builder.setName(SAMPLE_WRITER_GROUP_NAME);
    builder.setWriterGroupId(SAMPLE_WRITER_GROUP_ID);

    builder.setPublishingInterval(Duration.ofMillis(publishingInterval));
    builder.setKeepAliveTime(Duration.ofSeconds(120));

    if (builder instanceof PubSubUadpWriterGroupConf.Builder) {
      initUadpWriterGroup((PubSubUadpWriterGroupConf.Builder<?>) builder);
    }
    if (builder instanceof PubSubJsonWriterGroupConf.Builder) {
      initJsonWriterGroup((PubSubJsonWriterGroupConf.Builder<?>) builder, reversibleJson);
    }
    if (builder instanceof PubSubBrokerTransportSettingsConf.Builder) {
      initBrokerTransportSettings((PubSubBrokerTransportSettingsConf.Builder<?>) builder, queueName, metadataQueueName);
    }

    if (variableDataSet != null) {
      addVariableDataSetWriter(builder);
    }
    if (eventDataSet != null) {
      addEventDataSetWriter(builder);
    }

    connection.addOrReplaceGroup(builder.build());
  }

  private static void initUadpWriterGroup(PubSubUadpWriterGroupConf.Builder<?> builder) {
    // Configuration of meta data included in a NetworkMessage
    UadpNetworkMessageContentMask uadpNetworkMessageContentMask = UadpNetworkMessageContentMask.of(
        UadpNetworkMessageContentMask.PayloadHeader, UadpNetworkMessageContentMask.SequenceNumber,
        UadpNetworkMessageContentMask.DataSetClassId, UadpNetworkMessageContentMask.PublisherId,
        UadpNetworkMessageContentMask.WriterGroupId, UadpNetworkMessageContentMask.Timestamp,
        UadpNetworkMessageContentMask.GroupHeader, UadpNetworkMessageContentMask.NetworkMessageNumber);
    builder.setMessageContentMask(uadpNetworkMessageContentMask);

    // Set maximum Network Message size for written Network Messages. If message size exceeds the
    // limit, it is chunked into several messages. Note that 65535 is the maximum size allowed for
    // UDP connections.
    builder.setMaxNetworkMessageSize(UnsignedInteger.valueOf(4096));
  }

  private static void initJsonWriterGroup(PubSubJsonWriterGroupConf.Builder<?> builder, boolean reversibleJson) {
    // Configuration of meta data included in a NetworkMessage
    // Let's not include the headers to keep it simple
    JsonNetworkMessageContentMask jsonNetworkMessageContentMask =
        reversibleJson
            ? JsonNetworkMessageContentMask.of(JsonNetworkMessageContentMask.DataSetMessageHeader,
                JsonNetworkMessageContentMask.NetworkMessageHeader, JsonNetworkMessageContentMask.DataSetClassId,
                JsonNetworkMessageContentMask.PublisherId)
            : JsonNetworkMessageContentMask.of();
    builder.setMessageContentMask(jsonNetworkMessageContentMask);

    /*
     * JSON messages don't need a limit, though this is mainly since they are only usable with MQTT.
     */
    builder.setMaxNetworkMessageSize(UnsignedInteger.MAX_VALUE);
  }

  private static void initBrokerTransportSettings(PubSubBrokerTransportSettingsConf.Builder<?> builder,
      final String queueName, final String metadataQueueName) {
    // For MQTT connections we need to set the queueNames and some QoS parameters

    /*
     * IMPORTANT! For now the queue names are assumed to be non-wildcards.
     */
    builder.setQueueName(queueName);
    builder.setMetaDataQueueName(metadataQueueName);
    builder.setRequestedDeliveryGuarantee(BrokerTransportQualityOfService.AtLeastOnce);

    // Note that this is only needed in the Publisher side
    builder.setMetaDataUpdateTime(Duration.ofSeconds(30));
  }

  private void addVariableDataSetWriter(PubSubWriterGroupConf.Builder<?> group) {
    PubSubDataSetWriterConf.Builder<?> builder = group.getTransportProfile().createDataSetWriterConfBuilder();
    builder.setName(SAMPLE_VARIABLE_DATA_SET_WRITER_NAME);
    builder.setDataSetWriterId(SAMPLE_VARIABLE_DATASET_WRITER_ID);

    // Linking with the VariableDataSet that was created in createVariableDataSet
    builder.setDataSetName(variableDataSet.getName());

    /*
     * To optimise message sizes, DataSetWriter writes DataSetMessages that contain only the changed
     * values of its PublishedDataSet. These messages are Delta Frames. DataSetMessages that contain
     * all values of the PublishedDataSet are Key Frames. Parameter KeyFrameCount defines the
     * maximum amount of times the PublishingInterval expires before sending a new Key Frame
     * Message. If set as 1, every DataSetMessage will be a Key Frame message.
     */
    // Note that this parameter only has meaning for writers that write a variable dataset
    builder.setKeyFrameCount(UnsignedInteger.valueOf(SAMPLE_KEYFRAME_COUNT));

    if (builder instanceof PubSubUadpDataSetWriterConf.Builder) {
      initUadpDataSetWriter((PubSubUadpDataSetWriterConf.Builder<?>) builder);
    }
    if (builder instanceof PubSubJsonDataSetWriterConf.Builder) {
      initJsonDataSetWriter((PubSubJsonDataSetWriterConf.Builder<?>) builder, reversibleJson);
    }
    if (builder instanceof PubSubBrokerTransportSettingsConf.Builder) {
      initBrokerTransportSettings((PubSubBrokerTransportSettingsConf.Builder<?>) builder, queueName, metadataQueueName);
    }
    group.addOrReplaceWriter(builder.build());
  }

  private static void initUadpDataSetWriter(PubSubUadpDataSetWriterConf.Builder<?> builder) {
    // Headers to include in the network messages
    builder.setMessageContentMask(UadpDataSetMessageContentMask.Timestamp);

    // DataSetFieldContentMask defines if we want to include meta information like StatusCode or
    // SourceTimestamp for the published variables.
    DataSetFieldContentMask fieldContentMask = DataSetFieldContentMask.of(DataSetFieldContentMask.StatusCode,
        DataSetFieldContentMask.SourceTimestamp, DataSetFieldContentMask.ServerTimestamp);
    builder.setFieldContentMask(fieldContentMask);
  }

  private static void initJsonDataSetWriter(PubSubJsonDataSetWriterConf.Builder<?> builder, boolean reversibleJson) {
    // Headers to include in the network messages
    builder.setMessageContentMask(JsonDataSetMessageContentMask.Timestamp);

    // The fields to include in the dataset messages
    // Included here since the value depends on the reversible json mode
    DataSetFieldContentMask fieldContentMask = reversibleJson ? DataSetFieldContentMask.of()
        : DataSetFieldContentMask.of(DataSetFieldContentMask.Fields.StatusCode,
            DataSetFieldContentMask.Fields.SourceTimestamp);
    builder.setFieldContentMask(fieldContentMask);

  }

  private void addReaderGroup(PubSubConnectionConf.Builder<?> connection) {
    PubSubReaderGroupConf.Builder<?> builder = connection.getTransportProfile().createReaderGroupConfBuilder();
    builder.setName(SAMPLE_READER_GROUP_NAME);

    if (builder instanceof PubSubJsonReaderGroupConf.Builder) {
      initJsonReaderGroup((PubSubJsonReaderGroupConf.Builder<?>) builder);
    }
    if (builder instanceof PubSubUadpReaderGroupConf.Builder) {
      initUadpReaderGroup((PubSubUadpReaderGroupConf.Builder<?>) builder);
    }

    addVariableDataSetReader(builder);
    addEventDataSetReader(builder);
    connection.addOrReplaceGroup(builder.build());
  }

  private static void initUadpReaderGroup(PubSubUadpReaderGroupConf.Builder<?> builder) {
    // Set maximum Network Message size for written Network Messages. If message size exceeds the
    // limit, it is chunked into several messages. Note that 65535 is the maximum size allowed for
    // UDP connections. NOTE! this setting must match or be larger than the largest Publisher being
    // listened.
    builder.setMaxNetworkMessageSize(UnsignedInteger.valueOf(4096));
  }

    private static void initJsonReaderGroup(PubSubJsonReaderGroupConf.Builder<?> builder) {
    /*
     * JSON messages don't need a limit, though this is mainly since they are only usable with MQTT.
     */
    builder.setMaxNetworkMessageSize(UnsignedInteger.MAX_VALUE);
  }

  private void addVariableDataSetReader(PubSubReaderGroupConf.Builder<?> group) {
    final PubSubDataSetReaderConf.Builder<?> builder = group.getTransportProfile().createDataSetReaderConfBuilder();
    builder.setName(SAMPLE_VARIABLE_DATASET_READER_NAME);

    // PublisherId and DataSetWriterId can be used to receive messages from a
    // specific Publisher and DataSetWriter only, respectively
    builder.setPublisherId(publisherId);
    builder.setDataSetWriterId(SAMPLE_VARIABLE_DATASET_WRITER_ID);

    // The reader can copy data automatically to target variables in the server's own address
    // space if targetVariableId is defined
    builder.setSubscribedDataSet(createTargetVariables(targetVariableId));

    if (builder instanceof PubSubBrokerTransportSettingsConf.Builder) {
      initBrokerTransportSettings((PubSubBrokerTransportSettingsConf.Builder<?>) builder, queueName, metadataQueueName);
    }
    group.addOrReplaceReader(builder.build());
  }

  private static void initBrokerTransportSettings(PubSubBrokerTransportSettingsConf.Builder<?> builder,
      final String queueName, final String metadataQueueName) {
    // For MQTT connections we need to set the queueNames and some QoS parameters

    /*
     * IMPORTANT! For now the queue names are assumed to be non-wildcards.
     */
    builder.setQueueName(queueName);
    builder.setMetaDataQueueName(metadataQueueName);
    builder.setRequestedDeliveryGuarantee(BrokerTransportQualityOfService.AtLeastOnce);

    // Note that this is only needed in the Publisher side
    builder.setMetaDataUpdateTime(Duration.ofSeconds(30));
  }