SecurityPolicy

SecurityPolicy

关注
发信
关注(28)粉丝(399)

java - OPC Client for Milo无法连接到本地OPC发现服务

我是OPC UA的新手，并且正在使用milo OPC Subscriber client连接到本地发现服务。我有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 =新File（System.getProperty（“ java.io.tmpdir”），“ security”）;
        如果（！securityTempDir.exists（）&&！securityTempDir.mkdirs（））{
            抛出新的Exception（“无法创建安全目录：” + securityTempDir）;
        }
        LoggerFactory.getLogger（getClass（））
            .info（“ security temp dir：{}”，securityTempDir.getAbsolutePath（））;

        KeyStoreLoader loader =新的KeyStoreLoader（）。load（securityTempDir）;
        loader.load（）;

        SecurityPolicy securityPolicy = client.getSecurityPolicy（）;
        EndpointDescription []端点；

        尝试{
            端点= UaTcpStackClient
                .getEndpoints（client.getEndpointUrl（））
                。得到（）;
        } catch（Throwable ex）{
            ex.printStackTrace（）;
            //也尝试使用显式发现端点
            字符串DiscoveryUrl = client.getEndpointUrl（）;
            logger.info（“尝试使用显式发现URL：{}”，discoveryUrl）；
            端点= UaTcpStackClient
                .getEndpoints（discoveryUrl）
                。得到（）;
        }

        EndpointDescription端点= Arrays.stream（端点）
            .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 client”））
            .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 =“演示”;
        public static final String PASSWORD =“演示”;

        默认字符串getEndpointUrl（）{
            返回“ opc.tcp：// localhost：4840 / UADiscovery”；
        }

        默认的SecurityPolicy getSecurityPolicy（）{
             返回SecurityPolicy.None;
        }


        默认IdentityProvider getIdentityProvider（）{
    //返回新的UsernameProvider（USERNAME，PASSWORD）;
            返回新的AnonymousProvider（）;
        }

        无效运行（OpcUaClient客户端，CompletableFuture将来）将引发异常；

    }

订户运行实施


    @Override
    公共无效运行（OpcUaClient客户端，CompletableFuture将来）将引发异常{
        //同步连接
        client.connect（）。get（）;

        //创建订阅@ 1000ms
        UaSubscription订阅= client.getSubscriptionManager（）。createSubscription（1000.0）.get（）;

        列出nodeIds = Arrays.asList（“ SuctionPressure”，“ DischargePressure”，“ Flow”，“ BearingTemperature”，“ Vibration”，“ Power”）；
//列出nodeIds = Arrays.asList（“ DS”，“ PV”）;

        列出MICR = nodeIds.stream（）。map（id-> {
            ReadValueId readValueId = new ReadValueId（new NodeId（3，id），AttributeId.Value.uid（），null，
                    QualifiedName.NULL_VALUE）;

            //重要提示：每个项目的客户端句柄必须唯一
            UInteger clientHandle = uint（clientHandles.getAndIncrement（））;

            MonitoringParameters参数=新的MonitoringParameters（clientHandle，1000.0，//采样间隔
                    null，//过滤器，null表示使用默认值
                    uint（10），//队列大小
                    true //丢弃最旧的
            ）;

            MonitoredItemCreateRequest请求=新的MonitoredItemCreateRequest（readValueId，MonitoringMode.Reporting，
                    参数）;
            退货要求;
        }）。collect（Collectors.toList（））;

        //在MonitoringMode中创建项目时，报告此回调是每个
        //物品需要有它的
        //吸引了价值/事件消费者。另一种方法是在
        //采样模式，将
        //创建调用完成后的使用者，然后更改所有使用者的模式
        //要报告的项目。
        BiConsumer onItemCreated =（item，id）->项目
                .setValueConsumer（this :: onSubscriptionValue）;

        列表项= subscription.createMonitoredItems（TimestampsToReturn。两者，MICR，onItemCreated）
                。得到（）;

        对于（UaMonitoredItem item：项目）{
            如果（item.getStatusCode（）。isGood（））{
                logger.info（“为nodeId = {}创建的项目”，item.getReadValueId（）。getNodeId（））;
            }其他{
                logger.warn（“无法为nodeId = {}（status = {}）创建项目”，item.getReadValueId（）。getNodeId（），
                        item.getStatusCode（））;
            }
        }

        //让示例运行5秒钟，然后终止
        // Thread.sleep（1000 * 60 * 1）;
        // future.complete（client）;
    }

最佳答案

我让它与milo OPC Subscriber client一起工作。

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

客户端界面

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(); }
     */
}


}

10-06 04:12
Powered by LMLPHP ©2024 SecurityPolicy 0.024993