def instantiate_from_dict(cls, storage_kwargs=None, task_kwargs=None):
if storage_kwargs:
return cls(storage=aria.application_model_storage(
**(storage_kwargs or {})),
task_kwargs=task_kwargs)
else:
return cls(task_kwargs=task_kwargs)
def __init__(self, root_dir=None):
self._root_dir = root_dir or \
os.path.join(os.path.expanduser('~'), '.arest')
models_dir = os.path.join(self._root_dir, 'models')
resource_dir = os.path.join(self._root_dir, 'resources')
plugins_dir = os.path.join(self._root_dir, 'plugins')
self._create_paths(models_dir, resource_dir, plugins_dir)
# Create a model storage
self._model_storage = aria_.application_model_storage(
api=sql_mapi.SQLAlchemyModelAPI,
initiator_kwargs={'base_dir': models_dir}
)
self._resource_storage = aria_.application_resource_storage(
api=filesystem_rapi.FileSystemResourceAPI,
api_kwargs={'directory': resource_dir}
)
self._plugin_manager = plugin.PluginManager(
model=self._model_storage,
plugins_dir=plugins_dir
)
self._core = aria_core.Core(
model_storage=self.model,
resource_storage=self.resource,
plugin_manager=self._plugin_manager
)
def simple(tmpdir, inmemory=False, context_kwargs=None, topology=None):
initiator = init_inmemory_model_storage if inmemory else None
initiator_kwargs = {} if inmemory else dict(base_dir=tmpdir)
topology = topology or create_simple_topology_two_nodes
model_storage = aria.application_model_storage(
sql_mapi.SQLAlchemyModelAPI,
initiator=initiator,
initiator_kwargs=initiator_kwargs)
resource_storage = aria.application_resource_storage(
filesystem_rapi.FileSystemResourceAPI,
api_kwargs=dict(directory=os.path.join(tmpdir, 'resources')))
service_id = topology(model_storage)
execution = models.create_execution(model_storage.service.get(service_id))
model_storage.execution.put(execution)
final_kwargs = dict(name='simple_context',
model_storage=model_storage,
resource_storage=resource_storage,
service_id=service_id,
workflow_name=models.WORKFLOW_NAME,
execution_id=execution.id,
task_max_attempts=models.TASK_MAX_ATTEMPTS,
task_retry_interval=models.TASK_RETRY_INTERVAL)
final_kwargs.update(context_kwargs or {})
return context.workflow.WorkflowContext(**final_kwargs)
def fs_model(tmpdir):
result = application_model_storage(
sql_mapi.SQLAlchemyModelAPI,
initiator_kwargs=dict(base_dir=str(tmpdir)),
initiator=sql_mapi.init_storage)
yield result
storage.release_sqlite_storage(result)
def create_storage(self,
blueprint_path,
blueprint_plan,
deployment_plan,
blueprint_id,
deployment_id,
main_file_name=None):
resource_storage = application_resource_storage(
FileSystemResourceDriver(local_resource_storage()))
model_storage = application_model_storage(
FileSystemModelDriver(local_model_storage()))
resource_storage.setup()
model_storage.setup()
storage_manager = StorageManager(model_storage=model_storage,
resource_storage=resource_storage,
blueprint_path=blueprint_path,
blueprint_id=blueprint_id,
blueprint_plan=blueprint_plan,
deployment_id=deployment_id,
deployment_plan=deployment_plan)
storage_manager.create_blueprint_storage(blueprint_path,
main_file_name=main_file_name)
storage_manager.create_nodes_storage()
storage_manager.create_deployment_storage()
storage_manager.create_node_instances_storage()
def test_application_storage_factory():
driver = InMemoryModelDriver()
storage = application_model_storage(driver)
assert storage.node
assert storage.node_instance
assert storage.plugin
assert storage.blueprint
assert storage.snapshot
assert storage.deployment
assert storage.deployment_update
assert storage.deployment_update_step
assert storage.deployment_modification
assert storage.execution
assert storage.provider_context
reused_storage = application_model_storage(driver)
assert reused_storage == storage
def storage():
api_kwargs = test_storage.get_sqlite_api_kwargs()
workflow_storage = application_model_storage(SQLAlchemyModelAPI,
api_kwargs=api_kwargs)
workflow_storage.blueprint.put(models.get_blueprint())
blueprint = workflow_storage.blueprint.get_by_name(models.BLUEPRINT_NAME)
workflow_storage.deployment.put(models.get_deployment(blueprint))
yield workflow_storage
test_storage.release_sqlite_storage(workflow_storage)
def storage(self):
model_storage = application_model_storage(
sql_mapi.SQLAlchemyModelAPI,
initiator=tests_storage.init_inmemory_model_storage)
model_storage.register(MockModel)
for value in (1, 2, 3, 4):
model_storage.op_mock_model.put(MockModel(value=value))
yield model_storage
tests_storage.release_sqlite_storage(model_storage)
def instantiate_from_dict(cls, model_storage=None, resource_storage=None, **kwargs):
if model_storage:
model_storage = aria.application_model_storage(**model_storage)
if resource_storage:
resource_storage = aria.application_resource_storage(**resource_storage)
return cls(model_storage=model_storage,
resource_storage=resource_storage,
destroy_session=True,
**kwargs)
def storage():
workflow_storage = application_model_storage(
sql_mapi.SQLAlchemyModelAPI, initiator=test_storage.init_inmemory_model_storage)
workflow_storage.service_template.put(models.create_service_template())
service_template = workflow_storage.service_template.get_by_name(models.SERVICE_TEMPLATE_NAME)
service = models.create_service(service_template)
workflow_storage.service.put(service)
workflow_storage.execution.put(models.create_execution(service))
yield workflow_storage
test_storage.release_sqlite_storage(workflow_storage)
def get_model_storage():
"""Get aria model storage.
The model storage can be used to interact with the database using the mapi
abstraction.
:return: Aria model storage
:rtype: :class:`aria.storage.core.ModelStorage`
"""
return aria.application_model_storage(api=SQLAlchemyModelAPI,
api_kwargs=dict(engine=db.engine,
session=db.session),
models_prefix='ARIA_')
def test_application_storage_factory():
storage = application_model_storage(sql_mapi.SQLAlchemyModelAPI,
api_kwargs=get_sqlite_api_kwargs())
assert storage.node
assert storage.node_instance
assert storage.plugin
assert storage.blueprint
assert storage.deployment
assert storage.deployment_update
assert storage.deployment_update_step
assert storage.deployment_modification
assert storage.execution
release_sqlite_storage(storage)
def test_application_storage_factory():
storage = application_model_storage(
sql_mapi.SQLAlchemyModelAPI,
initiator=tests_storage.init_inmemory_model_storage)
assert storage.service_template
assert storage.node_template
assert storage.group_template
assert storage.policy_template
assert storage.substitution_template
assert storage.substitution_template_mapping
assert storage.requirement_template
assert storage.relationship_template
assert storage.capability_template
assert storage.interface_template
assert storage.operation_template
assert storage.artifact_template
assert storage.service
assert storage.node
assert storage.group
assert storage.policy
assert storage.substitution
assert storage.substitution_mapping
assert storage.relationship
assert storage.capability
assert storage.interface
assert storage.operation
assert storage.artifact
assert storage.execution
assert storage.service_update
assert storage.service_update_step
assert storage.service_modification
assert storage.plugin
assert storage.task
assert storage.input
assert storage.output
assert storage.property
assert storage.attribute
assert storage.type
assert storage.metadata
tests_storage.release_sqlite_storage(storage)
def operation_context_from_dict(context_dict):
context_cls = context_dict['context_cls']
context = context_dict['context']
model_storage = context['model_storage']
if model_storage:
api_cls = model_storage['api_cls']
api_kwargs = _deserialize_sql_mapi_kwargs(
model_storage.get('api_kwargs', {}))
context['model_storage'] = aria.application_model_storage(
api=api_cls, api_kwargs=api_kwargs)
resource_storage = context['resource_storage']
if resource_storage:
api_cls = resource_storage['api_cls']
api_kwargs = _deserialize_file_rapi_kwargs(
resource_storage.get('api_kwargs', {}))
context['resource_storage'] = aria.application_resource_storage(
api=api_cls, api_kwargs=api_kwargs)
return context_cls(**context)
def simple(mapi_kwargs, resources_dir=None, **kwargs):
model_storage = aria.application_model_storage(SQLAlchemyModelAPI,
api_kwargs=mapi_kwargs)
deployment_id = create_simple_topology_two_nodes(model_storage)
# pytest tmpdir
if resources_dir:
resource_storage = aria.application_resource_storage(
FileSystemResourceAPI, api_kwargs={'directory': resources_dir})
else:
resource_storage = None
final_kwargs = dict(name='simple_context',
model_storage=model_storage,
resource_storage=resource_storage,
deployment_id=deployment_id,
workflow_name=models.WORKFLOW_NAME,
task_max_attempts=models.TASK_MAX_ATTEMPTS,
task_retry_interval=models.TASK_RETRY_INTERVAL)
final_kwargs.update(kwargs)
return context.workflow.WorkflowContext(**final_kwargs)
def __call__(self, args_namespace):
super(ExecuteCommand, self).__call__(args_namespace)
parameters = (self.parse_inputs(args_namespace.parameters)
if args_namespace.parameters else {})
resource_storage = application_resource_storage(
FileSystemResourceDriver(local_resource_storage()))
model_storage = application_model_storage(
FileSystemModelDriver(local_model_storage()))
deployment = model_storage.deployment.get(args_namespace.deployment_id)
try:
workflow = deployment.workflows[args_namespace.workflow_id]
except KeyError:
raise ValueError(
'{0} workflow does not exist. existing workflows are: {1}'.
format(args_namespace.workflow_id,
deployment.workflows.keys()))
workflow_parameters = self._merge_and_validate_execution_parameters(
workflow, args_namespace.workflow_id, parameters)
workflow_context = WorkflowContext(
name=args_namespace.workflow_id,
model_storage=model_storage,
resource_storage=resource_storage,
deployment_id=args_namespace.deployment_id,
workflow_id=args_namespace.workflow_id,
parameters=workflow_parameters,
)
workflow_function = self._load_workflow_handler(workflow['operation'])
tasks_graph = workflow_function(workflow_context,
**workflow_context.parameters)
executor = ThreadExecutor()
workflow_engine = Engine(executor=executor,
workflow_context=workflow_context,
tasks_graph=tasks_graph)
workflow_engine.execute()
executor.close()
def model(tmpdir):
_storage = aria.application_model_storage(
aria.storage.sql_mapi.SQLAlchemyModelAPI,
initiator_kwargs=dict(base_dir=str(tmpdir)))
yield _storage
tests.storage.release_sqlite_storage(_storage)
def model_storage(self):
if not self._model_storage:
initiator_kwargs = {'base_dir': self.model_storage_dir}
self._model_storage = aria.application_model_storage(
api=SQLAlchemyModelAPI, initiator_kwargs=initiator_kwargs)
return self._model_storage
def inmemory_model():
model = application_model_storage(
sql_mapi.SQLAlchemyModelAPI,
initiator=storage.init_inmemory_model_storage)
yield model
storage.release_sqlite_storage(model)
def _empty_storage():
return application_model_storage(sql_mapi.SQLAlchemyModelAPI,
api_kwargs=get_sqlite_api_kwargs())
def instantiate_from_dict(cls, **kwargs):
if kwargs:
return cls(storage=aria.application_model_storage(**kwargs))
else:
return cls()
def model():
api_kwargs = storage.get_sqlite_api_kwargs()
model = application_model_storage(SQLAlchemyModelAPI, api_kwargs=api_kwargs)
yield model
storage.release_sqlite_storage(model)
def memory_model_storage():
result = aria.application_model_storage(
SQLAlchemyModelAPI, api_kwargs=storage.get_sqlite_api_kwargs())
yield result
storage.release_sqlite_storage(result)
def model(tmpdir):
api_kwargs = tests.storage.get_sqlite_api_kwargs(str(tmpdir))
result = application_model_storage(SQLAlchemyModelAPI, api_kwargs=api_kwargs)
yield result
tests.storage.release_sqlite_storage(result)
def _empty_storage():
return application_model_storage(sql_mapi.SQLAlchemyModelAPI,
initiator=init_inmemory_model_storage)
def storage(tmpdir):
return aria.application_model_storage(
aria.storage.sql_mapi.SQLAlchemyModelAPI,
initiator_kwargs=dict(base_dir=str(tmpdir)))
