fisco-bcos使用caliper进行压力测试

已于 2022-03-30 15:56:52 修改
阅读量4.7k 收藏 37
点赞数 12
分类专栏： Fisco-Bcos Fisco-bcos智能合约开发 文章标签： 压力测试 docker
于 2021-10-29 21:39:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38716929/article/details/121042501
版权

使用caliper对fisco-bcos进行压力测试

通过Caliper进行压力测试程序

注意：官网给出的测试案例会出现错误，我会给出相应的解决方案，本文以centos系统为例进行测试

1. 环境要求

第一步：配置基本环境
  1. 部署Caliper的计算机需要安装有以下软件：python 2.7、make、g++、gcc及git。
  2. 操作系统满足以下要求：centos>=7
第二步：安装NodeJs

NodeJS 版本建议 8 (LTS), 9, 或 10 (LTS)。
安装步骤：

# 安装nvm
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.2/install.sh | bash

# 若出现因网络问题导致长时间下载失败，可尝试以下命令
curl -o- https://gitee.com/mirrors/nvm/raw/v0.33.2/install.sh | bash

# 加载nvm配置
source ~/.$(basename $SHELL)rc
# 安装Node.js 8
nvm install 8
# 使用Node.js 8
nvm use 8
第三步：部署Docker

版本要求：>= 18.06.01
安装步骤：

sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum makecache fast
sudo yum install docker-ce
service docker start
ps -A | grep docker
systemctl enable docker
第四步：安装Docker Compose

版本要求：>= 1.22.0
安装步骤：

sudo curl -L “https://github.com/docker/compose/releases/download/1.24.0/docker-compose-(uname − s ) − (uname -s)-(uname −s)−(uname -m)” -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

2. Caliper部署

第一步：部署

Caliper提供了方便易用的命令行界面工具caliper-cli
具体步骤

1. 建立一个工作目录
mkdir benchmarks && cd benchmarks
2. 对npm项目进行初始化
npm init -y
3. 安装caliper-cli
npm install --only=prod @hyperledger/caliper-cli@0.2.0
4. 验证caliper-cli安装成功
npx caliper --version
5. 如安装成功，则会打印相应的版本信息，如下所示：

在这里插入图片描述

第二步：绑定

由于Caliper采用了轻量级的部署方式，因此需要显式的绑定步骤指定要测试的平台及适配器版本，caliper-cli会自动进行相应依赖项的安装。

使用如下方式绑定fisco-bcos
npx caliper bind --caliper-bind-sut fisco-bcos --caliper-bind-sdk latest

注意：在部署的时候可能会出现如下问题，
在这里插入图片描述
针对这个问题，去http://ping.chinaz.com/找海外节点信息即可
在这里插入图片描述
按照如下步骤进行配置域名
在这里插入图片描述
针对这个问题
在这里插入图片描述

第三步：快速体验fisco-bcos的基准测试

为方便测试人员快速上手，FISCO BCOS已经为Caliper提供了一组预定义的测试样例，测试对象涵盖HelloWorld合约、Solidity版转账合约及预编译版转账合约。同时在测试样例中，Caliper测试脚本会使用docker在本地自动部署及运行4个互连的节点组成的链，因此测试人员无需手工搭链及编写测试用例便可直接运行这些测试样例。
具体的步骤如下

1. 在工作目录下下载预定义测试用例
# 拉取gitee代码
git clone https://gitee.com/vita-dounai/caliper-benchmarks.git
2. 执行HelloWorld合约测试
npx caliper benchmark run --caliper-workspace caliper-benchmarks --caliper-benchconfig benchmarks/samples/fisco-bcos/helloworld/config.yaml  --caliper-networkconfig networks/fisco-bcos/4nodes1group/fisco-bcos.json
################################测试结果如下#################################

在这里插入图片描述
在这里插入图片描述

3. 执行Solidity版转账合约测试
npx caliper benchmark run --caliper-workspace caliper-benchmarks --caliper-benchconfig benchmarks/samples/fisco-bcos/transfer/solidity/config.yaml  --caliper-networkconfig networks/fisco-bcos/4nodes1group/fisco-bcos.json
################################测试结果如下#################################

在这里插入图片描述
在这里插入图片描述

