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_user(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_user(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 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 = net_config['orderer'] orderer = Orderer( endpoint=orderer_config['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 test_install_chaincode_success(self): """ Test a chaincode installation success. :return: """ opts = (('grpc.ssl_target_name_override', self.peer0_org1_tls_hostname), ) peer0_org1 = create_peer(endpoint=self.peer0_org1_endpoint, tls_cacerts=self.peer0_org1_tls_certs, opts=opts) org1_admin = get_peer_org_user('org1.example.com', "Admin", self.client.state_store) crypto = ecies() tran_prop_req = create_tx_prop_req(CC_INSTALL, CC_PATH, CC_TYPE_GOLANG, CC_NAME, CC_VERSION) tx_context = create_tx_context(org1_admin, crypto, tran_prop_req) queue = Queue(1) sleep(5) response = self.client.send_install_proposal(tx_context, [peer0_org1]) response.subscribe(on_next=lambda x: queue.put(x), on_error=lambda x: queue.put(x)) res = queue.get(timeout=5) proposal_response, _ = res[0][0] self.assertEqual(proposal_response.response.status, 200)
def test_instantiate_chaincode(self): channel = self.client.new_channel(self.channel_name) org1 = 'org1.example.com' peer_config = test_network['org1.example.com']['peers']['peer0'] tls_cacerts = peer_config['tls_cacerts'] opts = (('grpc.ssl_target_name_override', peer_config['server_hostname']), ) endpoint = peer_config['grpc_request_endpoint'] peer = create_peer(endpoint=endpoint, tls_cacerts=tls_cacerts, opts=opts) org1_admin = get_peer_org_user(org1, 'Admin', self.client.state_store) crypto = ecies() # for chain code install tran_prop_req_in = create_tx_prop_req(prop_type=CC_INSTALL, cc_path=CC_PATH, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION) # install chain code tx_context_in = create_tx_context(org1_admin, crypto, tran_prop_req_in) # for chain code deploy args = ['a', '100', 'b', '40'] tran_prop_req_dep = create_tx_prop_req(prop_type=CC_INSTANTIATE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION, args=args, fcn='init') # deploy the chain code tx_context_dep = create_tx_context(org1_admin, crypto, tran_prop_req_dep) # create a channel request = build_channel_request(self.client, self.channel_tx, self.channel_name) self.client._create_channel(request) # join channel join_req = build_join_channel_req(org1, channel, self.client) channel.join_channel(join_req) self.client.send_install_proposal(tx_context_in, [peer]) # send the transaction to the channel res = channel.send_instantiate_proposal(tx_context_dep, [peer]) tran_req = build_tx_req(res) tx_context = create_tx_context(org1_admin, crypto, TXProposalRequest()) response = send_transaction(channel.orderers, tran_req, tx_context) self.assertEqual(response[0].status, 200)
def test_instantiate_chaincode(self): peer_config = test_network['org1.example.com']['peers']['peer0'] tls_cacerts = peer_config['tls_cacerts'] endpoint = peer_config['grpc_request_endpoint'] opts = (('grpc.ssl_target_name_override', peer_config['server_hostname']), ) peer = create_peer(endpoint=endpoint, tls_cacerts=tls_cacerts, opts=opts) tran_prop_req_in = create_tx_prop_req(prop_type=CC_INSTALL, cc_path=CC_PATH, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION) args = ['a', '100', 'b', '40'] tran_prop_req_dep = create_tx_prop_req(prop_type=CC_INSTANTIATE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION, fcn='init', args=args) org1 = 'org1.example.com' crypto = ecies() org1_admin = get_peer_org_user(org1, 'Admin', self.client.state_store) tx_context_in = create_tx_context(org1_admin, crypto, tran_prop_req_in) request = build_channel_request(self.client, self.channel_tx, self.channel_name) res = self.client._create_channel(request) q = Queue(1) res.subscribe(on_next=lambda x: q.put(x), on_error=lambda x: q.put(x)) status, _ = q.get(timeout=5) if status.status == 200: logger.info("create channel successfully") time.sleep(5) channel = self.client.new_channel(self.channel_name) join_req = build_join_channel_req(org1, channel, self.client) channel.join_channel(join_req) res = self.client.send_install_proposal(tx_context_in, [peer]) res.subscribe(on_next=lambda x: q.put(x), on_error=lambda x: q.put(x)) status, _ = q.get(timeout=5)[0][0] if status.response.status == 200: logger.info("chaincode installed successfully") time.sleep(5) tx_context_dep = create_tx_context(org1_admin, crypto, tran_prop_req_dep) res = channel.send_instantiate_proposal(tx_context_dep, [peer]) assert (res)
async def upgrade_chaincode(self): org = 'org1.example.com' org_admin = get_peer_org_user(org, 'Admin', self.client.state_store) peers = ['peer0.' + org, 'peer1.' + org] # create a channel response = await self.client.channel_create( 'orderer.example.com', self.channel_name, org_admin, config_yaml=self.config_yaml, channel_profile=self.channel_profile) self.assertTrue(response) # join channel response = await self.client.channel_join( requestor=org_admin, channel_name=self.channel_name, peers=['peer0.' + org, 'peer1.' + org], orderer='orderer.example.com') self.assertTrue(response) instantiate_args = ['a', '200', 'b', '300'] query_args = ['b'] policy = s2d().parse("OR('Org1MSP.member')") chaincode = Chaincode(self.client, CC_NAME) res = await chaincode.install(org_admin, peers, CC_PATH, CC_VERSION) self.assertTrue(res) res = await chaincode.instantiate(org_admin, self.channel_name, peers, CC_VERSION, policy, args=instantiate_args, wait_for_event=True) self.assertTrue(res) res = await chaincode.query(org_admin, self.channel_name, peers, query_args) self.assertEqual(res, '300') res = await chaincode.install(org_admin, peers, CC_PATH, CC_UPGRADED_VERSION) self.assertTrue(res) res = await chaincode.upgrade(org_admin, self.channel_name, peers, CC_UPGRADED_VERSION, policy, args=instantiate_args, wait_for_event=True) self.assertTrue(res) res = await chaincode.query(org_admin, self.channel_name, peers, query_args) self.assertEqual(res, '300')
def test_invoke_chaincode_sucess(self): channel = self.client.new_channel(self.channel_name) org1 = "org1.example.com" peer_config = test_network['org1.example.com']['peers']['peer0'] tls_cacerts = peer_config['tls_cacerts'] opts = (('grpc.ssl_target_name_override', peer_config['server_hostname']), ) endpoint = peer_config['grpc_request_endpoint'] org1_peer = create_peer(endpoint=endpoint, tls_cacerts=tls_cacerts, opts=opts) org1_admin = get_peer_org_user(org1, "Admin", self.client.state_store) crypto = ecies() tran_prop_req_install = create_tx_prop_req(prop_type=CC_INSTALL, cc_path=CC_PATH, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION) tx_context_install = create_tx_context(org1_admin, crypto, tran_prop_req_install) args_dep = ['a', '200', 'b', '300'] tran_prop_req_dep = create_tx_prop_req(prop_type=CC_INSTANTIATE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION, args=args_dep, fcn='init') tx_context_dep = create_tx_context(org1_admin, crypto, tran_prop_req_dep) args = ['a', 'b', '100'] tran_prop_req = create_tx_prop_req(prop_type=CC_INVOKE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION, fcn='invoke', args=args) tx_context = create_tx_context(org1_admin, crypto, tran_prop_req) request = build_channel_request(self.client, self.channel_tx, self.channel_name) self.client._create_channel(request) sleep(5) join_req = build_join_channel_req(org1, channel, self.client) channel.join_channel(join_req) sleep(5) self.client.send_install_proposal(tx_context_install, [org1_peer]) sleep(5) res = channel.send_instantiate_proposal(tx_context_dep, [org1_peer]) sleep(5) tran_req = build_tx_req(res) send_transaction(channel.orderers, tran_req, tx_context) sleep(5) tx_context_tx = create_tx_context(org1_admin, crypto, TXProposalRequest()) res = channel.send_tx_proposal(tx_context, [org1_peer]) tran_req = build_tx_req(res) response = send_transaction(channel.orderers, tran_req, tx_context_tx) q = Queue(1) response.subscribe(on_next=lambda x: q.put(x), on_error=lambda x: q.put(x)) res, _ = q.get(timeout=5) self.assertEqual(res.status, 200)
async def invoke_chaincode(self): org1 = "org1.example.com" peer_config = test_network['org1.example.com']['peers']['peer0'] tls_cacerts = peer_config['tls_cacerts'] opts = (('grpc.ssl_target_name_override', peer_config['server_hostname']), ) endpoint = peer_config['grpc_request_endpoint'] self.peer = create_peer(endpoint=endpoint, tls_cacerts=tls_cacerts, opts=opts) self.org1_admin = get_peer_org_user(org1, "Admin", self.client.state_store) # channel create request = build_channel_request(self.client, self.channel_tx, self.channel_name) responses = await self.client._create_or_update_channel(request) self.assertTrue(all([x.status == 200 for x in responses])) self.channel = self.client.new_channel(self.channel_name) # join channel join_req = await build_join_channel_req(org1, self.channel, self.client) responses = self.channel.join_channel(join_req) res = await asyncio.gather(*responses) self.assertTrue(all([x.response.status == 200 for x in res])) # install tran_prop_req_install = create_tx_prop_req(prop_type=CC_INSTALL, cc_path=CC_PATH, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION) tx_context_install = create_tx_context(self.org1_admin, self.org1_admin.cryptoSuite, tran_prop_req_install) responses, proposal, header = self.client.send_install_proposal( tx_context_install, [self.peer]) await asyncio.gather(*responses) # instantiate args_dep = ['a', '200', 'b', '300'] tran_prop_req_dep = create_tx_prop_req(prop_type=CC_INSTANTIATE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION, args=args_dep, fcn='init') tx_context_dep = create_tx_context(self.org1_admin, self.org1_admin.cryptoSuite, tran_prop_req_dep) responses, proposal, header = self.channel.send_instantiate_proposal( tx_context_dep, [self.peer]) res = await asyncio.gather(*responses) tran_req = build_tx_req((res, proposal, header)) tx_context = create_tx_context(self.org1_admin, self.org1_admin.cryptoSuite, TXProposalRequest()) await get_stream_result( send_transaction(self.client.orderers, tran_req, tx_context)) # wait for event instantiate channel_event_hub = self.channel.newChannelEventHub( self.peer, self.org1_admin) stream = channel_event_hub.connect(filtered=False) channel_event_hub.registerTxEvent(tx_context_dep.tx_id, disconnect=True) try: await asyncio.wait_for(stream, timeout=30) except asyncio.TimeoutError: raise TimeoutError('waitForEvent timed out.') except Exception as e: if not isinstance(e, grpc._channel._Rendezvous) \ or not e.cancelled(): raise e finally: channel_event_hub.disconnect() # invoke part args = ['a', 'b', '100'] tran_prop_req = create_tx_prop_req(prop_type=CC_INVOKE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, fcn='invoke', args=args) tx_context = create_tx_context(self.org1_admin, self.org1_admin.cryptoSuite, tran_prop_req) responses, p, h = self.channel.send_tx_proposal( tx_context, [self.peer]) res = await asyncio.gather(*responses) tran_req = build_tx_req((res, p, h)) tx_context_tx = create_tx_context(self.org1_admin, self.org1_admin.cryptoSuite, tran_req) await get_stream_result( send_transaction(self.channel.orderers, tran_req, tx_context_tx)) # wait for chaincode events channel_event_hub = self.channel.newChannelEventHub( self.peer, self.org1_admin) stream = channel_event_hub.connect(filtered=False) self.evts = {} # with tx event # channel_event_hub.registerTxEvent(tx_context.tx_id, # unregister=True, disconnect=True, # onEvent=self.onTxEvent) # with chaincode event self.registerChaincodeEvent(tx_context.tx_id, CC_NAME, '^invoked*', channel_event_hub) try: await asyncio.wait_for(stream, timeout=30) except asyncio.TimeoutError: raise TimeoutError('waitForEvent timed out.') except Exception as e: if not isinstance(e, grpc._channel._Rendezvous) \ or not e.cancelled(): raise e finally: channel_event_hub.disconnect() return tx_context.tx_id
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_invoke_chaincode_sucess(self): loop = asyncio.get_event_loop() channel = self.client.new_channel(self.channel_name) org1 = "org1.example.com" peer_config = test_network['org1.example.com']['peers']['peer0'] tls_cacerts = peer_config['tls_cacerts'] opts = (('grpc.ssl_target_name_override', peer_config['server_hostname']), ) endpoint = peer_config['grpc_request_endpoint'] org1_peer = create_peer(endpoint=endpoint, tls_cacerts=tls_cacerts, opts=opts) org1_admin = get_peer_org_user(org1, "Admin", self.client.state_store) crypto = ecies() tran_prop_req_install = create_tx_prop_req(prop_type=CC_INSTALL, cc_path=CC_PATH, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION) tx_context_install = create_tx_context(org1_admin, crypto, tran_prop_req_install) args_dep = ['a', '200', 'b', '300'] tran_prop_req_dep = create_tx_prop_req(prop_type=CC_INSTANTIATE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION, args=args_dep, fcn='init') tx_context_dep = create_tx_context(org1_admin, crypto, tran_prop_req_dep) args = ['a', 'b', '100'] tran_prop_req = create_tx_prop_req(prop_type=CC_INVOKE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, fcn='invoke', args=args) tx_context = create_tx_context(org1_admin, crypto, tran_prop_req) request = build_channel_request(self.client, self.channel_tx, self.channel_name) loop.run_until_complete(self.client._create_or_update_channel(request)) join_req = loop.run_until_complete( build_join_channel_req(org1, channel, self.client)) responses = channel.join_channel(join_req) res = loop.run_until_complete(asyncio.gather(*responses)) self.assertTrue(all([x.response.status == 200 for x in res])) responses, proposal, header = self.client.send_install_proposal( tx_context_install, [org1_peer]) loop.run_until_complete(asyncio.gather(*responses)) responses, proposal, header = channel.send_instantiate_proposal( tx_context_dep, [org1_peer]) res = loop.run_until_complete(asyncio.gather(*responses)) tran_req = build_tx_req((res, proposal, header)) send_transaction(channel.orderers, tran_req, tx_context) loop.run_until_complete( get_stream_result( send_transaction(channel.orderers, tran_req, tx_context))) tx_context_tx = create_tx_context(org1_admin, crypto, TXProposalRequest()) responses, proposal, header = channel.send_tx_proposal( tx_context, [org1_peer]) res = loop.run_until_complete(asyncio.gather(*responses)) tran_req = build_tx_req((res, proposal, header)) responses = loop.run_until_complete( get_stream_result( send_transaction(channel.orderers, tran_req, tx_context_tx))) self.assertTrue(all([x.status == 200 for x in responses]))
def invoke_chaincode(self): self.channel = self.client.new_channel(self.channel_name) org1 = "org1.example.com" peer_config = test_network['org1.example.com']['peers']['peer0'] tls_cacerts = peer_config['tls_cacerts'] opts = (('grpc.ssl_target_name_override', peer_config['server_hostname']), ) endpoint = peer_config['grpc_request_endpoint'] self.org1_peer = create_peer(endpoint=endpoint, tls_cacerts=tls_cacerts, opts=opts) self.org1_admin = get_peer_org_user(org1, "Admin", self.client.state_store) crypto = ecies() tran_prop_req_install = create_tx_prop_req(prop_type=CC_INSTALL, cc_path=CC_PATH, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION) tx_context_install = create_tx_context(self.org1_admin, crypto, tran_prop_req_install) args_dep = ['a', '200', 'b', '300'] tran_prop_req_dep = create_tx_prop_req(prop_type=CC_INSTANTIATE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION, args=args_dep, fcn='init') tx_context_dep = create_tx_context(self.org1_admin, crypto, tran_prop_req_dep) args = ['a', 'b', '100'] tran_prop_req = create_tx_prop_req(prop_type=CC_INVOKE, cc_type=CC_TYPE_GOLANG, cc_name=CC_NAME, cc_version=CC_VERSION, fcn='invoke', args=args) tx_context = create_tx_context(self.org1_admin, crypto, tran_prop_req) request = build_channel_request(self.client, self.channel_tx, self.channel_name) self.client._create_channel(request) join_req = build_join_channel_req(org1, self.channel, self.client) self.channel.join_channel(join_req) self.client.send_install_proposal(tx_context_install, [self.org1_peer]) res = self.channel.send_instantiate_proposal(tx_context_dep, [self.org1_peer]) tran_req = build_tx_req(res) send_transaction(self.channel.orderers, tran_req, tx_context) tx_context_tx = create_tx_context(self.org1_admin, crypto, TXProposalRequest()) res = self.channel.send_tx_proposal(tx_context, [self.org1_peer]) tran_req = build_tx_req(res) res = send_transaction(self.channel.orderers, tran_req, tx_context_tx) tx_id = tx_context_dep.tx_id return tx_id
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 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