TypeScript node-opcua.OPCUAClient類代碼示例

    beforeEach(async () => {
        client = OPCUAClient.create({});
        await client.connect(endpointUrl);

        // make sure all certificates are "trusted"
        await server.userCertificateManager.trustCertificate(clientCertificate);
        await server.userCertificateManager.trustCertificate(invalidClientCertificate);
        await server.userCertificateManager.trustCertificate(notActiveClientCertificate);

    });

async function extractEndpoints(endpointUrl: string): Promise<EndpointDescription[]> {

    const client = OPCUAClient.create({
        endpoint_must_exist: false,

        connectionStrategy: {
            maxDelay: 1000,
            maxRetry: 0
        }
    });
    client.on("backoff", (count: number, delay: number) => {
        console.log(" backoff => ", count, delay);
    });

    try {
        await client.connect(endpointUrl);
        const endpoints = await client.getEndpoints();
        await client.disconnect();
        return endpoints;
    } catch (err) {
        console.log("Client error ", err.message);
        console.log(err);
        return [];
    }
}

    it("should browse a variable", async () => {
        const client = OPCUAClient.create({});
        await client.connect(endpointUrl);

        const session = await client.createSession();

        // we want a maximum of 10 refence per nodes
        session.requestedMaxReferencesPerNode = 10;
        const nodeToBrowse: BrowseDescriptionLike = {
            browseDirection: BrowseDirection.Forward,
            nodeClassMask: NodeClassMask.Object,
            nodeId: groupNodeId
        };

        const result: BrowseResult = await session.browse(nodeToBrowse);
        result.references!.length.should.eql(10);

        should.exist(result.continuationPoint);

        const resultNext1: BrowseResult = await session.browseNext(result.continuationPoint, false);

        resultNext1.references!.length.should.eql(10);

        should.exist(resultNext1.continuationPoint);

        const resultNext2: BrowseResult = await session.browseNext(resultNext1.continuationPoint, false);
        resultNext2.references!.length.should.eql(7);
        should.not.exist(resultNext2.continuationPoint);

        await session.close();

        await client.disconnect();
    });

async function main() {

    let counter = 1;

    while (true) {

        const client = OPCUAClient.create({ endpoint_must_exist: false });
        client.on("backoff", (retryCount: number, delay: number) =>
          console.log("    backoff", retryCount, delay));

        try {
            await client.connect(endpointUrl);
            const session = await client.createSession();
            await session.close();
            await client.disconnect();
        } catch (err) {
            console.log("err", err.message);
        }

        console.log(" Connected = ", counter++);
    }
}

async function main() {

    const client = OPCUAClient.create({

        endpoint_must_exist: false
    });

    client.on("backoff", (retry: number, delay: number) => {
        console.log(" cannot connect to endpoint retry = ", retry,
          " next attempt in " , delay/1000, "seconds");
    });

    // put the endpoint to your OPCUA Server here
    const endpointUrl = "opc.tcp://localhost:48020";

    try {

        await client.connect(endpointUrl);

        const session = await client.createSession();

        const dataValue = await session.read({
            attributeId: AttributeIds.Value,
            nodeId: "i=2258" // Server CurrentTime

        });

        console.log("Server time is ", dataValue.value.toString());

        await session.close();

        await client.disconnect();
    } catch (err) {
        console.log(" err ", err.message);
    }
}

