Prosys OPC UA SDK for Java

  protected ApplicationDescription initApplicationDescription(String applicationName, ApplicationType applicationType) {
    ApplicationDescription applicationDescription = new ApplicationDescription();
    // 'localhost' in the ApplicationName and ApplicationURI is converted to the actual host name of
    // the computer in which the application is run.
    applicationDescription.setApplicationName(new LocalizedText(applicationName + "@localhost"));
    // ApplicationUri defines a unique identifier for each application instance-. Therefore, we use
    // the actual computer name to ensure that it gets assigned differently in every installation.
    applicationDescription.setApplicationUri("urn:localhost:OPCUA:" + applicationName);
    // ProductUri should refer to your own company, since it identifies your product
    applicationDescription.setProductUri("urn:prosysopc.com:OPCUA:" + applicationName);
    applicationDescription.setApplicationType(applicationType);
    return applicationDescription;
  }

[...]
ApplicationDescription applicationDescription = initApplicationDescription(applicationName, ApplicationType.Server);

final ApplicationIdentity identity = ApplicationIdentity.loadOrCreateCertificate(
    appDescription,
    "Sample Organisation",
    privateKeyPassword,
    privatePath,
    issuerCertificate,
    keySizes,
    /* Enable renewing the certificate */true);

KeyPair issuerCertificate =
        ApplicationIdentity.loadOrCreateIssuerCertificate(
                "ProsysSampleCA", privatePath, privateKeyPassword, 3650, false);

// Use 0 to use the default keySize and default file names (for other
// values the file names will include the key size.
int[] keySizes = new int[] { 2048, 4096 };

String hostName = InetAddress.getLocalHost().getHostName();
identity.setHttpsCertificate(ApplicationIdentity
        .loadOrCreateHttpsCertificate(appDescription, hostName,
                privateKeyPassword, issuerCertificate, privatePath, true, certKeySize));

server.setApplicationIdentity(identity);

// TCP Port number for the UA TCP protocol
server.setPort(Protocol.OpcTcp, port);

// optional server name part of the URI (default for all protocols)
server.setServerName("OPCUA/" + applicationName);
[...]
server.setPort(Protocol.OpcHttps, httpsPort);

// Alternatively, the Server can be bound to all available InetAddresses.
// isEnableIPv6 defines whether IPv6 address should be included in the bound addresses.

server.setBindAddresses(EndpointUtil.getInetAddresses(server.isEnableIPv6()));

/*
 * Define the security modes to support for the Binary protocol.
 *
 * Note that different versions of the specification might add/deprecate some modes, in this
 * example all the modes are added, but you should add some way in your application to configure
 * these. The set is empty by default, you must add at least one SecurityMode for the server to
 * start.
 */
Set<SecurityPolicy> supportedSecurityPolicies = new HashSet<SecurityPolicy>();

/*
 * This policy does not support any security. Should only be used in isolated networks.
 */
supportedSecurityPolicies.add(SecurityPolicy.NONE);

// Modes defined in previous versions of the specification
supportedSecurityPolicies.addAll(SecurityPolicy.ALL_SECURE_101);
supportedSecurityPolicies.addAll(SecurityPolicy.ALL_SECURE_102);
supportedSecurityPolicies.addAll(SecurityPolicy.ALL_SECURE_103);

/*
 * Per the 1.05 specification, only these policies should be supported and the older ones should
 * be considered as deprecated. However, in practice this list only contains very new security
 * policies, which most of the client applications as of today that are used might not be unable
 * to (yet) use. Thus, you should build a way to select these in your application configuration.
 *
 * Note that the 1.05 list has the same contents as the 1.04 list.
 */
supportedSecurityPolicies.addAll(SecurityPolicy.ALL_SECURE_104);
supportedSecurityPolicies.addAll(SecurityPolicy.ALL_SECURE_105);

Set<MessageSecurityMode> supportedMessageSecurityModes = new HashSet<MessageSecurityMode>();

/*
 * This mode does not support any security. Should only be used in isolated networks. This is
 * also the only mode, which does not require certificate exchange between the client and server
 * application (when used in conjunction of only ANONYMOUS UserTokenPolicy).
 */
supportedMessageSecurityModes.add(MessageSecurityMode.None);

/*
 * This mode support signing, so it is possible to detect if messages are tampered. Note that
 * they are not encrypted.
 */
supportedMessageSecurityModes.add(MessageSecurityMode.Sign);