4.执行预编译版转账合约测试
npx caliper benchmark run --caliper-workspace caliper-benchmarks --caliper-benchconfig benchmarks/samples/fisco-bcos/transfer/precompiled/config.yaml  --caliper-networkconfig networks/fisco-bcos/4nodes1group/fisco-bcos.json
################################测试结果如下#################################

在这里插入图片描述
在这里插入图片描述

3. 需要注意的事项

由于FISCO BCOS对于caliper0.2.0版本的适配存在部分不兼容情况，需要修改代码后方可正常运行。
这里给出需要修改后的文件（注意：如果没有出现问题就不用修改）

在这里插入图片描述

fiscoBcos.js文件如下：

/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

'use strict';

const {
    BlockchainInterface,
    CaliperUtils
} = require('@hyperledger/caliper-core');
const installSmartContractImpl = require('./installSmartContract');
const invokeSmartContractImpl = require('./invokeSmartContract');
const generateRawTransactionImpl = require('./generateRawTransactions');
const sendRawTransactionImpl = require('./sendRawTransactions');
const Color = require('./common').Color;
const commLogger = CaliperUtils.getLogger('fiscoBcos.js');

/**
 * Implements {BlockchainInterface} for a FISCO BCOS backend.
 */
class FiscoBcos extends BlockchainInterface {
    /**
     * Create a new instance of the {FISCO BCOS} class.
     * @param {string} config_path The absolute path of the FISCO BCOS network configuration file.
     * @param {string} workspace_root The absolute path to the root location for the application configuration files.
     */
    constructor(config_path, workspace_root) {
        super(config_path);
        this.bcType = 'fisco-bcos';
        this.workspaceRoot = workspace_root;
        this.fiscoBcosSettings = CaliperUtils.parseYaml(this.configPath)['fisco-bcos'];

        if (this.fiscoBcosSettings.network && this.fiscoBcosSettings.network.authentication) {
            for (let k in this.fiscoBcosSettings.network.authentication) {
                this.fiscoBcosSettings.network.authentication[k] = CaliperUtils.resolvePath(this.fiscoBcosSettings.network.authentication[k], workspace_root);
            }
        }
    }

    /**
     * Initialize the {FISCO BCOS} object.
     * @async
     * @return {Promise<object>} The promise for the result of the execution.
     */
    async init() {
        return Promise.resolve();
    }

    /**
     * Deploy the smart contract specified in the network configuration file to all nodes.
     * @async
     */
    async installSmartContract() {
       const fiscoBcosSettings = this.fiscoBcosSettings;
        try {
            await installSmartContractImpl.run(fiscoBcosSettings, this.workspaceRoot);
        } catch (error) {
            commLogger.error(Color.error(`FISCO BCOS smart contract install failed: ${(error.stack ? error.stack : error)}`));
            throw error;
        }
    }

    /**
     * Get a context for subsequent operations
     * 'engine' attribute of returned context object must be reserved for benchmark engine to extend the context
     *  engine = {
     *   submitCallback: callback which must be called once new transaction(s) is submitted, it receives a number argument which tells how many transactions are submitted
     * }
     * @param {String} name name of the context
     * @param {Object} args adapter specific arguments
     * @param {Integer} clientIdx the client index
     * @return {Promise<object>} The promise for the result of the execution.
     */
    async getContext(name, args, clientIdx) {
        return Promise.resolve();
    }

    /**
     * Release a context as well as related resources
     * @param {Object} context adapter specific object
     * @return {Promise<object>} The promise for the result of the execution.
     */
    async releaseContext(context) {
        return Promise.resolve();
    }

