def test_delete_deployment(self):
dsl_path = resource("dsl/basic.yaml")
blueprint_id = self.id()
deployment_id = str(uuid.uuid4())
def change_execution_status(_execution_id, status):
self.client.executions.update(_execution_id, status)
executions = self.client.executions.list(deployment_id)
updated_execution = next(execution for execution in executions
if execution.id == _execution_id)
self.assertEqual(status, updated_execution.status)
# verifying a deletion of a new deployment, i.e. one which hasn't
# been installed yet, and therefore all its nodes are still in
# 'uninitialized' state.
self.client.blueprints.upload(dsl_path, blueprint_id)
self.client.deployments.create(blueprint_id, deployment_id)
do_retries(verify_deployment_environment_creation_complete, 30,
deployment_id=deployment_id)
delete_deployment(deployment_id, False)
self.client.blueprints.delete(blueprint_id)
# recreating the deployment, this time actually deploying it too
_, execution_id = deploy(dsl_path,
blueprint_id=blueprint_id,
deployment_id=deployment_id,
wait_for_execution=True)
execs = self.client.executions.list(include_system_workflows=True)
self.assertEqual(Execution.TERMINATED,
next(execution for execution in execs if
execution.id == execution_id).status)
# verifying deployment exists
result = self.client.deployments.get(deployment_id)
self.assertEqual(deployment_id, result.id)
# retrieving deployment nodes
nodes = self.client.node_instances.list(deployment_id=deployment_id)
self.assertTrue(len(nodes) > 0)
# setting one node's state to 'started' (making it a 'live' node)
# node must be read using get in order for it to have a version.
node = self.client.node_instances.get(nodes[0].id)
self.client.node_instances.update(node.id,
state='started',
version=node.version)
# setting the execution's status to 'started' so it'll prevent the
# deployment deletion
change_execution_status(execution_id, Execution.STARTED)
# attempting to delete the deployment - should fail because the
# execution is active
try:
delete_deployment(deployment_id)
self.fail("Deleted deployment {0} successfully even though it "
"should have had a running execution"
.format(deployment_id))
except CloudifyClientError, e:
self.assertTrue('running executions' in str(e))
self.assertTrue(len(nodes) > 0)
nodes_ids = [_node.id for _node in nodes]
# attempting to delete deployment - should fail because there are
# live nodes for this deployment
try:
delete_deployment(deployment_id)
self.fail("Deleted deployment {0} successfully even though it "
"should have had live nodes and the ignore_live_nodes "
"flag was set to False".format(deployment_id))
except CloudifyClientError, e:
self.assertTrue('live nodes' in str(e))
# deleting deployment - this time there's no execution running,
# and using the ignore_live_nodes parameter to force deletion
deleted_deployment_id = delete_deployment(deployment_id, True).id
self.assertEqual(deployment_id, deleted_deployment_id)
# verifying deployment does no longer exist
try:
self.client.deployments.get(deployment_id)
self.fail("Got deployment {0} successfully even though it "
"wasn't expected to exist".format(deployment_id))
except CloudifyClientError, e:
self.assertTrue('not found' in str(e))
# verifying deployment's execution does no longer exist
try:
self.client.executions.get(execution_id)
self.fail('execution {0} still exists even though it should have '
'been deleted when its deployment was deleted'
class BasicWorkflowsTest(TestCase):
def test_execute_operation(self):
dsl_path = resource('dsl/basic.yaml')
blueprint_id = self.id()
deployment, _ = deploy(
dsl_path,
blueprint_id=blueprint_id,
timeout_seconds=15
)
self.assertEqual(blueprint_id, deployment.blueprint_id)
machines = self.get_plugin_data(
plugin_name='cloudmock',
deployment_id=deployment.id
)['machines']
self.assertEquals(1, len(machines))
outputs = self.client.deployments.outputs.get(deployment.id).outputs
self.assertEquals(outputs['ip_address'], '')
def test_dependencies_order_with_two_nodes(self):
dsl_path = resource("dsl/dependencies_order_with_two_nodes.yaml")
blueprint_id = self.id()
deployment, _ = deploy(dsl_path, blueprint_id=blueprint_id)
self.assertEquals(blueprint_id, deployment.blueprint_id)
states = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment.id
)['state']
self.assertEquals(2, len(states))
self.assertTrue('host_node' in states[0]['id'])
self.assertTrue('db_node' in states[1]['id'])
@timeout(seconds=120)
def test_execute_operation_failure(self):
deployment_id = str(uuid.uuid4())
dsl_path = resource("dsl/basic.yaml")
try:
deploy(dsl_path, deployment_id=deployment_id)
self.fail('expected exception')
except Exception as e:
if e.message:
self.logger.info(e.message)
pass
def test_cloudify_runtime_properties_injection(self):
dsl_path = resource("dsl/dependencies_order_with_two_nodes.yaml")
deployment, _ = deploy(dsl_path)
states = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment.id
)['state']
node_runtime_props = None
for k, v in states[1]['capabilities'].iteritems():
if 'host_node' in k:
node_runtime_props = v
break
self.assertEquals('value1', node_runtime_props['property1'])
self.assertEquals(1,
len(node_runtime_props),
msg='Expected 2 but contains: {0}'.format(
node_runtime_props))
def test_non_existing_operation_exception(self):
dsl_path = resource("dsl/wrong_operation_name.yaml")
self.assertRaises(RuntimeError, deploy, dsl_path)
def test_inject_properties_to_operation(self):
dsl_path = resource("dsl/hardcoded_operation_properties.yaml")
deployment, _ = deploy(dsl_path)
states = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment.id
)['state']
invocations = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment.id
)['mock_operation_invocation']
self.assertEqual(1, len(invocations))
invocation = invocations[0]
self.assertEqual('mockpropvalue', invocation['mockprop'])
self.assertEqual(states[0]['id'], invocation['id'])
def test_start_monitor_node_operation(self):
dsl_path = resource("dsl/hardcoded_operation_properties.yaml")
deployment, _ = deploy(dsl_path)
invocations = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment.id
)['monitoring_operations_invocation']
self.assertEqual(1, len(invocations))
invocation = invocations[0]
self.assertEqual('start_monitor', invocation['operation'])
def test_plugin_get_resource(self):
dsl_path = resource("dsl/get_resource_in_plugin.yaml")
deployment, _ = deploy(dsl_path)
invocations = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment.id
)['get_resource_operation_invocation']
self.assertEquals(1, len(invocations))
invocation = invocations[0]
with open(resource("dsl/basic.yaml")) as f:
basic_data = f.read()
# checking the resources are the correct data
self.assertEquals(basic_data, invocation['res1_data'])
self.assertEquals(basic_data, invocation['res2_data'])
# checking the custom filepath provided is indeed where the second
# resource was saved
self.assertEquals(invocation['custom_filepath'],
invocation['res2_path'])
def test_search(self):
dsl_path = resource("dsl/basic.yaml")
blueprint_id = 'my_new_blueprint'
deployment, _ = deploy(dsl_path, blueprint_id=blueprint_id)
self.assertEqual(blueprint_id, deployment.blueprint_id)
machines = self.get_plugin_data(
plugin_name='cloudmock',
deployment_id=deployment.id
)['machines']
self.assertEquals(1, len(machines))
result = self.client.search.run_query({})
hits = map(lambda x: x['_source'], result['hits']['hits'])
expected_num_of_hits = 9 if IS_TRANSIENT_WORKERS_MODE else 7
self.assertEquals(expected_num_of_hits, len(hits))
def test_get_blueprint(self):
dsl_path = resource("dsl/basic.yaml")
blueprint_id = str(uuid.uuid4())
deployment, _ = deploy(dsl_path, blueprint_id=blueprint_id)
self.assertEqual(blueprint_id, deployment.blueprint_id)
blueprint = self.client.blueprints.get(blueprint_id)
self.assertEqual(blueprint_id, blueprint.id)
self.assertTrue(len(blueprint['plan']) > 0)
def test_publish_tar_archive(self):
archive_location = self._make_archive_file("dsl/basic.yaml")
blueprint_id = self.client.blueprints.publish_archive(
archive_location, str(uuid.uuid4()), 'basic.yaml').id
# verifying blueprint exists
result = self.client.blueprints.get(blueprint_id)
self.assertEqual(blueprint_id, result.id)
def test_publish_bz2_archive_from_url(self):
port = 53231
archive_location = self._make_archive_file("dsl/basic.yaml", 'w:bz2')
archive_filename = os.path.basename(archive_location)
archive_dir = os.path.dirname(archive_location)
archive_url = 'http://localhost:{0}/{1}'.format(
port, archive_filename)
fs = FileServer(archive_dir, False, port)
fs.start()
try:
wait_for_url(archive_url, timeout=30)
blueprint_id = self.client.blueprints.publish_archive(
archive_url,
str(uuid.uuid4()),
'basic.yaml').id
# verifying blueprint exists
result = self.client.blueprints.get(blueprint_id)
self.assertEqual(blueprint_id, result.id)
finally:
fs.stop()
def _make_archive_file(self, blueprint_path, write_mode='w'):
dsl_path = resource(blueprint_path)
blueprint_dir = os.path.dirname(dsl_path)
archive_location = tempfile.mkstemp()[1]
arcname = os.path.basename(blueprint_dir)
with tarfile.open(archive_location, write_mode) as tar:
tar.add(blueprint_dir, arcname=arcname)
return archive_location
def test_delete_blueprint(self):
dsl_path = resource("dsl/basic.yaml")
blueprint_id = self.client.blueprints.upload(dsl_path,
str(uuid.uuid4())).id
# verifying blueprint exists
result = self.client.blueprints.get(blueprint_id)
self.assertEqual(blueprint_id, result.id)
# deleting blueprint
deleted_bp_id = self.client.blueprints.delete(blueprint_id).id
self.assertEqual(blueprint_id, deleted_bp_id)
# verifying blueprint does no longer exist
try:
self.client.blueprints.get(blueprint_id)
self.fail("Got blueprint {0} successfully even though it "
"wasn't expected to exist".format(blueprint_id))
except CloudifyClientError:
pass
# trying to delete a nonexistent blueprint
try:
self.client.blueprints.delete(blueprint_id)
self.fail("Deleted blueprint {0} successfully even though it "
"wasn't expected to exist".format(blueprint_id))
except CloudifyClientError:
pass
def test_delete_deployment(self):
dsl_path = resource("dsl/basic.yaml")
blueprint_id = self.id()
deployment_id = str(uuid.uuid4())
def change_execution_status(_execution_id, status):
self.client.executions.update(_execution_id, status)
executions = self.client.executions.list(deployment_id)
updated_execution = next(execution for execution in executions
if execution.id == _execution_id)
self.assertEqual(status, updated_execution.status)
# verifying a deletion of a new deployment, i.e. one which hasn't
# been installed yet, and therefore all its nodes are still in
# 'uninitialized' state.
self.client.blueprints.upload(dsl_path, blueprint_id)
self.client.deployments.create(blueprint_id, deployment_id)
do_retries(verify_deployment_environment_creation_complete, 30,
deployment_id=deployment_id)
delete_deployment(deployment_id, False)
self.client.blueprints.delete(blueprint_id)
# recreating the deployment, this time actually deploying it too
_, execution_id = deploy(dsl_path,
blueprint_id=blueprint_id,
deployment_id=deployment_id,
wait_for_execution=True)
execs = self.client.executions.list(include_system_workflows=True)
self.assertEqual(Execution.TERMINATED,
next(execution for execution in execs if
execution.id == execution_id).status)
# verifying deployment exists
result = self.client.deployments.get(deployment_id)
self.assertEqual(deployment_id, result.id)
# retrieving deployment nodes
nodes = self.client.node_instances.list(deployment_id=deployment_id)
self.assertTrue(len(nodes) > 0)
# setting one node's state to 'started' (making it a 'live' node)
# node must be read using get in order for it to have a version.
node = self.client.node_instances.get(nodes[0].id)
self.client.node_instances.update(node.id,
state='started',
version=node.version)
# setting the execution's status to 'started' so it'll prevent the
# deployment deletion
change_execution_status(execution_id, Execution.STARTED)
# attempting to delete the deployment - should fail because the
# execution is active
try:
delete_deployment(deployment_id)
self.fail("Deleted deployment {0} successfully even though it "
"should have had a running execution"
.format(deployment_id))
except CloudifyClientError, e:
self.assertTrue('running executions' in str(e))
# setting the execution's status to 'terminated' so it won't prevent
# the deployment deletion
change_execution_status(execution_id, Execution.TERMINATED)
modification = self.client.deployment_modifications.start(
deployment_id,
nodes={'webserver_host': {'instances': 2}})
self.client.deployment_modifications.finish(modification.id)
# get updated node instances list
nodes = self.client.node_instances.list(deployment_id=deployment_id)
self.assertTrue(len(nodes) > 0)
nodes_ids = [_node.id for _node in nodes]
# attempting to delete deployment - should fail because there are
# live nodes for this deployment
try:
delete_deployment(deployment_id)
self.fail("Deleted deployment {0} successfully even though it "
"should have had live nodes and the ignore_live_nodes "
"flag was set to False".format(deployment_id))
except CloudifyClientError, e:
self.assertTrue('live nodes' in str(e))
def test_delete_deployment(self):
dsl_path = resource("dsl/basic.yaml")
blueprint_id = self.id()
deployment_id = str(uuid.uuid4())
def change_execution_status(_execution_id, status):
self.client.executions.update(_execution_id, status)
executions = self.client.executions.list(deployment_id)
updated_execution = next(execution for execution in executions
if execution.id == _execution_id)
self.assertEqual(status, updated_execution.status)
# verifying a deletion of a new deployment, i.e. one which hasn't
# been installed yet, and therefore all its nodes are still in
# 'uninitialized' state.
self.client.blueprints.upload(dsl_path, blueprint_id)
self.client.deployments.create(blueprint_id, deployment_id)
do_retries(verify_deployment_environment_creation_complete, 30,
deployment_id=deployment_id)
delete_deployment(deployment_id, False)
self.client.blueprints.delete(blueprint_id)
# recreating the deployment, this time actually deploying it too
_, execution_id = deploy(dsl_path,
blueprint_id=blueprint_id,
deployment_id=deployment_id,
wait_for_execution=True)
execs = self.client.executions.list(include_system_workflows=True)
self.assertEqual(Execution.TERMINATED,
next(execution for execution in execs if
execution.id == execution_id).status)
# verifying deployment exists
result = self.client.deployments.get(deployment_id)
self.assertEqual(deployment_id, result.id)
# retrieving deployment nodes
nodes = self.client.node_instances.list(deployment_id=deployment_id)
self.assertTrue(len(nodes) > 0)
# setting one node's state to 'started' (making it a 'live' node)
# node must be read using get in order for it to have a version.
node = self.client.node_instances.get(nodes[0].id)
self.client.node_instances.update(node.id,
state='started',
version=node.version)
# setting the execution's status to 'started' so it'll prevent the
# deployment deletion
change_execution_status(execution_id, Execution.STARTED)
# attempting to delete the deployment - should fail because the
# execution is active
try:
delete_deployment(deployment_id)
self.fail("Deleted deployment {0} successfully even though it "
"should have had a running execution"
.format(deployment_id))
except CloudifyClientError, e:
self.assertTrue('running executions' in str(e))
self.assertTrue(len(nodes) > 0)
nodes_ids = [_node.id for _node in nodes]
# attempting to delete deployment - should fail because there are
# live nodes for this deployment
try:
delete_deployment(deployment_id)
self.fail("Deleted deployment {0} successfully even though it "
"should have had live nodes and the ignore_live_nodes "
"flag was set to False".format(deployment_id))
except CloudifyClientError, e:
self.assertTrue('live nodes' in str(e))
# deleting deployment - this time there's no execution running,
# and using the ignore_live_nodes parameter to force deletion
deleted_deployment_id = delete_deployment(deployment_id, True).id
self.assertEqual(deployment_id, deleted_deployment_id)
# verifying deployment does no longer exist
try:
self.client.deployments.get(deployment_id)
self.fail("Got deployment {0} successfully even though it "
"wasn't expected to exist".format(deployment_id))
except CloudifyClientError, e:
self.assertTrue('not found' in str(e))
# verifying deployment's execution does no longer exist
try:
self.client.executions.get(execution_id)
self.fail('execution {0} still exists even though it should have '
'been deleted when its deployment was deleted'
def test_delete_deployment(self):
dsl_path = get_resource("dsl/basic.yaml")
blueprint_id = self.id()
deployment_id = str(uuid.uuid4())
def change_execution_status(execution_id, status):
self.client.executions.update(execution_id, status)
updated_execution = self.client.executions.get(deployment_id)
self.assertEqual(status, updated_execution.status)
@contextmanager
def client_error_check(expect_in_error_message, failer_message):
try:
yield
self.fail(failer_message)
except CloudifyClientError as exc:
self.assertTrue(expect_in_error_message in str(exc))
# verifying a deletion of a new deployment, i.e. one which hasn't
# been installed yet, and therefore all its nodes are still in
# 'uninitialized' state.
self.client.blueprints.upload(dsl_path, blueprint_id)
self.client.deployments.create(blueprint_id, deployment_id)
do_retries(verify_deployment_environment_creation_complete,
timeout_seconds=30,
deployment_id=deployment_id)
delete_deployment(deployment_id, ignore_live_nodes=False)
self.client.blueprints.delete(blueprint_id)
# recreating the deployment, this time actually deploying it too
_, execution_id = deploy_application(
dsl_path,
blueprint_id=blueprint_id,
deployment_id=deployment_id,
wait_for_execution=True)
execution = self.client.executions.get(execution_id)
self.assertEqual(Execution.TERMINATED, execution.status)
# verifying deployment exists
deployment = self.client.deployments.get(deployment_id)
self.assertEqual(deployment_id, deployment.id)
# retrieving deployment nodes
nodes = self.client.node_instances.list(deployment_id=deployment_id)
self.assertTrue(len(nodes) > 0)
# setting one node's state to 'started' (making it a 'live' node)
# node must be read using get in order for it to have a version.
node = self.client.node_instances.get(nodes[0].id)
self.client.node_instances.update(
node.id, state='started', version=node.version)
modification = self.client.deployment_modifications.start(
deployment_id,
nodes={'webserver_host': {'instances': 2}})
self.client.deployment_modifications.finish(modification.id)
# get updated node instances list
nodes = self.client.node_instances.list(deployment_id=deployment_id)
self.assertTrue(len(nodes) > 0)
nodes_ids = [_node.id for _node in nodes]
# attempting to delete deployment - should fail because there are
# live nodes for this deployment
with client_error_check(
failer_message='Deleted deployment {0} successfully even '
'though it should have had live nodes and the '
'ignore_live_nodes flag was set to False'
.format(deployment_id),
expect_in_error_message='live nodes'):
delete_deployment(deployment_id)
# deleting deployment - this time there's no execution running,
# and using the ignore_live_nodes parameter to force deletion
deleted_deployment_id = delete_deployment(deployment_id, True).id
self.assertEqual(deployment_id, deleted_deployment_id)
# verifying deployment does no longer exist
with client_error_check(
failer_message="Got deployment {0} successfully even though "
"it wasn't expected to exist"
.format(deployment_id),
expect_in_error_message='not found'):
self.client.deployments.get(deployment_id)
# verifying deployment's execution does no longer exist
with client_error_check(
failer_message='execution {0} still exists even though it '
'should have been deleted when its deployment '
'was deleted'.format(execution_id),
expect_in_error_message='not found'):
self.client.executions.get(execution_id)
# verifying deployment modification no longer exists
with client_error_check(
failer_message='deployment modification {0} still exists even '
'though it should have been deleted when its '
'deployment was deleted',
expect_in_error_message='not found'):
self.client.deployment_modifications.get(modification.id)
# verifying deployment's nodes do no longer exist
for node_id in nodes_ids:
with client_error_check(
failer_message='node {0} still exists even though it '
'should have been deleted when its '
'deployment was deleted'.format(node_id),
expect_in_error_message='not found'):
self.client.node_instances.get(node_id)
# trying to delete a nonexistent deployment
with client_error_check(
failer_message="Deleted deployment {0} successfully even "
"though it wasn't expected to exist"
.format(deployment_id),
expect_in_error_message='not found'):
delete_deployment(deployment_id)
