class RetrieveResourceRenderingTest(AgentlessTestCase):
dsl_path = resource('dsl/test-retrieve-resource-template.yaml')
template_path = 'jinja_rendering/for_template_rendering_tests.conf'
rendered_template_path = \
resource('dsl/jinja_rendering/rendered_template.conf')
def _get_expected_template(self):
with open(self.rendered_template_path, 'r') as f:
return f.read()
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
def test_get_resource_template(self):
expected, rendered_resource = self._retrieve_resource_test('get')
self.assertEqual(expected, rendered_resource)
def test_download_resource_template(self):
expected, rendered_resource_path = \
self._retrieve_resource_test('download')
out = self.read_manager_file(rendered_resource_path)
self.assertEqual(expected, out)
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_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 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_illegal_non_graph_to_graph_mode(self):
if not self.do_get:
# no need to run twice
return
self.assertRaises(RuntimeError, deploy,
resource('dsl/workflow_api.yaml'),
self._testMethodName)
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 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_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 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_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 _assert_upload_blueprint(self):
blueprint_path = resource('dsl/empty_blueprint.yaml')
# admins and deployers should be able to upload blueprints...
blueprint1_id = 'blueprint1_id'
blueprint2_id = 'blueprint2_id'
with self._login_cli(self.admin_username, self.admin_password):
self.cfy.blueprints.upload(blueprint_path,
blueprint_id=blueprint1_id)
with self._login_cli(self.deployer_username, self.deployer_password):
self.cfy.blueprints.upload(blueprint_path,
blueprint_id=blueprint2_id)
# ...but viewers and simple users should not
with self._login_cli(self.viewer_username, self.viewer_password):
self._assert_unauthorized(self.cfy.blueprints.upload,
blueprint_path,
blueprint_id='dummy_bp')
with self._login_cli(self.no_role_username, self.no_role_password):
self._assert_unauthorized(self.cfy.blueprints.upload,
blueprint_path,
blueprint_id='dummy_bp')
return blueprint1_id, blueprint2_id
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_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_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 _assert_plugins_installed(self):
local_script_path = resource('scripts/test_rest_plugins.sh')
remote_script_path = '/root/test_rest_plugins.sh'
self.copy_file_to_manager(source=local_script_path,
target=remote_script_path)
output = self.execute_on_manager('bash {0}'.format(remote_script_path))
# This tells us that plugin-template was successfully installed
self.assertIn('imported_plugin_tasks', output)
# This tells us that mock-rest-plugin was successfully installed
self.assertIn('mock_attribute_value', output)
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 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_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 test_node_operation_different_inputs(self):
"""
Tests storing different nodes with different structured inputs for
the same operation.
"""
blueprint_id = str(uuid.uuid4())
blueprint = self.client.blueprints.upload(
resource("dsl/two_nodes_different_inputs.yaml"), blueprint_id)
deployment_id = str(uuid.uuid4())
self.client.deployments.create(blueprint.id, deployment_id)
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 _create_execution(self):
blueprint_id = str(uuid.uuid4())
deployment_id = blueprint_id
blueprint_path = resource('dsl/empty_blueprint.yaml')
self.client.blueprints.upload(
blueprint_path=blueprint_path,
blueprint_id=blueprint_id)
self.client.deployments.create(
blueprint_id=blueprint_id,
deployment_id=deployment_id)
return self.client.executions.list(deployment_id=deployment_id)[0]
def _test_client(self, client_version, url_version_postfix):
shell_script_path = resource('scripts/test_old_rest_client.sh')
python_script_path = resource('scripts/test_old_rest_client.py')
result_path = os.path.join(self.workdir, 'result.json')
env = os.environ.copy()
env.update({
'python_script_path': python_script_path,
'client_version': client_version,
'manager_ip': utils.get_manager_ip(),
'url_version_postfix': url_version_postfix,
'result_path': result_path
})
subprocess.check_call(shell_script_path,
shell=True,
cwd=self.workdir,
env=env)
with open(result_path) as f:
result = json.load(f)
if result['failed']:
self.fail('Failed to get manager status from old client. '
'[error={0}]'.format(result['details']))
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_script_mapping_to_deployment_resource(self):
dsl_path = resource('dsl/test_script_mapping.yaml')
deployment, _ = deploy(dsl_path)
workflow_script_path = resource('dsl/scripts/workflows/workflow.py')
with open(workflow_script_path, 'r') as f:
workflow_script_content = f.read()
deployment_folder = ('/opt/manager/resources/deployments/{0}'.format(
deployment.id))
workflow_folder = os.path.join(deployment_folder, 'scripts/workflows')
try:
self.execute_on_manager('mkdir -p {0}'.format(workflow_folder))
deployment_workflow_script_path = os.path.join(
workflow_folder, 'workflow.py')
self.logger.info('Writing workflow.py to: {0}'.format(
deployment_workflow_script_path))
with tempfile.NamedTemporaryFile() as f:
f.write(workflow_script_content)
f.write(os.linesep)
f.write("instance.execute_operation('test.op3')")
f.write(os.linesep)
f.flush()
self.copy_file_to_manager(
source=f.name, target=deployment_workflow_script_path)
self.execute_on_manager(
'chmod 644 {0}'.format(deployment_workflow_script_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')
self.assertIn('op3_called', data)
finally:
self.execute_on_manager('rm -rf {0}'.format(deployment_folder))
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)
