def test_get_blueprint_deployments(self):
now = str(datetime.now())
blueprint = models.BlueprintState(id='blueprint-id',
created_at=now,
updated_at=now,
plan={'name': 'my-bp'},
source='bp-source')
storage_manager.instance().put_blueprint('blueprint-id', blueprint)
deployment1 = models.Deployment(id='dep-1',
created_at=now,
updated_at=now,
blueprint_id='blueprint-id',
plan={'name': 'my-bp'},
permalink=None,
workflows={},
inputs={},
policy_types={},
policy_triggers={},
groups={},
outputs={})
storage_manager.instance().put_deployment('dep-1', deployment1)
deployment2 = models.Deployment(id='dep-2',
created_at=now,
updated_at=now,
blueprint_id='blueprint-id',
plan={'name': 'my-bp'},
permalink=None,
workflows={},
inputs={},
policy_types={},
policy_triggers={},
groups={},
outputs={})
storage_manager.instance().put_deployment('dep-2', deployment2)
deployment3 = models.Deployment(id='dep-3',
created_at=now,
updated_at=now,
blueprint_id='another-blueprint-id',
plan={'name': 'my-bp'},
permalink=None,
workflows={},
inputs={},
policy_types={},
policy_triggers={},
groups={},
outputs={})
storage_manager.instance().put_deployment('dep-3', deployment3)
blueprint_deployments = storage_manager.instance()\
.get_blueprint_deployments(
'blueprint-id')
self.assertEquals(2, len(blueprint_deployments))
self.assertEquals(deployment1.__dict__,
blueprint_deployments[0].__dict__)
self.assertEquals(deployment2.__dict__,
blueprint_deployments[1].__dict__)
def test_fields_query(self):
now = str(datetime.now())
blueprint = models.BlueprintState(id='blueprint-id',
created_at=now,
updated_at=now,
plan={'name': 'my-bp'},
source='bp-source')
storage_manager.instance().put_blueprint('blueprint-id', blueprint)
blueprint_restored = \
storage_manager.instance().get_blueprint('blueprint-id',
{'id', 'created_at'})
self.assertEquals('blueprint-id', blueprint_restored.id)
self.assertEquals(now, blueprint_restored.created_at)
self.assertEquals(None, blueprint_restored.updated_at)
self.assertEquals(None, blueprint_restored.plan)
class BlueprintsManager(object):
@property
def sm(self):
return get_storage_manager()
def blueprints_list(self, include=None):
return self.sm.blueprints_list(include=include)
def deployments_list(self, include=None):
return self.sm.deployments_list(include=include)
def executions_list(self, deployment_id=None, include=None):
return self.sm.executions_list(deployment_id=deployment_id,
include=include)
def get_blueprint(self, blueprint_id, include=None):
return self.sm.get_blueprint(blueprint_id, include=include)
def get_deployment(self, deployment_id, include=None):
return self.sm.get_deployment(deployment_id=deployment_id,
include=include)
def get_execution(self, execution_id, include=None):
return self.sm.get_execution(execution_id, include=include)
# TODO: call celery tasks instead of doing this directly here
# TODO: prepare multi instance plan should be called on workflow execution
def publish_blueprint(self, dsl_location, alias_mapping_url,
resources_base_url, blueprint_id):
# TODO: error code if parsing fails (in one of the 2 tasks)
try:
plan = tasks.parse_dsl(dsl_location, alias_mapping_url,
resources_base_url)
except Exception, ex:
raise DslParseException(*ex.args)
now = str(datetime.now())
parsed_plan = json.loads(plan)
new_blueprint = models.BlueprintState(plan=parsed_plan,
id=blueprint_id,
created_at=now,
updated_at=now)
self.sm.put_blueprint(new_blueprint.id, new_blueprint)
return new_blueprint
def test_fields_query(self):
now = str(datetime.now())
blueprint = models.BlueprintState(id='blueprint-id',
created_at=now,
updated_at=now,
description=None,
plan={'name': 'my-bp'},
source='bp-source',
main_file_name='aaa')
sm = storage_manager._get_instance()
sm.put_blueprint('blueprint-id', blueprint)
blueprint_restored = sm.get_blueprint('blueprint-id',
{'id', 'created_at'})
self.assertEquals('blueprint-id', blueprint_restored.id)
self.assertEquals(now, blueprint_restored.created_at)
self.assertEquals(None, blueprint_restored.updated_at)
self.assertEquals(None, blueprint_restored.plan)
self.assertEquals(None, blueprint_restored.main_file_name)
def test_store_load_delete_blueprint(self):
now = str(datetime.now())
blueprint = models.BlueprintState(id='blueprint-id',
created_at=now,
updated_at=now,
plan={'name': 'my-bp'},
source='bp-source')
storage_manager.instance().put_blueprint('blueprint-id', blueprint)
blueprint_from_list = storage_manager.instance().blueprints_list()[0]
blueprint_restored = \
storage_manager.instance().get_blueprint('blueprint-id')
bp_from_delete = storage_manager.instance().delete_blueprint(
'blueprint-id')
self.assertEquals(blueprint.__dict__, blueprint_from_list.__dict__)
self.assertEquals(blueprint.__dict__, blueprint_restored.__dict__)
# in bp returned from delete operation only 'id' is guaranteed to
# return
self.assertEquals(blueprint.id, bp_from_delete.id)
self.assertEquals(0,
len(storage_manager.instance().blueprints_list()))
def test_store_load_delete_blueprint(self):
now = str(datetime.now())
sm = storage_manager._get_instance()
blueprint = models.BlueprintState(id='blueprint-id',
created_at=now,
updated_at=now,
description=None,
plan={'name': 'my-bp'},
source='bp-source',
main_file_name='aaa')
sm.put_blueprint('blueprint-id', blueprint)
blueprint_from_list = sm.blueprints_list().items[0]
blueprint_restored = sm.get_blueprint('blueprint-id')
bp_from_delete = sm.delete_blueprint('blueprint-id')
self.assertEquals(blueprint.to_dict(), blueprint_from_list.to_dict())
self.assertEquals(blueprint.to_dict(), blueprint_restored.to_dict())
# in bp returned from delete operation only 'id' is guaranteed to
# return
self.assertEquals(blueprint.id, bp_from_delete.id)
blueprints_list = sm.blueprints_list().items
self.assertEquals(0, len(blueprints_list))
class BlueprintsManager(object):
def __init__(self):
self.sm = storage_manager.get_storage_manager()
self.workflow_client = wf_client.get_workflow_client()
def blueprints_list(self, include=None, filters=None,
pagination=None, sort=None):
return self.sm.blueprints_list(include=include, filters=filters,
pagination=pagination, sort=sort)
def deployments_list(self, include=None, filters=None, pagination=None,
sort=None):
return self.sm.deployments_list(include=include, filters=filters,
pagination=pagination, sort=sort)
def snapshots_list(self, include=None, filters=None, pagination=None,
sort=None):
return self.sm.snapshots_list(include=include, filters=filters,
pagination=pagination, sort=sort)
def executions_list(self, include=None, is_include_system_workflows=False,
filters=None, pagination=None, sort=None):
filters = filters or {}
is_system_workflow = filters.get('is_system_workflow')
if is_system_workflow:
filters['is_system_workflow'] = []
for value in is_system_workflow:
value = str(value).lower() == 'true'
filters['is_system_workflow'].append(value)
elif not is_include_system_workflows:
filters['is_system_workflow'] = [False]
return self.sm.executions_list(include=include, filters=filters,
pagination=pagination, sort=sort)
def get_blueprint(self, blueprint_id, include=None):
return self.sm.get_blueprint(blueprint_id, include=include)
def get_snapshot(self, snapshot_id, include=None):
return self.sm.get_snapshot(snapshot_id, include=include)
def get_deployment(self, deployment_id, include=None):
return self.sm.get_deployment(deployment_id=deployment_id,
include=include)
def get_execution(self, execution_id, include=None):
return self.sm.get_execution(execution_id, include=include)
def get_plugin(self, plugin_id, include=None):
return self.sm.get_plugin(plugin_id, include=include)
def update_execution_status(self, execution_id, status, error):
execution = self.get_execution(execution_id)
if not self._validate_execution_update(execution.status, status):
raise manager_exceptions.InvalidExecutionUpdateStatus(
"Invalid relationship - can't change status from {0} to {1}"
.format(execution.status, status))
return self.sm.update_execution_status(
execution_id, status, error)
def _validate_execution_update(self, current_status, future_status):
if current_status in models.Execution.END_STATES:
return False
invalid_cancel_statuses = models.Execution.ACTIVE_STATES + [
models.Execution.TERMINATED]
if all((current_status == models.Execution.CANCELLING,
future_status in invalid_cancel_statuses)):
return False
invalid_force_cancel_statuses = invalid_cancel_statuses + [
models.Execution.CANCELLING]
if all((current_status == models.Execution.FORCE_CANCELLING,
future_status in invalid_force_cancel_statuses)):
return False
return True
def _get_conf_for_snapshots_wf(self):
return {
'file_server_root': config.instance().file_server_root,
'file_server_snapshots_folder':
config.instance().file_server_snapshots_folder,
'file_server_blueprints_folder':
config.instance().file_server_blueprints_folder,
'file_server_deployments_folder':
config.instance().file_server_deployments_folder,
'file_server_uploaded_blueprints_folder':
config.instance().file_server_uploaded_blueprints_folder,
'db_address': config.instance().db_address,
'db_port': config.instance().db_port,
'created_status': models.Snapshot.CREATED,
'failed_status': models.Snapshot.FAILED,
'file_server_uploaded_plugins_folder':
config.instance().file_server_uploaded_plugins_folder
}
def create_snapshot_model(self, snapshot_id,
status=models.Snapshot.CREATING):
now = str(datetime.now())
new_snapshot = models.Snapshot(id=snapshot_id,
created_at=now,
status=status,
error='')
self.sm.put_snapshot(snapshot_id, new_snapshot)
return new_snapshot
def update_snapshot_status(self, snapshot_id, status, error):
return self.sm.update_snapshot_status(snapshot_id, status, error)
def create_snapshot(self, snapshot_id,
include_metrics, include_credentials):
self.create_snapshot_model(snapshot_id)
try:
_, execution = self._execute_system_workflow(
wf_id='create_snapshot',
task_mapping='cloudify_system_workflows.snapshot.create',
execution_parameters={
'snapshot_id': snapshot_id,
'include_metrics': include_metrics,
'include_credentials': include_credentials,
'config': self._get_conf_for_snapshots_wf()
}
)
except manager_exceptions.ExistingRunningExecutionError:
self.delete_snapshot(snapshot_id)
raise
return execution
def restore_snapshot(self, snapshot_id, recreate_deployments_envs, force):
# Throws error if no snapshot found
snap = self.get_snapshot(snapshot_id)
if snap.status == models.Snapshot.FAILED:
raise manager_exceptions.SnapshotActionError(
'Failed snapshot cannot be restored'
)
_, execution = self._execute_system_workflow(
wf_id='restore_snapshot',
task_mapping='cloudify_system_workflows.snapshot.restore',
execution_parameters={
'snapshot_id': snapshot_id,
'recreate_deployments_envs': recreate_deployments_envs,
'config': self._get_conf_for_snapshots_wf(),
'force': force
}
)
return execution
def publish_blueprint(self,
application_dir,
application_file_name,
resources_base,
blueprint_id):
application_file = os.path.join(application_dir, application_file_name)
dsl_location = '{0}{1}'.format(resources_base, application_file)
try:
plan = tasks.parse_dsl(
dsl_location, resources_base,
**self._get_parser_context())
except Exception, ex:
raise DslParseException(str(ex))
now = str(datetime.now())
new_blueprint = models.BlueprintState(
plan=plan,
id=blueprint_id,
description=plan.get('description'),
created_at=now,
updated_at=now,
main_file_name=application_file_name)
self.sm.put_blueprint(new_blueprint.id, new_blueprint)
return new_blueprint
class BlueprintsManager(object):
def __init__(self):
self.sm = storage_manager.get_storage_manager()
self.workflow_client = wf_client.get_workflow_client()
def blueprints_list(self,
include=None,
filters=None,
pagination=None,
sort=None):
return self.sm.blueprints_list(include=include,
filters=filters,
pagination=pagination,
sort=sort)
def deployments_list(self,
include=None,
filters=None,
pagination=None,
sort=None):
return self.sm.deployments_list(include=include,
filters=filters,
pagination=pagination,
sort=sort)
def snapshots_list(self,
include=None,
filters=None,
pagination=None,
sort=None):
return self.sm.snapshots_list(include=include,
filters=filters,
pagination=pagination,
sort=sort)
def executions_list(self,
include=None,
is_include_system_workflows=False,
filters=None,
pagination=None,
sort=None):
filters = filters or {}
is_system_workflow = filters.get('is_system_workflow')
if is_system_workflow:
filters['is_system_workflow'] = []
for value in is_system_workflow:
value = str(value).lower() == 'true'
filters['is_system_workflow'].append(value)
elif not is_include_system_workflows:
filters['is_system_workflow'] = [False]
return self.sm.executions_list(include=include,
filters=filters,
pagination=pagination,
sort=sort)
def get_blueprint(self, blueprint_id, include=None):
return self.sm.get_blueprint(blueprint_id, include=include)
def get_snapshot(self, snapshot_id, include=None):
return self.sm.get_snapshot(snapshot_id, include=include)
def get_deployment(self, deployment_id, include=None):
return self.sm.get_deployment(deployment_id=deployment_id,
include=include)
def get_execution(self, execution_id, include=None):
return self.sm.get_execution(execution_id, include=include)
def get_plugin(self, plugin_id, include=None):
return self.sm.get_plugin(plugin_id, include=include)
def update_execution_status(self, execution_id, status, error):
if self._get_transient_deployment_workers_mode_config()['enabled'] and\
status in models.Execution.END_STATES:
execution = self.get_execution(execution_id)
# currently, the create and delete deployment environment
# workflows are still not marked as system workflows, so they're
# named explicitly
if not (execution.is_system_workflow or execution.workflow_id
in ('create_deployment_environment',
'delete_deployment_environment')):
# a user workflow has reached a final state - initiating
# a workflow to stop deployment workers
deployment = self.get_deployment(execution.deployment_id,
include=['id'])
wf_id = '_stop_deployment_environment'
deployment_env_creation_task_name = \
'cloudify_system_workflows.deployment_environment.stop'
exec_params = {'prerequisite_task_id': execution_id}
self._execute_system_workflow(
wf_id=wf_id,
task_mapping=deployment_env_creation_task_name,
deployment=deployment,
execution_parameters=exec_params)
return self.sm.update_execution_status(execution_id, status, error)
def _get_conf_for_snapshots_wf(self):
return {
'file_server_root':
config.instance().file_server_root,
'file_server_snapshots_folder':
config.instance().file_server_snapshots_folder,
'file_server_blueprints_folder':
config.instance().file_server_blueprints_folder,
'file_server_uploaded_blueprints_folder':
config.instance().file_server_uploaded_blueprints_folder,
'db_address':
config.instance().db_address,
'db_port':
config.instance().db_port,
'created_status':
models.Snapshot.CREATED,
'failed_status':
models.Snapshot.FAILED,
'file_server_uploaded_plugins_folder':
config.instance().file_server_uploaded_plugins_folder
}
def create_snapshot_model(self,
snapshot_id,
status=models.Snapshot.CREATING):
now = str(datetime.now())
new_snapshot = models.Snapshot(id=snapshot_id,
created_at=now,
status=status,
error='')
self.sm.put_snapshot(snapshot_id, new_snapshot)
return new_snapshot
def update_snapshot_status(self, snapshot_id, status, error):
return self.sm.update_snapshot_status(snapshot_id, status, error)
def create_snapshot(self, snapshot_id, include_metrics,
include_credentials):
self.create_snapshot_model(snapshot_id)
try:
_, execution = self._execute_system_workflow(
wf_id='create_snapshot',
task_mapping='cloudify_system_workflows.snapshot.create',
execution_parameters={
'snapshot_id': snapshot_id,
'include_metrics': include_metrics,
'include_credentials': include_credentials,
'config': self._get_conf_for_snapshots_wf()
})
except manager_exceptions.ExistingRunningExecutionError:
self.delete_snapshot(snapshot_id)
raise
return execution
def restore_snapshot(self, snapshot_id, recreate_deployments_envs, force):
self.get_snapshot(snapshot_id) # Throws error if no snapshot found
_, execution = self._execute_system_workflow(
wf_id='restore_snapshot',
task_mapping='cloudify_system_workflows.snapshot.restore',
execution_parameters={
'snapshot_id': snapshot_id,
'recreate_deployments_envs': recreate_deployments_envs,
'config': self._get_conf_for_snapshots_wf(),
'force': force
})
return execution
def publish_blueprint(self, application_dir, application_file_name,
resources_base, blueprint_id):
application_file = os.path.join(application_dir, application_file_name)
dsl_location = '{0}{1}'.format(resources_base, application_file)
try:
plan = tasks.parse_dsl(dsl_location, resources_base,
**self._get_parser_context())
except Exception, ex:
raise DslParseException(str(ex))
now = str(datetime.now())
new_blueprint = models.BlueprintState(
plan=plan,
id=blueprint_id,
description=plan.get('description'),
created_at=now,
updated_at=now,
main_file_name=application_file_name)
self.sm.put_blueprint(new_blueprint.id, new_blueprint)
return new_blueprint
class BlueprintsManager(object):
@property
def sm(self):
return get_storage_manager()
def blueprints_list(self, include=None, filters=None, pagination=None):
return self.sm.blueprints_list(include=include,
filters=filters,
pagination=pagination)
def deployments_list(self, include=None, filters=None, pagination=None):
return self.sm.deployments_list(include=include,
filters=filters,
pagination=pagination)
def executions_list(self,
include=None,
is_include_system_workflows=False,
filters=None,
pagination=None):
filters = filters or {}
is_system_workflow = filters.get('is_system_workflow')
if is_system_workflow:
filters['is_system_workflow'] = []
for value in is_system_workflow:
value = str(value).lower() == 'true'
filters['is_system_workflow'].append(value)
elif not is_include_system_workflows:
filters['is_system_workflow'] = [False]
return self.sm.executions_list(include=include,
filters=filters,
pagination=pagination)
def get_blueprint(self, blueprint_id, include=None):
return self.sm.get_blueprint(blueprint_id, include=include)
def get_deployment(self, deployment_id, include=None):
return self.sm.get_deployment(deployment_id=deployment_id,
include=include)
def get_execution(self, execution_id, include=None):
return self.sm.get_execution(execution_id, include=include)
def get_plugin(self, plugin_id, include=None):
return self.sm.get_plugin(plugin_id, include=include)
def update_execution_status(self, execution_id, status, error):
if self._get_transient_deployment_workers_mode_config()['enabled'] and\
status in models.Execution.END_STATES:
execution = self.get_execution(execution_id)
# currently, the create and delete deployment environment
# workflows are still not marked as system workflows, so they're
# named explicitly
if not (execution.is_system_workflow or execution.workflow_id
in ('create_deployment_environment',
'delete_deployment_environment')):
# a user workflow has reached a final state - initiating
# a workflow to stop deployment workers
deployment = self.get_deployment(execution.deployment_id,
include=['id'])
wf_id = '_stop_deployment_environment'
deployment_env_creation_task_name = \
'cloudify_system_workflows.deployment_environment.stop'
kwargs = {'prerequisite_task_id': execution_id}
self._execute_system_workflow(
deployment, wf_id, deployment_env_creation_task_name,
kwargs)
return self.sm.update_execution_status(execution_id, status, error)
def publish_blueprint(self, application_dir, application_file_name,
resources_base, blueprint_id):
application_file = os.path.join(application_dir, application_file_name)
dsl_location = '{0}{1}'.format(resources_base, application_file)
try:
plan = tasks.parse_dsl(dsl_location, resources_base,
**self._get_parser_context())
except Exception, ex:
raise DslParseException(str(ex))
now = str(datetime.now())
new_blueprint = models.BlueprintState(
plan=plan,
id=blueprint_id,
description=plan.get('description'),
created_at=now,
updated_at=now,
main_file_name=application_file_name)
self.sm.put_blueprint(new_blueprint.id, new_blueprint)
return new_blueprint
def test_get_blueprint_deployments(self):
now = str(datetime.now())
sm = storage_manager._get_instance()
blueprint = models.BlueprintState(id='blueprint-id',
created_at=now,
updated_at=now,
description=None,
plan={'name': 'my-bp'},
source='bp-source',
main_file_name='aaa')
sm.put_blueprint('blueprint-id', blueprint)
deployment1 = models.Deployment(id='dep-1',
created_at=now,
updated_at=now,
blueprint_id='blueprint-id',
plan={'name': 'my-bp'},
permalink=None,
description=None,
workflows={},
inputs={},
policy_types={},
policy_triggers={},
groups={},
scaling_groups={},
outputs={})
sm.put_deployment('dep-1', deployment1)
deployment2 = models.Deployment(id='dep-2',
created_at=now,
updated_at=now,
blueprint_id='blueprint-id',
plan={'name': 'my-bp'},
permalink=None,
description=None,
workflows={},
inputs={},
policy_types={},
policy_triggers={},
groups={},
scaling_groups={},
outputs={})
sm.put_deployment('dep-2', deployment2)
deployment3 = models.Deployment(id='dep-3',
created_at=now,
updated_at=now,
blueprint_id='another-blueprint-id',
plan={'name': 'my-bp'},
description=None,
permalink=None,
workflows={},
inputs={},
policy_types={},
policy_triggers={},
groups={},
scaling_groups={},
outputs={})
sm.put_deployment('dep-3', deployment3)
blueprint_deployments = \
sm.get_blueprint_deployments('blueprint-id').items
self.assertEquals(2, len(blueprint_deployments))
if blueprint_deployments[0].id != deployment1.id:
blueprint_deployments[0], blueprint_deployments[1] =\
blueprint_deployments[1], blueprint_deployments[0]
self.assertEquals(deployment1.to_dict(),
blueprint_deployments[0].to_dict())
self.assertEquals(deployment2.to_dict(),
blueprint_deployments[1].to_dict())