/*
 * This mode signs and encrypts the messages. Only this mode is recommended outside of isolated
 * networks.
 */
supportedMessageSecurityModes.add(MessageSecurityMode.SignAndEncrypt);

/*
 * This creates all possible combinations (NONE pairs only with None) of the configured
 * MessageSecurityModes and SecurityPolicies) for opc.tcp communication.
 */
server.getSecurityModes()
    .addAll(SecurityMode.combinations(supportedMessageSecurityModes, supportedSecurityPolicies));

/*
 *
 * NOTE! The MessageSecurityMode.None for HTTPS means Application level authentication is not
 * used. If used in combination with the UserTokenPolicy ANONYMOUS anyone can access the server
 * (but the traffic is encrypted). HTTPS mode is always encrypted, therefore the given
 * MessageSecurityMode only affects if the UA certificates are exchanged when forming the
 * Session.
 */
server.getHttpsSecurityModes().addAll(SecurityMode
    .combinations(EnumSet.of(MessageSecurityMode.None, MessageSecurityMode.Sign), supportedSecurityPolicies));

// The TLS security policies to use for OPC UA HTTPS
Set<HttpsSecurityPolicy> supportedHttpsSecurityPolicies = new HashSet<HttpsSecurityPolicy>();
// OPC UA HTTPS was added in UA 1.02
supportedHttpsSecurityPolicies.addAll(HttpsSecurityPolicy.ALL_102);
supportedHttpsSecurityPolicies.addAll(HttpsSecurityPolicy.ALL_103);
supportedHttpsSecurityPolicies.addAll(HttpsSecurityPolicy.ALL_104);
supportedHttpsSecurityPolicies.addAll(HttpsSecurityPolicy.ALL_105);
server.getHttpsSettings().setHttpsSecurityPolicies(supportedHttpsSecurityPolicies);

server.addUserTokenPolicy(UserTokenPolicy.ANONYMOUS);
server.addUserTokenPolicy(UserTokenPolicy.SECURE_USERNAME_PASSWORD);
server.addUserTokenPolicy(UserTokenPolicy.SECURE_CERTIFICATE);

server.setUserValidator(userValidator);

private static UserValidator userValidator = new UserValidator() {

        @Override
        public boolean onValidate(Session session, UserIdentity userIdentity) {
                // Return true, if the user is allowed access to the server
                // Note that the UserIdentity can be of different actual types,
                // depending on the selected authentication mode (by the client).
                println("onValidate: userIdentity=" + userIdentity);
                if (userIdentity.getType().equals(UserTokenType.UserName))
                        if (userIdentity.getName().equals("opcua")
                                        && userIdentity.getPassword().equals("opcua"))
                                return true;
                        else
                                return false;
                if (userIdentity.getType().equals(UserTokenType.Certificate))
                        // Implement your strategy here, for example using the
                        // PkiFileBasedCertificateValidator
                        return true;
                return true;
        }
};

DataItemType node = nodeManager.createInstance(DataItemTypeNode.class, "DataItem");

myNodeManager = new NodeManagerUaNode(server, "http://www.prosysopc.com/OPCUA/SampleAddressSpace");

int ns = myNodeManager.getNamespaceIndex();

// UA types and folders which we will use
final UaObject objectsFolder = getServer().getNodeManagerRoot().getObjectsFolder();
final UaType baseObjectType = getServer().getNodeManagerRoot().getType(Identifiers.BaseObjectType);
final UaType baseDataVariableType = getServer().getNodeManagerRoot().getType(Identifiers.BaseDataVariableType);

// Folder for my objects
final NodeId myObjectsFolderId = new NodeId(ns, "MyObjectsFolder");
myObjectsFolder = createInstance(FolderTypeNode.class, "MyObjects", myObjectsFolderId);

this.addNodeAndReference(objectsFolder, myObjectsFolder, Identifiers.Organizes);

// My Device Type

// The preferred way to create types is to use Information Models, but this example shows how
// you can do that also with your own code

final NodeId myDeviceTypeId = new NodeId(ns, "MyDeviceType");
UaObjectType myDeviceType = new UaObjectTypeNode(this, myDeviceTypeId, "MyDeviceType", Locale.ENGLISH);
this.addNodeAndReference(baseObjectType, myDeviceType, Identifiers.HasSubtype);

// My Device