    /**
     * Invoke the given smart contract according to the specified options. Multiple transactions will be generated according to the length of args.
     * @param {object} context The FISCO BCOS context returned by {getContext}.
     * @param {string} contractID The name of the smart contract.
     * @param {string} contractVer The version of the smart contract.
     * @param {Array} args Array of JSON formatted arguments for transaction(s). Each element contains arguments (including the function name) passing to the smart contract. JSON attribute named transaction_type is used by default to specify the function name. If the attribute does not exist, the first attribute will be used as the function name.
     * @param {number} timeout The timeout to set for the execution in seconds.
     * @return {Promise<object>} The promise for the result of the execution.
     */
    async invokeSmartContract(context, contractID, contractVer, args, timeout) {
        let promises = [];
        try {
            args.forEach((arg) => {
                let fcn = null;
                let fcArgs = [];

                for (let key in arg) {
                    if (key === 'transaction_type') {
                        fcn = arg[key].toString();
                    } else {
                        fcArgs.push(arg[key].toString());
                    }
                }
                promises.push(invokeSmartContractImpl.run(context, this.fiscoBcosSettings, contractID, fcn, fcArgs, this.workspaceRoot));
            });

            return await Promise.all(promises);
        } catch (error) {
            commLogger.error(Color.error(`FISCO BCOS smart contract invoke failed: ${(error.stack ? error.stack : JSON.stringify(error))}`));
            throw error;
        }
    }

    /**
     * Query state from the ledger
     * @param {Object} context The FISCO BCOS context returned by {getContext}
     * @param {String} contractID Identity of the contract
     * @param {String} contractVer Version of the contract
     * @param {String} key lookup key
     * @param {String} fcn The smart contract query function name
     * @return {Promise<object>} The result of the query.
     */
    async queryState(context, contractID, contractVer, key, fcn) {
        try {
            return invokeSmartContractImpl.run(context, this.fiscoBcosSettings, contractID, fcn, key, this.workspaceRoot, true);
        } catch (error) {
            commLogger.error(Color.error(`FISCO BCOS smart contract query failed: ${(error.stack ? error.stack : error)}`));
            throw error;
        }
    }

    /**
     * Generate an raw transaction and store in local file
     * @param {Object} context The FISCO BCOS context returned by {getContext}
     * @param {String} contractID Identity of the contract
     * @param {Object} arg Arguments of the transaction
     * @param {String} file File path which will be used to store then transaction
     * @return {TaskStatus} Indicates whether the transaction is written to the file successfully or not
     */
    async generateRawTransaction(context, contractID, arg, file) {
        return generateRawTransactionImpl.run(this.fiscoBcosSettings, this.workspaceRoot, context, contractID, arg, file);
    }

    /**
     * Send raw transactions
     * @param {Object} context The FISCO BCOS context returned by {getContext}
     * @param {Array} transactions List of raw transactions
     * @return {Promise} The promise for the result of the execution
     */
    async sendRawTransaction(context, transactions) {
        return sendRawTransactionImpl.run(this.fiscoBcosSettings, context, transactions);
    }
}

module.exports = FiscoBcos;

channelPromise.js如下所示：

/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

'use strict';

const tls = require('tls');
const fs = require('fs');
const net = require('net');
const uuidv4 = require('uuid/v4');
const events = require('events');

/**
 * NetworkError exception class thrown in socket connection
 */
class NetworkError extends Error {
    /**
     *
     * @param {String} msg exception message
     */
    constructor(msg) {
        super(msg);
        this.name = 'NetworkError';
    }
}

let emitters = new Map();
let buffers = new Map();
let sockets = new Map();
let lastBytesRead = new Map();

/**
 * Parse response returned by node
 * @param {Buffer} response Node's response
 */
function parseResponse(response) {
    let seq = response.slice(6, 38).toString();
    let result = JSON.parse(response.slice(42).toString());
    let emitter = emitters.get(seq);
    if(!emitter) {
        //Stale message receieved
        return;
    }
    emitter = emitter.emitter;

    if (emitter) {
        let readOnly = Object.getOwnPropertyDescriptor(emitter, 'readOnly').value;
        if (readOnly) {
            if (result.error || result.result !== undefined ) {
                emitter.emit('gotresult', result);
            }
        } else {
            if (result.error || result.status || (result.result && result.result.status)) {
                emitter.emit('gotresult', result);
            } else {
                if (!result.result) {
                    throw new NetworkError(`unknown message receieved, seq=${seq}, data=${response.toString()}`);
                }
            }
        }
    } else {
        throw new NetworkError(`unknown owner message receieved, seq=${seq}, data=${response.toString()}`);
    }
}

/**
 * Create a new TLS socket
 * @param {String} ip IP of channel server
 * @param {Number} port Port of channel server
 * @param {Object} authentication A JSON object contains certificate file path, private key file path and CA file path
 * @return {TLSSocket} A new TLS socket
 */
