def step_impl(context):
assert 'compose_containers' in context, "compose_containers not found in context"
assert 'table' in context, "table (of peers, username, secret) not found in context"
peerToSecretMessage = {}
# Login to each container specified using username and secret
for row in context.table.rows:
peer, userName, secret = row['peer'], row['username'], row['secret']
secretMsg = {"enrollId": userName, "enrollSecret": secret}
ipAddress = context.containerAliasMap[peer].ipAddress
request_url = buildUrl(context, ipAddress, "/registrar")
bdd_log("POSTing to service = {0}, path = {1}".format(
peer, request_url))
resp = requests.post(request_url,
headers={'Content-type': 'application/json'},
data=json.dumps(secretMsg),
verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" % (
request_url, resp.text)
context.response = resp
bdd_log("message = {0}".format(resp.json()))
peerToSecretMessage[peer] = secretMsg
context.peerToSecretMessage = peerToSecretMessage
def step_impl(context, chaincodeName, functionName):
assert 'chaincodeSpec' in context, "chaincodeSpec not found in context"
assert 'compose_containers' in context, "compose_containers not found in context"
# Update the chaincodeSpec ctorMsg for invoke
args = []
if 'table' in context:
# There is ctor arguments
args = context.table[0].cells
args = prepend(functionName, args)
context.chaincodeSpec['ctorMsg'][
'args'] = args #context.table[0].cells if ('table' in context) else []
# Invoke the POST
chaincodeOpPayload = createChaincodeOpPayload("query",
context.chaincodeSpec)
responses = []
for container in context.compose_containers:
request_url = buildUrl(context, container.ipAddress, "/chaincode")
bdd_log("POSTing path = {}".format(request_url))
resp = requests.post(request_url,
headers={'Content-type': 'application/json'},
data=json.dumps(chaincodeOpPayload),
verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" % (
request_url, resp.text)
responses.append(resp)
context.responses = responses
def compose_op(context, op):
assert 'table' in context, "table (of peers) not found in context"
assert 'compose_yaml' in context, "compose_yaml not found in context"
fileArgsToDockerCompose = bdd_compose_util.getDockerComposeFileArgsFromYamlFile(
context.compose_yaml)
services = context.table.headings
# Loop through services and start/stop them, and modify the container data list if successful.
for service in services:
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(["docker-compose"] + fileArgsToDockerCompose + [op, service], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to {0} {0}".format(
op, service)
if op == "stop" or op == "pause":
context.compose_containers = [
containerData for containerData in context.compose_containers
if containerData.composeService != service
]
else:
bdd_compose_util.parseComposeOutput(context)
bdd_log("After {0}ing, the container service list is = {1}".format(
op, [
containerData.composeService
for containerData in context.compose_containers
]))
context.containerAliasMap = bdd_compose_util.mapAliasesToContainers(
context)
context.containerNameMap = bdd_compose_util.mapContainerNamesToContainers(
context)
def getToken(context):
#if 'token' in context:
if hasattr(context, 'token'):
return context.token
headers = {
'Accept': 'application/json',
'Content-type': 'application/json'
}
#if context.byon:
# headers = {'Accept': 'application/vnd.ibm.zaci.payload+json;version=1.0',
# 'Content-type': 'application/vnd.ibm.zaci.payload+json;version=1.0',
# 'zACI-API': 'com.ibm.zaci.system/1.0'}
#url = "{0}://{1}/api/com.ibm.zaci.system/api-tokens".format(getSchema(context.tls), context.remote_ip)
url = "https://{1}/api/com.ibm.zaci.system/api-tokens".format(
getSchema(context.tls), context.remote_ip)
body = {
"kind": "request",
"parameters": {
"user": "******",
"password": "******"
}
}
response = httpPost(url, body, headers=headers)
try:
context.token = getAttributeFromJSON("parameters.token",
response.json())
except:
bdd_log("Unable to get the token for the network at {}".format(
context.remote_ip))
raise Exception, "Unable to get the network token"
return response
def getIpFromContainerName(containerName):
output, error, returncode = \
cli_call(["docker", "inspect", "--format", "{{ .NetworkSettings.IPAddress }}", containerName], expect_success=True)
bdd_log("container {0} has address = {1}".format(containerName,
output.splitlines()[0]))
return output.splitlines()[0]
def query_common(context, chaincodeName, functionName, value, failOnError):
assert 'chaincodeSpec' in context, "chaincodeSpec not found in context"
assert 'compose_containers' in context, "compose_containers not found in context"
assert 'table' in context, "table (of peers) not found in context"
assert 'peerToSecretMessage' in context, "peerToSecretMessage map not found in context"
# Update the chaincodeSpec ctorMsg for invoke
context.chaincodeSpec['ctorMsg']['args'] = [functionName, value]
# Make deep copy of chaincodeSpec as we will be changing the SecurityContext per call.
chaincodeOpPayload = createChaincodeOpPayload("query", copy.deepcopy(context.chaincodeSpec))
responses = []
aliases = context.table.headings
containers = [context.containerAliasMap[alias] for alias in aliases]
for container in containers:
# Change the SecurityContext per call
chaincodeOpPayload['params']["secureContext"] = \
context.peerToSecretMessage[container.composeService]['enrollId']
bdd_log("Container {0} enrollID = {1}".format(container.name, container.getEnv("CORE_SECURITY_ENROLLID")))
resp = bdd_request_util.httpPostToContainer(context, \
container, "/chaincode", chaincodeOpPayload, expectSuccess=failOnError)
responses.append(resp)
context.responses = responses
def step_impl(context, userName, secret):
assert 'compose_containers' in context, "compose_containers not found in context"
assert 'table' in context, "table (of peers) not found in context"
# Get list of IPs to login to
aliases = context.table.headings
containerDataList = bdd_test_util.getContainerDataValuesFromContext(context, aliases, lambda containerData: containerData)
secretMsg = {
"enrollId": userName,
"enrollSecret" : secret
}
# Login to each container specified
for containerData in containerDataList:
request_url = buildUrl(context, containerData.ipAddress, "/registrar")
bdd_log("POSTing path = {}".format(request_url))
resp = requests.post(request_url, headers={'Content-type': 'application/json'}, data=json.dumps(secretMsg), verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" %(request_url, resp.text)
context.response = resp
bdd_log("message = {0}".format(resp.json()))
# Create new User entry
bdd_test_util.registerUser(context, secretMsg, containerData.composeService)
# Store the username in the context
context.userName = userName
# if we already have the chaincodeSpec, change secureContext
if 'chaincodeSpec' in context:
context.chaincodeSpec["secureContext"] = context.userName
def query_common(context, chaincodeName, functionName, value, failOnError):
assert 'chaincodeSpec' in context, "chaincodeSpec not found in context"
assert 'compose_containers' in context, "compose_containers not found in context"
assert 'table' in context, "table (of peers) not found in context"
assert 'peerToSecretMessage' in context, "peerToSecretMessage map not found in context"
# Update the chaincodeSpec ctorMsg for invoke
context.chaincodeSpec['ctorMsg']['args'] = [functionName, value]
# Make deep copy of chaincodeSpec as we will be changing the SecurityContext per call.
chaincodeOpPayload = createChaincodeOpPayload(
"query", copy.deepcopy(context.chaincodeSpec))
responses = []
aliases = context.table.headings
containers = [context.containerAliasMap[alias] for alias in aliases]
for container in containers:
# Change the SecurityContext per call
chaincodeOpPayload['params']["secureContext"] = \
context.peerToSecretMessage[container.composeService]['enrollId']
bdd_log("Container {0} enrollID = {1}".format(
container.name, container.getEnv("CORE_SECURITY_ENROLLID")))
resp = bdd_request_util.httpPostToContainer(context, \
container, "/chaincode", chaincodeOpPayload, expectSuccess=failOnError)
responses.append(resp)
context.responses = responses
def getEnvironmentVariablesFromContainerName(containerName):
output, error, returncode = \
cli_call(["docker", "inspect", "--format", "{{ .Config.Env }}", containerName], expect_success=True)
env = output.splitlines()[0][1:-1].split()
bdd_log("container {0} has env = {1}".format(containerName, env))
return env
def formatResponseText(response):
# Limit to 300 chars because of the size of the Base64 encoded Certs
bdd_log("Response: {}".format(response))
try:
return json.dumps(response.json(), indent=4)[:300]
except:
return ""
def getIpFromContainerName(containerName):
output, error, returncode = cli_call(
["docker", "inspect", "--format", "{{ .NetworkSettings.IPAddress }}", containerName], expect_success=True
)
bdd_log("container {0} has address = {1}".format(containerName, output.splitlines()[0]))
return output.splitlines()[0]
def step_impl(context, seconds):
""" This step takes into account the chaincodeImagesUpToDate tag, in which case the wait is reduce to some default seconds"""
reducedWaitTime = 4
if 'chaincodeImagesUpToDate' in context.tags:
bdd_log("Assuming images are up to date, sleeping for {0} seconds instead of {1} in scenario {2}".format(reducedWaitTime, seconds, context.scenario.name))
time.sleep(float(reducedWaitTime))
else:
time.sleep(float(seconds))
def getEnvironmentVariablesFromContainerName(containerName):
output, error, returncode = cli_call(
["docker", "inspect", "--format", "{{ .Config.Env }}", containerName], expect_success=True
)
env = output.splitlines()[0][1:-1].split()
bdd_log("container {0} has env = {1}".format(containerName, env))
return env
def step_impl(context, path, containerAlias):
ipAddress = context.containerAliasMap[containerAlias].ipAddress
request_url = buildUrl(context, ipAddress, path)
bdd_log("Requesting path = {0}".format(request_url))
resp = requests.get(request_url, headers={'Accept': 'application/json'}, verify=False)
assert resp.status_code == 200, "Failed to GET url %s: %s" % (request_url,resp.text)
context.response = resp
bdd_log("")
def step_impl(context, seconds):
""" This step takes into account the chaincodeImagesUpToDate tag, in which case the wait is reduce to some default seconds"""
reducedWaitTime = 4
if 'chaincodeImagesUpToDate' in context.tags:
bdd_log("Assuming images are up to date, sleeping for {0} seconds instead of {1} in scenario {2}".format(reducedWaitTime, seconds, context.scenario.name))
time.sleep(float(reducedWaitTime))
else:
time.sleep(float(seconds))
def step_impl(context, action, attribute):
assert attribute in context.response.json(
), "Attribute not found in response ({})".format(attribute)
foundValue = context.response.json()[attribute]
if action == 'store':
foundValue = getAttributeFromJSON(attribute, context.response.json())
setattr(context, attribute, foundValue)
bdd_log("Stored %s: %s" % (attribute, getattr(context, attribute)))
def step_impl(context, path, containerName):
ipAddress = bdd_test_util.ipFromContainerNamePart(containerName, context.compose_containers)
request_url = buildUrl(context, ipAddress, path)
bdd_log("Requesting path = {0}".format(request_url))
resp = requests.get(request_url, headers={'Accept': 'application/json'}, verify=False)
assert resp.status_code == 200, "Failed to GET url %s: %s" % (request_url,resp.text)
context.response = resp
bdd_log("")
def step_impl(context, expectedValue):
bdd_log(context.response.json())
foundValue = getAttributeFromJSON("OK", context.response.json(),
"Attribute not found in response (OK)")
bdd_log(len(set(foundValue)))
assert (
len(set(foundValue)) == int(expectedValue)
), "For attribute OK, expected different transaction cert of size (%s), instead found (%s)" % (
expectedValue, len(set(foundValue)))
def step_impl(context, seconds, containerName):
assert 'transactionID' in context, "transactionID not found in context"
ipAddress = bdd_test_util.ipFromContainerNamePart(containerName, context.compose_containers)
request_url = buildUrl(context, ipAddress, "/transactions/{0}".format(context.transactionID))
bdd_log("GETing path = {}".format(request_url))
resp = requests.get(request_url, headers={'Accept': 'application/json'}, verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" %(request_url, resp.text)
context.response = resp
def peersAreReadyByTimestamp(context, containers, timeoutTimestamp):
peers = getPeerContainers(containers)
bdd_log("Detected Peers: {}".format(peers))
for peer in peers:
if not peerIsReadyByTimestamp(context, peer, peers, timeoutTimestamp):
return False
return True
def tcpPortsAreReady(container):
netstatOutput = getContainerNetstatOutput(container.name)
for line in netstatOutput.splitlines():
if re.search("ESTABLISHED|LISTEN", line):
return True
bdd_log("No TCP connections are ready in container {}".format(container.name))
return False
def peersAreReadyByTimestamp(context, containers, timeoutTimestamp):
peers = getPeerContainers(containers)
bdd_log("Detected Peers: {}".format(peers))
for peer in peers:
if not peerIsReadyByTimestamp(context, peer, peers, timeoutTimestamp):
return False
return True
def tcpPortsAreReady(container):
netstatOutput = getContainerNetstatOutput(container.name)
for line in netstatOutput.splitlines():
if re.search("ESTABLISHED|LISTEN", line):
return True
bdd_log("No TCP connections are ready in container {}".format(container.name))
return False
def getDockerComposeServiceForContainer(containerName):
# Get the Labels to access the com.docker.compose.service value
output, error, returncode = \
cli_call(["docker", "inspect", "--format", "{{ .Config.Labels }}", containerName], expect_success=True)
labels = output.splitlines()[0][4:-1].split()
dockerComposeService = [composeService[27:] for composeService in labels if composeService.startswith("com.docker.compose.service:")][0]
bdd_log("dockerComposeService = {0}".format(dockerComposeService))
return dockerComposeService
def deployChainCodeToContainer(context, chaincode, container):
chaincodeSpec = createChaincodeSpec(context, chaincode)
chaincodeOpPayload = createChaincodeOpPayload("deploy", chaincodeSpec)
context.response = bdd_request_util.httpPostToContainer(context, \
container, "/chaincode", chaincodeOpPayload)
chaincodeName = context.response.json()['result']['message']
chaincodeSpec['chaincodeID']['name'] = chaincodeName
context.chaincodeSpec = chaincodeSpec
bdd_log(json.dumps(chaincodeSpec, indent=4))
bdd_log("")
def step_impl(context, chaincodePath, chainLang, ctor, containerName):
bdd_log("Printing chaincode language " + chainLang)
chaincode = {
"path": chaincodePath,
"language": chainLang,
"constructor": ctor,
"args": getArgsFromContext(context),
}
deployChainCodeToContainer(context, chaincode, containerName)
def step_impl(context, path, containerAlias):
ipAddress = context.containerAliasMap[containerAlias].ipAddress
request_url = buildUrl(context, ipAddress, path)
bdd_log("Requesting path = {0}".format(request_url))
resp = requests.get(request_url,
headers={'Accept': 'application/json'},
verify=False)
assert resp.status_code == 200, "Failed to GET url %s: %s" % (request_url,
resp.text)
context.response = resp
bdd_log("")
def deployChainCodeToContainer(context, chaincode, container):
chaincodeSpec = createChaincodeSpec(context, chaincode)
chaincodeOpPayload = createChaincodeOpPayload("deploy", chaincodeSpec)
context.response = bdd_request_util.httpPostToContainer(context, \
container, "/chaincode", chaincodeOpPayload)
chaincodeName = context.response.json()['result']['message']
chaincodeSpec['chaincodeID']['name'] = chaincodeName
context.chaincodeSpec = chaincodeSpec
bdd_log(json.dumps(chaincodeSpec, indent=4))
bdd_log("")
def getDockerComposeServiceForContainer(containerName):
# Get the Labels to access the com.docker.compose.service value
output, error, returncode = cli_call(
["docker", "inspect", "--format", "{{ .Config.Labels }}", containerName], expect_success=True
)
labels = output.splitlines()[0][4:-1].split()
dockerComposeService = [
composeService[27:] for composeService in labels if composeService.startswith("com.docker.compose.service:")
][0]
bdd_log("dockerComposeService = {0}".format(dockerComposeService))
return dockerComposeService
def restPortRespondsIfContainerIsPeer(container):
containerName = container.name
command = ["docker", "exec", containerName, "curl", "localhost:{}".format(CORE_REST_PORT)]
if containerIsPeer(container):
stdout, stderr, returnCode = cli_call(command, expect_success=False)
if returnCode != 0:
bdd_log("Connection to REST Port on {} failed".format(containerName))
return returnCode == 0
return True
def restPortRespondsIfContainerIsPeer(container):
containerName = container.name
command = ["docker", "exec", containerName, "curl", "localhost:{}".format(CORE_REST_PORT)]
if containerIsPeer(container):
stdout, stderr, returnCode = cli_call(command, expect_success=False)
if returnCode != 0:
bdd_log("Connection to REST Port on {} failed".format(containerName))
return returnCode == 0
return True
def step_impl(context, command, containerName):
bdd_log("Run command: \"{0}\" in container {1}".format(
command, containerName))
executeCommandInContainer(context, command, containerName)
bdd_log("stdout: {0}".format(context.command["stdout"]))
bdd_log("stderr: {0}".format(context.command["stderr"]))
bdd_log("returnCode: {0}".format(context.command["returnCode"]))
def step_impl(context, enrollId, enrollSecret, composeService):
assert 'compose_containers' in context, "compose_containers not found in context"
# Get the sampleApp IP Address
sampleAppIpAddress = context.containerAliasMap[composeService].ipAddress
secretMsg = {
"enrollId": enrollId,
"enrollSecret" : enrollSecret
}
request_url = buildUrl(context, sampleAppIpAddress, "/")
resp = requests.get(request_url, headers={'Accept': 'application/json'}, verify=False)
assert resp.status_code == 200, "Failed to GET url %s: %s" % (request_url,resp.text)
context.response = resp
bdd_log("")
def query_common(context, chaincodeName, functionName, value, failOnError):
assert 'chaincodeSpec' in context, "chaincodeSpec not found in context"
assert 'compose_containers' in context, "compose_containers not found in context"
assert 'table' in context, "table (of peers) not found in context"
assert 'peerToSecretMessage' in context, "peerToSecretMessage map not found in context"
aliases = context.table.headings
containerDataList = bdd_test_util.getContainerDataValuesFromContext(context, aliases, lambda containerData: containerData)
# Update the chaincodeSpec ctorMsg for invoke
context.chaincodeSpec['ctorMsg']['args'] = [functionName, value]
# Invoke the POST
# Make deep copy of chaincodeSpec as we will be changing the SecurityContext per call.
chaincodeOpPayload = createChaincodeOpPayload("query", copy.deepcopy(context.chaincodeSpec))
responses = []
for container in containerDataList:
# Change the SecurityContext per call
chaincodeOpPayload['params']["secureContext"] = context.peerToSecretMessage[container.composeService]['enrollId']
bdd_log("Container {0} enrollID = {1}".format(container.containerName, container.getEnv("CORE_SECURITY_ENROLLID")))
request_url = buildUrl(context, container.ipAddress, "/chaincode")
bdd_log("POSTing path = {}".format(request_url))
resp = requests.post(request_url, headers={'Content-type': 'application/json'}, data=json.dumps(chaincodeOpPayload), timeout=30, verify=False)
if failOnError:
assert resp.status_code == 200, "Failed to POST to %s: %s" %(request_url, resp.text)
bdd_log("RESULT from {0} of chaincode from peer {1}".format(functionName, container.containerName))
bdd_log(json.dumps(resp.json(), indent = 4))
responses.append(resp)
context.responses = responses
def step_impl(context):
try:
# Kill chaincode containers
res, error, returncode = bdd_test_util.cli_call(
["docker", "ps", "-n=4", "-q"],
expect_success=True)
bdd_log("Killing chaincode containers: {0}".format(res))
result, error, returncode = bdd_test_util.cli_call(
["docker", "rm", "-f"] + res.split('\n'),
expect_success=False)
bdd_log("Stopped chaincode containers")
except:
raise Exception("Unable to kill chaincode images")
def checkHeight(context, foundValue, expectedValue):
# if context.byon:
# errStr = "For attribute height, expected equal or greater than (%s), instead found (%s)" % (expectedValue, foundValue)
# assert (foundValue >= int(expectedValue)), errStr
# elif expectedValue == 'previous':
if expectedValue == 'previous':
bdd_log("Stored height: {}".format(context.height))
errStr = "For attribute height, expected (%s), instead found (%s)" % (
context.height, foundValue)
assert (foundValue == context.height), errStr
else:
errStr = "For attribute height, expected (%s), instead found (%s)" % (
expectedValue, foundValue)
assert (formatStringToCompare(foundValue) == expectedValue), errStr
def step_impl(context, attribute, expectedValue):
foundValue = getAttributeFromJSON(attribute, context.response.json())
if expectedValue == 'previous':
prev_value = getattr(context, attribute)
bdd_log("Stored value: {}".format(prev_value))
errStr = "For attribute %s, expected greater than (%s), instead found (%s)" % (
attribute, prev_value, foundValue)
assert (foundValue > prev_value), errStr
else:
errStr = "For attribute %s, expected greater than (%s), instead found (%s)" % (
attribute, expectedValue, foundValue)
assert (formatStringToCompare(foundValue) > expectedValue), errStr
# Set the new value of the attribute
setattr(context, attribute, foundValue)
def invokeUsingChaincodeService(context, devopsFunc, functionName,
containerAlias):
# Invoke the POST
chaincodeOpPayload = createChaincodeOpPayload(devopsFunc,
context.chaincodeSpec)
ipAddress = context.containerAliasMap[containerAlias].ipAddress
request_url = buildUrl(context, ipAddress, "/chaincode")
bdd_log("POSTing path = {}".format(request_url))
bdd_log("Using attributes {0}".format(context.chaincodeSpec['attributes']))
resp = requests.post(request_url,
headers={'Content-type': 'application/json'},
data=json.dumps(chaincodeOpPayload),
verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" % (request_url,
resp.text)
context.response = resp
bdd_log("RESULT from {0} of chaincode from peer {1}".format(
functionName, containerAlias))
bdd_log(json.dumps(context.response.json(), indent=4))
if 'result' in resp.json():
result = resp.json()['result']
if 'message' in result:
transactionID = result['message']
context.transactionID = transactionID
def containersAreReadyWithinTimeout(context, containers, timeout):
timeoutTimestamp = time.time() + timeout
formattedTime = time.strftime("%X", time.localtime(timeoutTimestamp))
bdd_log("All containers should be up by {}".format(formattedTime))
for container in containers:
if not containerIsInitializedByTimestamp(container, timeoutTimestamp):
return False
peersAreReady = peersAreReadyByTimestamp(context, containers, timeoutTimestamp)
if peersAreReady:
bdd_log("Containers in ready state, ready to proceed")
return peersAreReady
def containersAreReadyWithinTimeout(context, containers, timeout):
timeoutTimestamp = time.time() + timeout
formattedTime = time.strftime("%X", time.localtime(timeoutTimestamp))
bdd_log("All containers should be up by {}".format(formattedTime))
for container in containers:
if not containerIsInitializedByTimestamp(container, timeoutTimestamp):
return False
peersAreReady = peersAreReadyByTimestamp(context, containers,
timeoutTimestamp)
if peersAreReady:
bdd_log("Containers in ready state, ready to proceed")
return peersAreReady
def step_impl(context, enrollId, enrollSecret, composeService):
assert 'compose_containers' in context, "compose_containers not found in context"
# Get the sampleApp IP Address
containerDataList = bdd_test_util.getContainerDataValuesFromContext(
context, [composeService], lambda containerData: containerData)
sampleAppIpAddress = containerDataList[0].ipAddress
secretMsg = {"enrollId": enrollId, "enrollSecret": enrollSecret}
request_url = buildUrl(context, sampleAppIpAddress, "/")
resp = requests.get(request_url,
headers={'Accept': 'application/json'},
verify=False)
assert resp.status_code == 200, "Failed to GET url %s: %s" % (request_url,
resp.text)
context.response = resp
bdd_log("")
def compose_op(context, op):
assert 'table' in context, "table (of peers) not found in context"
assert 'compose_yaml' in context, "compose_yaml not found in context"
fileArgsToDockerCompose = bdd_compose_util.getDockerComposeFileArgsFromYamlFile(context.compose_yaml)
services = context.table.headings
# Loop through services and start/stop them, and modify the container data list if successful.
for service in services:
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(["docker-compose"] + fileArgsToDockerCompose + [op, service], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to {0} {0}".format(op, service)
if op == "stop" or op == "pause":
context.compose_containers = [containerData for containerData in context.compose_containers if containerData.composeService != service]
else:
bdd_compose_util.parseComposeOutput(context)
bdd_log("After {0}ing, the container service list is = {1}".format(op, [containerData.composeService for containerData in context.compose_containers]))
def multiRequest(context, seconds, containerDataList, pathBuilderFunc):
"""Perform a multi request against the system"""
# Build map of "containerName" : response
respMap = {container.containerName:None for container in containerDataList}
# Set the max time before stopping attempts
maxTime = datetime.now() + timedelta(seconds = int(seconds))
for container in containerDataList:
ipAddress = container.ipAddress
request_url = buildUrl(context, ipAddress, pathBuilderFunc(context, container))
# Loop unless failure or time exceeded
while (datetime.now() < maxTime):
bdd_log("GETing path = {}".format(request_url))
resp = requests.get(request_url, headers={'Accept': 'application/json'}, verify=False)
respMap[container.containerName] = resp
else:
raise Exception("Max time exceeded waiting for multiRequest with current response map = {0}".format(respMap))
def step_impl(context):
try:
# Kill chaincode images
res, error, returncode = bdd_test_util.cli_call(
["docker", "images"],
expect_success=True)
images = res.split('\n')
for image in images:
if image.startswith('dev-vp'):
fields = image.split()
r, e, ret= bdd_test_util.cli_call(
["docker", "rmi", "-f", fields[2]],
expect_success=False)
bdd_log("Removed chaincode images")
except:
raise Exception("Unable to kill chaincode images")
def step_impl(context, chaincodeName, functionName):
assert 'chaincodeSpec' in context, "chaincodeSpec not found in context"
assert 'compose_containers' in context, "compose_containers not found in context"
# Update the chaincodeSpec ctorMsg for invoke
args = []
if 'table' in context:
# There is ctor arguments
args = context.table[0].cells
args = prepend(functionName, args)
context.chaincodeSpec['ctorMsg']['args'] = args #context.table[0].cells if ('table' in context) else []
# Invoke the POST
chaincodeOpPayload = createChaincodeOpPayload("query", context.chaincodeSpec)
responses = []
for container in context.compose_containers:
request_url = buildUrl(context, container.ipAddress, "/chaincode")
bdd_log("POSTing path = {}".format(request_url))
resp = requests.post(request_url, headers={'Content-type': 'application/json'}, data=json.dumps(chaincodeOpPayload), verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" %(request_url, resp.text)
responses.append(resp)
context.responses = responses
def invokeMasterChaincode(context, devopsFunc, chaincodeName, functionName, containerName):
args = []
if 'table' in context:
args = context.table[0].cells
args = prepend(functionName, args)
typeGolang = 1
chaincodeSpec = {
"type": typeGolang,
"chaincodeID": {
"name" : chaincodeName
},
"ctorMsg": {
"args" : args
}
}
if 'userName' in context:
chaincodeSpec["secureContext"] = context.userName
chaincodeOpPayload = createChaincodeOpPayload(devopsFunc, chaincodeSpec)
ipAddress = bdd_test_util.ipFromContainerNamePart(containerName, context.compose_containers)
request_url = buildUrl(context, ipAddress, "/chaincode")
bdd_log("POSTing path = {}".format(request_url))
resp = requests.post(request_url, headers={'Content-type': 'application/json'}, data=json.dumps(chaincodeOpPayload), verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" %(request_url, resp.text)
context.response = resp
bdd_log("RESULT from {0} of chaincode from peer {1}".format(functionName, containerName))
bdd_log(json.dumps(context.response.json(), indent = 4))
if 'result' in resp.json():
result = resp.json()['result']
if 'message' in result:
transactionID = result['message']
context.transactionID = transactionID
def step_impl(context, seconds):
assert 'transactionID' in context, "transactionID not found in context"
assert 'compose_containers' in context, "compose_containers not found in context"
# Build map of "containerName" : resp.statusCode
respMap = {container.containerName:0 for container in context.compose_containers}
# Set the max time before stopping attempts
maxTime = datetime.now() + timedelta(seconds = int(seconds))
for container in context.compose_containers:
ipAddress = container.ipAddress
request_url = buildUrl(context, ipAddress, "/transactions/{0}".format(context.transactionID))
# Loop unless failure or time exceeded
while (datetime.now() < maxTime):
bdd_log("GETing path = {}".format(request_url))
resp = requests.get(request_url, headers={'Accept': 'application/json'}, verify=False)
if resp.status_code == 404:
# Pause then try again
respMap[container.containerName] = 404
time.sleep(1)
continue
elif resp.status_code == 200:
# Success, continue
respMap[container.containerName] = 200
break
else:
raise Exception("Error requesting {0}, returned result code = {1}".format(request_url, resp.status_code))
else:
raise Exception("Max time exceeded waiting for transactions with current response map = {0}".format(respMap))
bdd_log("Result of request to all peers = {0}".format(respMap))
bdd_log("")
def step_impl(context):
assert 'compose_containers' in context, "compose_containers not found in context"
assert 'table' in context, "table (of peers, username, secret) not found in context"
peerToSecretMessage = {}
# Login to each container specified using username and secret
for row in context.table.rows:
peer, userName, secret = row['peer'], row['username'], row['secret']
secretMsg = {
"enrollId": userName,
"enrollSecret" : secret
}
ipAddress = bdd_test_util.ipFromContainerNamePart(peer, context.compose_containers)
request_url = buildUrl(context, ipAddress, "/registrar")
bdd_log("POSTing to service = {0}, path = {1}".format(peer, request_url))
resp = requests.post(request_url, headers={'Content-type': 'application/json'}, data=json.dumps(secretMsg), verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" %(request_url, resp.text)
context.response = resp
bdd_log("message = {0}".format(resp.json()))
peerToSecretMessage[peer] = secretMsg
context.peerToSecretMessage = peerToSecretMessage
def peerIsReadyByTimestamp(context, peerContainer, allPeerContainers, timeoutTimestamp):
while peerIsNotReady(context, peerContainer, allPeerContainers):
if timestampExceeded(timeoutTimestamp):
bdd_log("Timed out waiting for peer {}".format(peerContainer.name))
return False
bdd_log("Peer {} not ready, waiting...".format(peerContainer.name))
time.sleep(1)
bdd_log("Peer {} now available".format(peerContainer.name))
return True
def containerIsInitializedByTimestamp(container, timeoutTimestamp):
while containerIsNotInitialized(container):
if timestampExceeded(timeoutTimestamp):
bdd_log("Timed out waiting for {} to initialize".format(container.name))
return False
bdd_log("{} not initialized, waiting...".format(container.name))
time.sleep(1)
bdd_log("{} now available".format(container.name))
return True
def invokeUsingChaincodeService(context, devopsFunc, functionName, containerName):
# Invoke the POST
chaincodeOpPayload = createChaincodeOpPayload(devopsFunc, context.chaincodeSpec)
ipAddress = bdd_test_util.ipFromContainerNamePart(containerName, context.compose_containers)
request_url = buildUrl(context, ipAddress, "/chaincode")
bdd_log("POSTing path = {}".format(request_url))
bdd_log("Using attributes {0}".format(context.chaincodeSpec['attributes']))
resp = requests.post(request_url, headers={'Content-type': 'application/json'}, data=json.dumps(chaincodeOpPayload), verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" %(request_url, resp.text)
context.response = resp
bdd_log("RESULT from {0} of chaincode from peer {1}".format(functionName, containerName))
bdd_log(json.dumps(context.response.json(), indent = 4))
if 'result' in resp.json():
result = resp.json()['result']
if 'message' in result:
transactionID = result['message']
context.transactionID = transactionID
def _request(method, url, expectSuccess=True, **kwargs):
bdd_log("HTTP {} to url = {}".format(method, url))
response = requests.request(method, url, \
headers=ACCEPT_JSON_HEADER, verify=False, **kwargs)
if expectSuccess:
assert response.status_code == 200, \
"Failed to {} to {}: {}".format(method, url, response.text)
bdd_log("Response from {}:".format(url))
bdd_log(formatResponseText(response))
return response
def peerIsReady(context, thisPeer, allPeers):
connectedPeers = getConnectedPeersFromPeer(context, thisPeer)
if connectedPeers is None:
return False
numPeers = len(allPeers)
numConnectedPeers = len(connectedPeers)
if numPeers != numConnectedPeers:
bdd_log("Expected {} peers, got {}".format(numPeers, numConnectedPeers))
bdd_log("Connected Peers: {}".format(connectedPeers))
bdd_log("Expected Peers: {}".format(allPeers))
return numPeers == numConnectedPeers
def deployChainCodeToContainer(context, chaincode, containerName):
ipAddress = bdd_test_util.ipFromContainerNamePart(containerName, context.compose_containers)
request_url = buildUrl(context, ipAddress, "/chaincode")
bdd_log("Requesting path = {0}".format(request_url))
chaincodeSpec = createChaincodeSpec(context, chaincode)
chaincodeOpPayload = createChaincodeOpPayload("deploy", chaincodeSpec)
resp = requests.post(request_url, headers={'Content-type': 'application/json'}, data=json.dumps(chaincodeOpPayload), verify=False)
assert resp.status_code == 200, "Failed to POST to %s: %s" %(request_url, resp.text)
context.response = resp
chaincodeName = resp.json()['result']['message']
chaincodeSpec['chaincodeID']['name'] = chaincodeName
context.chaincodeSpec = chaincodeSpec
bdd_log(json.dumps(chaincodeSpec, indent=4))
bdd_log("")
def step_impl(context, containerName):
assert 'table' in context, "table (of query parameters) not found in context"
assert 'userName' in context, "userName not found in context"
assert 'compose_containers' in context, "compose_containers not found in context"
ipAddress = bdd_test_util.ipFromContainerNamePart(containerName, context.compose_containers)
request_url = buildUrl(context, ipAddress, "/registrar/{0}/tcert".format(context.userName))
bdd_log("Requesting path = {0}".format(request_url))
queryParams = {}
for row in context.table.rows:
key, value = row['key'], row['value']
queryParams[key] = value
bdd_log("Query parameters = {0}".format(queryParams))
resp = requests.get(request_url, params=queryParams, headers={'Accept': 'application/json'}, verify=False)
assert resp.status_code == 200, "Failed to GET to %s: %s" % (request_url, resp.text)
context.response = resp
bdd_log("")