final NodeId myDeviceId = new NodeId(ns, "MyDevice");
myDevice = new UaObjectNode(this, myDeviceId, "MyDevice", Locale.ENGLISH);
myDevice.setTypeDefinition(myDeviceType);
myObjectsFolder.addReference(myDevice, Identifiers.HasComponent, false);

// My Level Type

final NodeId myLevelTypeId = new NodeId(ns, "MyLevelType");
UaType myLevelType = this.addType(myLevelTypeId, "MyLevelType", baseDataVariableType);

// My Level Measurement

final NodeId myLevelId = new NodeId(ns, "MyLevel");
UaDataType doubleType = getServer().getNodeManagerRoot().getDataType(Identifiers.Double);
myLevel = (BaseDataVariableTypeNode) createInstance(myLevelType.getNodeId(), "MyLevel", myLevelId);
myLevel.setDataType(doubleType);
myLevel.setValueRank(ValueRanks.Scalar);
myDevice.addComponent(myLevel);

EventManagerUaNode myEventManager = new MyEventManager(myNodeManager);

myNodeManager.getEventManager().setListener(myEventManagerListener);

/**
 * A sample implementation of an EventManagerListener.
 */
public class MyEventManagerListener implements EventManagerListener {

  @Override
  public boolean onAcknowledge(ServiceContext serviceContext, AcknowledgeableConditionTypeNode condition,
      ByteString eventId, LocalizedText comment) throws StatusException {
    // Handle acknowledge request to a condition event
    println("Acknowledge: Condition=" + condition + "; EventId=" + eventId + "; Comment=" + comment);
    // If the acknowledged event is no longer active, return an error
    if (!eventId.equals(condition.getEventId())) {
      throw new StatusException(StatusCodes.Bad_EventIdUnknown);
    }
    if (condition.isAcked()) {
      throw new StatusException(StatusCodes.Bad_ConditionBranchAlreadyAcked);
    }

    final DateTime now = DateTime.currentTime();
    condition.setAcked(true, now);
    final ByteString userEventId = getNextUserEventId();
    // addComment triggers a new event
    condition.addComment(eventId, comment, now, userEventId);
    return true; // Handled here
    // NOTE: If you do not handle acknowledge here, and return false,
    // the EventManager (or MethodManager) will call
    // condition.acknowledge, which performs the same actions as this
    // handler, except for setting Retain
  }

  @Override
  public boolean onAddComment(ServiceContext serviceContext, ConditionTypeNode condition, ByteString eventId,
      LocalizedText comment) throws StatusException {
    // Handle add command request to a condition event
    println("AddComment: Condition=" + condition + "; Event=" + eventId + "; Comment=" + comment);
    // Only the current eventId can get comments
    if (!eventId.equals(condition.getEventId())) {
      throw new StatusException(StatusCodes.Bad_EventIdUnknown);
    }
    // triggers a new event
    final ByteString userEventId = getNextUserEventId();
    condition.addComment(eventId, comment, DateTime.currentTime(), userEventId);
    return true; // Handled here
    // NOTE: If you do not handle addComment here, and return false,
    // the EventManager (or MethodManager) will call
    // condition.addComment automatically
  }

  @Override
  public void onAfterCreateMonitoredEventItem(ServiceContext serviceContext, Subscription subscription,
      MonitoredEventItem item) {
    //
  }

  @Override
  public void onAfterDeleteMonitoredEventItem(ServiceContext serviceContext, Subscription subscription,
      MonitoredEventItem item) {
    //
  }

  @Override
  public void onAfterModifyMonitoredEventItem(ServiceContext serviceContext, Subscription subscription,
      MonitoredEventItem item) {
    //
  }

  @Override
  public void onConditionRefresh(ServiceContext serviceContext, Subscription subscription) throws StatusException {
    //
  }

  @Override
  public void onConditionRefresh2(ServiceContext serviceContext, MonitoredEventItem item) throws StatusException {
    //
  }