function createNewSocket(ip, port, authentication) {
    let secureContextOptions = {
        key: fs.readFileSync(authentication.key),
        cert: fs.readFileSync(authentication.cert),
        ca: fs.readFileSync(authentication.ca),
        ecdhCurve: 'secp256k1',
    };

    let secureContext = tls.createSecureContext(secureContextOptions);

    let socket = new net.Socket();
    socket.connect(port, ip);

    let clientOptions = {
        rejectUnauthorized: false,
        secureContext: secureContext,
        socket: socket
    };

    let tlsSocket = tls.connect(clientOptions);

    tlsSocket.on('error', function (error) {
        throw new Error(error);
    });

    let socketID = `${ip}:${port}`;

    lastBytesRead.set(socketID, 0);

    tlsSocket.on('data', function (data) {
        let response = null;
        if (data instanceof Buffer) {
            response = data;
        }
        else {
            response = Buffer.from(data, 'ascii');
        }

        if (!buffers.has(socketID)) {
            // First time to read data from this socket
            let expectedLength = null;
            if (tlsSocket.bytesRead - lastBytesRead.get(socketID) >= 4) {
                expectedLength = response.readUIntBE(0, 4);
            }

            if (!expectedLength || tlsSocket.bytesRead < lastBytesRead.get(socketID) + expectedLength) {
                buffers.set(socketID, {
                    expectedLength: expectedLength,
                    buffer: response
                });
            } else {
                lastBytesRead.set(socketID, lastBytesRead.get(socketID) + expectedLength);
                parseResponse(response);
                buffers.delete(socketID);
            }
        } else {
            // Multiple reading
            let cache = buffers.get(socketID);
            cache.buffer = Buffer.concat([cache.buffer, response]);
            if (!cache.expectedLength && tlsSocket.bytesRead - lastBytesRead.get(socketID) >= 4) {
                cache.expectedLength = cache.buffer.readUIntBE(0, 4);
            }

            if (cache.expectedLength && tlsSocket.bytesRead - lastBytesRead.get(socketID) >= cache.expectedLength) {
                lastBytesRead.set(socketID, lastBytesRead.get(socketID) + cache.expectedLength);
                parseResponse(buffers.get(socketID).buffer);
                buffers.delete(socketID);
            }
        }
    });

    return tlsSocket;
}

/**
 * Prepare the data which will be sent to channel server
 * @param {String} data JSON string of load
 * @return {Object} UUID and packaged data
 */
function packageData(data) {
    const headerLength = 4 + 2 + 32 + 4;

    let length = Buffer.alloc(4);
    length.writeUInt32BE(headerLength + data.length);
    let type = Buffer.alloc(2);
    type.writeUInt16BE(0x12);
    let uuid = uuidv4();
    uuid = uuid.replace(/-/g, '');
    let seq = Buffer.from(uuid, 'ascii');
    let result = Buffer.alloc(4);
    result.writeInt32BE(0);
    let msg = Buffer.from(data, 'ascii');

    return {
        'uuid': uuid,
        'packagedData': Buffer.concat([length, type, seq, result, msg])
    };
}

/**
 * Clear context when a message got response or timeout
 * @param {String} uuid The ID of an `channelPromise`request
 */
function clearContext(uuid) {
    clearTimeout(emitters.get(uuid).timer);
    emitters.delete(uuid);
    buffers.delete(uuid);
}

/**
 * Return channel promise for a request
 * @param {Object} node A JSON object which contains IP and port configuration of channel server
 * @param {Object} authentication A JSON object contains certificate file path, private key file path and CA file path
 * @param {String} data JSON string of load
 * @param {Number} timeout Timeout to wait response
 * @param {Boolean} readOnly Is this request read-only?
 * @return {Promise} a promise which will be resolved when the request is satisfied
 */
