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 = 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)