describe("Testing Session with user certificate", () => {

    before(startServer);
    after(endServer);

    const certificateFolder = path.join(__dirname, "../../../node-opcua-samples/certificates");

    const clientPrivateKeyFilename = path.join(certificateFolder, "client_key_2048.pem");
    const privateKey: PrivateKeyPEM = crypto_utils.readPrivateKeyPEM(clientPrivateKeyFilename);

    const wrongClientPrivateKeyFilename = path.join(certificateFolder, "server_key_2048.pem");
    const wrongPrivateKey: PrivateKeyPEM = crypto_utils.readPrivateKeyPEM(wrongClientPrivateKeyFilename);

    const clientCertificateFilename = path.join(certificateFolder, "client_cert_2048.pem");
    const clientCertificate: Certificate = crypto_utils.readCertificate(clientCertificateFilename);
    const invalidClientCertificateFilename = path.join(certificateFolder, "client_cert_2048_outofdate.pem");
    const invalidClientCertificate: Certificate = crypto_utils.readCertificate(invalidClientCertificateFilename);
    const notActiveClientCertificateFilename = path.join(certificateFolder, "client_cert_2048_not_active_yet.pem");
    const notActiveClientCertificate: Certificate = crypto_utils.readCertificate(notActiveClientCertificateFilename);

    let client: OPCUAClient|null = null;

    beforeEach(async () => {
        client = OPCUAClient.create({});
        await client.connect(endpointUrl);

        // make sure all certificates are "trusted"
        await server.userCertificateManager.trustCertificate(clientCertificate);
        await server.userCertificateManager.trustCertificate(invalidClientCertificate);
        await server.userCertificateManager.trustCertificate(notActiveClientCertificate);

    });

    afterEach(async () => {
        await server.userCertificateManager.trustCertificate(clientCertificate);
        await server.userCertificateManager.trustCertificate(invalidClientCertificate);
        await server.userCertificateManager.trustCertificate(notActiveClientCertificate);
        await client!.disconnect();
        client = null;
    });

    it("should create a session with a valid client certificates", async () => {

        const userIdentity: UserIdentityInfoX509 = {
            certificateData: clientCertificate,
            privateKey,
            type: UserTokenType.Certificate,
        };
        const session = await client!.createSession(userIdentity);
        await session.close();

    });

    it("should fail to create a session with a valid client certificate which is untrusted", async () => {

        await server.userCertificateManager.rejectCertificate(clientCertificate);

        const userIdentity: UserIdentityInfoX509 = {
            certificateData: clientCertificate,
            privateKey,
            type: UserTokenType.Certificate,
        };
        let exceptionCaught: Error|null = null;
        try {
            const session = await client!.createSession(userIdentity);
            await session.close();

        } catch (err) {
            exceptionCaught = err;
        }
        should(exceptionCaught).not.be.null();
    });


    it("should fail to create a session with a invalid client certificate (outofdate)", async () => {

        const userIdentity: UserIdentityInfoX509 = {
            certificateData: invalidClientCertificate,
            privateKey,
            type: UserTokenType.Certificate,
        };
        let exceptionCaught: Error|null = null;
        try {
            const session = await client!.createSession(userIdentity);
            await session.close();
        } catch (err) {
            exceptionCaught = err;
        }
        should(exceptionCaught).not.be.null();

    });

    it("should fail to create a session with a invalid client certificate (not_active_yet)", async () => {

        const userIdentity: UserIdentityInfoX509 = {
            certificateData: notActiveClientCertificate,
            privateKey,
            type: UserTokenType.Certificate,
        };
        let exceptionCaught: Error|null = null;
//.........這裏部分代碼省略.........

async function main() {

    const optionsInitial = {
        endpoint_must_exist: false,
        keepSessionAlive: true,

        connectionStrategy: {
            initialDelay: 2000,
            maxDelay: 10 * 1000,
            maxRetry: 10
        }
    };

    client = OPCUAClient.create(optionsInitial);

    client.on("backoff", (retry: number, delay: number) => {
        console.log(chalk.bgWhite.yellow("backoff  attempt #"), retry, " retrying in ", delay / 1000.0, " seconds");
    });

    console.log(" connecting to ", chalk.cyan.bold(endpointUrl));
    console.log("    strategy", client.connectionStrategy);

    await client.connect(endpointUrl);

    const endpoints = await client.getEndpoints();

    if (argv.debug) {
        fs.writeFileSync("tmp/endpoints.log", JSON.stringify(endpoints, null, " "));
        console.log(treeify.asTree(endpoints, true));
    }

    const table = new Table();

    let serverCertificate: Certificate;

    let i = 0;
    for (const endpoint of endpoints) {
        table.cell("endpoint", endpoint.endpointUrl + "");
        table.cell("Application URI", endpoint.server.applicationUri);
        table.cell("Product URI", endpoint.server.productUri);
        table.cell("Application Name", endpoint.server.applicationName.text);
        table.cell("Security Mode", endpoint.securityMode.toString());
        table.cell("securityPolicyUri", endpoint.securityPolicyUri);
        table.cell("Type", ApplicationType[endpoint.server.applicationType]);
        table.cell("certificate", "..." /*endpoint.serverCertificate*/);
        endpoint.server.discoveryUrls = endpoint.server.discoveryUrls || [];
        table.cell("discoveryUrls", endpoint.server.discoveryUrls.join(" - "));

        serverCertificate = endpoint.serverCertificate;

        const certificate_filename = path.join(__dirname, "../certificates/PKI/server_certificate" + i + ".pem");

        if (serverCertificate) {
            fs.writeFile(certificate_filename, toPem(serverCertificate, "CERTIFICATE"), () => {/**/
            });
        }
        table.newRow();
        i++;
    }
    console.log(table.toString());

    for (const endpoint of endpoints) {
        console.log("Identify Token for : Security Mode=", endpoint.securityMode.toString(), " Policy=", endpoint.securityPolicyUri);
        const table2 = new Table();
        for (const token of endpoint.userIdentityTokens!) {
            table2.cell("policyId", token.policyId);
            table2.cell("tokenType", token.tokenType.toString());
            table2.cell("issuedTokenType", token.issuedTokenType);
            table2.cell("issuerEndpointUrl", token.issuerEndpointUrl);
            table2.cell("securityPolicyUri", token.securityPolicyUri);
            table2.newRow();
        }
        console.log(table2.toString());
    }
    await client.disconnect();

    // reconnect using the correct end point URL now
    console.log(chalk.cyan("Server Certificate :"));
    console.log(chalk.yellow(hexDump(serverCertificate!)));

    const options = {
        securityMode,
        securityPolicy,
        serverCertificate,

        defaultSecureTokenLifetime: 40000,

        endpoint_must_exist: false,

        connectionStrategy: {
            initialDelay: 2000,
            maxDelay: 10 * 1000,
            maxRetry: 10
        }
    };
    console.log("Options = ", options.securityMode.toString(), options.securityPolicy.toString());

    client = OPCUAClient.create(options);

    console.log(" reconnecting to ", chalk.cyan.bold(endpointUrl));
//.........這裏部分代碼省略.........

 setTimeout(async () => {
     console.log("time out => shutting down ");
     if (!the_subscription) {
         return resolve();
     }
     if (the_subscription) {
         const s = the_subscription;
         the_subscription = null;
         await s.terminate();
         await the_session.close();
         await client.disconnect();
         console.log(" Done ");
         process.exit(0);
     }
 }, timeout);

process.on("SIGINT", async () => {

    console.log(" user interruption ...");

    user_interruption_count += 1;
    if (user_interruption_count >= 3) {
        process.exit(1);
    }
    if (the_subscription) {
        console.log(chalk.red.bold(" Received client interruption from user "));
        console.log(chalk.red.bold(" shutting down ..."));
        const subscription = the_subscription;
        the_subscription = null;;
        await subscription.terminate();
        await the_session.close();
        await client.disconnect();
        process.exit(0);
    }
});