  @Override
  public boolean onConfirm(ServiceContext serviceContext, AcknowledgeableConditionTypeNode condition,
      ByteString eventId, LocalizedText comment) throws StatusException {
    // Handle confirm request to a condition event
    println("Confirm: Condition=" + condition + "; EventId=" + eventId + "; Comment=" + comment);
    // If the confirmed event is no longer active, return an error
    if (!eventId.equals(condition.getEventId())) {
      throw new StatusException(StatusCodes.Bad_EventIdUnknown);
    }
    if (condition.isConfirmed()) {
      throw new StatusException(StatusCodes.Bad_ConditionBranchAlreadyConfirmed);
    }
    if (!condition.isAcked()) {
      throw new StatusException("Condition can only be confirmed when it is acknowledged.",
          StatusCodes.Bad_InvalidState);
    }
    // If the condition is no longer active, set retain to false, i.e.
    // remove it from the visible alarms
    if (!(condition instanceof AlarmConditionTypeNode) || !((AlarmConditionTypeNode) condition).isActive()) {
      condition.setRetain(false);
    }

    final DateTime now = DateTime.currentTime();
    condition.setConfirmed(true, now);
    final ByteString userEventId = getNextUserEventId();
    // addComment triggers a new event
    condition.addComment(eventId, comment, now, userEventId);
    return true; // Handled here
    // NOTE: If you do not handle Confirm here, and return false,
    // the EventManager (or MethodManager) will call
    // condition.confirm, which performs the same actions as this
    // handler
  }

  @Override
  public void onCreateMonitoredEventItem(ServiceContext serviceContext, NodeId nodeId, EventFilter eventFilter,
      EventFilterResult filterResult) throws StatusException {
    // Item created
  }

  @Override
  public void onDeleteMonitoredEventItem(ServiceContext serviceContext, Subscription subscription,
      MonitoredEventItem monitoredItem) {
    // Stop monitoring the item?
  }

  @Override
  public boolean onDisable(ServiceContext serviceContext, ConditionTypeNode condition) throws StatusException {
    // Handle disable request to a condition
    println("Disable: Condition=" + condition);
    if (condition.isEnabled()) {
      DateTime now = DateTime.currentTime();
      // Setting enabled to false, also sets retain to false
      condition.setEnabled(false, now);
      // notify the clients of the change
      condition.triggerEvent(now, null, getNextUserEventId());
    }
    return true; // Handled here
    // NOTE: If you do not handle disable here, and return false,
    // the EventManager (or MethodManager) will request the
    // condition to handle the call, and it will unset the enabled
    // state, and triggers a new notification event, as here
  }

  @Override
  public boolean onEnable(ServiceContext serviceContext, ConditionTypeNode condition) throws StatusException {
    // Handle enable request to a condition
    println("Enable: Condition=" + condition);
    if (!condition.isEnabled()) {
      DateTime now = DateTime.currentTime();
      condition.setEnabled(true, now);
      // You should evaluate the condition now, set Retain to true,
      // if necessary and in that case also call triggerEvent
      // condition.setRetain(true);
      // condition.triggerEvent(now, null, getNextUserEventId());
    }
    return true; // Handled here
    // NOTE: If you do not handle enable here, and return false,
    // the EventManager (or MethodManager) will request the
    // condition to handle the call, and it will set the enabled
    // state.

    // You should however set the status of the condition yourself
    // and trigger a new event if necessary
  }

  @Override
  public void onModifyMonitoredEventItem(ServiceContext serviceContext, Subscription subscription,
      MonitoredEventItem monitoredItem, EventFilter eventFilter, EventFilterResult filterResult)
      throws StatusException {
    // Modify event monitoring, when the client modifies a monitored
    // item
  }

  @Override
  public boolean onOneshotShelve(ServiceContext serviceContext, AlarmConditionTypeNode condition,
      ShelvedStateMachineTypeNode stateMachine) throws StatusException {
    return false;
  }

  @Override
  public boolean onTimedShelve(ServiceContext serviceContext, AlarmConditionTypeNode condition,
      ShelvedStateMachineTypeNode stateMachine, double shelvingTime) throws StatusException {
    return false;
  }

  @Override
  public boolean onUnshelve(ServiceContext serviceContext, AlarmConditionTypeNode condition,
      ShelvedStateMachineTypeNode stateMachine) throws StatusException {
    return false;
  }

  private void println(String string) {
    MyNodeManager.println(string);
  }

  ByteString getNextUserEventId() throws RuntimeException {
    return ByteString.fromUUID(UUID.randomUUID());
  }

}

MyEventType ev = createEvent(MyEventType.class);

