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