def decompose(self):
self.issueCommand(["unpause"])
self.issueCommand(["down"])
self.issueCommand(["kill"])
self.issueCommand(["rm", "-f"])
# Now remove associated chaincode containers if any
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["ps", "-qa", "--filter", "name={0}".format(self.projectName)], expect_success=True, env=self.getEnv())
for containerId in output.splitlines():
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["rm", "-f", containerId], expect_success=True, env=self.getEnv())
# Remove the associated network
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["network", "ls", "-q", "--filter", "name={0}".format(self.projectName)], expect_success=True, env=self.getEnv())
for networkId in output.splitlines():
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["network", "rm", networkId], expect_success=True, env=self.getEnv())
# Invoke callbacks
[
callback.decomposing(self, self.context) for callback in
Composition.GetCompositionCallbacksFromContext(self.context)
]
def parseComposeOutput(context):
"""Parses the compose output results and set appropriate values into context"""
# Use the prefix to get the container name
containerNamePrefix = os.path.basename(os.getcwd()) + "_"
containerNames = []
for l in context.compose_error.splitlines():
print(l.split())
containerNames.append(l.split()[1])
print(containerNames)
# Now get the Network Address for each name, and set the ContainerData onto the context.
containerDataList = []
for containerName in containerNames:
output, error, returncode = \
bdd_test_util.cli_call(context, ["docker", "inspect", "--format", "{{ .NetworkSettings.IPAddress }}", containerName], expect_success=True)
#print("container {0} has address = {1}".format(containerName, output.splitlines()[0]))
ipAddress = output.splitlines()[0]
# Get the environment array
output, error, returncode = \
bdd_test_util.cli_call(context, ["docker", "inspect", "--format", "{{ .Config.Env }}", containerName], expect_success=True)
env = output.splitlines()[0][1:-1].split()
# Get the Labels to access the com.docker.compose.service value
output, error, returncode = \
bdd_test_util.cli_call(context, ["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]
print("dockerComposeService = {0}".format(dockerComposeService))
print("container {0} has env = {1}".format(containerName, env))
containerDataList.append(ContainerData(containerName, ipAddress, env, dockerComposeService))
setattr(context, "compose_containers", containerDataList)
print("")
def rebuildContainerData(self):
self.containerDataList = []
for containerID in self.refreshContainerIDs():
output, error, returncode = \
bdd_test_util.cli_call(["docker", "inspect", "--format", "{{ .Name }}", containerID], expect_success=True)
containerName = output.splitlines()[0][1:]
#print("container has address = {0}".format(containerName))
ipAddress = output.splitlines()[0]
output, error, returncode = \
bdd_test_util.cli_call(["docker", "inspect", "--format", "{{ .NetworkSettings.IPAddress }}", containerID], expect_success=True)
#print("container {0} has address = {1}".format(containerName, output.splitlines()[0]))
ipAddress = output.splitlines()[0]
# Get the environment array
output, error, returncode = \
bdd_test_util.cli_call(["docker", "inspect", "--format", "{{ .Config.Env }}", containerID], expect_success=True)
env = output.splitlines()[0][1:-1].split()
# Get the Labels to access the com.docker.compose.service value
output, error, returncode = \
bdd_test_util.cli_call(["docker", "inspect", "--format", "{{ .Config.Labels }}", containerID], expect_success=True)
labels = output.splitlines()[0][4:-1].split()
dockerComposeService = [unicode(composeService[27:]) for composeService in labels if composeService.startswith("com.docker.compose.service:")][0]
#print("dockerComposeService = {0}".format(dockerComposeService))
#print("container {0} has env = {1}".format(containerName, env))
self.containerDataList.append(peer_basic_impl.ContainerData(containerName, ipAddress, env, dockerComposeService))
def remove_chaincode_images(self):
'Remove associated chaincode images if any for this project only.'
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["images", "-qa", "{}*".format(self.projectName)], expect_success=True, env=self.getEnv())
for imageId in output.splitlines():
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["rmi", imageId], expect_success=True, env=self.getEnv())
def rebuildContainerData(self):
self.containerDataList = []
for containerID in self.refreshContainerIDs():
output, error, returncode = \
bdd_test_util.cli_call(["docker", "inspect", "--format", "{{ .Name }}", containerID], expect_success=True)
containerName = output.splitlines()[0][1:]
#print("container has address = {0}".format(containerName))
ipAddress = output.splitlines()[0]
output, error, returncode = \
bdd_test_util.cli_call(["docker", "inspect", "--format", "{{ .NetworkSettings.IPAddress }}", containerID], expect_success=True)
#print("container {0} has address = {1}".format(containerName, output.splitlines()[0]))
ipAddress = output.splitlines()[0]
# Get the environment array
output, error, returncode = \
bdd_test_util.cli_call(["docker", "inspect", "--format", "{{ .Config.Env }}", containerID], expect_success=True)
env = output.splitlines()[0][1:-1].split()
# Get the Labels to access the com.docker.compose.service value
output, error, returncode = \
bdd_test_util.cli_call(["docker", "inspect", "--format", "{{ .Config.Labels }}", containerID], expect_success=True)
labels = output.splitlines()[0][4:-1].split()
dockerComposeService = [
unicode(composeService[27:]) for composeService in labels
if composeService.startswith("com.docker.compose.service:")
][0]
#print("dockerComposeService = {0}".format(dockerComposeService))
#print("container {0} has env = {1}".format(containerName, env))
self.containerDataList.append(
peer_basic_impl.ContainerData(containerName, ipAddress, env,
dockerComposeService))
def decompose(self):
self.issueCommand(["unpause"])
self.issueCommand(["kill"])
self.issueCommand(["rm", "-f"])
# Now remove associated chaincode containers if any
#c.dockerHelper.RemoveContainersWithNamePrefix(c.projectName)
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["ps", "-qa", "--filter", "name={0}".format(self.projectName)], expect_success=True, env=self.getEnv())
for containerId in output.splitlines():
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["rm", "-f", containerId], expect_success=True, env=self.getEnv())
def decompose(self):
self.issueCommand(["unpause"])
self.issueCommand(["kill"])
self.issueCommand(["rm", "-f"])
# Now remove associated chaincode containers if any
#c.dockerHelper.RemoveContainersWithNamePrefix(c.projectName)
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["ps", "-qa", "--filter", "name={0}".format(self.projectName)], expect_success=True, env=self.getEnv())
for containerId in output.splitlines():
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["rm", "-f", containerId], expect_success=True, env=self.getEnv())
def parseComposeOutput(context):
"""Parses the compose output results and set appropriate values into context. Merges existing with newly composed."""
# Use the prefix to get the container name
containerNamePrefix = os.path.basename(os.getcwd()) + "_"
containerNames = []
for l in context.compose_error.splitlines():
tokens = l.split()
bdd_log(tokens)
if 1 < len(tokens):
thisContainer = tokens[1]
if containerNamePrefix not in thisContainer:
thisContainer = containerNamePrefix + thisContainer + "_1"
if thisContainer not in containerNames:
containerNames.append(thisContainer)
bdd_log("Containers started: ")
bdd_log(containerNames)
# Now get the Network Address for each name, and set the ContainerData onto the context.
containerDataList = []
for containerName in containerNames:
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]))
ipAddress = output.splitlines()[0]
# Get the environment array
output, error, returncode = \
cli_call(["docker", "inspect", "--format", "{{ .Config.Env }}", containerName], expect_success=True)
env = output.splitlines()[0][1:-1].split()
# 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))
bdd_log("container {0} has env = {1}".format(containerName, env))
containerDataList.append(
ContainerData(containerName, ipAddress, env, dockerComposeService))
# Now merge the new containerData info with existing
newContainerDataList = []
if "compose_containers" in context:
# Need to merge I new list
newContainerDataList = context.compose_containers
newContainerDataList = newContainerDataList + containerDataList
setattr(context, "compose_containers", newContainerDataList)
bdd_log("")
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 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 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 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 rebuildContainerData(self):
self.containerDataList = []
for containerID in self.refreshContainerIDs():
# get container metadata
container = json.loads(bdd_test_util.cli_call(["docker", "inspect", containerID], expect_success=True)[0])[0]
# container name
container_name = container['Name'][1:]
# container ip address (only if container is running)
container_ipaddress = None
if container['State']['Running']:
container_ipaddress = container['NetworkSettings']['IPAddress']
if not container_ipaddress:
# ipaddress not found at the old location, try the new location
container_ipaddress = container['NetworkSettings']['Networks'].values()[0]['IPAddress']
# container environment
container_env = container['Config']['Env']
# container docker-compose service
container_compose_service = container['Config']['Labels']['com.docker.compose.service']
self.containerDataList.append(peer_basic_impl.ContainerData(container_name, container_ipaddress, container_env, container_compose_service))
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 = 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(context, ["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:
parseComposeOutput(context)
print("After {0}ing, the container service list is = {1}".format(
op, [
containerData.composeService
for containerData in context.compose_containers
]))
def rebuildContainerData(self):
self.containerDataList = []
for containerID in self.refreshContainerIDs():
# get container metadata
container = json.loads(
bdd_test_util.cli_call(["docker", "inspect", containerID],
expect_success=True)[0])[0]
# container name
container_name = container['Name'][1:]
# container ip address (only if container is running)
container_ipaddress = None
if container['State']['Running']:
container_ipaddress = container['NetworkSettings']['IPAddress']
if not container_ipaddress:
# ipaddress not found at the old location, try the new location
container_ipaddress = container['NetworkSettings'][
'Networks'].values()[0]['IPAddress']
# container environment
container_env = container['Config']['Env']
# container docker-compose service
container_compose_service = container['Config']['Labels'][
'com.docker.compose.service']
self.containerDataList.append(
peer_basic_impl.ContainerData(container_name,
container_ipaddress,
container_env,
container_compose_service))
def parseComposeOutput(context):
"""Parses the compose output results and set appropriate values into context. Merges existing with newly composed."""
# Use the prefix to get the container name
containerNamePrefix = os.path.basename(os.getcwd()) + "_"
containerNames = []
for l in context.compose_error.splitlines():
tokens = l.split()
print(tokens)
if 1 < len(tokens):
thisContainer = tokens[1]
if containerNamePrefix not in thisContainer:
thisContainer = containerNamePrefix + thisContainer + "_1"
if thisContainer not in containerNames:
containerNames.append(thisContainer)
print("Containers started: ")
print(containerNames)
# Now get the Network Address for each name, and set the ContainerData onto the context.
containerDataList = []
for containerName in containerNames:
output, error, returncode = \
bdd_test_util.cli_call(context, ["docker", "inspect", "--format", "{{ .NetworkSettings.IPAddress }}", containerName], expect_success=True)
print("container {0} has address = {1}".format(containerName, output.splitlines()[0]))
ipAddress = output.splitlines()[0]
# Get the environment array
output, error, returncode = \
bdd_test_util.cli_call(context, ["docker", "inspect", "--format", "{{ .Config.Env }}", containerName], expect_success=True)
env = output.splitlines()[0][1:-1].split()
# Get the Labels to access the com.docker.compose.service value
output, error, returncode = \
bdd_test_util.cli_call(context, ["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]
print("dockerComposeService = {0}".format(dockerComposeService))
print("container {0} has env = {1}".format(containerName, env))
containerDataList.append(ContainerData(containerName, ipAddress, env, dockerComposeService))
# Now merge the new containerData info with existing
newContainerDataList = []
if "compose_containers" in context:
# Need to merge I new list
newContainerDataList = context.compose_containers
newContainerDataList = newContainerDataList + containerDataList
setattr(context, "compose_containers", newContainerDataList)
print("")
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 testCreateSystemCoverageFile(folderName, rootName, containerNames, extension):
'Will create a single aggregate coverage file fromsave the converage files to folderName'
files = glob.glob(os.path.join('coverage','*.cov'))
for containerName in containerNames:
srcPath = "{0}:/opt/gopath/src/github.com/hyperledger/mchain/peer/coverage.cov".format(containerName)
destPath = os.path.join(folderName, "{0}-{1}.{2}".format(rootName, containerName, extension))
output, error, returncode = \
bdd_test_util.cli_call(["docker", "cp", srcPath, destPath], expect_success=False)
def testCreateSystemCoverageFile(folderName, rootName, containerNames, extension):
'Will create a single aggregate coverage file fromsave the converage files to folderName'
files = glob.glob(os.path.join('coverage','*.cov'))
for containerName in containerNames:
srcPath = "{0}:/opt/gopath/src/github.com/hyperledger/fabric/peer/coverage.cov".format(containerName)
destPath = os.path.join(folderName, "{0}-{1}.{2}".format(rootName, containerName, extension))
output, error, returncode = \
bdd_test_util.cli_call(["docker", "cp", srcPath, destPath], expect_success=False)
def inspect(self, format='{{.Id}} {{.Path}} {{.Image}}'):
'Returns the inspect information for each container in this project'
inspect_results = []
for containerId in self.docker_ids():
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["inspect", "--format={0}".format(format), containerId], expect_success=True, env=self.getEnv())
inspect_results.append(output.split())
return inspect_results
def step_impl(context, composeYamlFile):
context.compose_yaml = composeYamlFile
fileArgsToDockerCompose = getDockerComposeFileArgsFromYamlFile(context.compose_yaml)
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose"] + fileArgsToDockerCompose + ["up","--force-recreate", "-d"], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to bring up {0}".format(composeYamlFile)
parseComposeOutput(context)
time.sleep(10) # Should be replaced with a definitive interlock guaranteeing that all peers/membersrvc are ready
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 issueCommand(self, args):
cmdArgs = self.getFileArgs() + args
output, error, returncode = \
bdd_test_util.cli_call(["docker-compose"] + cmdArgs, expect_success=True, env=self.getEnv())
# Don't rebuild if ps command
if args[0] != "ps":
self.rebuildContainerData()
return output
def step_impl(context, composeYamlFile):
context.compose_yaml = composeYamlFile
fileArgsToDockerCompose = getDockerComposeFileArgsFromYamlFile(context.compose_yaml)
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose"] + fileArgsToDockerCompose + ["up","--force-recreate", "-d"], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to bring up {0}".format(composeYamlFile)
parseComposeOutput(context)
time.sleep(10) # Should be replaced with a definitive interlock guaranteeing that all peers/membersrvc are ready
def issueCommand(self, args):
cmdArgs = self.getFileArgs()+ args
output, error, returncode = \
bdd_test_util.cli_call(["docker-compose"] + cmdArgs, expect_success=True, env=self.getEnv())
# Don't rebuild if ps command
if args[0] !="ps":
self.rebuildContainerData()
return output
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 _createDeploymentSpecAsFile(ccSpec, outputPath):
'''peer chaincode package -n myCC -c '{"Args":["init","a","100","b","200"]}' -p github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02 --logging-level=DEBUG test.file'''
myEnv = os.environ.copy()
myEnv['CORE_PEER_MSPCONFIGPATH'] = "./../msp/sampleConfig"
nameArgs = ["-n", ccSpec.chaincodeID.name]
ctorArgs = ["-c", json.dumps({'Args' : [item for item in ccSpec.input.args]})]
pathArgs = ["-p", ccSpec.chaincodeID.path]
output, error, returncode = \
bdd_test_util.cli_call(["peer","chaincode","package"] + nameArgs + ctorArgs + pathArgs + [outputPath], expect_success=True, env=myEnv)
return output
def remove_chaincode_containers(self):
'Remove associated chaincode containers if any for this project only.'
chaincode_inspect_list = [
info
for info in self.inspect(format='{{.Id}} {{.Path}} {{.Image}}')
if info[1] == 'chaincode'
]
for container_id, path, image_id in chaincode_inspect_list:
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["rm", "-f", container_id], expect_success=True, env=self.getEnv())
def step_impl(context):
assert 'table' in context, "table (of peers) not found in context"
assert 'compose_yaml' in context, "compose_yaml not found in context"
services = context.table.headings
# Loop through services and start them
for service in services:
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose", "-f", context.compose_yaml, "start", service], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to start {0}".format(service)
def executeCommand(context, command):
# cli_call expects an array of arguments, hence splitting here.
commandArgs = command.split()
stdout, stderr, retcode = cli_call(commandArgs, expect_success=False)
context.command = {
"stdout": stdout,
"stderr": stderr,
"returnCode": retcode
}
def executeCommand(context, command):
# cli_call expects an array of arguments, hence splitting here.
commandArgs = command.split()
stdout, stderr, retcode = cli_call(commandArgs, expect_success=False)
context.command = {
"stdout": stdout,
"stderr": stderr,
"returnCode": retcode
}
def step_impl(context, composeYamlFile):
# Use the uninstalled version of `cf active-deploy` rather than the installed version on the OS $PATH
#cmd = os.path.dirname(os.path.abspath(__file__)) + "/../../../cf_update/v1/cf_update.py"
# Expand $vars, e.g. "--path $PATH" becomes "--path /bin"
#args = re.sub('\$\w+', lambda v: os.getenv(v.group(0)[1:]), composeYamlFile)
context.compose_yaml = composeYamlFile
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose", "-f", composeYamlFile, "up","--force-recreate", "-d"], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to bring up {0}".format(composeYamlFile)
parseComposeOutput(context)
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 decompose(self):
self.issueCommand(["unpause"])
self.issueCommand(["kill"])
self.issueCommand(["rm", "-f"])
# Now remove associated chaincode containers if any
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["ps", "-qa", "--filter", "name={0}".format(self.projectName)], expect_success=True, env=self.getEnv())
for containerId in output.splitlines():
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["rm", "-f", containerId], expect_success=True, env=self.getEnv())
# Remove the associated network
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["network", "ls", "-q", "--filter", "name={0}".format(self.projectName)], expect_success=True, env=self.getEnv())
for networkId in output.splitlines():
output, error, returncode = \
bdd_test_util.cli_call(["docker"] + ["network", "rm", networkId], expect_success=True, env=self.getEnv())
# Invoke callbacks
[callback.decomposing(self, self.context) for callback in Composition.GetCompositionCallbacksFromContext(self.context)]
def step_impl(context):
assert 'table' in context, "table (of peers) not found in context"
assert 'compose_yaml' in context, "compose_yaml not found in context"
services = context.table.headings
# Loop through services and start them
for service in services:
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose", "-f", context.compose_yaml, "start", service], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to start {0}".format(service)
parseComposeOutput(context)
print("After starting peers, the container service list is = {0}".format([containerData.composeService + ":" + containerData.ipAddress for containerData in context.compose_containers]))
def step_impl(context):
assert 'table' in context, "table (of peers) not found in context"
assert 'compose_yaml' in context, "compose_yaml not found in context"
services = context.table.headings
# Loop through services and start them
for service in services:
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose", "-f", context.compose_yaml, "start", service], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to start {0}".format(service)
parseComposeOutput(context)
print("After starting peers, the container service list is = {0}".format([containerData.composeService + ":" + containerData.ipAddress for containerData in context.compose_containers]))
def step_impl(context, composeYamlFile):
context.compose_yaml = composeYamlFile
fileArgsToDockerCompose = bdd_compose_util.getDockerComposeFileArgsFromYamlFile(context.compose_yaml)
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(["docker-compose"] + fileArgsToDockerCompose + ["up","--force-recreate", "-d"], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to bring up {0}".format(composeYamlFile)
bdd_compose_util.parseComposeOutput(context)
timeoutSeconds = 15
assert bdd_compose_util.allContainersAreReadyWithinTimeout(context, timeoutSeconds), \
"Containers did not come up within {} seconds, aborting".format(timeoutSeconds)
def step_impl(context, composeYamlFile):
context.compose_yaml = composeYamlFile
fileArgsToDockerCompose = bdd_compose_util.getDockerComposeFileArgsFromYamlFile(context.compose_yaml)
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(["docker-compose"] + fileArgsToDockerCompose + ["up","--force-recreate", "-d"], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to bring up {0}".format(composeYamlFile)
bdd_compose_util.parseComposeOutput(context)
timeoutSeconds = 15
assert bdd_compose_util.allContainersAreReadyWithinTimeout(context, timeoutSeconds), \
"Containers did not come up within {} seconds, aborting".format(timeoutSeconds)
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, composeYamlFile):
# Use the uninstalled version of `cf active-deploy` rather than the installed version on the OS $PATH
#cmd = os.path.dirname(os.path.abspath(__file__)) + "/../../../cf_update/v1/cf_update.py"
# Expand $vars, e.g. "--path $PATH" becomes "--path /bin"
#args = re.sub('\$\w+', lambda v: os.getenv(v.group(0)[1:]), composeYamlFile)
context.compose_yaml = composeYamlFile
fileArgsToDockerCompose = getDockerComposeFileArgsFromYamlFile(context.compose_yaml)
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose"] + fileArgsToDockerCompose + ["up","--force-recreate", "-d"], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to bring up {0}".format(composeYamlFile)
parseComposeOutput(context)
time.sleep(10) # Should be replaced with a definitive interlock guaranteeing that all peers/membersrvc are ready
def step_impl(context, composeYamlFile):
# Use the uninstalled version of `cf active-deploy` rather than the installed version on the OS $PATH
#cmd = os.path.dirname(os.path.abspath(__file__)) + "/../../../cf_update/v1/cf_update.py"
# Expand $vars, e.g. "--path $PATH" becomes "--path /bin"
#args = re.sub('\$\w+', lambda v: os.getenv(v.group(0)[1:]), composeYamlFile)
context.compose_yaml = composeYamlFile
fileArgsToDockerCompose = getDockerComposeFileArgsFromYamlFile(context.compose_yaml)
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose"] + fileArgsToDockerCompose + ["up","--force-recreate", "-d"], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to bring up {0}".format(composeYamlFile)
parseComposeOutput(context)
time.sleep(10) # Should be replaced with a definitive interlock guaranteeing that all peers/membersrvc are ready
def step_impl(context):
assert 'table' in context, "table (of peers) not found in context"
assert 'compose_yaml' in context, "compose_yaml not found in context"
assert 'compose_containers' in context, "compose_containers not found in context"
services = context.table.headings
# Loop through services and stop them, and remove from the container data list if stopped successfully.
for service in services:
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose", "-f", context.compose_yaml, "stop", service], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to stop {0}".format(service)
#remove from the containerDataList
context.compose_containers = [containerData for containerData in context.compose_containers if containerData.composeService != service]
print("After stopping, the container serive list is = {0}".format([containerData.composeService for containerData in context.compose_containers]))
def step_impl(context):
assert 'table' in context, "table (of peers) not found in context"
assert 'compose_yaml' in context, "compose_yaml not found in context"
assert 'compose_containers' in context, "compose_containers not found in context"
services = context.table.headings
# Loop through services and stop them, and remove from the container data list if stopped successfully.
for service in services:
context.compose_output, context.compose_error, context.compose_returncode = \
bdd_test_util.cli_call(context, ["docker-compose", "-f", context.compose_yaml, "stop", service], expect_success=True)
assert context.compose_returncode == 0, "docker-compose failed to stop {0}".format(service)
#remove from the containerDataList
context.compose_containers = [containerData for containerData in context.compose_containers if containerData.composeService != service]
print("After stopping, the container serive list is = {0}".format([containerData.composeService for containerData in context.compose_containers]))
def saveCoverageFiles(folderName, rootName, containerNames, extension):
'Will save the converage files to folderName'
# Make the directory
try:
os.makedirs(folderName)
except OSError as exception:
if exception.errno != errno.EEXIST:
raise
for containerName in containerNames:
srcPath = "{0}:/opt/gopath/src/github.com/hyperledger/mchain/coverage.cov".format(containerName)
print("sourcepath = {0}".format(srcPath))
destPath = os.path.join(folderName, "{0}-{1}.{2}".format(rootName, containerName, extension))
output, error, returncode = \
bdd_test_util.cli_call(["docker", "cp", srcPath, destPath], expect_success=False)
def saveCoverageFiles(folderName, rootName, containerNames, extension):
'Will save the converage files to folderName'
# Make the directory
try:
os.makedirs(folderName)
except OSError as exception:
if exception.errno != errno.EEXIST:
raise
for containerName in containerNames:
srcPath = "{0}:/opt/gopath/src/github.com/hyperledger/fabric/coverage.cov".format(containerName)
print("sourcepath = {0}".format(srcPath))
destPath = os.path.join(folderName, "{0}-{1}.{2}".format(rootName, containerName, extension))
output, error, returncode = \
bdd_test_util.cli_call(["docker", "cp", srcPath, destPath], expect_success=False)
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"
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(context, ["docker-compose", "-f", context.compose_yaml, 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:
parseComposeOutput(context)
print("After {0}ing, the container service list is = {1}".format(op, [containerData.composeService for containerData in context.compose_containers]))
def _createDeploymentSpecAsFile(ccSpec, outputPath):
'''peer chaincode package -n myCC -c '{"Args":["init","a","100","b","200"]}' -p github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02 --logging-level=DEBUG test.file'''
myEnv = os.environ.copy()
# These values must now be set in the ENV
# myEnv['CORE_PEER_MSPCONFIGPATH'] = "./../sampleconfig/msp"
# myEnv['CORE_PEER_MSPCONFIGPATH'] = "./../sampleconfig/msp"
# CORE_PEER_MSPCONFIGPATH=$PWD/chaincode-docker-devmode/msp
# FABRIC_CFG_PATH=./config
nameArgs = ["-n", ccSpec.chaincode_id.name]
ctorArgs = [
"-c", json.dumps({'Args': [item for item in ccSpec.input.args]})
]
pathArgs = ["-p", ccSpec.chaincode_id.path]
versionArgs = ["-v", ccSpec.chaincode_id.version]
output, error, returncode = \
bdd_test_util.cli_call(["peer","chaincode","package"] + nameArgs + ctorArgs + pathArgs + versionArgs + [outputPath], expect_success=True, env=myEnv)
return output
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 parseComposeOutput(context):
"""Parses the compose output results and set appropriate values into context"""
# Use the prefix to get the container name
containerNamePrefix = os.path.basename(os.getcwd()) + "_"
containerNames = []
for l in context.compose_error.splitlines():
print(l.split())
containerNames.append(l.split()[1])
print(containerNames)
# Now get the Network Address for each name, and set the ContainerData onto the context.
containerDataList = []
for containerName in containerNames:
output, error, returncode = \
bdd_test_util.cli_call(context, ["docker", "inspect", "--format", "{{ .NetworkSettings.IPAddress }}", containerName], expect_success=True)
print("container {0} has address = {1}".format(containerName, output.splitlines()[0]))
containerDataList.append(ContainerData(containerName, output.splitlines()[0]))
setattr(context, "compose_containers", containerDataList)
print("")
def getContainerNetstatOutput(containerName):
command = ["docker", "exec", containerName, "netstat", "-atun"]
stdout, stderr, returnCode = cli_call(command, expect_success=False)
return stdout
def _callCLI(self, argList, expect_success, env):
return bdd_test_util.cli_call(argList, expect_success=expect_success, env=env)
def getPeerLogs(context, peerName):
fullContainerName = context.containerAliasMap[peerName].name
stdout, stderr, retcode = cli_call(["docker", "logs", fullContainerName], expect_success=True)
return stdout, stderr
def getPeerLogs(context, peerName):
fullContainerName = bdd_test_util.fullNameFromContainerNamePart(peerName, context.compose_containers)
stdout, stderr, retcode = bdd_test_util.cli_call(["docker", "logs", fullContainerName], expect_success=True)
return stdout, stderr
