@siglesiasg/node-red-hyperledger-fabric-gateway/dist/libs/fabric-connection-pool.js

Hyperledger Fabric 2.x nodes for node-red with latest fabric-gateway library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getGateway = exports.closeGateway = void 0;
const fabric_functions_1 = require("./fabric-functions");
const connectionMap = new Map();
const gatewayMap = new Map();
const connectionOwners = new Map();
const gatewayOwners = new Map();
async function closeGateway(ownerNode, connection) {
    ownerNode.debug('Closing Gateway');
    await releaseGateway(ownerNode, connection);
    await releaseGrpcClient(ownerNode, connection);
}
exports.closeGateway = closeGateway;
async function getGateway(ownerNode, connection) {
    const grpcClient = await buildGrpcClient(ownerNode, connection);
    return await buildGateway(grpcClient, ownerNode, connection);
}
exports.getGateway = getGateway;
async function buildGateway(grpcClient, ownerNode, connection) {
    let gateway;
    if (gatewayMap.has(connection.identity.identitySelector)) {
        gateway = gatewayMap.get(connection.identity.identitySelector);
    }
    else {
        gateway = await (0, fabric_functions_1.buildGatewayConnection)(grpcClient, connection);
        gatewayMap.set(connection.identity.identitySelector, gateway);
        ownerNode.debug('Added new gateway to gateway map. Current Size: ' + connectionMap.size);
    }
    if (gatewayOwners.has(gateway)) {
        gatewayOwners.get(gateway).add(ownerNode.id);
    }
    else {
        gatewayOwners.set(gateway, new Set([ownerNode.id]));
    }
    return gateway;
}
async function buildGrpcClient(ownerNode, connection) {
    let grpcClient;
    if (connectionMap.has(connection.gateway.peer.peerSelector)) {
        grpcClient = connectionMap.get(connection.gateway.peer.peerSelector);
    }
    else {
        grpcClient = await (0, fabric_functions_1.newGrpcConnection)(connection);
        connectionMap.set(connection.gateway.peer.peerSelector, grpcClient);
        ownerNode.debug('Added new connection to connection map. Current Size: ' + connectionMap.size);
    }
    if (connectionOwners.has(grpcClient)) {
        connectionOwners.get(grpcClient).add(ownerNode.id);
    }
    else {
        connectionOwners.set(grpcClient, new Set([ownerNode.id]));
    }
    return grpcClient;
}
async function releaseGrpcClient(ownerNode, connection) {
    const grpcClient = await buildGrpcClient(ownerNode, connection);
    if (connectionOwners.has(grpcClient)) {
        const owners = connectionOwners.get(grpcClient);
        if (owners.size > 1) {
            ownerNode.debug('Grpc Client is being used by other nodes');
        }
        else {
            ownerNode.debug('Closing Grpc Client. No more nodes are using it');
            grpcClient.close();
            connectionOwners.delete(grpcClient);
            connectionMap.delete(connection.gateway.peer.peerSelector);
            return;
        }
        owners.delete(ownerNode.id);
        ownerNode.debug('Remaining nodes attached to Grpc Client: ' + owners.size);
    }
    else {
        ownerNode.warn('Trying to close unknown Grpc Client');
    }
}
async function releaseGateway(ownerNode, connection) {
    const gateway = await getGateway(ownerNode, connection);
    if (gatewayOwners.has(gateway)) {
        const owners = gatewayOwners.get(gateway);
        if (owners.size > 1) {
            ownerNode.debug('Gateway is being used by other nodes');
        }
        else {
            ownerNode.debug('Closing gateway. No more nodes are using it');
            gateway.close();
            gatewayOwners.delete(gateway);
            gatewayMap.delete(connection.identity.identitySelector);
            return;
        }
        owners.delete(ownerNode.id);
        ownerNode.debug('Remaining nodes attached to gateway: ' + owners);
    }
    else {
        ownerNode.warn('Trying to close unknown gateway');
    }
}
//# sourceMappingURL=fabric-connection-pool.js.map