def channel_create(self, orderer_name, channel_name, requestor, config_yaml, channel_profile): """ Create a channel, send request to orderer, and check the response :param orderer_name: Name of orderer to send request to :param channel_name: Name of channel to create :param requestor: Name of creator :param config_yaml: Directory path of config yaml to be set for FABRIC_ CFG_PATH variable :param channel_profile: Name of the channel profile defined inside config yaml file :return: True (creation succeeds) or False (creation failed) """ if self.get_channel(channel_name): _logger.warning("channel {} already existed when creating".format( channel_name)) return False orderer = self.get_orderer(orderer_name) if not orderer: _logger.error("No orderer_name instance found with name {}".format( orderer_name)) return False tx = self.generate_channel_tx(channel_name, config_yaml, channel_profile) if tx is None: _logger.error('Configtx is empty') return False _logger.info("Configtx file successfully created in current directory") with open(tx, 'rb') as f: envelope = f.read() config = utils.extract_channel_config(envelope) # convert envelope to config self.tx_context = TXContext(requestor, Ecies(), {}) tx_id = self.tx_context.tx_id nonce = self.tx_context.nonce signatures = [] org1_admin_signature = self.sign_channel_config(config) # append org1_admin_signature to signatures signatures.append(org1_admin_signature) request = { 'tx_id': tx_id, 'nonce': nonce, 'signatures': signatures, 'config': config, 'orderer': orderer, 'channel_name': channel_name } response = self._create_channel(request) if response[0].status == 200: self.new_channel(channel_name) return True else: return False
def test_string_to_signature(self): with open(self.channel_tx, 'rb') as f: channel_tx = f.read() channel_config = utils.extract_channel_config(channel_tx) client = Client() client.state_store = FileKeyValueStore(self.kv_store_path) orderer_org_admin = get_orderer_org_admin(client) orderer_org_admin_tx_context = \ TXContext(orderer_org_admin, Ecies(), {}) client.tx_context = orderer_org_admin_tx_context orderer_org_admin_signature = client.sign_channel_config( channel_config) orderer_org_admin_signature_bytes = \ orderer_org_admin_signature.SerializeToString() proto_signature = utils.string_to_signature( [orderer_org_admin_signature_bytes]) self.assertIsInstance(proto_signature, list) self.assertTrue( 'OrdererMSP' in proto_signature[0].signature_header.__str__())
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_extract_channel_config(self): with open(self.channel_tx, 'rb') as f: channel_tx = f.read() config_update = configtx_pb2.ConfigUpdate() channel_config = utils.extract_channel_config(channel_tx) self.assertTrue(hasattr(channel_config, 'decode')) config_update.ParseFromString(channel_config) self.assertEqual(config_update.channel_id, self.channel_id)
def channel_create(self, orderer_name, channel_name, requester, tx): """ Create a channel, send request to orderer, and check the response :param orderer_name: Name of orderer to send request to :param channel_name: Name of channel to create :param requester: Name of creator :param tx: Path to the new channel tx file :return: True (creation succeeds) or False (creation failed) """ if self.get_channel(channel_name): logging.warning("channel {} already existed when creating".format( channel_name)) return True orderer = self.get_orderer(orderer_name) if not orderer: logging.error("No orderer_name instance found with name {}".format( orderer_name)) return False with open(tx, 'rb') as f: envelope = f.read() config = extract_channel_config(envelope) # convert envelope to config self.tx_context = TXContext(requester, Ecies(), {}) tx_id = self.tx_context.tx_id nonce = self.tx_context.nonce signatures = [] org1_admin_signature = self.sign_channel_config(config) # append org1_admin_signature to signatures signatures.append(org1_admin_signature) request = { 'tx_id': tx_id, 'nonce': nonce, 'signatures': signatures, 'config': config, 'orderer': orderer, 'channel_name': channel_name } q = Queue(1) response = self._create_channel(request) response.subscribe(on_next=lambda x: q.put(x), on_error=lambda x: q.put(x)) status, _ = q.get(timeout=5) if status.status == 200: self.new_channel(channel_name) return True else: return False
def test_string_to_signature(self): with open(self.channel_tx, 'rb') as f: channel_tx = f.read() channel_config = utils.extract_channel_config(channel_tx) client = Client('test/fixtures/network.json') orderer_org_admin = get_orderer_org_user( state_store=client.state_store) orderer_org_admin_tx_context = \ TXContext(orderer_org_admin, Ecies(), {}) client.tx_context = orderer_org_admin_tx_context orderer_org_admin_signature = client.sign_channel_config( channel_config) proto_signature = utils.string_to_signature( [orderer_org_admin_signature]) self.assertIsInstance(proto_signature, list) self.assertTrue( 'OrdererMSP' in proto_signature[0].signature_header.__str__())
def create_channel(self, orderer_name, channel, creator, tx): """ Create a channel :param orderer_name: Name of orderer to send request to :param channel: Name of channel to create :param creator: Name of creator :param tx: Path to the new channel tx file :return: """ orderer = self.get_orderer(orderer_name) if not orderer: logging.error("No orderer_name instance found with name {}".format( orderer_name)) return None with open(tx, 'rb') as f: envelope = f.read() config = extract_channel_config(envelope) # convert envelope to config self.tx_context = TXContext(creator, Ecies(), {}) tx_id = self.tx_context.tx_id nonce = self.tx_context.nonce signatures = [] org1_admin_signature = self.sign_channel_config(config) # append org1_admin_signature to signatures signatures.append(org1_admin_signature) request = { 'tx_id': tx_id, 'nonce': nonce, 'signatures': signatures, 'config': config, 'orderer': orderer, 'channel_name': channel } return self._create_channel(request)
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)