def init_with_net_profile(self, profile_path='network.json'): """ Load the connection profile from external file to network_info. Init the handlers for orgs, peers, orderers, ca nodes :param profile_path: The connection profile file path :return: """ with open(profile_path, 'r') as profile: d = json.load(profile) self.network_info = d # read kv store path self.kv_store_path = self.get_net_info('client', 'credentialStore', 'path') if self.kv_store_path: self._state_store = FileKeyValueStore(self.kv_store_path) else: _logger.warning( 'No kv store path exists in profile {}'.format(profile_path)) # Init organizations orgs = self.get_net_info('organizations') for name in orgs: _logger.debug("create org with name={}".format(name)) org = create_org(name, orgs[name], self.state_store) self._organizations[name] = org # Init CAs # TODO # Init orderer nodes orderers = self.get_net_info('orderers') _logger.debug("Import orderers = {}".format(orderers.keys())) for name in orderers: orderer = Orderer(name=name, endpoint=orderers[name]['url']) orderer.init_with_bundle(orderers[name]) self.orderers[name] = orderer # Init peer nodes peers = self.get_net_info('peers') _logger.debug("Import peers = {}".format(peers.keys())) for name in peers: peer = Peer(name=name) peer.init_with_bundle(peers[name]) self._peers[name] = peer
def build_channel_request(client, channel_tx, channel_name): """ Args: client: the client instance channel_tx: channel config file channel_name: channel name return channel request to create a channel """ signatures = [] prop_req = TXProposalRequest() with open(channel_tx, 'rb') as f: envelope = f.read() config = utils.extract_channel_config(envelope) orderer_config = TRUSTAS_NETWORK['orderer'] if "LOCAL_DEPLOY" in os.environ: LOCAL_DEPLOY = os.environ["LOCAL_DEPLOY"] == "True" env = "local_" if LOCAL_DEPLOY else "gcp_" orderer = Orderer( endpoint=orderer_config[env + 'grpc_endpoint'], tls_ca_cert_file=orderer_config['tls_cacerts'], opts=(('grpc.ssl_target_name_override', 'orderer.example.com'), ), ) orderer_admin = get_orderer_org_user(state_store=client.state_store) orderer_tx_context = TXContext(orderer_admin, ecies(), prop_req, {}) client.tx_context = orderer_tx_context orderer_admin_signature = client.sign_channel_config(config) signatures.append(orderer_admin_signature) tx_id = orderer_tx_context.tx_id nonce = orderer_tx_context.nonce org1_admin = get_peer_org_user('org1.example.com', "Admin", client.state_store) org1_tx_context = TXContext(org1_admin, ecies(), prop_req, {}) client.tx_context = org1_tx_context org1_admin_signature = client.sign_channel_config(config) signatures.append(org1_admin_signature) # org2_admin = get_peer_org_user('org2.example.com', "Admin", # client.state_store) # org2_tx_context = TXContext(org2_admin, ecies(), prop_req, {}) # client.tx_context = org2_tx_context # org2_admin_signature = client.sign_channel_config(config) # signatures.append(org2_admin_signature) request = { 'config': config, 'signatures': signatures, 'channel_name': channel_name, 'orderer': orderer, 'tx_id': tx_id, 'nonce': nonce } return request
def build_channel_request(client, channel_tx, channel_name): """ Args: client: the client instance channel_tx: channel config file channel_name: channel name return channel request to create a channel """ signatures = [] prop_req = TXProposalRequest() with open(channel_tx, 'rb') as f: envelope = f.read() config = utils.extract_channel_config(envelope) orderer_config = E2E_CONFIG['test-network']['orderer'] with open(orderer_config['tls_cacerts'], 'rb') as tls_cacerts: pem = tls_cacerts.read() opts = (('grpc.ssl_target_name_override', 'orderer.example.com'), ) orderer = Orderer(endpoint=orderer_config['grpc_endpoint'], pem=pem, opts=opts) orderer_admin = get_orderer_org_admin(client) orderer_tx_context = TXContext(orderer_admin, Ecies(), prop_req, {}) client.tx_context = orderer_tx_context orderer_admin_signature = client.sign_channel_config(config) orderer_admin_signature_bytes = orderer_admin_signature.SerializeToString() signatures.append(orderer_admin_signature_bytes) tx_id = orderer_tx_context.tx_id nonce = orderer_tx_context.nonce org1_admin = get_peer_org_admin(client, 'org1.example.com') org1_tx_context = TXContext(org1_admin, Ecies(), prop_req, {}) client.tx_context = org1_tx_context org1_admin_signature = client.sign_channel_config(config) org1_admin_signature_bytes = org1_admin_signature.SerializeToString() signatures.append(org1_admin_signature_bytes) org2_admin = get_peer_org_admin(client, 'org2.example.com') org2_tx_context = TXContext(org2_admin, Ecies(), prop_req, {}) client.tx_context = org2_tx_context org2_admin_signature = client.sign_channel_config(config) org2_admin_signature_bytes = org2_admin_signature.SerializeToString() signatures.append(org2_admin_signature_bytes) request = { 'config': config, 'signatures': signatures, 'channel_name': channel_name, 'orderer': orderer, 'tx_id': tx_id, 'nonce': nonce } return request
def test_install(self): time.sleep(5) client = Client() chain = client.new_chain(CHAIN_ID) client.set_state_store(file_key_value_store(self.kv_store_path)) chain.add_peer(Peer()) chain.add_orderer(Orderer()) submitter = get_submitter() signing_identity = submitter.signing_identity cc_install_req = create_installment_proposal_req( CHAINCODE_NAME, CHAINCODE_PATH, CHAINCODE_VERSION) queue = Queue(1) chain.install_chaincode(cc_install_req, signing_identity) \ .subscribe(on_next=lambda x: queue.put(x), on_error=lambda x: queue.put(x)) response, _ = queue.get(timeout=5) # TODO: create channel not implement yet print(response.status) self.assertEqual(404, response.status)
def build_join_channel_req(org, channel, client): """ For test, there is only one peer. Args: org: org channel: the channel to join client: client instance Return: return request for joining channel """ def block_event_callback(block): pass client._crypto_suite = ecies() request = {} tx_prop_req = TXProposalRequest() # add the orderer orderer_config = test_network['orderer'] endpoint = orderer_config['grpc_endpoint'] ca_root_path = orderer_config['tls_cacerts'] orderer = Orderer(endpoint=endpoint, tls_ca_cert_file=ca_root_path, opts=(('grpc.ssl_target_name_override', 'orderer.example.com'),)) channel.add_orderer(orderer) # get the genesis block orderer_admin = get_orderer_org_user(state_store=client.state_store) tx_context = TXContext(orderer_admin, ecies(), tx_prop_req) client.tx_context = tx_context genesis_block = channel.get_genesis_block().SerializeToString() # create the peer org_admin = get_peer_org_user(org, "Admin", client.state_store) client.tx_context = TXContext(org_admin, ecies(), tx_prop_req) tx_id = client.tx_context.tx_id peer_config = test_network[org]["peers"]['peer0'] ca_root = peer_config["tls_cacerts"] endpoint = peer_config["grpc_request_endpoint"] opts = (('grpc.ssl_target_name_override', peer_config['server_hostname']),) peer = Peer(endpoint=endpoint, tls_cacerts=ca_root, opts=opts) """ # connect the peer eh = EventHub() event = peer_config['grpc_event_endpoint'] tx_id = client.tx_context.tx_id eh.set_peer_addr(event) eh.connect() eh.register_block_event(block_event_callback) all_ehs.append(eh) """ request["targets"] = [peer] request["block"] = genesis_block request["tx_id"] = tx_id request["transient_map"] = {} return request
def test_create_orderer_custom_orderer(self): orderer = Orderer(endpoint=self.custom_orderer_endpoint) self.assertEqual(orderer.endpoint, self.custom_orderer_endpoint)
def test_create_orderer_default_orderer(self): orderer = Orderer() self.assertEqual(orderer.endpoint, self.deault_orderer_endpoint)
def test_create_channel(self): # TODO impl channel = Channel() channel.add_orderer(Orderer()) self.fail()
def update_client_with_discovery(client, discovery_results): # Get all msp tls root cert files tls_root_certs = {} for mspid, msp_info in discovery_results['config']['msps'].items(): tls_root_certs[mspid] = base64.decodebytes( msp_info['tls_root_certs'].pop().encode()) # Load one peer per msp for endorsing transaction for msp in discovery_results['members']: if not len(msp): continue peer_info = msp[0] if peer_info['mspid'] != LEDGER['client']['msp_id']: peer = Peer(name=peer_info['mspid']) with tempfile.NamedTemporaryFile() as tls_root_cert: tls_root_cert.write(tls_root_certs[peer_info['mspid']]) tls_root_cert.flush() url = peer_info['endpoint'] external_port = os.environ.get('BACKEND_PEER_PORT_EXTERNAL', None) # use case for external development if external_port: url = f"{peer_info['endpoint'].split(':')[0]}:{external_port}" peer.init_with_bundle({ 'url': url, 'grpcOptions': { 'grpc-max-send-message-length': 15, 'grpc.ssl_target_name_override': peer_info['endpoint'].split(':')[0] }, 'tlsCACerts': { 'path': tls_root_cert.name }, 'clientKey': { 'path': LEDGER['peer']['clientKey'] }, # use peer creds (mutual tls) 'clientCert': { 'path': LEDGER['peer']['clientCert'] }, # use peer creds (mutual tls) }) client._peers[peer_info['mspid']] = peer # Load one orderer for broadcasting transaction orderer_mspid, orderer_info = list( discovery_results['config']['orderers'].items())[0] orderer = Orderer(name=orderer_mspid) with tempfile.NamedTemporaryFile() as tls_root_cert: tls_root_cert.write(tls_root_certs[orderer_mspid]) tls_root_cert.flush() # Need loop orderer.init_with_bundle({ 'url': f"{orderer_info[0]['host']}:{orderer_info[0]['port']}", 'grpcOptions': { 'grpc-max-send-message-length': 15, 'grpc.ssl_target_name_override': orderer_info[0]['host'] }, 'tlsCACerts': { 'path': tls_root_cert.name }, 'clientKey': { 'path': LEDGER['peer']['clientKey'] }, # use peer creds (mutual tls) 'clientCert': { 'path': LEDGER['peer']['clientCert'] }, # use peer creds (mutual tls) }) client._orderers[orderer_mspid] = orderer
def test_create_channel_missing_signatures(self): signatures = [] with open(self.orderer_tls_certs) as f: pem = f.read() opts = (('grpc.ssl_target_name_override', 'orderer.example.com'), ) orderer = Orderer(pem=pem, opts=opts) with open(self.configtx_path, 'rb') as f: envelope = f.read() # convert envelope to config config = extract_channel_config(envelope) channel_name = 'businesschannel' # signatures orderer admin orderer_admin = get_orderer_org_admin(self.client) orderer_admin_tx_context = TXContext(orderer_admin, Ecies(), {}) self.client.tx_context = orderer_admin_tx_context orderer_admin_signature = self.client.sign_channel_config(config) orderer_admin_signature.SerializeToString() # take the tx_id and nonce from the oderer user context tx_id = orderer_admin_tx_context.tx_id nonce = orderer_admin_tx_context.nonce # reset the state store to handle different # users with one client object self.client.state_store = FileKeyValueStore(self.kv_store_path) # signatures org1 admin org1_admin = get_peer_org_user(self.client, 'org1.example.com') org1_admin_tx_context = TXContext(org1_admin, Ecies(), {}) self.client.tx_context = org1_admin_tx_context org1_admin_signature = self.client.sign_channel_config(config) org1_admin_signature.SerializeToString() # reset the state store to handle different # users with one client object self.client.state_store = FileKeyValueStore(self.kv_store_path) # signatures org2 admin org2_admin = get_peer_org_user(self.client, 'org2.example.com') org2_admin_tx_context = TXContext(org2_admin, Ecies(), {}) self.client.tx_context = org2_admin_tx_context org2_admin_signature = self.client.sign_channel_config(config) org2_admin_signature.SerializeToString() request = { 'tx_id': tx_id, 'nonce': nonce, 'signatures': signatures, 'config': config, 'orderer': orderer, 'channel_name': channel_name } queue = Queue(1) response = self.client.create_channel(request) response.subscribe(on_next=lambda x: queue.put(x), on_error=lambda x: queue.put(x)) status, _ = queue.get(timeout=5) self.assertEqual(status.status, 400)
def _update_client_with_discovery(client, discovery_results): # Get all msp tls root cert files tls_root_certs = {} for mspid, msp_info in discovery_results['config']['msps'].items(): tls_root_certs[mspid] = base64.decodebytes( msp_info['tls_root_certs'].pop().encode()) # Load one peer per msp for endorsing transaction for msp in discovery_results['members']: if not len(msp): continue peer_info = msp[0] if peer_info['mspid'] != settings.LEDGER_MSP_ID: peer = Peer(name=peer_info['mspid']) with tempfile.NamedTemporaryFile() as tls_root_cert: tls_root_cert.write(tls_root_certs[peer_info['mspid']]) tls_root_cert.flush() url = peer_info['endpoint'] peer.init_with_bundle({ 'url': url, 'grpcOptions': ledger_grpc_options(peer_info['endpoint'].split(':')[0]), 'tlsCACerts': { 'path': tls_root_cert.name }, 'clientKey': { 'path': settings.LEDGER_PEER_TLS_CLIENT_KEY }, 'clientCert': { 'path': settings.LEDGER_PEER_TLS_CLIENT_CERT } }) client._peers[peer_info['mspid']] = peer # Load one orderer for broadcasting transaction orderer_mspid, orderer_info = list( discovery_results['config']['orderers'].items())[0] orderer = Orderer(name=orderer_mspid) with tempfile.NamedTemporaryFile() as tls_root_cert: tls_root_cert.write(tls_root_certs[orderer_mspid]) tls_root_cert.flush() # Need loop orderer.init_with_bundle({ 'url': f"{orderer_info[0]['host']}:{orderer_info[0]['port']}", 'grpcOptions': ledger_grpc_options(orderer_info[0]['host']), 'tlsCACerts': { 'path': tls_root_cert.name }, 'clientKey': { 'path': settings.LEDGER_PEER_TLS_CLIENT_KEY }, 'clientCert': { 'path': settings.LEDGER_PEER_TLS_CLIENT_CERT } }) client._orderers[orderer_mspid] = orderer
def update_cli(cli, orgs): for org in orgs: # add organization cli._organizations.update( {org['name']: create_org(org['name'], org, cli.state_store)}) # register users except rca boostrap admin for user_name in org['users'].keys(): org_user = org['users'][user_name] org_user_home = org_user['home'] org_user_msp_dir = os.path.join(org_user_home, 'msp') # register user user_cert_path = os.path.join(org_user_msp_dir, 'signcerts', 'cert.pem') user_key_path = os.path.join(org_user_msp_dir, 'keystore', 'key.pem') user = create_user(name=org_user['name'], org=org['name'], state_store=cli.state_store, msp_id=org['mspid'], cert_path=user_cert_path, key_path=user_key_path) cli._organizations[org['name']]._users.update( {org_user['name']: user}) # register orderer if 'orderers' in org: for o in org['orderers']: tls_orderer_client_dir = os.path.join( o['tls']['dir']['external'], o['tls']['client']['dir']) orderer = Orderer( o['name'], endpoint=f"{o['host']}:{o['port']['internal']}", tls_ca_cert_file=os.path.join(tls_orderer_client_dir, o['tls']['client']['ca']), client_cert_file=os.path.join(tls_orderer_client_dir, o['tls']['client']['cert']), client_key_file=os.path.join(tls_orderer_client_dir, o['tls']['client']['key']), ) cli._orderers.update({o['name']: orderer}) # register peers if 'peers' in org: for peer in org['peers']: tls_peer_client_dir = os.path.join( peer['tls']['dir']['external'], peer['tls']['client']['dir']) port = peer['port'][os.environ.get('ENV', 'external')] p = Peer( name=peer['name'], endpoint=f"{peer['host']}:{port}", tls_ca_cert_file=os.path.join(tls_peer_client_dir, peer['tls']['client']['ca']), client_cert_file=os.path.join( tls_peer_client_dir, peer['tls']['client']['cert']), client_key_file=os.path.join(tls_peer_client_dir, peer['tls']['client']['key'])) cli._peers.update({peer['name']: p}) # register system channel system_channel_name = org['misc']['system_channel_name'] if not cli.get_channel(system_channel_name): cli.new_channel(system_channel_name) return cli
def test_create_chain(self): # TODO impl chain = Chain() chain.add_peer(Peer()) chain.add_orderer(Orderer()) self.fail()
def build_join_channel_req(org, channel, client): """ For test, there is only one peer. Args: org: org channel: the channel to join client: client instance Return: return request for joining channel """ def block_event_callback(block): pass client._crypto_suite = ecies() all_ehs = [] request = {} tx_prop_req = TXProposalRequest() # add the orderer orderer_config = test_network['orderer'] endpoint = orderer_config['grpc_endpoint'] opts = (('grpc.ssl_target_name_override', orderer_config['server_hostname']),) ca_root_path = orderer_config['tls_cacerts'] with open(ca_root_path, 'rb') as f: pem = f.read() orderer = Orderer(endpoint=endpoint, pem=pem, opts=opts) channel.add_orderer(orderer) # get the genesis block orderer_admin = get_orderer_org_admin(client) tx_context = TXContext(orderer_admin, ecies(), tx_prop_req) client.tx_context = tx_context genesis_block = channel.get_genesis_block().SerializeToString() if not genesis_block: return None # create the peer org_admin = get_peer_org_user(client, org) client.tx_context = TXContext(org_admin, ecies(), tx_prop_req) peer_config = test_network[org]["peers"]['peer0'] ca_root = peer_config["tls_cacerts"] with open(ca_root, 'rb') as f: pem = f.read() peer = Peer(pem=pem, opts=None) # connect the peer eh = EventHub() event = peer_config['grpc_event_endpoint'] opts = {'pem': pem, 'hostname': peer_config['server_hostname']} tx_id = client.tx_context.tx_id eh.set_peer_addr(event) eh.connect() eh.register_block_event(block_event_callback) all_ehs.append(eh) request["targets"] = [peer] request["block"] = genesis_block request["tx_id"] = tx_id return request