0

我是 OPC UA 的新手，我正在使用milo OPC 订阅者客户端 连接到本地发现服务。我有连接到本地发现服务的 Prosys 模拟服务器。

注意：如果我直接连接到 prosys 端点，它工作正常。它仅通过发现服务失败。

运行代码时出现以下异常

<pre>12:38:35.916 [main] INFO org.eclipse.milo.opcua.stack.core.Stack -
Successfully removed cryptography restrictions. 12:38:36.167 [main]
INFO com.company.OpcuaClientRunner - security temp dir:
C:\Users\Z003Z2YP\AppData\Local\Temp\security 12:38:36.173 [main] INFO
com.company.KeyStoreLoader - Loading KeyStore at
C:\Users\Z003Z2YP\AppData\Local\Temp\security\example-client.pfx
12:38:37.594 [main] INFO com.company.OpcuaClientRunner - Using
endpoint: opc.tcp://<hostname>:4840 [None] 12:38:37.600 [main] INFO
org.eclipse.milo.opcua.sdk.client.OpcUaClient - Eclipse Milo OPC UA
Stack version: 0.2.3 12:38:37.600 [main] INFO
org.eclipse.milo.opcua.sdk.client.OpcUaClient - Eclipse Milo OPC UA
Client SDK version: 0.2.3 12:38:37.809 [NonceUtilSecureRandom] INFO
org.eclipse.milo.opcua.stack.core.util.NonceUtil - SecureRandom seeded
in 0ms. 12:38:37.815 [ua-netty-event-loop-1] ERROR
org.eclipse.milo.opcua.stack.client.handlers.UaTcpClientMessageHandler
- [remote=<hostname>/<IP>:4840] errorMessage=ErrorMessage{error=StatusCode{name=Bad_ServiceUnsupported,
value=0x800B0000, quality=bad}, reason=null} 12:38:53.828 [main] ERROR
com.company.OpcuaClientRunner - Error running client example:
UaException: status=Bad_Timeout, message=request timed out after
16000ms java.util.concurrent.ExecutionException: UaException:
status=Bad_Timeout, message=request timed out after 16000ms     
at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
at com.company.OpcuaSubscriber.run(OpcuaSubscriber.java:49)     
at com.company.OpcuaClientRunner.run(OpcuaClientRunner.java:122)    
at com.company.OpcuaSubscriber.main(OpcuaSubscriber.java:120) Caused by:
org.eclipse.milo.opcua.stack.core.UaException: request timed out after
16000ms     
at org.eclipse.milo.opcua.stack.client.UaTcpStackClient.lambda$scheduleRequestTimeout$13(UaTcpStackClient.java:326)
at io.netty.util.HashedWheelTimer$HashedWheelTimeout.expire(HashedWheelTimer.java:581)
at io.netty.util.HashedWheelTimer$HashedWheelBucket.expireTimeouts(HashedWheelTimer.java:655)
at io.netty.util.HashedWheelTimer$Worker.run(HashedWheelTimer.java:367)
at java.lang.Thread.run(Thread.java:748) 12:38:53.828 [main] ERROR
com.company.OpcuaClientRunner - Error running example: UaException:
status=Bad_Timeout, message=request timed out after 16000ms
java.util.concurrent.ExecutionException: UaException:
status=Bad_Timeout, message=request timed out after 16000ms     
at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
at com.company.OpcuaSubscriber.run(OpcuaSubscriber.java:49)     
at com.company.OpcuaClientRunner.run(OpcuaClientRunner.java:122)    
at com.company.OpcuaSubscriber.main(OpcuaSubscriber.java:120) Caused by:
org.eclipse.milo.opcua.stack.core.UaException: request timed out after
16000ms     
at org.eclipse.milo.opcua.stack.client.UaTcpStackClient.lambda$scheduleRequestTimeout$13(UaTcpStackClient.java:326)
at io.netty.util.HashedWheelTimer$HashedWheelTimeout.expire(HashedWheelTimer.java:581)
at io.netty.util.HashedWheelTimer$HashedWheelBucket.expireTimeouts(HashedWheelTimer.java:655)
at io.netty.util.HashedWheelTimer$Worker.run(HashedWheelTimer.java:367)
at java.lang.Thread.run(Thread.java:748)</pre>