ev.setMessage("MyEvent");
ev.setMyVariable(new Random().nextInt());
ev.setMyProperty("Property Value " + ev.getMyVariable());

  /**
   * Create a sample alarm node structure.
   *
   * @param source the variable that is the source of the alarm
   *
   * @throws StatusException if something goes wrong in the initialization
   * @throws UaInstantiationException if something goes wrong regarding object instantiation
   */
  private void createAlarmNode(UaVariable source) throws StatusException, UaInstantiationException {

    // Level Alarm from the LevelMeasurement

    // See the Spec. Part 9. Appendix B.2 for a similar example

    int ns = this.getNamespaceIndex();
    final NodeId myAlarmId = new NodeId(ns, source.getNodeId().getValue() + ".Alarm");
    String name = source.getBrowseName().getName() + "Alarm";

    // Since the HighHighLimit and others are Optional nodes,
    // we need to define them to be instantiated.
    TypeDefinitionBasedNodeBuilderConfiguration.Builder conf = TypeDefinitionBasedNodeBuilderConfiguration.builder();
    conf.addOptional(UaBrowseNamePath.from(Ids.LimitAlarmType, UaQualifiedName.standard("HighHighLimit")));
    conf.addOptional(UaBrowseNamePath.from(Ids.LimitAlarmType, UaQualifiedName.standard("HighLimit")));
    conf.addOptional(UaBrowseNamePath.from(Ids.LimitAlarmType, UaQualifiedName.standard("LowLimit")));
    conf.addOptional(UaBrowseNamePath.from(Ids.LimitAlarmType, UaQualifiedName.standard("LowLowLimit")));

    // The configuration must be set to be used
    // this.getNodeManagerTable().setNodeBuilderConfiguration(conf.build()); //global
    // this.setNodeBuilderConfiguration(conf.build()); //local to this NodeManager
    // createNodeBuilder(ExclusiveLevelAlarmTypeNode.class, conf.build()); //NodeBuilder specific
    // (createInstance uses this internally)

    // for purpose of this sample program, it is set to this manager, normally this would be set
    // once after creating this NodeManager
    this.setNodeBuilderConfiguration(conf.build());

    myAlarm = createInstance(ExclusiveLevelAlarmTypeNode.class, name, myAlarmId);

    // ConditionSource is the node which has this condition
    myAlarm.setSource(source);
    // Input is the node which has the measurement that generates the alarm
    myAlarm.setInput(source);

    myAlarm.setMessage(new LocalizedText("Level exceeded"));
    myAlarm.setSeverity(500); // Medium level warning
    myAlarm.setHighHighLimit(90.0);
    myAlarm.setHighLimit(70.0);
    myAlarm.setLowLimit(30.0);
    myAlarm.setLowLowLimit(10.0);
    myAlarm.setEnabled(true);
    myDevice.addComponent(myAlarm); // addReference(...Identifiers.HasComponent...)

    // + HasCondition, the SourceNode of the reference should normally
    // correspond to the Source set above
    source.addReference(myAlarm, Identifiers.HasCondition, false);

    // + EventSource, the target of the EventSource is normally the
    // source of the HasCondition reference
    myDevice.addReference(source, Identifiers.HasEventSource, false);

    // + HasNotifier, these are used to link the source of the EventSource
    // up in the address space hierarchy
    myObjectsFolder.addReference(myDevice, Identifiers.HasNotifier, false);
  }

ev.triggerEvent(null);

  /**
   * Send an event notification.
   *
   * @param event The event to trigger.
   */
  private void triggerEvent(BaseEventTypeNode event) {
    // Trigger event
    final DateTime now = DateTime.currentTime();
    // Use your own EventId to keep track of your events, if you need to (for example when alarms
    // are acknowledged)
    ByteString myEventId = getNextUserEventId();
    // If you wish, you can record the full event ID that is provided by triggerEvent, although your
    // own 'myEventId' is usually enough to keep track of the event.
    /* ByteString fullEventId = */event.triggerEvent(now, now, myEventId);
  }

ByteString userEventId = EventManager.extractUserEventId(fullEventId);

// 1. Register the generated classes in your UaServer object by
// using the ServerInformationModel class that is generated in the server package.
server.registerModel(example.packagename.server.ServerInformationModel.MODEL);

// 2. Load the type nodes from the SampleTypes.xml file.
server.getAddressSpace().loadModel(
        new File("SampleTypes.xml").toURI());

// 3. Now you can create an instance of ValveObjectType by using the NodeManagerUaNode:
ValveObjectType sampleValve =
  manager.createInstance(ValveObjectTypeNode.class, "SampleValve");

// 4. Use the instance.
// e.g., set the value of the PowerInput Property.
sampleValve.setPowerInput(160.5);