function channelPromise(node, authentication, data, timeout, readOnly = false) {
    let ip = node.ip;
    let port = node.channelPort;

    let connectionID = `${ip}${port}`;
    if (!sockets.has(connectionID)) {
        let newSocket = createNewSocket(ip, port, authentication);
        newSocket.unref();
        sockets.set(connectionID, newSocket);
    }
    let tlsSocket = sockets.get(connectionID);

    let dataPackage = packageData(JSON.stringify(data));
    let uuid = dataPackage.uuid;

    tlsSocket.socketID = uuid;
    let packagedData = dataPackage.packagedData;
    let channelPromise = new Promise(async (resolve, reject) => {
        let eventEmitter = new events.EventEmitter();
        Object.defineProperty(eventEmitter, 'readOnly', {
            value: readOnly,
            writable: false,
            configurable: false,
            enumerable: false
        });

        eventEmitter.on('gotresult', (result) => {
            clearContext(uuid);
            if (result.error) {
                reject(result);
            } else {
                resolve(result);
            }
            return; // This `return` is not necessary, but it may can avoid future trap
        });

        eventEmitter.on('timeout', () => {
            clearContext(uuid);
            reject({ 'error': 'timeout' });
            return; // This `return` is not necessary, but it may can avoid future trap
        });

        emitters.set(uuid, {
            emitter: eventEmitter,
            timer: setTimeout(() => {
                eventEmitter.emit('timeout');
            }, timeout)
        });

        tlsSocket.write(packagedData);
    });
    return channelPromise;
}

module.exports = channelPromise;

web3sync.js如下所示：

/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

'use strict';

const uuidv4 = require('uuid/v4');
const utils = require('./utils');
const Transaction = require('./transactionObject').Transaction;

/**
 * Generate a random number via UUID
 * @return {Number} random number
 */
function genRandomID() {
    let uuid = uuidv4();
    uuid = '0x' + uuid.replace(/-/g, '');

    return uuid;
}

/**
 * Sign a transaction with private key and callback
 * @param {String} txData transaction data
 * @param {Buffer} privKey private key
 * @param {callback} callback callback function
 * @return {String} signed transaction data
 */
function signTransaction(txData, privKey, callback) {
    let tx = new Transaction(txData);
    let privateKey = Buffer.from(privKey, 'hex');
    tx.sign(privateKey);

    // Build a serialized hex version of the tx
    let serializedTx = '0x' + tx.serialize().toString('hex');
    if (callback !== null) {
        callback(serializedTx);
    } else {
        return serializedTx;
    }
}

/**
 * get transaction data
 * @param {String} func function name
 * @param {Array} params params
 * @return {String} transaction data
 */
function getTxData(func, params) {
    let r = /^\w+\((.*)\)$/g.exec(func);
    let types = [];
    if (r[1]) {
        types = r[1].split(',');
    }
    return utils.encodeTxData(func, types, params);
}

/**
 * get signed transaction data
 * @param {Number} groupId ID of the group where this transaction will be sent to
 * @param {Buffer} account user account
 * @param {Buffer} privateKey private key
 * @param {Buffer} to target address
 * @param {String} func function name
 * @param {Array} params params
 * @param {Number} blockLimit block limit
 * @return {String} signed transaction data
 */
function getSignTx(groupId, account, privateKey, to, func, params, blockLimit) {
    let txData = getTxData(func, params);

    let postdata = {
        data: txData,
        from: account,
        to: to,
        gas: 1000000,
        randomid: genRandomID(),
        blockLimit: blockLimit,
        chainId: 1,
        groupId: groupId,
         extraData: '0x0'
    };

    return signTransaction(postdata, privateKey, null);
}

/**
 * get signed deploy tx
 * @param {Number} groupId ID of the group where this transaction will be sent to
 * @param {Buffer} account user account
 * @param {Buffer} privateKey private key
 * @param {Buffer} bin contract bin
 * @param {Number} blockLimit block limit
 * @return {String} signed deploy transaction data
 */
function getSignDeployTx(groupId, account, privateKey, bin, blockLimit) {
    let txData = bin.indexOf('0x') === 0 ? bin : ('0x' + bin);

    let postdata = {
        data: txData,
        from: account,
        to: null,
        gas: 1000000,
        randomid: genRandomID(),
        blockLimit: blockLimit,
        chainId: 1,
        groupId: groupId,
        extraData: '0x0'
    };

    return signTransaction(postdata, privateKey, null);
}

module.exports.getSignDeployTx = getSignDeployTx;
module.exports.signTransaction = signTransaction;
module.exports.getSignTx = getSignTx;
module.exports.getTxData = getTxData;

