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