TypeScript chalk.cyan类代码示例

    eventFields.map((key: string) => {

        const variant = eventData[key];
        if (!variant || variant.dataType === DataType.Null) {
            return;
        }
        if (variant.dataType === DataType.ByteString) {
            console.log(w("", 20), chalk.yellow(w(key, 15)),
              chalk.cyan(w(DataType[variant.dataType], 10).toString()),
              variant.value.toString("hex"));

        } else if (variant.dataType === DataType.NodeId) {

            const node = addressSpace.findNode(variant.value);
            const name = node ? node.browseName.toString() : variant.value.toString();

            console.log(chalk.yellow(w(name, 20), w(key, 15)),
              chalk.cyan(w(DataType[variant.dataType], 10).toString()),
              chalk.cyan.bold(name), "(", w(variant.value, 20), ")");

        } else {
            console.log(w("", 20),
              chalk.yellow(w(key, 15)),
              chalk.cyan(w(DataType[variant.dataType], 10).toString()),
              variant.value.toString());
        }
    });

async function main() {

    const discovery_server_endpointUrl = "opc.tcp://localhost:4840/UADiscovery";

    console.log("Interrogating ", discovery_server_endpointUrl);

    try {
        const { servers, endpoints } = await findServers(discovery_server_endpointUrl);
        for (const server of servers) {

            console.log("     applicationUri:", chalk.cyan.bold(server.applicationUri!));
            console.log("         productUri:", chalk.cyan.bold(server.productUri!));
            console.log("    applicationName:", chalk.cyan.bold(server.applicationName!.text!));
            console.log("               type:", chalk.cyan.bold(ApplicationType[server.applicationType]));
            console.log("   gatewayServerUri:", server.gatewayServerUri ? chalk.cyan.bold(server.gatewayServerUri) : "");
            console.log("discoveryProfileUri:", server.discoveryProfileUri ? chalk.cyan.bold(server.discoveryProfileUri) : "");
            console.log("      discoveryUrls:");

            for (const discoveryUrl of server.discoveryUrls!) {
                console.log("                    " + chalk.cyan.bold(discoveryUrl!));
            }
            console.log("-------------");
        }

        for (const endpoint of endpoints){
            console.log(endpoint.endpointUrl!.toString(), endpoint.securityLevel, endpoint.securityPolicyUri,
              MessageSecurityMode[endpoint.securityMode]);
        }
    } catch (err) {
        console.log("err ", err.message);
        process.exit(-2);
    }
}

export function trace_from_this_projet_only(err?: Error): string {

    const str = [];
    str.push(chalk.cyan.bold(" display_trace_from_this_project_only = "));
    if (err) {
        str.push(err.message);
    }
    err = err || new Error("Error used to extract stack trace");
    let stack: any = err.stack;
    if (stack) {
        stack = stack.split("\n").filter((el: string) =>
          el.match(/node-opcua/) && !el.match(/node_modules/));
        str.push(chalk.yellow(stack.join("\n")));
    } else {
        str.push(chalk.red(" NO STACK TO TRACE !!!!"));
    }
    return str.join("\n");
}

async function __dumpEvent1(
  session: ClientSession,
  fields: any,
  variant: VariantLike,
  index: number
) {

    if (variant.dataType === DataType.Null) {
        return;
    }
    if (variant.dataType === DataType.NodeId) {

        const name = await getBrowseName(session, variant.value);
        console.log(chalk.yellow(w(name, 20), w(fields[index], 15)),
          chalk.cyan(w(DataType[variant.dataType], 10).toString()), chalk.cyan.bold(name), "(", w(variant.value, 20), ")");

    } else {
        console.log(chalk.yellow(w("", 20), w(fields[index], 15)),
          chalk.cyan(w(DataType[variant.dataType as number], 10).toString()), variant.value);
    }
}

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));
//.........这里部分代码省略.........

	public echoPrefixedMagenta(outputText: string, filename: string) {
		console.log(chalk.magenta.bold(outputText), chalk.cyan.bold(filename));
	}

    /**
     * @method send_response
     * @async
     * @param msgType
     * @param response
     * @param message
     * @param callback
     */
    public send_response(
      msgType: string,
      response: Response,
      message: Message,
      callback?: ErrorCallback
    ): void {

        const request = message.request;
        const requestId = message.requestId;

        if (this.aborted) {
            debugLog("channel has been terminated , cannot send responses");
            return callback && callback(new Error("Aborted"));
        }

        // istanbul ignore next
        if (doDebug) {
            assert(response.schema);
            assert(request.schema);
            assert(requestId > 0);
            // verify that response for a given requestId is only sent once.
            if (!this.__verifId) {
                this.__verifId = {};
            }
            assert(!this.__verifId[requestId], " response for requestId has already been sent !! - Internal Error");
            this.__verifId[requestId] = requestId;
        }

        if (doPerfMonitoring) {
            // record tick : send response received.
            this._tick2 = get_clock_tick();
        }

        assert(this.securityToken);

        let options = {
            channelId: this.securityToken.channelId,
            chunkSize: this.transport.receiveBufferSize,
            requestId,
            tokenId: this.securityToken.tokenId
        };

        const securityOptions =
          msgType === "OPN" ? this._get_security_options_for_OPN() : this._get_security_options_for_MSG();
        options = _.extend(options, securityOptions);

        response.responseHeader.requestHandle = request.requestHeader.requestHandle;

        /* istanbul ignore next */
        if (0 && doDebug) {
            console.log(" options ", options);
            analyze_object_binary_encoding(response as any as BaseUAObject);
        }

        /* istanbul ignore next */
        if (doTraceMessages) {
            console.log(
              chalk.cyan.bold("xxxx   >>>> ---------------------------------------- "),
              chalk.green.bold(response.schema.name),
              requestId
            );
            console.log(response.toString());
            console.log(chalk.cyan.bold("xxxx   >>>> ----------------------------------------|\n"));
        }

        if (this._on_response) {
            this._on_response(msgType, response, message);
        }

        this._transactionsCount += 1;
        this.messageChunker.chunkSecureMessage(
          msgType,
          options as ChunkMessageOptions,
          response as any as BaseUAObject,
          (messageChunk: Buffer | null) => {
              return this._send_chunk(callback, messageChunk);
          });
    }