在 ClientRunner 中创建客户端的代码。

私有 OpcUaClient createClient() 抛出异常 {
        文件 securityTempDir = new File(System.getProperty("java.io.tmpdir"), "security");
        if (!securityTempDir.exists() && !securityTempDir.mkdirs()) {
            throw new Exception("无法创建安全目录：" + securityTempDir);
        }
        LoggerFactory.getLogger(getClass())
            .info("安全临时目录：{}", securityTempDir.getAbsolutePath());

        KeyStoreLoader loader = new KeyStoreLoader().load(securityTempDir);
        加载器.load();

        SecurityPolicy securityPolicy = client.getSecurityPolicy();
        EndpointDescription[] 端点；

        尝试 {
            端点 = UaTcpStackClient
                .getEndpoints(client.getEndpointUrl())
                。得到（）;
        } 捕捉（可投掷的前）{
            ex.printStackTrace();
            // 也尝试显式发现端点
            字符串 discoveryUrl = client.getEndpointUrl();
            logger.info("尝试显式发现 URL：{}", discoveryUrl);
            端点 = UaTcpStackClient
                .getEndpoints(discoveryUrl)
                。得到（）;
        }

        EndpointDescription 端点 = Arrays.stream(endpoints)
            .filter(e -> e.getSecurityPolicyUri().equals(securityPolicy.getSecurityPolicyUri()))
            .findFirst().orElseThrow(() -> new Exception("没有返回想要的端点"));
        logger.info("使用端点：{} [{}]", endpoint.getEndpointUrl(), securityPolicy);

        OpcUaClientConfig 配置 = OpcUaClientConfig.builder()
            .setApplicationName(LocalizedText.english("eclipse milo opc-ua 客户端"))
            .setApplicationUri("urn:eclipse:milo:examples:client")
            .setCertificate(loader.getClientCertificate())
            .setKeyPair(loader.getClientKeyPair())
            .setEndpoint(端点)
            .setIdentityProvider(client.getIdentityProvider())
            .setRequestTimeout(uint(5000))
            。建造（）;

        返回新的 OpcUaClient(config);

客户端接口类

公共接口 OpcuaClientInterface {

        public static final String USERNAME = "demo";
        公共静态最终字符串密码=“演示”；

        默认字符串 getEndpointUrl() {
            返回“opc.tcp://localhost:4840/UADiscovery”；
        }

        默认安全策略 getSecurityPolicy() {
             返回 SecurityPolicy.None;
        }


        默认身份提供者 getIdentityProvider() {
    // return new UsernameProvider(USERNAME,PASSWORD);
            返回新的 AnonymousProvider();
        }

        void run（OpcUaClient 客户端，CompletableFuture 未来）抛出异常；

    }

订阅者运行实现

    @覆盖
    公共无效运行（OpcUaClient 客户端，CompletableFuture 未来）抛出异常 {
        //同步连接
        客户端.connect().get();

        // 创建订阅 @ 1000ms
        UaSubscription 订阅 = client.getSubscriptionManager().createSubscription(1000.0).get();

        List nodeIds = Arrays.asList("SuctionPressure", "DischargePressure", "Flow", "BearingTemperature", "Vibration", "Power");
// 列出 nodeIds = Arrays.asList("DS", "PV");

        列出 MICRs = nodeIds.stream().map(id -> {
            ReadValueId readValueId = new ReadValueId(new NodeId(3, id), AttributeId.Value.uid(), null,
                    QualifiedName.NULL_VALUE);

            // 重要：每个项目的客户端句柄必须是唯一的
            UIinteger clientHandle = uint(clientHandles.getAndIncrement());

            MonitoringParameters parameters = new MonitoringParameters(clientHandle, 1000.0, // 采样间隔
                    null, // 过滤器，null 表示使用默认值
                    uint(10), // 队列大小
                    true // 丢弃最旧的
            );

            MonitoredItemCreateRequest 请求 = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting,
                    参数）;
            退货请求；
        }).collect(Collectors.toList());

        // 在 MonitoringMode.Reporting 中创建项目时，此回调是每个
        // item 需要有它的
        // 价值/事件消费者连接起来。另一种方法是在
        // 采样模式，连接
        // 创建调用完成后消费者，然后更改所有的模式
        // 要报告的项目。
        BiConsumer onItemCreated = (item, id) -> item
                .setValueConsumer(this::onSubscriptionValue);

        列表项 = subscription.createMonitoredItems(TimestampsToReturn.Both, MICRs, onItemCreated)
                。得到（）;

        对于（UaMonitoredItem 项目：项目）{
            if (item.getStatusCode().isGood()) {
                logger.info("为 nodeId={} 创建的项目", item.getReadValueId().getNodeId());
            } 别的 {
                logger.warn("未能为 nodeId={} (status={}) 创建项目", item.getReadValueId().getNodeId(),
                        item.getStatusCode());
            }
        }

        // 让示例运行 5 秒然后终止
        // 线程.sleep(1000 * 60 * 1);
        // future.complete(client);
    }
4

2 回答 2

2

我让它与milo OPC Subscriber 客户端一起使用。

以下是我在课堂上所做的更改。

客户端接口

public interface OpcuaClientInterface {

public static final String USERNAME = "demo";
public static final String PASSWORD = "demo";
public static final String UaServerName = "SimulationServer";

default String getEndpointUrl() {
    return "opc.tcp://localhost:4840";
}

default SecurityPolicy getSecurityPolicy() {
     return SecurityPolicy.None;
}

default String getUaServerName () {
    return UaServerName;
}


default IdentityProvider getIdentityProvider() {
     return new UsernameProvider(USERNAME,PASSWORD);
}

void run (OpcUaClient client, CompletableFuture<OpcUaClient> future) throws Exception;

}

客户端运行器类

public class OpcuaClientRunner {

static {
    CryptoRestrictions.remove();
    Security.addProvider(new BouncyCastleProvider());
}
private final AtomicLong requestHandle = new AtomicLong(1L);

private final Logger logger = LoggerFactory.getLogger(getClass());
private final CompletableFuture<OpcUaClient> future = new CompletableFuture<>();

private final OpcuaClientInterface client;

public OpcuaClientRunner(OpcuaClientInterface client) throws Exception {
    this.client = client;
}

private KeyStoreLoader createKeyStore() {
    KeyStoreLoader loader = null;
    try {
        File securityTempDir = new File(System.getProperty("java.io.tmpdir"), "security");
        if (!securityTempDir.exists() && !securityTempDir.mkdirs()) {
            throw new Exception("unable to create security dir: " + securityTempDir);
        }
        LoggerFactory.getLogger(getClass()).info("security temp dir: {}", securityTempDir.getAbsolutePath());
        loader = new KeyStoreLoader().load(securityTempDir);
        loader.load();
    } catch (Exception e) {
        logger.error("Could not load keys {}", e);
        return null;
    }
    return loader;
}

private CompletableFuture<ServerOnNetwork[]> findServersOnNetwork(String discoveryEndpointUrl)
        throws InterruptedException, ExecutionException {
    UaStackClient c = createDiscoveryClient(client.getEndpointUrl()).connect().get();
    RequestHeader header = new RequestHeader(NodeId.NULL_VALUE, DateTime.now(),
            uint(requestHandle.getAndIncrement()), uint(0), null, uint(60), null);

    FindServersOnNetworkRequest request = new FindServersOnNetworkRequest(header, null, null, null);

    return c.<FindServersOnNetworkResponse>sendRequest(request).thenCompose(result -> {
        StatusCode statusCode = result.getResponseHeader().getServiceResult();

        if (statusCode.isGood()) {
            return CompletableFuture.completedFuture(result.getServers());
        } else {
            CompletableFuture<ServerOnNetwork[]> f = new CompletableFuture<>();
            f.completeExceptionally(new UaException(statusCode));
            return f;
        }
    });
}

private UaTcpStackClient createDiscoveryClient(String endpointUrl) {
    KeyStoreLoader loader = createKeyStore();
    if (loader == null) {
        return null;
    }
    UaTcpStackClientConfig config = UaTcpStackClientConfig.builder()
            .setApplicationName(LocalizedText.english("Stack Example Client"))
            .setApplicationUri(String.format("urn:example-client:%s", UUID.randomUUID()))
            .setCertificate(loader.getClientCertificate()).setKeyPair(loader.getClientKeyPair())
            .setEndpointUrl(endpointUrl).build();

    return new UaTcpStackClient(config);
}

private OpcUaClient createUaClient() throws Exception {

    KeyStoreLoader loader = createKeyStore();
    if (loader == null) {
        return null;
    }

    SecurityPolicy securityPolicy = client.getSecurityPolicy();
    EndpointDescription[] endpoints = null;

    try {
        ServerOnNetwork[] servers = findServersOnNetwork(client.getEndpointUrl()).get();
        ServerOnNetwork server = Arrays.stream(servers)
                .filter(e -> e.getServerName().equals(client.getUaServerName())).findFirst()
                .orElseThrow(() -> new Exception("no desired UA Server returned."));
        endpoints = UaTcpStackClient.getEndpoints(server.getDiscoveryUrl()).get();
    } catch (Throwable ex) {
        ex.printStackTrace();
    }

    EndpointDescription endpoint = Arrays.stream(endpoints)
            .filter(e -> e.getSecurityPolicyUri().equals(securityPolicy.getSecurityPolicyUri())).findFirst()
            .orElseThrow(() -> new Exception("no desired endpoints returned"));
    logger.info("Using endpoint: {} [{}]", endpoint.getEndpointUrl(), securityPolicy);

    OpcUaClientConfig config = OpcUaClientConfig.builder()
            .setApplicationName(LocalizedText.english("eclipse milo opc-ua client"))
            .setApplicationUri("urn:eclipse:milo:examples:client").setCertificate(loader.getClientCertificate())
            .setKeyPair(loader.getClientKeyPair()).setEndpoint(endpoint)
            .setIdentityProvider(client.getIdentityProvider()).setRequestTimeout(uint(5000)).build();

    return new OpcUaClient(config);
}

public void run() {
    try {
        OpcUaClient uaClient = createUaClient();
        future.whenComplete((c, ex) -> {
            if (ex != null) {
                logger.error("Error running example: {}", ex.getMessage(), ex);
            }

            try {
                uaClient.disconnect().get();
                Stack.releaseSharedResources();
            } catch (InterruptedException | ExecutionException e) {
                logger.error("Error disconnecting:", e.getMessage(), e);
            }

            try {
                Thread.sleep(1000);
                System.exit(0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        try {
            client.run(uaClient, future);
            future.get(15, TimeUnit.SECONDS);
        } catch (Throwable t) {
            logger.error("Error running client example: {}", t.getMessage(), t);
            future.completeExceptionally(t);
        }

    } catch (Throwable t) {
        logger.error("Error getting client: {}", t.getMessage(), t);

        future.completeExceptionally(t);

        try {
            Thread.sleep(1000);
            System.exit(0);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /*
     * try { Thread.sleep(999999999); } catch (InterruptedException e) {
     * e.printStackTrace(); }
     */
}

}

于 2018-11-26T04:07:11.797 回答
0

我认为您可能对 Discovery Server 的功能感到困惑。

您不会“通过”发现服务器连接到另一台服务器。它更像是一个注册表，其他服务器可以在其中注册自己，然后客户端可以查看哪些服务器可用。

客户端向发现服务器查询服务器列表，选择一个，然后使用从发现服务器获得的信息直接连接到该服务器。

于 2018-11-24T20:50:23.173 回答