def start_nodes(self):
# Destroy the box to begin, so that we are guaranteed
# a clean build.
check_safe_call(
['vagrant', 'destroy', '-f'],
cwd=self.vagrant_path.path)
box_version = vagrant_version(self.package_source.version)
# Boot the VMs
check_safe_call(
['vagrant', 'up'],
cwd=self.vagrant_path.path,
env=extend_environ(FLOCKER_BOX_VERSION=box_version))
for node in self.NODE_ADDRESSES:
remove_known_host(node)
perform(
dispatcher,
run_remotely(
username='******',
address=node,
commands=task_pull_docker_images()
),
)
return self.NODE_ADDRESSES
def start_nodes(self, reactor):
# Destroy the box to begin, so that we are guaranteed
# a clean build.
yield run(
reactor,
['vagrant', 'destroy', '-f'],
path=self.vagrant_path.path)
if self.package_source.version:
env = extend_environ(
FLOCKER_BOX_VERSION=vagrant_version(
self.package_source.version))
else:
env = os.environ
# Boot the VMs
yield run(
reactor,
['vagrant', 'up'],
path=self.vagrant_path.path,
env=env)
for node in self.NODE_ADDRESSES:
yield remove_known_host(reactor, node)
yield perform(
make_dispatcher(reactor),
run_remotely(
username='******',
address=node,
commands=task_pull_docker_images()
),
)
returnValue([
VagrantNode(address=address, distribution=self.distribution)
for address in self.NODE_ADDRESSES
])
def main(reactor, args, base_path, top_level):
try:
options = TestBrewOptions()
try:
options.parseOptions(args)
except UsageError as e:
sys.stderr.write("Error: {error}.\n".format(error=str(e)))
sys.exit(1)
eliot_to_stdout(MESSAGE_FORMATS, {})
recipe_url = options['recipe_url']
options['vmpath'] = FilePath(options['vmpath'])
# Open the recipe URL just to validate and verify that it exists.
# We do not need to read its content.
urllib2.urlopen(recipe_url)
yield run(reactor, [
"vmrun",
"revertToSnapshot",
options['vmpath'].path,
options['vmsnapshot'],
])
yield run(reactor, [
"vmrun",
"start",
options['vmpath'].path,
"nogui",
])
yield perform(
make_dispatcher(reactor),
run_remotely(
username=options['vmuser'],
address=options['vmhost'],
commands=sequence([
task_configure_brew_path(),
task_test_homebrew(recipe_url),
]),
),
)
yield run(reactor, [
"vmrun",
"stop",
options['vmpath'].path,
"hard",
])
print "Done."
except ProcessTerminated as e:
sys.stderr.write(
("Error: Command terminated with exit status {code}.\n").format(
code=e.exitCode))
raise
def reboot(self):
"""
Reboot the node.
:return Effect:
"""
def do_reboot(_):
self._node.reboot()
self._node, self.addresses = self._node.driver.wait_until_running([self._node], wait_period=15)[0]
return
return run_remotely(username="******", address=self.address, commands=run_from_args(["sync"])).on(
success=do_reboot
)
def reboot(self):
"""
Reboot the node.
:return Effect:
"""
def do_reboot(_):
self._node.reboot()
self._node, self.addresses = (self._node.driver.wait_until_running(
[self._node], wait_period=15)[0])
return
return run_remotely(username="******",
address=self.address,
commands=run_from_args(["sync"
])).on(success=do_reboot)
def main(reactor, args, base_path, top_level):
try:
options = TestBrewOptions()
try:
options.parseOptions(args)
except UsageError as e:
sys.stderr.write("Error: {error}.\n".format(error=str(e)))
sys.exit(1)
add_destination(eliot_output)
recipe_url = options['recipe_url']
options['vmpath'] = FilePath(options['vmpath'])
# Open the recipe URL just to validate and verify that it exists.
# We do not need to read its content.
urllib2.urlopen(recipe_url)
yield run(reactor, [
"vmrun", "revertToSnapshot",
options['vmpath'].path, options['vmsnapshot'],
])
yield run(reactor, [
"vmrun", "start", options['vmpath'].path, "nogui",
])
yield perform(
make_dispatcher(reactor),
run_remotely(
username=options['vmuser'],
address=options['vmhost'],
commands=sequence([
task_configure_brew_path(),
task_test_homebrew(recipe_url),
]),
),
)
yield run(reactor, [
"vmrun", "stop", options['vmpath'].path, "hard",
])
print "Done."
except ProcessTerminated as e:
sys.stderr.write(
(
"Error: Command terminated with exit status {code}.\n"
).format(code=e.exitCode)
)
raise
def main(args):
try:
options = TestBrewOptions()
try:
options.parseOptions(args)
except UsageError as e:
sys.stderr.write("Error: {error}.\n".format(error=str(e)))
sys.exit(1)
recipe_url = options['recipe_url']
options['vmpath'] = FilePath(options['vmpath'])
# Open the recipe URL just to validate and verify that it exists.
# We do not need to read its content.
urllib2.urlopen(recipe_url)
check_output([
"vmrun",
"revertToSnapshot",
options['vmpath'].path,
options['vmsnapshot'],
])
check_output([
"vmrun",
"start",
options['vmpath'].path,
"nogui",
])
perform(
dispatcher,
run_remotely(username=options['vmuser'],
address=options['vmhost'],
commands=task_test_homebrew(recipe_url)),
)
check_output([
"vmrun",
"stop",
options['vmpath'].path,
"hard",
])
print "Done."
except CalledProcessError as e:
sys.stderr.write(
("Error: Command {cmd} terminated with exit status {code}.\n"
).format(cmd=" ".join(e.cmd), code=e.returncode))
raise
def start_nodes(self):
# Destroy the box to begin, so that we are guaranteed
# a clean build.
check_safe_call(['vagrant', 'destroy', '-f'],
cwd=self.vagrant_path.path)
box_version = vagrant_version(self.package_source.version)
# Boot the VMs
check_safe_call(['vagrant', 'up'],
cwd=self.vagrant_path.path,
env=extend_environ(FLOCKER_BOX_VERSION=box_version))
for node in self.NODE_ADDRESSES:
remove_known_host(node)
perform(
dispatcher,
run_remotely(username='******',
address=node,
commands=task_pull_docker_images()),
)
return self.NODE_ADDRESSES
def main(args):
try:
options = TestBrewOptions()
try:
options.parseOptions(args)
except UsageError as e:
sys.stderr.write("Error: {error}.\n".format(error=str(e)))
sys.exit(1)
recipe_url = options['recipe_url']
options['vmpath'] = FilePath(options['vmpath'])
# Open the recipe URL just to validate and verify that it exists.
# We do not need to read its content.
urllib2.urlopen(recipe_url)
check_output([
"vmrun", "revertToSnapshot",
options['vmpath'].path, options['vmsnapshot'],
])
check_output([
"vmrun", "start", options['vmpath'].path, "nogui",
])
perform(
dispatcher,
run_remotely(
username=options['vmuser'],
address=options['vmhost'],
commands=task_test_homebrew(recipe_url)
),
)
check_output([
"vmrun", "stop", options['vmpath'].path, "hard",
])
print "Done."
except CalledProcessError as e:
sys.stderr.write(
(
"Error: Command {cmd} terminated with exit status {code}.\n"
).format(cmd=" ".join(e.cmd), code=e.returncode)
)
raise
def run_client_tests(reactor, node):
"""
Run the client acceptance tests.
:param INode node: The node to run client acceptance tests against.
:return int: The exit-code of trial.
"""
def check_result(f):
f.trap(ProcessTerminated)
if f.value.exitCode is not None:
return f.value.exitCode
else:
return f
return perform(make_dispatcher(reactor), run_remotely(
username=node.get_default_username(),
address=node.address,
commands=task_client_installation_test()
)).addCallbacks(
callback=lambda _: 0,
errback=check_result,
)
def run_client_tests(reactor, node):
"""
Run the client acceptance tests.
:param INode node: The node to run client acceptance tests against.
:return int: The exit-code of trial.
"""
def check_result(f):
f.trap(ProcessTerminated)
if f.value.exitCode is not None:
return f.value.exitCode
else:
return f
return perform(
make_dispatcher(reactor),
run_remotely(username=node.get_default_username(),
address=node.address,
commands=task_client_installation_test())).addCallbacks(
callback=lambda _: 0,
errback=check_result,
)
def main(reactor, args, base_path, top_level):
"""
:param reactor: Reactor to use.
:param list args: The arguments passed to the script.
:param FilePath base_path: The executable being run.
:param FilePath top_level: The top-level of the flocker repository.
"""
options = RunOptions(top_level=top_level)
add_destination(eliot_output)
try:
options.parseOptions(args)
except UsageError as e:
sys.stderr.write("%s: %s\n" % (base_path.basename(), e))
raise SystemExit(1)
runner = options.runner
from flocker.common.script import eliot_logging_service
log_writer = eliot_logging_service(
destination=FileDestination(
file=open("%s.log" % (base_path.basename(),), "a")
),
reactor=reactor,
capture_stdout=False)
log_writer.startService()
reactor.addSystemEventTrigger(
'before', 'shutdown', log_writer.stopService)
cluster = None
try:
yield runner.ensure_keys(reactor)
cluster = yield runner.start_cluster(reactor)
if options['distribution'] in ('centos-7',):
remote_logs_file = open("remote_logs.log", "a")
for node in cluster.all_nodes:
capture_journal(reactor, node.address, remote_logs_file)
if not options["no-pull"]:
yield perform(
make_dispatcher(reactor),
parallel([
run_remotely(
username='******',
address=node.address,
commands=task_pull_docker_images()
) for node in cluster.agent_nodes
]),
)
result = yield run_tests(
reactor=reactor,
cluster=cluster,
trial_args=options['trial-args'])
except:
result = 1
raise
finally:
# Unless the tests failed, and the user asked to keep the nodes, we
# delete them.
if not options['keep']:
runner.stop_cluster(reactor)
else:
print "--keep specified, not destroying nodes."
if cluster is None:
print ("Didn't finish creating the cluster.")
else:
print ("To run acceptance tests against these nodes, "
"set the following environment variables: ")
environment_variables = get_trial_environment(cluster)
for environment_variable in environment_variables:
print "export {name}={value};".format(
name=environment_variable,
value=shell_quote(
environment_variables[environment_variable]),
)
raise SystemExit(result)
def main(reactor, args, base_path, top_level):
"""
:param reactor: Reactor to use.
:param list args: The arguments passed to the script.
:param FilePath base_path: The executable being run.
:param FilePath top_level: The top-level of the flocker repository.
"""
options = RunOptions(top_level=top_level)
add_destination(eliot_output)
try:
options.parseOptions(args)
except UsageError as e:
sys.stderr.write("%s: %s\n" % (base_path.basename(), e))
raise SystemExit(1)
runner = options.runner
from flocker.common.script import eliot_logging_service
log_writer = eliot_logging_service(
destination=FileDestination(
file=open("%s.log" % (base_path.basename(),), "a")
),
reactor=reactor,
capture_stdout=False)
log_writer.startService()
reactor.addSystemEventTrigger(
'before', 'shutdown', log_writer.stopService)
cluster = None
results = []
setup_succeeded = False
reached_finally = False
def cluster_cleanup():
if not reached_finally:
print "interrupted..."
print "stopping cluster"
return runner.stop_cluster(reactor)
cleanup_trigger_id = reactor.addSystemEventTrigger('before', 'shutdown',
cluster_cleanup)
try:
yield runner.ensure_keys(reactor)
cluster = yield runner.start_cluster(reactor)
if options['distribution'] in ('centos-7',):
remote_logs_file = open("remote_logs.log", "a")
for node in cluster.all_nodes:
results.append(capture_journal(reactor,
node.address,
remote_logs_file)
)
elif options['distribution'] in ('ubuntu-14.04',):
remote_logs_file = open("remote_logs.log", "a")
for node in cluster.all_nodes:
results.append(capture_upstart(reactor,
node.address,
remote_logs_file)
)
gather_deferreds(results)
if not options["no-pull"]:
yield perform(
make_dispatcher(reactor),
parallel([
run_remotely(
username='******',
address=node.address,
commands=task_pull_docker_images()
) for node in cluster.agent_nodes
]),
)
setup_succeeded = True
result = yield run_tests(
reactor=reactor,
cluster=cluster,
trial_args=options['trial-args'])
finally:
reached_finally = True
# We delete the nodes if the user hasn't asked to keep them
# or if we failed to provision the cluster.
if not setup_succeeded:
print "cluster provisioning failed"
elif not options['keep']:
print "not keeping cluster"
else:
print "--keep specified, not destroying nodes."
print ("To run acceptance tests against these nodes, "
"set the following environment variables: ")
environment_variables = get_trial_environment(cluster)
for environment_variable in environment_variables:
print "export {name}={value};".format(
name=environment_variable,
value=shell_quote(
environment_variables[environment_variable]),
)
reactor.removeSystemEventTrigger(cleanup_trigger_id)
raise SystemExit(result)
def main(reactor, args, base_path, top_level):
"""
:param reactor: Reactor to use.
:param list args: The arguments passed to the script.
:param FilePath base_path: The executable being run.
:param FilePath top_level: The top-level of the flocker repository.
"""
options = RunOptions(top_level=top_level)
add_destination(eliot_output)
try:
options.parseOptions(args)
except UsageError as e:
sys.stderr.write("%s: %s\n" % (base_path.basename(), e))
raise SystemExit(1)
runner = options.runner
from flocker.common.script import eliot_logging_service
log_file = open("%s.log" % base_path.basename(), "a")
log_writer = eliot_logging_service(log_file=log_file,
reactor=reactor,
capture_stdout=False)
log_writer.startService()
reactor.addSystemEventTrigger('before', 'shutdown', log_writer.stopService)
cluster = None
try:
cluster = yield runner.start_cluster(reactor)
if options['distribution'] in ('centos-7', ):
remote_logs_file = open("remote_logs.log", "a")
for node in cluster.all_nodes:
capture_journal(reactor, node.address, remote_logs_file)
if not options["no-pull"]:
yield perform(
make_dispatcher(reactor),
parallel([
run_remotely(username='******',
address=node.address,
commands=task_pull_docker_images())
for node in cluster.agent_nodes
]),
)
result = yield run_tests(reactor=reactor,
cluster=cluster,
trial_args=options['trial-args'])
except:
result = 1
raise
finally:
# Unless the tests failed, and the user asked to keep the nodes, we
# delete them.
if not options['keep']:
runner.stop_cluster(reactor)
else:
print "--keep specified, not destroying nodes."
if cluster is None:
print("Didn't finish creating the cluster.")
else:
print(
"To run acceptance tests against these nodes, "
"set the following environment variables: ")
environment_variables = get_trial_environment(cluster)
for environment_variable in environment_variables:
print "export {name}={value};".format(
name=environment_variable,
value=shell_quote(
environment_variables[environment_variable]),
)
raise SystemExit(result)
def main(reactor, args, base_path, top_level):
"""
:param reactor: Reactor to use.
:param list args: The arguments passed to the script.
:param FilePath base_path: The executable being run.
:param FilePath top_level: The top-level of the flocker repository.
"""
options = RunOptions(top_level=top_level)
add_destination(eliot_output)
try:
options.parseOptions(args)
except UsageError as e:
sys.stderr.write("%s: %s\n" % (base_path.basename(), e))
raise SystemExit(1)
runner = options.runner
try:
nodes = yield runner.start_nodes(reactor)
ca_directory = FilePath(mkdtemp())
print("Generating certificates in: {}".format(ca_directory.path))
certificates = Certificates.generate(ca_directory, nodes[0].address,
len(nodes))
yield perform(
make_dispatcher(reactor),
parallel([
run_remotely(
username='******',
address=node.address,
commands=task_pull_docker_images()
) for node in nodes
]),
)
control_node = nodes[0]
dataset_backend = options.dataset_backend
yield perform(
make_dispatcher(reactor),
configure_cluster(control_node=control_node, agent_nodes=nodes,
certificates=certificates,
dataset_backend=dataset_backend))
result = yield run_tests(
reactor=reactor,
nodes=nodes,
control_node=control_node,
agent_nodes=nodes,
dataset_backend=dataset_backend,
trial_args=options['trial-args'],
certificates_path=ca_directory)
except:
result = 1
raise
finally:
# Unless the tests failed, and the user asked to keep the nodes, we
# delete them.
if not (result != 0 and options['keep']):
runner.stop_nodes(reactor)
elif options['keep']:
print "--keep specified, not destroying nodes."
print ("To run acceptance tests against these nodes, "
"set the following environment variables: ")
environment_variables = {
'FLOCKER_ACCEPTANCE_NODES':
':'.join(node.address for node in nodes),
'FLOCKER_ACCEPTANCE_CONTROL_NODE': control_node.address,
'FLOCKER_ACCEPTANCE_AGENT_NODES':
':'.join(node.address for node in nodes),
'FLOCKER_ACCEPTANCE_VOLUME_BACKEND': dataset_backend.name,
'FLOCKER_ACCEPTANCE_API_CERTIFICATES_PATH': ca_directory.path,
}
for environment_variable in environment_variables:
print "export {name}={value};".format(
name=environment_variable,
value=environment_variables[environment_variable],
)
raise SystemExit(result)