当出现以下问题时，非常抱歉，这是一个愚蠢的bug，指定secp256k1依赖包时版本限制没写对，导致在绑定时时自动安装了4.0版本的secp256k1包，但是最新的4.0的包API全部变了，导致执行出错。

有一个临时的解决方案，进入node_modules/@hyperledger/caliper-fisco-bcos目录，编辑该目录下的package.json文件，在"dependencies"中添加一项"secp256k1": “^3.8.0”，随后在该目录下执行npm i，更新完成后测试程序就能启动了。
在这里插入图片描述

菜鸟逆袭之路
关注
  • 12
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
FISCO BCOS 六、通过Caliper进行压力测试程序(及常见问题)
qq_63235624的博客
07-21 1678
同时在测试样例中，Caliper测试脚本会使用docker在本地自动部署及运行4个互连的节点组成的链，因此测试人员无需手工搭链及编写测试用例便可直接运行这些测试样例。：用于指定需要测试的区块链平台，即受测系统（***S***ystem ***u***nder ***T***est）；：用于指定测试配置文件，测试配置文件中包含测试的具体参数，如交易的发送方式、发送速率控制器类型、性能监视器类型等；由于Caliper采用了轻量级的部署方式，因此需要显式的绑定步骤指定要测试的平台及适配器版本，
【FISCO-BCOS】十四、使用Caliper进行压力测试fisco-bcos
naihe_fish的博客
06-02 2266
修改完成后，进入~/benchmarks/node_modules/@hyperledger/caliper-fisco-bcos目录，编辑该目录下的package.json文件，在"dependencies"中添加一项"secp256k1": "^3.8.0"，随后在该目录下执行npm i secp256k1@3.0.0。路径： ~/benchmarks/node_modules/@hyperledger/caliper-fisco-bcos/lib/web3lib/web3sync.js。
【区块链】caliper压力测试
最新发布
2201_75540404的博客
05-23 608
浏览器输入 /opt/benchmarks/caliper-benchmarks/report.html 打开报告文件。参照工程项目使用Caliper测试工具对食品安全溯源系统智能合约生成新食品(newFood)功能进行压力测试。首先启动webase。命令便捷查看网络配置。
Caliper压力测试
qq_51562644的博客
10-18 562
caliper压力测试，看完就会
区块链安全应用----压力测试
2201_76041915的博客
04-17 1432
有一个临时的解决方案，进入node_modules/@hyperledger/caliper-fisco-bcos目录，编辑该目录下的package.json文件，在"dependencies"中添加一项"secp256k1": “^3.8.0”，随后在该目录下执行npm i，更新完成后测试程序就能启动了。变动文件二：绿色为新增的代码，红色为源代码，需要删除。在部署完成后，可以通过。：用于指定需要测试的区块链平台，即受测系统（***S***ystem ***u***nder ***T***est）；
FISCO BCOS入门（九）使用Caliper进行压力测试
2302_77339802的博客
10-12 1591
Caliper是一个用于区块链性能测试和基准测试的工具，使用Caliper进行基准测试可以提供关于区块链系统性能的重要指标，本文章Caliper 测试工具通过调用 Helloorld 合约来进行区块链系统进行压力测试并设置交易数量txNumber=10，交易速率tps=1。
Fabric 超级账本学习【7】安装 Hyperledger Caliper0.5.0 对 fabric2.4.4 网络进行压力测试
weixin_42694422的博客
03-29 2089
Fabric 超级账本学习【7】安装 Hyperledger Caliper0.5.0 对 fabric2.4.4 网络进行压力测试。Hyperledger Caliper是一个通用的区块链性能测试框架，它允许用户使用自定义的用例测试不同的区块链解决方案，并得到一组性能测试结果。中文文档由汇智网翻译整理，访问地址：http://cw.hubwiz.com/card/c/hyperledger-caliper/
FISCO BCOS区块链平台上的智能合约压力测试指南
欢迎来到“Python算法探索”，我是GT算法工程师，一名热爱计算机算法的博主。在这里，我们将一起深入探索Python世界中的各种算法，从基础到高级，从理论到实践。我参加过很多算法比赛，积累了丰富的经验，希望通过这个播客与你分享。让我们一起用Python探
03-06 6854
本指南详细阐述了如何在FISCO BCOS区块链平台上进行智能合约的压力测试，通过使用VSCode、Truffle和Ganache工具。
fiscoTest:测试
04-16
fiscoTest 测试asdfasdfasdf Kanadaramabasa
Caliper性能测试工具配置.docx
10-10
1. Caliper性能测试工具安装步骤 2. Caliper性能测试工具安装问题注意事项
ansible-for-fisco-bcos：自动生成FISCO-BCOS企业归档部署文件
01-30
标签中的“ansible”、“blockchain”和“fisco-bcos”明确了讨论的主题是关于使用Ansible进行区块链技术的自动化部署，特别是针对FISCO-BCOS平台。“AnsibleHTML”可能是指这个项目包含了HTML格式的文档或者使用了...
基于区块链Fisco-Bcos应用实战项目源码
05-31
FISCO BCOS 是由国内企业主导研发、对外开源、安全可控的企业级金融联盟链底层平台。另外通过微信小程序作为媒介，客户端由小程序和后台管理网站通过https 请求，经过 nginx 进行负载均衡。后台采用 django,将用户的...
fisco-bcos-browser:显示FISCO BCOS链条正在运行的详细信息的浏览器
05-01
全新适配FISCO-BCOS 2+版本，如果使用FISCO-BCOS 1.2或1.3版本请用。 区块链浏览器将区块链中的数据可视化，并进行实时展示。方便用户以Web页面的方式，获取当前区块链中的信息。觉得不错的话，就给个:star:吧~~~ ...
FISCO-BCOS:FISCO-BCOS，1.3.8
03-16
FISCO BCOS平台是金融区块链合作联盟（以下简称：金链盟）开源工作组以金融业务实践为参考样本，在BCOS开源平台基础上进行模块升级与功能重塑，深度定制的安全可控，适用于金融行业且完全开源的区块链链平台。...
FISCO-BCOS及WeBase-Front中间件安装包.zip
10-24
FISCO-BCOS平台采用了分层架构设计，包括网络层、共识层、存储层以及应用接口层，旨在降低区块链技术的使用门槛，便于开发者构建分布式应用。 WeBase-Front则是基于FISCO-BCOS的前端管理工具，为开发者提供了友好的...
一文说清FISCO BCOS性能压测（附实例教程）
向彪-区块链技术研究
04-02 9271
“我的区块链能跑多少TPS？”“能不能达到‘官方’所说的峰值？”“为啥总是压不上去？是我的机器不够好吗？” 如今，区块链技术被广泛应用在各行各业中，也接受海量用户、海量数据的挑战，越来越多同学开始关注链与合约的性能。 本文分别从原理、实操和技巧三个方面，为大家提供了详尽的FISCO BCOS性能压测指引，结合实例进行演示，总结出压测实用技巧与常见问题，以便大家更好地提升性能。 压测原理 压测这事，原理其实不复杂，起一个或一堆区块链客户端，先往链上部署一个用来压测的合约或者需要评估性能的智能合
fisco-bcos-browser-master.zip
11-19
fisco-bcos-browser-master.zip是一个文件压缩包。其中的"fisco-bcos-browser"表示该压缩包内的文件或文件夹的命名，"master"表示这是一个主要版本。该压缩包可能包含了一个名为"fisco-bcos-browser"的项目或软件的源代码或可执行文件。 FISCO BCOS是一个基于区块链技术的开源联盟链平台，"fisco-bcos-browser"可能是一个与FISCO BCOS相关的浏览器工具。该浏览器可能提供了可视化的方式来查看FISCO BCOS联盟链上的区块、交易和智能合约等信息。 使用该压缩包，可以解压缩得到"fisco-bcos-browser"项目的源代码或可执行文件。如果是源代码，可以通过编译和构建得到可执行文件。如果是可执行文件，可以直接运行该浏览器工具。该浏览器可能具有用户友好的界面和功能，使得用户可以方便地查看和分析FISCO BCOS联盟链上的区块链数据。 总之，根据"fisco-bcos-browser-master.zip"的命名可以推测出这是一个与FISCO BCOS区块链平台相关的浏览器工具的压缩包，用户可以通过解压和使用该压缩包中的文件来查看和分析FISCO BCOS联盟链的区块链数据。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

菜鸟逆袭之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值