def test_deployment_logs(self):
message = 'TEST MESSAGE'
inputs = {'message': message}
dsl_path = resource("dsl/deployment_logs.yaml")
deployment, _ = deploy(dsl_path, inputs=inputs)
deployment_log_path = ('/var/log/cloudify/mgmtworker/logs/{0}.log'
.format(deployment.id))
def read_deployment_logs():
return self.read_manager_file(deployment_log_path, no_strip=True)
def verify_logs_exist_with_content():
self.assertIn(message, read_deployment_logs())
verify_logs_exist_with_content()
undeploy(deployment.id, is_delete_deployment=True)
# Verify log file id truncated on deployment delete
self.assertEqual('', read_deployment_logs())
deployment, _ = deploy(dsl_path, inputs=inputs,
deployment_id=deployment.id)
# Verify new deployment with the same deployment id
# can write to the previous location.
verify_logs_exist_with_content()
def _local_task_fail_impl(self, wf_name):
if self.do_get:
deploy(resource('dsl/workflow_api.yaml'),
wf_name,
parameters={'do_get': self.do_get})
else:
self.assertRaises(RuntimeError,
deploy,
resource('dsl/workflow_api.yaml'),
wf_name,
parameters={'do_get': self.do_get})
def _verify_plugin_can_be_used_in_blueprint(self):
blueprint_path = resource('dsl/managed_plugins.yaml')
test_input_value = 'MY_TEST_INPUT'
inputs = {'test_input': test_input_value}
deployment, _ = deploy(blueprint_path, inputs=inputs)
outputs = self.client.deployments.outputs.get(deployment.id)
self.assertEqual(outputs.outputs['test_output'], test_input_value)
def test_hello_world(self):
blueprint_file = self._prepare_hello_world()
deployment, _ = deploy(blueprint_file, timeout_seconds=120)
self._assert_hello_world_events(deployment.id)
self._assert_hello_world_metric(deployment.id)
ip = self.test_case.get_host_ip(node_id='vm',
deployment_id=deployment.id)
url = 'http://{0}:8080'.format(ip)
def _webserver_request():
return requests.get(url, timeout=1)
# assert webserver running
response = utils.do_retries(
_webserver_request,
exception_class=requests.exceptions.ConnectionError)
self.test_case.assertIn('http_web_server', response.text)
if not self.skip_uninstall:
utils.undeploy_application(deployment.id)
# assert webserver not running
self.test_case.assertRaises(requests.exceptions.ConnectionError,
_webserver_request)
return deployment
def test_post_source_started_location_target(self):
dsl_path = resource(
"dsl/relationship_interface_post_source_location_target.yaml")
deployment, _ = deploy(dsl_path)
self.verify_assertions(deployment.id,
hook='post-init',
runs_on_source=False)
def get_and_download_deployment_resource_test(self):
blueprint_id = str(uuid.uuid4())
deployment_id = blueprint_id
blueprint_path = resource('dsl/deployment_resource.yaml')
deployment_folder_on_manager = \
'/opt/manager/resources/deployments/{0}'.format(deployment_id)
full_resource_path = os.path.join(deployment_folder_on_manager,
RESOURCE_PATH)
self.execute_on_manager(
'mkdir -p {0}/resources'.format(deployment_folder_on_manager))
with tempfile.NamedTemporaryFile() as f:
f.write(RESOURCE_CONTENT)
f.flush()
self.copy_file_to_manager(source=f.name, target=full_resource_path)
self.execute_on_manager('chmod +r {0}'.format(full_resource_path))
deployment, _ = deploy(blueprint_path,
blueprint_id=blueprint_id,
deployment_id=deployment_id,
inputs={'resource_path': RESOURCE_PATH})
plugin_data = self.get_plugin_data(plugin_name='testmockoperations',
deployment_id=deployment.id)
get_resource_content = plugin_data['get_resource']
download_resource_path = plugin_data['download_resource']
self.assertEquals(RESOURCE_CONTENT, get_resource_content)
self.assertEquals(RESOURCE_CONTENT,
self.read_manager_file(download_resource_path))
self.client.deployments.delete(deployment_id, ignore_live_nodes=True)
self.assertRaises(sh.ErrorReturnCode, self.execute_on_manager,
'test -d {0}'.format(deployment_folder_on_manager))
def test_pre_source_started_location_source(self):
dsl_path = resource(
"dsl/relationship_interface_pre_source_location_source.yaml")
deployment, _ = deploy(dsl_path)
self.verify_assertions(deployment.id,
hook='pre-init',
runs_on_source=True)
def test_events_timestamp_format(self):
dsl_path = resource('dsl/empty_blueprint.yaml')
deployment, _ = deploy(dsl_path)
# connect to Elastic search
es = elasticsearch.Elasticsearch(hosts=[{
'host': utils.get_manager_ip(),
'port': 9200
}])
index = "cloudify_events" if es.indices.exists(
index=["cloudify_events"]) else "logstash-*"
def read_events():
res = es.search(
index=index,
body={"query": {
"match": {
"deployment_id": deployment.id
}
}})
# check if events were created
self.assertNotEqual(
0, res['hits']['total'], 'There are no events in for '
'deployment ' + deployment.id)
return res
result = self.do_assertions(read_events, timeout=120)
# loop over all the events and compare timestamp to regular expression
for hit in result['hits']['hits']:
if not (re.match(TIMESTAMP_PATTERN, hit["_source"]['timestamp'])):
self.fail('Got {0}. Does not match format '
'YYYY-MM-DDTHH:MM:SS.***Z'.format(
hit["_source"]['timestamp']))
def test_policies_flow_with_diamond(self):
dsl_path = resource('dsl/with_policies_and_diamond.yaml')
self.deployment, _ = deploy(dsl_path)
expected_metric_value = 42
self.wait_for_executions(3)
invocations = self.wait_for_invocations(self.deployment.id, 1)
self.assertEqual(expected_metric_value, invocations[0]['metric'])
def test_workflow_deployment_scaling_groups(self):
deployment, _ = deploy(resource('dsl/store-scaling-groups.yaml'),
workflow_name='workflow')
instance = self.client.node_instances.list(deployment.id)[0]
self.assertEqual(
['node'],
instance.runtime_properties['scaling_groups']['group1']['members'])
def test_uninstall_with_dependency_order(self):
dsl_path = resource(
"dsl/uninstall_dependencies-order-with-three-nodes.yaml")
deployment, _ = deploy(dsl_path)
deployment_id = deployment.id
undeploy(deployment_id)
# Checking that uninstall wasn't called on the contained node
states = self.get_plugin_data(plugin_name='testmockoperations',
deployment_id=deployment_id)['state']
node1_id = states[0]['id']
node2_id = states[1]['id']
node3_id = states[2]['id']
unreachable_call_order = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment_id)['unreachable_call_order']
self.assertEquals(3, len(unreachable_call_order))
self.assertEquals(node3_id, unreachable_call_order[0]['id'])
self.assertEquals(node2_id, unreachable_call_order[1]['id'])
self.assertEquals(node1_id, unreachable_call_order[2]['id'])
configurer_state = self.get_plugin_data(
plugin_name='connection_configurer_mock',
deployment_id=deployment_id)['state']
self.assertEquals(2, len(configurer_state))
self.assertTrue(
configurer_state[0]['source_id'].startswith('contained_in_node2'))
self.assertTrue(
configurer_state[0]['target_id'].startswith('contained_in_node1'))
self.assertTrue(
configurer_state[1]['target_id'].startswith('containing_node'))
self.assertTrue(
configurer_state[1]['source_id'].startswith('contained_in_node1'))
def test_cancel_on_wait_for_task_termination(self):
_, eid = deploy(resource('dsl/workflow_api.yaml'),
self._testMethodName,
parameters={'do_get': self.do_get},
wait_for_execution=False)
self.wait_for_execution_status(eid, status=Execution.STARTED)
self.client.executions.cancel(eid)
self.wait_for_execution_status(eid, status=Execution.CANCELLED)
def test_cancel_on_task_retry_interval(self):
self.configure(retries=2, interval=1000000)
_, eid = deploy(resource('dsl/workflow_api.yaml'),
self._testMethodName,
parameters={'do_get': self.do_get},
wait_for_execution=False)
self.wait_for_execution_status(eid, status=Execution.STARTED)
self.client.executions.cancel(eid)
self.wait_for_execution_status(eid, status=Execution.CANCELLED)
def test_subgraph_retries_provider_config_config(self):
context = {
'cloudify': {
'workflows': {
'task_retries': 0,
'task_retry_interval': 0,
'subgraph_retries': 2
}
}
}
deployment_id = str(uuid.uuid4())
self.client.manager.create_context(self._testMethodName, context)
deploy(resource('dsl/workflow_subgraph_retries.yaml'),
deployment_id=deployment_id)
invocations = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment_id)['failure_invocation']
self.assertEqual(len(invocations), 3)
def test_deployment_modifications_sort(self):
deployment = deploy(resource('dsl/sort.yaml'))
for i in range(2, 12):
modification = self.client.deployment_modifications.start(
deployment_id=deployment.id, nodes={'node': {
'instances': i
}})
self.client.deployment_modifications.finish(modification.id)
self._test_sort('deployment_modifications', 'deployment_id')
def test_script_mapping(self):
dsl_path = resource('dsl/test_script_mapping.yaml')
deployment, _ = deploy(dsl_path)
execute_workflow('workflow', deployment.id)
data = self.get_plugin_data(plugin_name='script',
deployment_id=deployment.id)
self.assertEqual(data['op1_called_with_property'], 'op2_called')
self.assertEqual(data['op2_prop'], 'op2_value')
def _test_custom_workflow(self, workflow, error_expected=False):
deployment = deploy(resource("dsl/basic_task_not_exist.yaml"))
try:
execute_workflow(workflow, deployment.id)
if error_expected:
self.fail('RuntimeError expected')
except RuntimeError as e:
if not error_expected:
self.fail('Success expected. error message: {0}'.format(e))
self.assertIn(self.AGENT_ALIVE_FAIL, str(e))
def test_operation_retry(self):
self.configure(retries=5, retry_interval=5)
deployment_id = str(uuid.uuid4())
deploy(resource('dsl/test-operation-retry-blueprint.yaml'),
deployment_id=deployment_id)
invocations = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment_id)['retry_invocations']
self.assertEqual(4, invocations)
# 1 asserting event messages reflect that the task has been rescheduled
# 2 asserting that task events contain current_retries/total_retries
# only asserting that the properties exists and nothing logical
# because this is already covered in the local workflow tests
def assertion():
events = self.client.events.list(deployment_id=deployment_id,
include_logs=True)
self.assertGreater(len(events), 0)
for event in events:
if 'Task rescheduled' in event['message']['text']:
break
else:
self.fail('could not find expected message')
for event in events:
if 'Retrying operation' in event['message']['text']:
break
else:
self.fail('could not find expected message')
events = [
e for e in events
if e.get('event_type', '').startswith('task_')
or e.get('event_type', '') == 'sending_task'
]
seen_current_retries = set()
for event in events:
current_retries = event['context']['task_current_retries']
seen_current_retries.add(current_retries)
total_retries = event['context']['task_total_retries']
self.assertEqual(total_retries, 5)
self.assertSetEqual(seen_current_retries, {0, 1, 2, 3})
# events are async so we may have to wait some
self.do_assertions(assertion, timeout=120)
def test_failed_uninstall_task(self):
dsl_path = resource('dsl/basic_stop_error.yaml')
deployment, _ = deploy(dsl_path)
deployment_id = deployment.id
undeploy(deployment_id, parameters={'ignore_failure': True})
machines = self.get_plugin_data(
plugin_name='cloudmock', deployment_id=deployment_id)['machines']
self.assertEquals(0, len(machines))
def launch_deployment(self, yaml_file, expected_num_of_node_instances=1):
deployment, _ = deploy(resource(yaml_file))
self.deployment = deployment
self.node_instances = self.client.node_instances.list(deployment.id)
self.assertEqual(
expected_num_of_node_instances,
len(self.node_instances)
)
self.wait_for_executions(self.NUM_OF_INITIAL_WORKFLOWS,
expect_exact_count=False)
def test_operation_mapping_override(self):
dsl_path = resource("dsl/operation_mapping.yaml")
deployment, _ = deploy(dsl_path, 'workflow2')
invocations = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment.id)['mock_operation_invocation']
self.assertEqual(3, len(invocations))
for invocation in invocations:
self.assertEqual(1, len(invocation))
self.assertEqual(invocation['test_key'], 'overridden_test_value')
def test_sort_executions(self):
dsl_path = resource("dsl/basic.yaml")
deployment, execution_id = deploy(dsl_path)
wait_for_execution_to_end(self.client.executions.get(execution_id))
deployment, execution_id = deploy(dsl_path)
wait_for_execution_to_end(self.client.executions.get(execution_id))
deployments_executions = self.client.executions.list(sort='created_at')
for i in range(len(deployments_executions) - 1):
self.assertTrue(
deployments_executions[i]['created_at'] <
deployments_executions[i + 1]['created_at'],
'execution list not sorted correctly')
deployments_executions = self.client.executions.list(
sort='created_at', is_descending=True)
for i in range(len(deployments_executions) - 1):
self.assertTrue(
deployments_executions[i]['created_at'] >
deployments_executions[i + 1]['created_at'],
'execution list not sorted correctly')
def test_uninstall_application_single_host_node(self):
dsl_path = resource("dsl/basic.yaml")
deployment, _ = deploy(dsl_path)
deployment_id = deployment.id
undeploy(deployment_id)
machines = self.get_plugin_data(
plugin_name='cloudmock', deployment_id=deployment_id)['machines']
self.assertEquals(0, len(machines))
def test_fail_remote_task_eventual_success(self):
deployment, _ = deploy(resource('dsl/workflow_api.yaml'),
self._testMethodName,
parameters={'do_get': self.do_get})
# testing workflow remote task
invocations = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment.id)['failure_invocation']
self.assertEqual(3, len(invocations))
for i in range(len(invocations) - 1):
self.assertLessEqual(1, invocations[i + 1] - invocations[i])
def test_deploy_multi_instance_many_different_hosts(self):
dsl_path = resource('dsl/multi_instance_many_different_hosts.yaml')
deployment, _ = deploy(dsl_path, timeout_seconds=60)
machines = set(
self.get_plugin_data(plugin_name='cloudmock',
deployment_id=deployment.id)['machines'])
self.assertEquals(15, len(machines))
self.assertEquals(
5, len(filter(lambda ma: ma.startswith('host1'), machines)))
self.assertEquals(
5, len(filter(lambda ma: ma.startswith('host2'), machines)))
self.assertEquals(
5, len(filter(lambda ma: ma.startswith('host3'), machines)))
def test_update_node_bad_version(self):
deploy(resource("dsl/basic.yaml"))
client = self.client
instance = client.node_instances.list()[0]
instance = client.node_instances.get(instance.id) # need the version
props = {'key': 'value'}
result = client.node_instances.update(
instance.id,
state='started',
runtime_properties=props,
version=instance.version,
)
self.assertEquals(instance.version + 1, result.version)
self.assertEquals(instance.id, result.id)
self.assertDictContainsSubset(props, result.runtime_properties)
self.assertEquals('started', result.state)
# making another call with a bad version
self.assertRaises(CloudifyClientError,
client.node_instances.update,
instance.id,
version=1)
def test_stop_monitor_node_operation(self):
dsl_path = resource("dsl/hardcoded_operation_properties.yaml")
deployment, _ = deploy(dsl_path)
deployment_id = deployment.id
undeploy(deployment_id)
# test stop monitor invocations
invocations = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment_id)['monitoring_operations_invocation']
self.assertEqual(2, len(invocations))
self.assertTrue('single_node' in invocations[0]['id'])
self.assertEquals('start_monitor', invocations[0]['operation'])
self.assertTrue('single_node' in invocations[1]['id'])
self.assertEquals('stop_monitor', invocations[1]['operation'])
def test_deploy_multi_instance_application(self):
dsl_path = resource("dsl/multi_instance.yaml")
deployment, _ = deploy(dsl_path)
machines = set(
self.get_plugin_data(plugin_name='cloudmock',
deployment_id=deployment.id)['machines'])
self.assertEquals(2, len(machines))
apps_state = self.get_plugin_data(plugin_name='testmockoperations',
deployment_id=deployment.id)['state']
machines_with_apps = set([])
for app_state in apps_state:
host_id = app_state['capabilities'].keys()[0]
machines_with_apps.add(host_id)
self.assertEquals(machines, machines_with_apps)
def _test_retries_and_retry_interval_impl(self,
blueprint,
retries,
retry_interval,
expected_interval,
expected_retries,
invocations_type,
expect_failure=False):
self.configure(retries=retries, retry_interval=retry_interval)
deployment_id = str(uuid.uuid4())
if expect_failure:
self.assertRaises(RuntimeError,
deploy,
dsl_path=resource(blueprint),
deployment_id=deployment_id)
else:
deploy(resource(blueprint), deployment_id=deployment_id)
invocations = self.get_plugin_data(
plugin_name='testmockoperations',
deployment_id=deployment_id)[invocations_type]
self.assertEqual(expected_retries + 1, len(invocations))
for i in range(len(invocations) - 1):
self.assertLessEqual(expected_interval,
invocations[i + 1] - invocations[i])
def _retrieve_resource_test(self, mode):
blueprint_id = 'blueprint-' + str(uuid.uuid4())
deployment, _ = deploy(self.dsl_path,
blueprint_id=blueprint_id,
timeout_seconds=15,
inputs={
'rendering_tests_demo_conf':
self.template_path,
'mode': mode
})
rendered_resource = \
self.get_plugin_data('testmockoperations',
deployment.id)['rendered_resource']
expected = self._get_expected_template()
return expected, rendered_resource
