async 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
"""
tx_prop_req = TXProposalRequest()
# add the orderer
orderer = client.get_orderer('orderer.example.com')
channel.add_orderer(orderer)
# get the genesis block
orderer_admin = client.get_user('orderer.example.com', 'Admin')
tx_context = TXContext(orderer_admin, orderer_admin.cryptoSuite,
tx_prop_req)
genesis_block = None
stream = orderer.get_genesis_block(tx_context, channel.name)
async for v in stream:
if v.block is None or v.block == '':
msg = "fail to get genesis block"
raise Exception(msg)
genesis_block = v.block
break
genesis_block = genesis_block.SerializeToString()
org_admin = client.get_user(org, 'Admin')
tx_context = TXContext(org_admin, org_admin.cryptoSuite, tx_prop_req)
peer = client.get_peer('peer0.' + org)
request = {
"targets": [peer],
"block": genesis_block,
"tx_context": tx_context,
"transient_map": {},
}
return request
def test_query_instantiated_chaincodes_sucess(self):
self.invoke_chaincode()
sleep(5)
tx_context = create_tx_context(self.org1_admin,
ecies(),
TXProposalRequest())
response = self.channel.query_instantiated_chaincodes(tx_context,
[self.org1_peer])
q = Queue(1)
response.subscribe(on_next=lambda x: q.put(x),
on_error=lambda x: q.put(x))
res = q.get(timeout=10)
logger.debug(res)
self.assertEqual(res[0][0][0].response.status, 200)
def query_block_by_txid(self,
requestor,
channel_name,
peer_names,
tx_id,
timeout=5):
"""
Queries block by tx id
:param requestor: User role who issue the request
:param channel_name: Name of channel to query
:param peer_names: Names of the peers to install
:param tx_id: Transaction ID
:return: A `BlockDecoder`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
channel = self.get_channel(channel_name)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
response = channel.query_block_by_txid(tx_context, peers, tx_id)
queue = Queue(1)
response.subscribe(on_next=lambda x: queue.put(x),
on_error=lambda x: queue.put(x))
try:
res = queue.get(timeout=timeout)
_logger.debug(res)
response = res[0][0][0]
if response.response:
_logger.debug('response status {}'.format(
response.response.status))
block = BlockDecoder().decode(response.response.payload)
_logger.debug('looking at block {}'.format(
block['header']['number']))
return block
return response
except Exception:
_logger.error("Failed to query block: {}", sys.exc_info()[0])
raise
def query_installed_chaincodes(self, requestor, peer_names, timeout=5):
"""
Queries installed chaincode, returns all chaincodes installed on a peer
:param requestor: User role who issue the request
:param peer_names: Names of the peers to query
:return: A `ChaincodeQueryResponse`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
request = create_tx_prop_req(prop_type=CC_QUERY,
fcn='getinstalledchaincodes',
cc_name='lscc',
cc_type=CC_TYPE_GOLANG,
args=[])
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
tx_context.tx_prop_req = request
response = Channel('businesschannel',
self).send_tx_proposal(tx_context, peers)
queue = Queue(1)
response.subscribe(on_next=lambda x: queue.put(x),
on_error=lambda x: queue.put(x))
try:
res = queue.get(timeout=timeout)
_logger.debug(res)
response = res[0][0][0]
if response.response:
query_trans = query_pb2.ChaincodeQueryResponse()
query_trans.ParseFromString(res[0][0][0].response.payload)
for cc in query_trans.chaincodes:
_logger.debug('cc name {}, version {}, path {}'.format(
cc.name, cc.version, cc.path))
return query_trans
return response
except Exception:
_logger.error("Failed to query installed chaincodes: {}",
sys.exc_info()[0])
raise
def test_query_transaction_id_success(self, timeout=30):
loop = asyncio.get_event_loop()
tx_id = loop.run_until_complete(self.invoke_chaincode())
tx_context = create_tx_context(self.org1_admin,
ecies(),
TXProposalRequest())
responses, proposal, header = self.channel.query_transaction(
tx_context,
[self.peer],
tx_id)
res = loop.run_until_complete(asyncio.gather(*responses))
logger.debug('Responses of query transaction:\n {}'.format(res))
self.assertEqual(res[0].response.status, 200)
def query_instantiated_chaincodes(self,
requestor,
channel_name,
peer_names,
timeout=5):
"""
Queries instantiated chaincode
:param requestor: User role who issue the request
:param channel_name: name of channel to query
:param peer_names: Names of the peers to query
:return: A `ChaincodeQueryResponse`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
channel = self.get_channel(channel_name)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
response = channel.query_instantiated_chaincodes(tx_context, peers)
queue = Queue(1)
response.subscribe(on_next=lambda x: queue.put(x),
on_error=lambda x: queue.put(x))
try:
res = queue.get(timeout=timeout)
_logger.debug(res)
response = res[0][0][0]
if response.response:
query_trans = query_pb2.ChaincodeQueryResponse()
query_trans.ParseFromString(res[0][0][0].response.payload)
for cc in query_trans.chaincodes:
_logger.debug('cc name {}, version {}, path {}'.format(
cc.name, cc.version, cc.path))
return query_trans
return response
except Exception:
_logger.error("Failed to query instantiated chaincodes: {}",
sys.exc_info()[0])
raise
def get_channel_config(self,
requestor,
channel_name,
peer_names,
decode=True):
"""
Get configuration block for the channel
:param requestor: User role who issue the request
:param channel_name: name of channel to query
:param peer_names: Names of the peers to query
:param deocode: Decode the response payload
:return: A `ChaincodeQueryResponse` or `ProposalResponse`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
channel = self.get_channel(channel_name)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
responses = channel.get_channel_config(tx_context, peers)
try:
if responses[0][0].response and decode:
_logger.debug('response status {}'.format(
responses[0][0].response.status))
block = common_pb2.Block()
block.ParseFromString(responses[0][0].response.payload)
envelope = common_pb2.Envelope()
envelope.ParseFromString(block.data.data[0])
payload = common_pb2.Payload()
payload.ParseFromString(envelope.payload)
config_envelope = configtx_pb2.ConfigEnvelope()
config_envelope.ParseFromString(payload.data)
return config_envelope
return responses[0][0]
except Exception:
_logger.error("Failed to get channel config block: {}",
sys.exc_info()[0])
raise
def query_transaction(self, requestor, channel_name,
peer_names, tx_id, timeout=5):
"""
Queries block by number
:param requestor: User role who issue the request
:param channel_name: name of channel to query
:param peer_names: Names of the peers to install
:param tx_id: The id of the transaction
:return: A `BlockDecoder`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
channel = self.get_channel(channel_name)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
response = channel.query_transaction(tx_context, peers, tx_id)
queue = Queue(1)
response.subscribe(
on_next=lambda x: queue.put(x),
on_error=lambda x: queue.put(x)
)
try:
res = queue.get(timeout=timeout)
response = res[0][0][0]
if response.response:
logging.debug('response status {}'.format(
response.response.status))
process_trans = BlockDecoder().decode_transaction(
response.response.payload)
return process_trans
return response
except Exception:
logging.error(
"Failed to query block: {}", sys.exc_info()[0])
raise
def query_info(self, requestor, channel_name,
peer_names, timeout=10):
"""
Queries information of a channel
:param requestor: User role who issue the request
:param channel_name: Name of channel to query
:param peer_names: Names of the peers to install
:return: A `BlockchainInfo`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
channel = self.get_channel(channel_name)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
response = channel.query_info(tx_context, peers)
queue = Queue(1)
response.subscribe(
on_next=lambda x: queue.put(x),
on_error=lambda x: queue.put(x)
)
try:
res = queue.get(timeout=timeout)
_logger.debug(res)
response = res[0][0][0]
if response.response:
chain_info = ledger_pb2.BlockchainInfo()
chain_info.ParseFromString(response.response.payload)
_logger.debug('response status {}'.format(
response.response.status))
return chain_info
return response
except Exception:
_logger.error(
"Failed to query info: {}", sys.exc_info()[0])
raise
def test_query_block_success(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self.invoke_chaincode())
orgs = ["org1.example.com"]
for org in orgs:
org_admin = self.client.get_user(org, "Admin")
channel = self.client.get_channel(self.channel_name)
tx_context = create_tx_context(org_admin, org_admin.cryptoSuite,
TXProposalRequest())
responses, p, h = channel.query_block(tx_context, [self.peer], '1')
res = loop.run_until_complete(asyncio.gather(*responses))
self.assertTrue(all([x.response.status == 200 for x in res]))
blocks = [BlockDecoder().decode(v.response.payload) for v in res]
self.assertEqual(blocks[0]['header']['number'], 1)
def _get_stream(self):
""" get the events of the channel.
Return: the events in success or None in fail.
"""
_logger.info("create peer delivery stream")
if self._signed_event is not None:
return self._peer.delivery(self._signed_event,
filtered=self._filtered)
seek_info = self._create_seek_info(self._start, self._stop)
kwargs = {}
if self._peer._client_cert_path:
with open(self._peer._client_cert_path, 'rb') as f:
b64der = pem_to_der(f.read())
kwargs['tls_cert_hash'] = sha256(b64der).digest()
tx_context = TXContext(self._requestor, self._requestor.cryptoSuite,
TXProposalRequest())
seek_info_header = build_channel_header(
common_pb2.HeaderType.Value('DELIVER_SEEK_INFO'),
tx_context.tx_id,
self._channel_name,
current_timestamp(),
tx_context.epoch,
**kwargs
)
seek_header = build_header(
tx_context.identity,
seek_info_header,
tx_context.nonce)
seek_payload_bytes = create_seek_payload(seek_header, seek_info)
sig = tx_context.sign(seek_payload_bytes)
envelope = create_envelope(sig, seek_payload_bytes)
# this is a stream response
return self._peer.delivery(envelope, filtered=self._filtered)
def query_transaction(self,
requestor,
channel_name,
peer_names,
tx_id,
decode=True):
"""
Queries block by number
:param requestor: User role who issue the request
:param channel_name: name of channel to query
:param peer_names: Names of the peers to install
:param tx_id: The id of the transaction
:param deocode: Decode the response payload
:return: A `BlockDecoder` or `ProposalResponse`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
channel = self.get_channel(channel_name)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
responses = channel.query_transaction(tx_context, peers, tx_id)
try:
if responses[0][0].response and decode:
_logger.debug('response status {}'.format(
responses[0][0].response.status))
process_trans = BlockDecoder().decode_transaction(
responses[0][0].response.payload)
return process_trans
return responses[0][0]
except Exception:
_logger.error("Failed to query block: {}", sys.exc_info()[0])
raise
def query_block(self,
requestor,
channel_name,
peer_names,
block_number,
decode=True):
"""
Queries block by number
:param requestor: User role who issue the request
:param channel_name: name of channel to query
:param peer_names: Names of the peers to install
:param block_number: Number of a block
:param deocode: Decode the response payload
:return: A `BlockDecoder` or `ProposalResponse`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
channel = self.get_channel(channel_name)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
responses = channel.query_block(tx_context, peers, block_number)
try:
if responses[0][0].response and decode:
_logger.debug('response status {}'.format(
responses[0][0].response.status))
block = BlockDecoder().decode(responses[0][0].response.payload)
_logger.debug('looking at block {}'.format(
block['header']['number']))
return block
return responses[0][0]
except Exception:
_logger.error("Failed to query block: {}", sys.exc_info()[0])
raise
def query_installed_chaincodes(self, requestor, peer_names, decode=True):
"""
Queries installed chaincode, returns all chaincodes installed on a peer
:param requestor: User role who issue the request
:param peer_names: Names of the peers to query
:param deocode: Decode the response payload
:return: A `ChaincodeQueryResponse` or `ProposalResponse`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
request = create_tx_prop_req(prop_type=CC_QUERY,
fcn='getinstalledchaincodes',
cc_name='lscc',
cc_type=CC_TYPE_GOLANG,
args=[])
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
tx_context.tx_prop_req = request
responses = Channel._send_tx_proposal('', tx_context, peers)
try:
if responses[0][0].response and decode:
query_trans = query_pb2.ChaincodeQueryResponse()
query_trans.ParseFromString(responses[0][0].response.payload)
for cc in query_trans.chaincodes:
_logger.debug('cc name {}, version {}, path {}'.format(
cc.name, cc.version, cc.path))
return query_trans
return responses[0][0]
except Exception:
_logger.error("Failed to query installed chaincodes: {}",
sys.exc_info()[0])
raise
def query_channels(self, requestor, peer_names, decode=True):
"""
Queries channel name joined by a peer
:param requestor: User role who issue the request
:param peer_names: Names of the peers to install
:param deocode: Decode the response payload
:return: A `ChannelQueryResponse` or `ProposalResponse`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
request = create_tx_prop_req(prop_type=CC_QUERY,
fcn='GetChannels',
cc_name='cscc',
cc_type=CC_TYPE_GOLANG,
args=[])
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
tx_context.tx_prop_req = request
responses = Channel._send_tx_proposal('', tx_context, peers)
try:
if responses[0][0].response and decode:
query_trans = query_pb2.ChannelQueryResponse()
query_trans.ParseFromString(responses[0][0].response.payload)
for ch in query_trans.channels:
_logger.debug('channel id {}'.format(ch.channel_id))
return query_trans
return responses[0][0]
except Exception:
_logger.error("Failed to query channel: {}", sys.exc_info()[0])
raise
def query_instantiated_chaincodes(self,
requestor,
channel_name,
peer_names,
decode=True):
"""
Queries instantiated chaincode
:param requestor: User role who issue the request
:param channel_name: name of channel to query
:param peer_names: Names of the peers to query
:param deocode: Decode the response payload
:return: A `ChaincodeQueryResponse` or `ProposalResponse`
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
channel = self.get_channel(channel_name)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
responses = channel.query_instantiated_chaincodes(tx_context, peers)
try:
if responses[0][0].response and decode:
query_trans = query_pb2.ChaincodeQueryResponse()
query_trans.ParseFromString(responses[0][0].response.payload)
for cc in query_trans.chaincodes:
_logger.debug('cc name {}, version {}, path {}'.format(
cc.name, cc.version, cc.path))
return query_trans
return responses[0][0]
except Exception:
_logger.error("Failed to query instantiated chaincodes: {}",
sys.exc_info()[0])
raise
def query_installed_chaincode(self, requestor, peer_names,
timeout=5, channel_name='businesschannel'):
"""
query installed chaincode
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
response = self.get_channel(
channel_name).query_installed_chaincodes(tx_context, peers)
queue = Queue(1)
response.subscribe(
on_next=lambda x: queue.put(x),
on_error=lambda x: queue.put(x)
)
res = queue.get(timeout=timeout)
return res[0][0][0].response.status == 200
def cc_invoke(self, args, cc_name, fcn, cc_version, queryonly=False):
loop = asyncio.get_event_loop()
crypto = ecies()
endorses = self._get_endorsers(queryonly)
tran_prop_req = create_tx_prop_req(prop_type=CC_INVOKE,
cc_type=CC_TYPE_GOLANG,
cc_name=cc_name,
fcn=fcn,
cc_version=cc_version,
args=args)
tx_context = create_tx_context(self.user, crypto, tran_prop_req)
responses, proposal, header = self.channel.send_tx_proposal(
tx_context, endorses.values())
res = loop.run_until_complete(asyncio.gather(*responses))
if queryonly:
return res
tran_req = build_tx_req((res, proposal, header))
tx_context_tx = create_tx_context(self.user, crypto,
TXProposalRequest())
responses = loop.run_until_complete(
base.get_stream_result(
send_transaction(self.client.orderers, tran_req,
tx_context_tx)))
logger.info('Tx response: {}'.format(responses))
return responses
def chaincode_instantiate(self,
requestor,
channel_name,
peer_names,
args,
cc_name,
cc_version,
timeout=10):
"""
Instantiate installed chaincode to particular peer in
particular channel
:param requestor: User role who issue the request
:param channel_name: the name of the channel to send tx proposal
:param peer_names: Names of the peers to install
:param args (list): arguments (keys and values) for initialization
:param cc_name: chaincode name
:param cc_version: chaincode version
:param timeout: Timeout to wait
:return: True or False
"""
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
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)
tx_context_dep = create_tx_context(requestor, ecies(),
tran_prop_req_dep)
res = self.send_instantiate_proposal(tx_context_dep, peers,
channel_name)
tx_context = create_tx_context(requestor, ecies(), TXProposalRequest())
tran_req = utils.build_tx_req(res)
responses = utils.send_transaction(self.orderers, tran_req, tx_context)
if not (tran_req.responses[0].response.status == 200
and responses[0].status == 200):
return False
# Wait until chaincode is really instantiated
# Note : we will remove this part when we have channel event hub
starttime = int(time.time())
while int(time.time()) - starttime < timeout:
try:
response = self.query_transaction(requestor=requestor,
channel_name=channel_name,
peer_names=peer_names,
tx_id=tx_context_dep.tx_id,
decode=False)
if response.response.status == 200:
return True
time.sleep(1)
except Exception:
time.sleep(1)
return False
def __cc_call(self, fcn, args, prop_type=CC_INVOKE):
"""Instantiate chaincode or invoke a cc function with args
Args:
fcn: Chaincode function name
args: Chaincode function arguments
prop_type: Proposal request type (defaults to CC_INVOKE)
Returns:
Chaincode response
None when prop_type is not valid
"""
tran_prop_req = create_tx_prop_req(
prop_type=prop_type,
cc_type=CC_TYPE_GOLANG,
cc_name=CC_NAME,
cc_version=CC_VERSION,
fcn=fcn,
args=args)
tx_ctx = create_tx_context(self.ixp_admin, self.crypto, tran_prop_req)
# invoke calls
if prop_type == CC_INVOKE:
# send standard invocation
res = self.channel.send_tx_proposal(tx_ctx, self.peers)
# query calls
elif prop_type == CC_QUERY:
response = self.channel.send_tx_proposal(tx_ctx, [self.peers[0]])
q = Queue(1)
response.subscribe(
on_next=lambda x: q.put(x), on_error=lambda x: q.put(x))
try:
res = q.get(timeout=DEFAULT_SLEEP)
logger.debug(res)
response = res[0][0][0]
if response.response:
pld = response.response.payload
logger.debug("Query Payload: %s", pld)
pld = json.loads(pld.decode('utf-8'))
return pld
return response
except Exception:
logger.error("Failed to query chaincode: {}", sys.exc_info()[0])
raise
# instantiate calls
elif prop_type == CC_INSTANTIATE:
# instantiate chaincode and wait for propagation
res = self.channel.send_instantiate_proposal(tx_ctx, [self.peers[0]])
time.sleep(LONGER_SLEEP)
# invalid call
else:
logger.error("Invalid proposal request type." + \
"Must be {} or {}.".format(CC_INVOKE, CC_INSTANTIATE))
return None
# send the transaction to the channel
tran_req = build_tx_req(res)
tx_2_ctx = create_tx_context(self.ixp_admin, self.crypto,
TXProposalRequest())
response = send_transaction(self.channel.orderers, tran_req, tx_2_ctx)
# wait for chaincode instantiation consensus
if prop_type == CC_INSTANTIATE:
time.sleep(LONGER_SLEEP)
# collect results
q = Queue(1)
response.subscribe(
on_next=lambda x: q.put(x), on_error=lambda x: q.put(x))
res, _ = q.get(timeout=DEFAULT_SLEEP)
return res
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)
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
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
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 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
async def _instantiate_or_upgrade(
self,
operation_name,
requestor,
channel_name,
peers,
cc_version,
cc_endorsement_policy=None,
fcn='init',
args=None,
transient_map=None,
collections_config=None,
wait_for_event=False,
wait_for_event_timeout=DEFAULT_WAIT_FOR_EVENT_TIMEOUT,
cc_type=CC_TYPE_GOLANG):
"""
Instantiate installed chaincode to particular peer in
particular channel
:param operation_name: CC_INSTANTIATE or CC_UPGRADE
:param requestor: User role who issue the request
:param channel_name: the name of the channel to send tx proposal
:param peers: List of peer name and/or Peer to install
:param cc_version: chaincode version
:param cc_endorsement_policy: chaincode endorsement policy
:param fcn: chaincode function to send
:param args (list): arguments (keys and values) for initialization
:param transient_map: transient map
:param collections_config: collection configuration
:param wait_for_event: Whether to wait for the event from each peer's
deliver filtered service signifying that the 'invoke' transaction has
been committed successfully
:param wait_for_event_timeout: Time to wait for the event from each
peer's deliver filtered service signifying that the 'invoke'
transaction has been committed successfully (default 30s)
:param cc_type: the language type of the chaincode
:return: chaincode data payload
"""
target_peers = self._client.get_target_peers(peers)
operation = self.operation_mapping[operation_name](fcn)
tran_prop_req_dep = create_tx_prop_req(
prop_type=operation.operation_type,
cc_type=cc_type,
cc_name=self._name,
cc_version=cc_version,
cc_endorsement_policy=cc_endorsement_policy,
fcn=operation.fcn,
args=args,
transient_map=transient_map,
collections_config=collections_config)
tx_context_dep = create_tx_context(requestor, requestor.cryptoSuite,
tran_prop_req_dep)
channel = self._client.get_channel(channel_name)
responses, proposal, header = operation.send_proposal(
tx_context_dep, target_peers, channel)
res = await asyncio.gather(*responses)
# if proposal was not good, return
if not all([x.response.status == SUCCESS_STATUS for x in res]):
raise RuntimeError(res[0].response.message)
tran_req = utils.build_tx_req((res, proposal, header))
tx_context = create_tx_context(requestor, requestor.cryptoSuite,
TXProposalRequest())
responses = utils.send_transaction(self._client.orderers, tran_req,
tx_context)
# responses will be a stream
async for v in responses:
if not v.status == SUCCESS_STATUS:
raise RuntimeError(v.message)
res = decode_proposal_response_payload(res[0].payload)
# wait for transaction id proposal available in ledger and block
# commited
if wait_for_event:
await self.wait_for_event(tx_context_dep, target_peers, channel,
requestor, None, wait_for_event_timeout)
ccd = ChaincodeData()
payload = res['extension']['response']['payload']
ccd.ParseFromString(payload)
cdsData = CDSData()
cdsData.ParseFromString(ccd.data)
policy = decode_signature_policy_envelope(
ccd.policy.SerializeToString())
instantiation_policy = decode_signature_policy_envelope(
ccd.instantiation_policy.SerializeToString())
chaincode = {
'name': ccd.name,
'version': ccd.version,
'escc': ccd.escc,
'vscc': ccd.vscc,
'policy': policy,
'data': {
'hash': cdsData.hash,
'metadatahash': cdsData.metadatahash,
},
'id': ccd.id,
'instantiation_policy': instantiation_policy,
}
return chaincode
def channel_join(self, requester, channel_name, peer_names, orderer_name):
"""
Join a channel.
Get genesis block from orderer, then send request to peer
:param requester: User to send the request
:param channel_name: Name of channel to create
:param peer_names: List of peers to join to the channel
:param orderer_name: Name of orderer to get genesis block from
:return: True (creation succeeds) or False (creation failed)
"""
channel = self.get_channel(channel_name)
if not channel:
logging.warning("channel {} not existed when join".format(
channel_name))
return False
orderer = self.get_orderer(orderer_name)
if not orderer:
logging.warning("orderer {} not existed when channel join".format(
orderer_name))
return False
tx_prop_req = TXProposalRequest()
# get the genesis block
orderer_admin = self.get_user('orderer.example.com', 'Admin')
tx_context = TXContext(orderer_admin, ecies(), tx_prop_req)
genesis_block = orderer.get_genesis_block(
tx_context,
channel.name).SerializeToString()
# create the peer
tx_context = TXContext(requester, ecies(), tx_prop_req)
peers = []
for peer_name in peer_names:
peer = self.get_peer(peer_name)
peers.append(peer)
"""
# 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": peers,
"block": genesis_block,
"tx_context": tx_context,
"transient_map": {}
}
return channel.join_channel(request)
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)
sleep(5)
# join channel
join_req = build_join_channel_req(org1, channel, self.client)
channel.join_channel(join_req)
sleep(5)
self.client.send_install_proposal(tx_context_in, [peer])
sleep(5)
# 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)
q = Queue(1)
response.subscribe(on_next=lambda x: q.put(x),
on_error=lambda x: q.put(x))
res, _ = q.get(timeout=20)
logger.debug(res)
self.assertEqual(res.status, 200)
