async def chaincode_install(self):
"""
Test installing an example chaincode to peer
:return:
"""
logger.info("E2E: Chaincode install start")
cc = f'/var/hyperledger/production/chaincodes/{CC_NAME}.{CC_VERSION}'
# create packaged chaincode before for having same id
code_package = package_chaincode(CC_PATH, CC_TYPE_GOLANG)
orgs = ["org1.example.com", "org2.example.com"]
for org in orgs:
org_admin = self.client.get_user(org, "Admin")
node_info = self.network_info['peers']['peer0.' + org]
set_tls = self.client.set_tls_client_cert_and_key(
node_info['clientKey']['path'],
node_info['clientCert']['path']
)
self.assertTrue(set_tls)
responses = await self.client.chaincode_install(
requestor=org_admin,
peers=['peer0.' + org, 'peer1.' + org],
cc_path=CC_PATH,
cc_name=CC_NAME,
cc_version=CC_VERSION,
packaged_cc=code_package
)
self.assertTrue(responses)
# Verify the cc pack exists now in the peer node
dc = docker.from_env()
for peer in ['peer0', 'peer1']:
peer_container = dc.containers.get(peer + '.' + org)
code, output = peer_container.exec_run(f'test -f {cc}')
self.assertEqual(code, 0, "chaincodes pack not exists")
logger.info("E2E: chaincode install done")
def send_install_proposal(self, tx_context, peers=None):
"""Send install chaincode proposal
:param install_proposal_req: install proposal request
:param targets: a set of peer to send
:param tx_context: a tx_context instance
:param peers: peers (Default value = None)
:return: a set of proposal response
"""
if peers is None:
targets = self._peers.values()
else:
targets = peers
# self._validate_state() # TODO: enable this later
# self._validate_peers(targets) # TODO: enable this later
if not tx_context:
raise ValueError("InstallProposalRequest is null.")
cc_deployment_spec = chaincode_pb2.ChaincodeDeploymentSpec()
cc_deployment_spec.chaincode_spec.type = \
chaincode_pb2.ChaincodeSpec.Type.Value(
utils.proto_str(tx_context.tx_prop_req.cc_type))
cc_deployment_spec.chaincode_spec.chaincode_id.name = \
proto_str(tx_context.tx_prop_req.cc_name)
cc_deployment_spec.chaincode_spec.chaincode_id.path = \
proto_str(tx_context.tx_prop_req.cc_path)
cc_deployment_spec.chaincode_spec.chaincode_id.version = \
proto_str(tx_context.tx_prop_req.cc_version)
if not self._is_dev_mode:
if not tx_context.tx_prop_req.packaged_cc:
cc_deployment_spec.code_package = \
package_chaincode(
tx_context.tx_prop_req.cc_path,
tx_context.tx_prop_req.cc_type)
else:
cc_deployment_spec.code_package = \
tx_context.tx_prop_req.packaged_cc
channel_header_extension = proposal_pb2.ChaincodeHeaderExtension()
channel_header_extension.chaincode_id.name = \
proto_str("lscc")
channel_header = utils.build_channel_header(
common_pb2.ENDORSER_TRANSACTION,
tx_context.tx_id,
'',
utils.current_timestamp(),
tx_context.epoch,
channel_header_extension.SerializeToString()
)
header = utils.build_header(tx_context.identity,
channel_header,
tx_context.nonce)
cci_spec = chaincode_pb2.ChaincodeInvocationSpec()
cci_spec.chaincode_spec.type = \
chaincode_pb2.ChaincodeSpec.Type.Value(CC_TYPE_GOLANG)
cci_spec.chaincode_spec.chaincode_id.name = proto_str("lscc")
cci_spec.chaincode_spec.input.args.extend(
[proto_b(CC_INSTALL), cc_deployment_spec.SerializeToString()])
proposal = utils.build_cc_proposal(
cci_spec, header,
tx_context.tx_prop_req.transient_map)
signed_proposal = utils.sign_proposal(tx_context, proposal)
responses = [peer.send_proposal(signed_proposal)
for peer in targets]
return responses, proposal, header