def step_impl(context, userName, anchorSetName): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) nodeAdminTuples = [directory.findNodeAdminTuple(row['User'], row['Peer'], row['Organization']) for row in context.table.rows] user.setTagValue(anchorSetName, bootstrap_util.getAnchorPeersConfigGroup(context=context, nodeAdminTuples=nodeAdminTuples))
def step_impl(context, userName, create_channel_config_update_name, consortium_name): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) consortium_config_group = user.getTagValue(tagKey=consortium_name) peer_org_set = user.getTagValue(tagKey=context.table.rows[0]["PeerOrgSet"]) peer_anchor_set_tag_key = context.table.rows[0]["[PeerAnchorSet]"] peer_anchor_config_group = None if peer_anchor_set_tag_key != "": peer_anchor_config_group = user.getTagValue(tagKey=peer_anchor_set_tag_key) channel_id = context.table.rows[0]["ChannelID"] # Loop through templates referenced orgs # mspOrgNames = [org.name for org in user.tags[templateName]] # TODO: Where does the system_channel_version come from? system_channel_version = 0 channel_config_update = bootstrap_util.create_channel_config_update(system_channel_version, channel_id, consortium_config_group) # Add the anchors config group if peer_anchor_config_group: bootstrap_util.merge_config_groups(channel_config_update.write_set, peer_anchor_config_group) # Make sure orgs exist in consortium for orgName in peer_org_set: assert orgName in channel_config_update.write_set.groups[ 'Application'].groups.keys(), "PeerOrgSet entry {0} not found in consortium".format(orgName) # Strip out any organizations that are NOT referenced in peerOrgSet for orgName in channel_config_update.write_set.groups['Application'].groups.keys(): if not orgName in peer_org_set: del (channel_config_update.read_set.groups['Application'].groups[orgName]) del (channel_config_update.write_set.groups['Application'].groups[orgName]) user.setTagValue(create_channel_config_update_name, channel_config_update)
def step_impl(context, userName, createChannelSignedConfigEnvelope): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) muralisRequiredSignedConfigItems = [] channelID = context.table.rows[0]["ChannelID"] chainCreationPolicyName = context.table.rows[0][ "Chain Creation Policy Name"] # Intermediate step until template tool is ready signedConfigItems = bootstrap_util.createSignedConfigItems( context, channelID, "solo", signedConfigItems=muralisRequiredSignedConfigItems) #NOTE: Conidered passing signing key for appDeveloper, but decided that the peer org signatures they need to collect subsequently should be proper way signedConfigEnvelope = bootstrap_util.signInitialChainConfig( signedConfigItems=signedConfigItems, chainId=channelID, chainCreationPolicyName=chainCreationPolicyName) user.tags[createChannelSignedConfigEnvelope] = ChannelCreationInfo( channelID, chainCreationPolicyName, signedConfigEnvelope)
def step_impl(context, userName, createChannelSignedConfigEnvelope): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) channelID = context.table.rows[0]["ChannelID"] chainCreationPolicyName = context.table.rows[0][ "Chain Creation Policy Name"] templateName = context.table.rows[0]["Template"] # Loop through templates referenced orgs mspOrgNames = [org.name for org in user.tags[templateName]] signedMspConfigItems = bootstrap_util.getSignedMSPConfigItems( context=context, orgNames=mspOrgNames) # Add the anchors signed config Items anchorSignedConfigItemsName = context.table.rows[0]["Anchors"] signedAnchorsConfigItems = user.tags[anchorSignedConfigItemsName] # Intermediate step until template tool is ready channel_config_groups = bootstrap_util.createSignedConfigItems( directory, configGroups=signedMspConfigItems + signedAnchorsConfigItems) # bootstrap_util.setMetaPolicy(channelId=channelID, channgel_config_groups=channgel_config_groups) #NOTE: Conidered passing signing key for appDeveloper, but decided that the peer org signatures they need to collect subsequently should be proper way config_update_envelope = bootstrap_util.createConfigUpdateEnvelope( channelConfigGroup=channel_config_groups, chainId=channelID, chainCreationPolicyName=chainCreationPolicyName) user.setTagValue(createChannelSignedConfigEnvelope, config_update_envelope)
def step_impl(context, userName, proposalResponseName, proposalResponseResultCode): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) proposalResponse = user.tags[proposalResponseName] print("ProposalResponse: \n{0}\n".format(proposalResponse)) print("") raise NotImplementedError(u'STEP: Then user "dev0Org0" expects result code for "joinChannelResult" of "200"')
def step_impl(context, userName, chaincodeInvocationSpecName, templateSpecName): directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName) args = bootstrap_util.getArgsFromContextForUser(context, userName) template_chaincode_spec = user.tags[templateSpecName] cc_invocation_spec = endorser_util.getChaincodeSpecUsingTemplate(template_chaincode_spec=template_chaincode_spec, args=bdd_grpc_util.toStringArray(args)) user.setTagValue(chaincodeInvocationSpecName, cc_invocation_spec)
def step_impl(context, ordererSystemChainIdName, mspConfigItemsName): assert 'table' in context, "Expected table of policy names" directory = bootstrap_util.getDirectory(context) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) ordererSystemChainIdGUUID = ordererBootstrapAdmin.tags[ordererSystemChainIdName] mspSignedConfigItems = bootstrap_util.getMspConfigItemsForPolicyNames(context, chainId=ordererSystemChainIdGUUID, policyNames=[row['PolicyName'] for row in context.table.rows]) ordererBootstrapAdmin.tags[mspConfigItemsName] = mspSignedConfigItems
def step_impl(context, user_name, cert_alias, org_name, channel_id, compose_service): directory = bootstrap_util.getDirectory(context) requesting_config_admin = directory.getUser(userName=user_name) requesting_config_admin_nat = requesting_config_admin.tags[cert_alias] signing_nats = [directory.getUser(row['User']).getTagValue(row['Cert Alias']) for row in context.table.rows] bootstrap_util.add_org_to_channel(context, directory, requesting_config_admin_nat, signing_nats, directory.getOrganization(org_name), channel_id)
def step_impl(context, user_name, function, alias_target, alias_result): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=user_name) target = user.getTagValue(alias_target) result = None exec ('result = target.{0}'.format(function)) user.setTagValue(tagKey=alias_result, tagValue=result)
def step_impl(context, userName, transactionAlias, proposalAlias, proposalResponseAlias, channelId): directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName) proposalResponsesDict = user.tags[proposalResponseAlias] proposal = user.tags[proposalAlias] signedTx = endorser_util.createSignedTx(user, proposal, proposalResponsesDict.values()) user.setTagValue(transactionAlias, signedTx)
def step_impl(context, userName, certAlias, proposalAlias, ccSpecAlias): channelName = "" directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName=userName) assert ccSpecAlias in user.tags, "ChaincodeSpec alias '{0}' not found for user '{1}'".format( ccSpecAlias, userName) ccSpec = user.tags[ccSpecAlias] ccDeploymentSpec = endorser_util.createDeploymentSpec(context=context, ccSpec=ccSpec) lcChaincodeSpec = endorser_util.createInstallChaincodeSpecForBDD( ccDeploymentSpec=ccDeploymentSpec, chainID=str(channelName)) # Find the cert using the cert tuple information saved for the user under certAlias nodeAdminTuple = user.tags[certAlias] signersCert = directory.findCertForNodeAdminTuple(nodeAdminTuple) mspID = nodeAdminTuple.organization proposal = endorser_util.createInvokeProposalForBDD( context, ccSpec=lcChaincodeSpec, chainID=channelName, signersCert=signersCert, Mspid=mspID, type="ENDORSER_TRANSACTION") signedProposal = endorser_util.signProposal(proposal=proposal, entity=user, signersCert=signersCert) # proposal = endorser_util.createDeploymentProposalForBDD(ccDeploymentSpec) assert not proposalAlias in user.tags, "Proposal alias '{0}' already exists for '{1}'".format( proposalAlias, userName) user.setTagValue(proposalAlias, signedProposal)
def __init__(self, contextHelper, scenario): self.contextHelper = contextHelper self.directory = getDirectory(contextHelper.context) self.output = StringIO() self.currentStep = 0 self.composition = None #Weave advices into contextHelper weave(target=self.contextHelper.before_step, advices=self.beforeStepAdvice) weave(target=self.contextHelper.after_step, advices=self.afterStepAdvice) weave(target=self.contextHelper.after_scenario, advices=self.afterScenarioAdvice) weave(target=self.contextHelper.getBootrapHelper, advices=self.getBootstrapHelperAdvice) weave(target=self.contextHelper.registerComposition, advices=self.registerCompositionAdvice) # Weave advices into Directory weave(target=self.directory._registerOrg, advices=self.registerOrgAdvice) weave(target=self.directory._registerUser, advices=self.registerUserAdvice) weave(target=self.directory.registerOrdererAdminTuple, advices=self.registerNamedNodeAdminTupleAdvice)
def step_impl(context, userName, create_channel_config_update_name, consortium_name): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) consortium_config_group = user.getTagValue(tagKey=consortium_name) peer_org_set = user.getTagValue(tagKey=context.table.rows[0]["PeerOrgSet"]) peer_anchor_set_tag_key = context.table.rows[0]["[PeerAnchorSet]"] peer_anchor_config_group = None if peer_anchor_set_tag_key != "": peer_anchor_config_group = user.getTagValue(tagKey=peer_anchor_set_tag_key) channel_id = context.table.rows[0]["ChannelID"] # Loop through templates referenced orgs # mspOrgNames = [org.name for org in user.tags[templateName]] #TODO: Where does the system_channel_version come from? system_channel_version = 0 channel_config_update = bootstrap_util.create_channel_config_update(system_channel_version, channel_id, consortium_config_group) # Add the anchors config group if peer_anchor_config_group: bootstrap_util.mergeConfigGroups(channel_config_update.write_set, peer_anchor_config_group) #Make sure orgs exist in consortium for orgName in peer_org_set: assert orgName in channel_config_update.write_set.groups['Application'].groups.keys(), "PeerOrgSet entry {0} not found in consortium".format(orgName) # Strip out any organizations that are NOT referenced in peerOrgSet for orgName in channel_config_update.write_set.groups['Application'].groups.keys(): if not orgName in peer_org_set: del(channel_config_update.read_set.groups['Application'].groups[orgName]) del(channel_config_update.write_set.groups['Application'].groups[orgName]) user.setTagValue(create_channel_config_update_name, channel_config_update)
def step_impl(context): assert 'table' in context, "Expected table with triplet of Developer/ChainCreationPolicyName/Organization" directory = bootstrap_util.getDirectory(context) for row in context.table.rows: directory.registerOrdererAdminTuple(row['Developer'], row['ChainCreationPolicyName'], row['Organization'])
def step_impl(context, userName, configUpdateEnvelopeName, configUpdateName): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) config_update_envelope = bootstrap_util.create_config_update_envelope( config_update=user.getTagValue(configUpdateName)) user.setTagValue(tagKey=configUpdateEnvelopeName, tagValue=config_update_envelope)
def step_impl(context, certAlias, ordererGenesisBlockName, ordererSystemChainIdName, composeFile, consensusType, consortiumsModPolicy): directory = bootstrap_util.getDirectory(context=context) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) ordererSystemChainIdGUUID = ordererBootstrapAdmin.tags[ordererSystemChainIdName] # Now collect the named signed config items configGroups =[bootstrap_util.getDefaultConsortiumGroup(consortiumsModPolicy)] for row in context.table.rows: configGroupName = row['Consortium'] configGroups += ordererBootstrapAdmin.tags[configGroupName] # Concatenate signedConfigItems service_names = compose.Composition(context, composeFilesYaml=composeFile, register_and_up=False).getServiceNames() # Construct block nodeAdminTuple = ordererBootstrapAdmin.tags[certAlias] bootstrapCert = directory.findCertForNodeAdminTuple(nodeAdminTuple=nodeAdminTuple) (genesisBlock, envelope, genesis_block_channel_config) = bootstrap_util.createGenesisBlock(context=context, service_names=service_names, chainId=ordererSystemChainIdGUUID, consensusType=consensusType, nodeAdminTuple=nodeAdminTuple, signedConfigItems=configGroups) ordererBootstrapAdmin.setTagValue(ordererGenesisBlockName + "_genesis_channel_config", genesis_block_channel_config) ordererBootstrapAdmin.setTagValue(ordererGenesisBlockName, genesisBlock) ordererBootstrapAdmin.setTagValue("ConsensusType", consensusType) bootstrap_util.OrdererGensisBlockCompositionCallback(context, genesisBlock) bootstrap_util.PeerCompositionCallback(context)
def step_impl(context, userName, latest_config_name, service_name, channel_id_name): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) streamHelper = user.getDelivererStreamHelper(context, service_name) latest_config_block = bootstrap_util.get_latest_configuration_block(deliverer_stream_helper=streamHelper, channel_id=user.getTagValue(channel_id_name)) channel_group = bootstrap_util.get_channel_group_from_config_block(latest_config_block) user.setTagValue(tagKey=latest_config_name, tagValue=channel_group)
def step_impl(context, userName, certAlias, composeService, port): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) user.connectToDeliverFunction(context, composeService, nodeAdminTuple=user.tags[certAlias], port=port)
def step_impl(context, user_name, existing_channel_config_update_name, input_config_update_name): directory = bootstrap_util.getDirectory(context) user = directory.getUser(user_name) input_config_update = user.getTagValue(tagKey=input_config_update_name) channel_id = context.table.rows[0]["ChannelID"] peer_anchor_set_tag_key = context.table.rows[0]["[PeerAnchorSet]"] peer_anchor_config_group = None if peer_anchor_set_tag_key != "": peer_anchor_config_group = user.getTagValue( tagKey=peer_anchor_set_tag_key) assert peer_anchor_config_group != None, "Required to specify a PeerAnchorSet for now" #TODO: Where does the system_channel_version come from? system_channel_version = 0 channel_config_update = bootstrap_util.create_existing_channel_config_update( system_channel_version=system_channel_version, channel_id=channel_id, input_config_update=input_config_update, config_groups=[peer_anchor_config_group]) user.setTagValue(existing_channel_config_update_name, channel_config_update)
def step_impl(context, userName, certAlias, proposalAlias, timeout, proposalResponsesAlias): assert 'table' in context, "Expected table of endorsers" directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName=userName) assert proposalAlias in user.tags, "Proposal alias '{0}' not found for user '{1}'".format( proposalAlias, userName) signedProposal = user.tags[proposalAlias] # Send proposal to each specified endorser, waiting 'timeout' seconds for response/error endorsers = [row['Endorser'] for row in context.table.rows] nodeAdminTuple = user.tags[certAlias] endorserStubs = endorser_util.getEndorserStubs( context, composeServices=endorsers, directory=directory, nodeAdminTuple=nodeAdminTuple) proposalResponseFutures = [ endorserStub.ProcessProposal.future(signedProposal, int(timeout)) for endorserStub in endorserStubs ] resultsDict = dict( zip(endorsers, [respFuture.result() for respFuture in proposalResponseFutures])) user.setTagValue(proposalResponsesAlias, resultsDict)
def step_impl(context, user_name, serialized_identity_name, cert_alias): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=user_name) nat = user.getTagValue(cert_alias) signers_cert = directory.findCertForNodeAdminTuple(nat) serialized_identity = endorser_util.create_serialized_identity(msp_id=nat.organization, signers_cert=signers_cert) user.setTagValue(tagKey=serialized_identity_name, tagValue=serialized_identity)
def step_impl(context, certAlias, ordererGenesisBlockName, ordererSystemChainIdName, networkConfigPolicy, consensusType): directory = bootstrap_util.getDirectory(context=context) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) ordererSystemChainIdGUUID = ordererBootstrapAdmin.tags[ ordererSystemChainIdName] # Now collect the named signed config items configGroups = [] for row in context.table.rows: configGroupName = row['ConfigGroup Names'] configGroups += ordererBootstrapAdmin.tags[configGroupName] # Concatenate signedConfigItems # Construct block nodeAdminTuple = ordererBootstrapAdmin.tags[certAlias] bootstrapCert = directory.findCertForNodeAdminTuple( nodeAdminTuple=nodeAdminTuple) (genesisBlock, envelope) = bootstrap_util.createGenesisBlock( context, ordererSystemChainIdGUUID, consensusType, nodeAdminTuple=nodeAdminTuple, signedConfigItems=configGroups) ordererBootstrapAdmin.setTagValue(ordererGenesisBlockName, genesisBlock) bootstrap_util.OrdererGensisBlockCompositionCallback(context, genesisBlock) bootstrap_util.PeerCompositionCallback(context)
def step_impl(context, userName, proposalResponseName, proposalResponseResultCode): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) peerToProposalResponseDict = user.tags[proposalResponseName] unexpectedResponses = [(composeService,proposalResponse) for composeService, proposalResponse in peerToProposalResponseDict.items() if proposalResponse.response.payload != proposalResponseResultCode] print("ProposalResponse: \n{0}\n".format(proposalResponse)) print("")
def step_impl(context, userName, certAlias, genisisBlockName, joinChannelResult): timeout = 10 directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) # Find the cert using the cert tuple information saved for the user under certAlias signersCert = directory.findCertForNodeAdminTuple(user.tags[certAlias]) # Retrieve the genesis block from the returned value of deliver (Will be list with first block as genesis block) genesisBlock = user.tags[genisisBlockName][0] ccSpec = endorser_util.getChaincodeSpec( "GOLANG", "", "cscc", ["JoinChain", genesisBlock.SerializeToString()]) proposal = endorser_util.createInvokeProposalForBDD( ccSpec=ccSpec, chainID="", signersCert=signersCert, Mspid="DEFAULT", type="CONFIGURATION_TRANSACTION") signedProposal = endorser_util.signProposal(proposal=proposal, entity=user, signersCert=signersCert) # Send proposal to each specified endorser, waiting 'timeout' seconds for response/error endorsers = [row['Peer'] for row in context.table.rows] proposalResponseFutures = [ endorserStub.ProcessProposal.future(signedProposal, int(timeout)) for endorserStub in endorser_util.getEndorserStubs(context, endorsers) ] resultsDict = dict( zip(endorsers, [respFuture.result() for respFuture in proposalResponseFutures])) user.tags[joinChannelResult] = resultsDict
def getEnv(self, composition, context, env): directory = getDirectory(context) for composer_service in self.getComposerList(composition): (orderer_trusted_roots, peer_trusted_roots) = self.getTrustedRootsPaths( project_name=composition.projectName, composer_service=composer_service, pathType=PathType.Container) keyValStorePath = self.getKeyValStorePath( project_name=composition.projectName, composer_service=composer_service, pathType=PathType.Container) (owning_org_name, peer_compose_services) = get_peers_for_composer_service( directory=directory, composer_service=composer_service) connectionProfileDict = self.getConnectionProfile( ordererCertPath=orderer_trusted_roots, peerCertPath=peer_trusted_roots, key_val_store_path=keyValStorePath, orderer_compose_services=['orderer0'], peer_compose_services=peer_compose_services, msp_id=owning_org_name) env["{0}_COMPOSER_CONFIG".format( composer_service.upper())] = json.dumps(connectionProfileDict, separators=(',', ':')) keyValStorePath = self.getKeyValStorePath( project_name=composition.projectName, composer_service=composer_service, pathType=PathType.Local) env["{0}_PATH_TO_HFC".format( composer_service.upper())] = keyValStorePath
def step_impl(context, userName, createChannelSignedConfigEnvelope): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) channelID = context.table.rows[0]["ChannelID"] chainCreationPolicyName = context.table.rows[0]["Chain Creation Policy Name"] templateName = context.table.rows[0]["Template"] # Loop through templates referenced orgs mspOrgNames = [org.name for org in user.tags[templateName]] signedMspConfigItems = bootstrap_util.getSignedMSPConfigItems(context=context, orgNames=mspOrgNames) # Add the anchors signed config Items anchorSignedConfigItemsName = context.table.rows[0]["Anchors"] signedAnchorsConfigItems = user.tags[anchorSignedConfigItemsName] # Intermediate step until template tool is ready consensus_type = ordererBootstrapAdmin.tags["ConsensusType"] channel_config_groups = bootstrap_util.createSignedConfigItems(directory=directory, consensus_type=consensus_type, configGroups=signedMspConfigItems + signedAnchorsConfigItems) # bootstrap_util.setMetaPolicy(channelId=channelID, channgel_config_groups=channgel_config_groups) #NOTE: Conidered passing signing key for appDeveloper, but decided that the peer org signatures they need to collect subsequently should be proper way config_update_envelope = bootstrap_util.createConfigUpdateEnvelope(channelConfigGroup=channel_config_groups, chainId=channelID, chainCreationPolicyName=chainCreationPolicyName) user.setTagValue(createChannelSignedConfigEnvelope, config_update_envelope)
def step_impl(context, ordererSystemChainIdName, mspConfigItemsName): assert 'table' in context, "Expected table of policy names" directory = bootstrap_util.getDirectory(context) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) ordererSystemChainIdGUUID = ordererBootstrapAdmin.tags[ordererSystemChainIdName] mspSignedConfigItems = bootstrap_util.getMspConfigItemsForPolicyNames(context, policyNames=[row['PolicyName'] for row in context.table.rows]) ordererBootstrapAdmin.setTagValue(mspConfigItemsName, mspSignedConfigItems)
def step_impl(context, userName, ccType, chaincodeName, chaincodePath, ccSpecAlias): directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName) args = bootstrap_util.getArgsFromContextForUser(context, userName) ccSpec = endorser_util.getChaincodeSpec(ccType=ccType, path=chaincodePath, name=chaincodeName, args=bdd_grpc_util.toStringArray(args)) print("ccSpec = {0}".format(ccSpec)) user.tags[ccSpecAlias] = ccSpec
def step_impl(context): assert 'table' in context, "Expected table with triplet of Developer/ChainCreationPolicyName/Organization" directory = bootstrap_util.getDirectory(context) for row in context.table.rows: userName = row['Developer'] nodeAdminNamedTuple = directory.registerOrdererAdminTuple(userName, row['ChainCreationPolicyName'], row['Organization']) user = directory.getUser(userName) user.setTagValue(row['AliasSavedUnder'], nodeAdminNamedTuple)
def step_impl(context, userName, peerOrgSetName): ' At the moment, only really defining MSP Config Items (NOT SIGNED)' directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) user.setTagValue(peerOrgSetName, [ directory.getOrganization(row['Organization']).name for row in context.table.rows ])
def step_impl(context, certAlias): assert "table" in context, "Expected table of Organizations" directory = bootstrap_util.getDirectory(context) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) assert len(context.table.rows) == 1, "Only support single orderer orgnaization at moment" for row in context.table.rows: nodeAdminNamedTuple = directory.registerOrdererAdminTuple(ordererBootstrapAdmin.name, "ordererBootstrapAdmin", row['Organization']) ordererBootstrapAdmin.setTagValue(certAlias, nodeAdminNamedTuple)
def step_impl(context, userName, ccDeploymentSpecAlias, ccSpecAlias, devopsComposeService): directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName=userName) assert ccSpecAlias in user.tags, "ChaincodeSpec alias '{0}' not found for user '{1}'".format(ccSpecAlias, userName) deploymentSpec = None raise Exception("Not Implemented") #user.setTagValue(ccDeploymentSpecAlias, deploymentSpec) user.setTagValue(ccDeploymentSpecAlias, deploymentSpec)
def step_impl(context): assert 'table' in context, "Expected table with triplet of User/Peer/Organization" directory = bootstrap_util.getDirectory(context) for row in context.table.rows: nodeAdminTuple = directory.registerOrdererAdminTuple(row['User'], row['Peer'], row['Organization']) aliasToSaveUnder = row['AliasSavedUnder'] if aliasToSaveUnder != "": directory.getUser(row['User']).setTagValue(aliasToSaveUnder, nodeAdminTuple)
def step_impl(context, userName, configTxName, createChannelSignedConfigEnvelopeName): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) channelCreationInfo = user.tags[createChannelSignedConfigEnvelopeName] user.tags[configTxName] = bootstrap_util.createConfigTxEnvelope( channelCreationInfo.channelId, channelCreationInfo.signedConfigEnvelope)
def step_impl(context, userName, templateName, chainCreatePolicyName): ' At the moment, only really defining MSP Config Items (NOT SIGNED)' directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) user.tags[templateName] = [ directory.getOrganization(row['Organization']) for row in context.table.rows ]
def step_impl(context, userName, composeService): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) row = context.table.rows[0] chainID = row['ChainId'] start, end, = orderer_util.convertSeek(row['Start']), orderer_util.convertSeek(row['End']) streamHelper = user.getDelivererStreamHelper(context, composeService) streamHelper.seekToRange(chainID=chainID, start = start, end = end)
def step_impl(context, userName, deliveryName, composeService, expectedBlocks, numMsgsToBroadcast, batchTimeout): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) streamHelper = user.getDelivererStreamHelper(context, composeService) blocks = streamHelper.getBlocks() # Verify block count assert len(blocks) == int(expectedBlocks), "Expected {0} blocks, received {1}".format(expectedBlocks, len(blocks))
def step_impl(context, user_name, compose_service, upgrade_version): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=user_name) assert "composition" in context, "No composition found in context" composition = context.composition composition.issueCommand(['stop'], [compose_service]) composition.issueCommand(['rm', '-f'], [compose_service]) composition.set_version_for_service(compose_service, upgrade_version) composition.issueCommand(['up', '-d'], [compose_service])
def step_impl(context, userName, transactionAlias, orderer, channelId): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) transaction = user.tags[transactionAlias] bootstrap_util.broadcastCreateChannelConfigTx(context=context, composeService=orderer, chainId=channelId, user=user, configTxEnvelope=transaction)
def step_impl(context, userName, transactionAlias, orderer): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) transaction = user.tags[transactionAlias] bootstrap_util.broadcast_channel_config_tx(context=context, certAlias=None, composeService=orderer, user=user, configTxEnvelope=transaction)
def step_impl(context, userName, createChannelSignedConfigEnvelopeName): assert 'table' in context, "Expected table of peer organizations" directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) config_update_envelope = user.tags[createChannelSignedConfigEnvelopeName] for row in context.table.rows: org = directory.getOrganization(row['Organization']) assert bootstrap_util.Network.Peer in org.networks, "Organization '{0}' not in Peer network".format(org.name) bootstrap_util.BootstrapHelper.addSignatureToSignedConfigItem(config_update_envelope, (org, org.getSelfSignedCert()))
def step_impl(context, ordererConfigAdmin, consortiumName, modPolicy): directory = bootstrap_util.getDirectory(context) ordererConfigAdmin = directory.getUser(ordererConfigAdmin) # Collect the orgs from the table orgNames = [row['Organization'] for row in context.table.rows] bootstrap_util.addOrdererBootstrapAdminOrgReferences(context, consortiumName, orgNames) consortium = bootstrap_util.createConsortium(context=context, consortium_name=consortiumName, org_names=orgNames, mod_policy=modPolicy) ordererConfigAdmin.setTagValue(consortiumName, consortium)
def step_impl(context, userName, ccDeploymentSpecAlias, ccSpecAlias, devopsComposeService): directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName=userName) assert ccSpecAlias in user.tags, "ChaincodeSpec alias '{0}' not found for user '{1}'".format(ccSpecAlias, userName) ipAddress = bdd_test_util.ipFromContainerNamePart(devopsComposeService, context.compose_containers) channel = bdd_grpc_util.getGRPCChannel(ipAddress) devopsStub = devops_pb2.beta_create_Devops_stub(channel) deploymentSpec = devopsStub.Build(user.tags[ccSpecAlias],20) user.tags[ccDeploymentSpecAlias] = deploymentSpec
def step_impl(context, userName, createChannelSignedConfigEnvelopeName): assert 'table' in context, "Expected table of peer organizations" directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) config_update_envelope = user.tags[createChannelSignedConfigEnvelopeName] for row in context.table.rows: user = directory.getUser(row['Developer']) namedAdminTuple = user.tags[row['Cert Alias']] cert = directory.findCertForNodeAdminTuple(namedAdminTuple) # assert bootstrap_util.Network.Peer in org.networks, "Organization '{0}' not in Peer network".format(org.name) bootstrap_util.BootstrapHelper.addSignatureToSignedConfigItem(config_update_envelope, (user, namedAdminTuple.organization, cert))
def step_impl(context, consortiumName): directory = bootstrap_util.getDirectory(context) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) # Collect the orgs from the table orgNames = [row['Organization'] for row in context.table.rows] bootstrap_util.addOrdererBootstrapAdminOrgReferences(context, consortiumName, orgNames) consortium = bootstrap_util.createConsortium(context=context, consortium_name=consortiumName, org_names=orgNames) ordererBootstrapAdmin.setTagValue(consortiumName, [consortium])
def step_impl(context, chainCreatePolicyName, ordererSystemChainId): directory = bootstrap_util.getDirectory(context) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) ordererSystemChainIdGuuid = ordererBootstrapAdmin.tags[ordererSystemChainId] # Collect the orgs from the table orgNames = [row['Organization'] for row in context.table.rows] (chainCreationPolicyNamesSignedConfigItem, chainCreatorsOrgsPolicySignedConfigItem) = \ bootstrap_util.createChainCreatorsPolicy(context=context, chainCreatePolicyName=chainCreatePolicyName, chaindId=ordererSystemChainIdGuuid, orgNames=orgNames) ordererBootstrapAdmin.tags[chainCreatePolicyName] = (chainCreationPolicyNamesSignedConfigItem, chainCreatorsOrgsPolicySignedConfigItem)
def step_impl(context, userName, createChannelSignedConfigEnvelopeName): assert 'table' in context, "Expected table of peer organizations" directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) # Get the ChannelCreationInfo object that holds the signedConfigEnvelope channelCreationInfo = user.tags[createChannelSignedConfigEnvelopeName] signedConfigEnvelope = channelCreationInfo.signedConfigEnvelope for row in context.table.rows: org = directory.getOrganization(row['Organization']) assert bootstrap_util.Network.Peer in org.networks, "Organization '{0}' not in Peer network".format(org.name) bootstrap_util.BootstrapHelper.addSignatureToSignedConfigItem(signedConfigEnvelope.Items[0], (org.ecdsaSigningKey, org.getSelfSignedCert())) print("Signatures for signedConfigEnvelope:\n {0}\n".format(signedConfigEnvelope.Items[0]))
def step_impl(context, userName, proposalResponsesAlias): directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName=userName) assert proposalResponsesAlias in user.tags, "Expected proposal responses at tag '{0}', for user '{1}'".format(proposalResponsesAlias, userName) proposalRespDict = user.tags[proposalResponsesAlias] assert len(proposalRespDict) > 0, "Expected at least 1 proposal response, found none in proposal responses dictionary" if len(proposalRespDict) == 1: pass else: endorsers = [row['Endorser'] for row in context.table.rows] endorserToProposalResponseHashDict = dict(zip(endorsers, [user.computeHash(proposalRespDict[endorser].payload) for endorser in endorsers])) setOfHashes = set(endorserToProposalResponseHashDict.values()) assert len(setOfHashes) == 1, "Hashes from endorsers did NOT match: {0}".format(endorserToProposalResponseHashDict)
def step_impl(context, userName, certAlias, configUpdateTxName, createChannelSignedConfigEnvelopeName): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName=userName) namedAdminTuple = user.tags[certAlias] cert = directory.findCertForNodeAdminTuple(namedAdminTuple) config_update_envelope = user.tags[createChannelSignedConfigEnvelopeName] config_update = bootstrap_util.getChannelIdFromConfigUpdateEnvelope(config_update_envelope) envelope_for_config_update = bootstrap_util.createEnvelopeForMsg(directory=directory, nodeAdminTuple=namedAdminTuple, chainId=config_update.channel_id, msg=config_update_envelope, typeAsString="CONFIG_UPDATE") user.setTagValue(configUpdateTxName, envelope_for_config_update)
def step_impl(context, userName, proposalResponsesAlias, statusCode): assert 'table' in context, "Expected table of endorsers" directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName=userName) # Make sure proposalResponseAlias not already defined assert proposalResponsesAlias in user.tags, "Expected proposal responses at tag '{0}', for user '{1}'".format(proposalResponsesAlias, userName) proposalRespDict = user.tags[proposalResponsesAlias] # Loop through endorser proposal Responses endorsers = [row['Endorser'] for row in context.table.rows] print("Endorsers = {0}, rsults keys = {1}".format(endorsers, proposalRespDict.keys())) for respSatusCode in [proposalRespDict[endorser].response.status for endorser in endorsers]: assert int(statusCode) == respSatusCode, "Expected proposal response status code of {0} from {1}, received {2}".format(statusCode, endorser, respSatusCode)
def step_impl(context, userName, proposalAlias, timeout, proposalResponsesAlias): assert 'table' in context, "Expected table of endorsers" directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName=userName) assert proposalAlias in user.tags, "Proposal alias '{0}' not found for user '{1}'".format(proposalAlias, userName) signedProposal = user.tags[proposalAlias] # Send proposal to each specified endorser, waiting 'timeout' seconds for response/error endorsers = [row['Endorser'] for row in context.table.rows] endorserStubs = endorser_util.getEndorserStubs(context, endorsers) proposalResponseFutures = [endorserStub.ProcessProposal.future(signedProposal, int(timeout)) for endorserStub in endorserStubs] resultsDict = dict(zip(endorsers, [respFuture.result() for respFuture in proposalResponseFutures])) user.tags[proposalResponsesAlias] = resultsDict
def step_impl(context, ordererConfigAdmin, consortiumsConfigUpdateName, configName, ordererSystemChainIdName): ''' channel group/Consortiums/ Read the consortiums Group from existing genesis block. ''' directory = bootstrap_util.getDirectory(context) ordererConfigAdmin = directory.getUser(ordererConfigAdmin) channel_group = ordererConfigAdmin.getTagValue(configName) orderer_system_chain_id = ordererConfigAdmin.getTagValue(ordererSystemChainIdName) config_groups = [] # Now collect the consortiums for row in context.table.rows: config_groups.append(ordererConfigAdmin.getTagValue(row['Consortium'])) config_update = bootstrap_util.create_orderer_consortium_config_update(orderer_system_chain_id, channel_group, config_groups) ordererConfigAdmin.setTagValue(tagKey=consortiumsConfigUpdateName, tagValue=config_update)
def step_impl(context, userName, certAlias, proposalAlias, channelName, ccSpecAlias): directory = bootstrap_util.getDirectory(context=context) user = directory.getUser(userName=userName) assert ccSpecAlias in user.tags, "ChaincodeSpec alias '{0}' not found for user '{1}'".format(ccSpecAlias, userName) lcChaincodeSpec = user.tags[ccSpecAlias] # Find the cert using the cert tuple information saved for the user under certAlias nodeAdminTuple = user.tags[certAlias] signersCert = directory.findCertForNodeAdminTuple(nodeAdminTuple) mspID = nodeAdminTuple.organization proposal = endorser_util.createInvokeProposalForBDD(context, ccSpec=lcChaincodeSpec, chainID=channelName,signersCert=signersCert, Mspid=mspID, type="ENDORSER_TRANSACTION") signedProposal = endorser_util.signProposal(proposal=proposal, entity=user, signersCert=signersCert) # proposal = endorser_util.createDeploymentProposalForBDD(ccDeploymentSpec) assert not proposalAlias in user.tags, "Proposal alias '{0}' already exists for '{1}'".format(proposalAlias, userName) user.setTagValue(proposalAlias, signedProposal)
def step_impl(context, userName, createChannelSignedConfigEnvelope): directory = bootstrap_util.getDirectory(context) user = directory.getUser(userName) ordererBootstrapAdmin = bootstrap_util.getOrdererBootstrapAdmin(context) muralisRequiredSignedConfigItems = [] channelID = context.table.rows[0]["ChannelID"] chainCreationPolicyName = context.table.rows[0]["Chain Creation Policy Name"] # Intermediate step until template tool is ready signedConfigItems = bootstrap_util.createSignedConfigItems(context, channelID, "solo", signedConfigItems=muralisRequiredSignedConfigItems) #NOTE: Conidered passing signing key for appDeveloper, but decided that the peer org signatures they need to collect subsequently should be proper way signedConfigEnvelope = bootstrap_util.signInitialChainConfig(signedConfigItems=signedConfigItems, chainId=channelID, chainCreationPolicyName=chainCreationPolicyName) user.tags[createChannelSignedConfigEnvelope] = ChannelCreationInfo(channelID, chainCreationPolicyName, signedConfigEnvelope)