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 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: {0}'.format(responses))
return responses
def query_info(self, requestor, channel_name, peer_names, decode=True):
"""
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
:param deocode: Decode the response payload
:return: A `BlockchainInfo` 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_info(tx_context, peers)
try:
if responses[0][0].response and decode:
chain_info = ledger_pb2.BlockchainInfo()
chain_info.ParseFromString(responses[0][0].response.payload)
_logger.debug('response status {}'.format(
responses[0][0].response.status))
return chain_info
return responses[0][0]
except Exception:
_logger.error("Failed to query info: {}", sys.exc_info()[0])
raise
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 channel_join(self, requestor, channel_name, peer_names, orderer_name):
"""
Join a channel.
Get genesis block from orderer, then send request to peer
:param requestor: 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:
_logger.warning(
"channel {} not existed when join".format(channel_name))
return False
orderer = self.get_orderer(orderer_name)
if not orderer:
_logger.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(requestor, 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 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)
sleep(5)
tx_context = create_tx_context(requestor,
ecies(),
TXProposalRequest())
tran_req = utils.build_tx_req(res)
response = utils.send_transaction(self.orderers, tran_req, tx_context)
sleep(5)
self.txid_for_test = tx_context_dep.tx_id # used only for query test
queue = Queue(1)
response.subscribe(
on_next=lambda x: queue.put(x),
on_error=lambda x: queue.put(x)
)
res, _ = queue.get(timeout=timeout)
_logger.debug(res)
return res.status == 200
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 test_query_installed_chaincodes_sucess(self):
self.invoke_chaincode()
tx_context = create_tx_context(self.org1_admin, ecies(),
TXProposalRequest())
response = self.channel.query_info(tx_context, [self.org1_peer])
self.assertEqual(response[0][0].response.status, 200)
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_query_chain_info(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self.invoke_chaincode())
tx_context = create_tx_context(self.org1_admin, ecies(),
TXProposalRequest())
responses, proposal, header = self.channel.query_info(
tx_context, [self.peer])
res = loop.run_until_complete(asyncio.gather(*responses))
self.assertEqual(res[0].response.status, 200)
def test_query_transaction_id_success(self):
tx_id = self.invoke_chaincode()
tx_context = create_tx_context(self.org1_admin, ecies(),
TXProposalRequest())
response = self.channel.query_transaction(tx_context, [self.org1_peer],
tx_id)
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[0][0][0].response.status, 200)
def query_channels(self, requestor, peer_names, request_channel='mychannel', timeout=10):
"""
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 request_channel: Name of the channel that the query sent to
:return: A `ChannelQueryResponse`
"""
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
response = Channel(request_channel, 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.ChannelQueryResponse()
query_trans.ParseFromString(res[0][0][0].response.payload)
for ch in query_trans.channels:
_logger.debug('channel id {}'.format(
ch.channel_id))
return query_trans
return response
except Exception:
_logger.error(
"Failed to query channel: {}", sys.exc_info()[0])
raise
def query_installed_chaincodes(self, requestor, peer_names, channel_name='mychannel', timeout=10):
"""
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 channel_name: Name of the channel to send query to
: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(channel_name, 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 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) # TODO: where should we add orderer?
# get the genesis block
orderer_admin = client.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()
org_admin = client.get_user(org, 'Admin')
tx_context = TXContext(org_admin, ecies(), tx_prop_req)
peer = client.get_peer('peer0.'+org)
"""
# 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],
"block": genesis_block,
"tx_context": tx_context,
"transient_map": {},
}
return request
def test_query_block_success(self):
block_hash = self.invoke_chaincode()
sleep(5)
tx_context = create_tx_context(self.org1_admin, ecies(),
TXProposalRequest())
response = self.channel.query_block_by_hash(tx_context,
[self.org1_peer],
block_hash)
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[0][0][0].response.status, 200)
def cc_invoke(self, args, cc_name, fcn, cc_version, queryonly=False):
"""
Invoke a chaincode method.
Parameters:
args JSON RPC serialized data used as the
sole parameter to invoke the chaincode
cc_name chaincode name
fcn chaincode function name to be invoked
cc_version chaincode version to be used
queryonly If the invocation does not result in ledger change,
queryonly should be set to True.
If the invocation does result in ledger change, it should
be set to False.
"""
if queryonly:
return self.cc_query(args, cc_name, fcn)
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))
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 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 test_query_transaction_id_success(self, timeout=30):
tx_id = self.invoke_chaincode()
tx_context = create_tx_context(self.org1_admin, ecies(),
TXProposalRequest())
starttime = int(time.time())
while int(time.time()) - starttime < timeout:
responses = self.channel.query_transaction(tx_context,
[self.org1_peer], tx_id)
if responses[0][0].response.status == 200:
break
logger.debug('Responses of query transaction:\n {}'.format(responses))
self.assertEqual(responses[0][0].response.status, 200)
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)
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 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_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 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 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 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_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
