ariatosca-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mxm...@apache.org
Subject [1/2] incubator-ariatosca git commit: code review 1
Date Sat, 03 Dec 2016 13:14:42 GMT
Repository: incubator-ariatosca
Updated Branches:
  refs/heads/ARIA-30-SQL-based-storage-implementation c9df5b140 -> 2d8f13385


http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/aria/storage/sql_mapi.py
----------------------------------------------------------------------
diff --git a/aria/storage/sql_mapi.py b/aria/storage/sql_mapi.py
new file mode 100644
index 0000000..ab26dd7
--- /dev/null
+++ b/aria/storage/sql_mapi.py
@@ -0,0 +1,363 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+SQLAlchemy based MAPI
+"""
+
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.sql.elements import Label
+
+from aria.utils.collections import OrderedDict
+
+from aria.storage import (
+    api,
+    exceptions
+)
+
+
+DEFAULT_SQL_DIALECT = 'sqlite'
+
+
+class SQLAlchemyModelAPI(api.ModelAPI):
+    """
+    SQL based MAPI.
+    """
+
+    def __init__(self,
+                 engine,
+                 session,
+                 **kwargs):
+        super(SQLAlchemyModelAPI, self).__init__(**kwargs)
+        self._engine = engine
+        self._session = session
+
+    def get(self, entry_id, include=None, filters=None, locking=False, **kwargs):
+        """Return a single result based on the model class and element ID
+        """
+        filters = filters or {'id': entry_id}
+        query = self._get_query(include, filters)
+        if locking:
+            query = query.with_for_update()
+        result = query.first()
+
+        if not result:
+            raise exceptions.StorageError(
+                'Requested {0} with ID `{1}` was not found'
+                .format(self.model_cls.__name__, entry_id)
+            )
+        return result
+
+    def iter(self,
+             include=None,
+             filters=None,
+             pagination=None,
+             sort=None,
+             **kwargs):
+        """Return a (possibly empty) list of `model_class` results
+        """
+        query = self._get_query(include, filters, sort)
+
+        results, _, _, _ = self._paginate(query, pagination)
+
+        for result in results:
+            yield result
+
+    def put(self, entry, **kwargs):
+        """Create a `model_class` instance from a serializable `model` object
+
+        :param entry: A dict with relevant kwargs, or an instance of a class
+        that has a `to_dict` method, and whose attributes match the columns
+        of `model_class` (might also my just an instance of `model_class`)
+        :return: An instance of `model_class`
+        """
+        self._session.add(entry)
+        self._safe_commit()
+        return entry
+
+    def delete(self, entry_id, filters=None, **kwargs):
+        """Delete a single result based on the model class and element ID
+        """
+        try:
+            instance = self.get(
+                entry_id,
+                filters=filters
+            )
+        except exceptions.StorageError:
+            raise exceptions.StorageError(
+                'Could not delete {0} with ID `{1}` - element not found'
+                .format(
+                    self.model_cls.__name__,
+                    entry_id
+                )
+            )
+        self._load_properties(instance)
+        self._session.delete(instance)
+        self._safe_commit()
+        return instance
+
+    # TODO: this might need rework
+    def update(self, entry, **kwargs):
+        """Add `instance` to the DB session, and attempt to commit
+
+        :return: The updated instance
+        """
+        return self.put(entry)
+
+    def refresh(self, entry):
+        """Reload the instance with fresh information from the DB
+
+        :param entry: Instance to be re-loaded from the DB
+        :return: The refreshed instance
+        """
+        self._session.refresh(entry)
+        self._load_properties(entry)
+        return entry
+
+    def _destroy_connection(self):
+        pass
+
+    def _establish_connection(self):
+        pass
+
+    def create(self):
+        self.model_cls.__table__.create(self._engine)
+
+    def drop(self):
+        """
+        Drop the table from the storage.
+        :return:
+        """
+        self.model_cls.__table__.drop(self._engine)
+
+    def _safe_commit(self):
+        """Try to commit changes in the session. Roll back if exception raised
+        Excepts SQLAlchemy errors and rollbacks if they're caught
+        """
+        try:
+            self._session.commit()
+        except SQLAlchemyError as e:
+            self._session.rollback()
+            raise exceptions.StorageError(
+                'SQL Storage error: {0}'.format(str(e))
+            )
+
+    def _get_base_query(self, include, joins):
+        """Create the initial query from the model class and included columns
+
+        :param include: A (possibly empty) list of columns to include in
+        the query
+        :param joins: A (possibly empty) list of models on which the query
+        should join
+        :return: An SQLAlchemy AppenderQuery object
+        """
+
+        # If only some columns are included, query through the session object
+        if include:
+            query = self._session.query(*include)
+        else:
+            # If all columns should be returned, query directly from the model
+            query = self._session.query(self.model_cls)
+
+        # Add any joins that might be necessary
+        for join_model in joins:
+            query = query.join(join_model)
+
+        return query
+
+    @staticmethod
+    def _sort_query(query, sort=None):
+        """Add sorting clauses to the query
+
+        :param query: Base SQL query
+        :param sort: An optional dictionary where keys are column names to
+        sort by, and values are the order (asc/desc)
+        :return: An SQLAlchemy AppenderQuery object
+        """
+        if sort:
+            for column, order in sort.items():
+                if order == 'desc':
+                    column = column.desc()
+                query = query.order_by(column)
+        return query
+
+    @staticmethod
+    def _filter_query(query, filters):
+        """Add filter clauses to the query
+
+        :param query: Base SQL query
+        :param filters: An optional dictionary where keys are column names to
+        filter by, and values are values applicable for those columns (or lists
+        of such values)
+        :return: An SQLAlchemy AppenderQuery object
+        """
+        for column, value in filters.items():
+            # If there are multiple values, use `in_`, otherwise, use `eq`
+            if isinstance(value, (list, tuple)):
+                query = query.filter(column.in_(value))
+            else:
+                query = query.filter(column == value)
+
+        return query
+
+    def _get_query(self,
+                   include=None,
+                   filters=None,
+                   sort=None):
+        """Get an SQL query object based on the params passed
+
+        :param include: An optional list of columns to include in the query
+        :param filters: An optional dictionary where keys are column names to
+        filter by, and values are values applicable for those columns (or lists
+        of such values)
+        :param sort: An optional dictionary where keys are column names to
+        sort by, and values are the order (asc/desc)
+        :return: A sorted and filtered query with only the relevant
+        columns
+        """
+
+        include = include or []
+        filters = filters or dict()
+        sort = sort or OrderedDict()
+
+        joins = self._get_join_models_list(include, filters, sort)
+        include, filters, sort = self._get_columns_from_field_names(
+            include, filters, sort
+        )
+
+        query = self._get_base_query(include, joins)
+        query = self._filter_query(query, filters)
+        query = self._sort_query(query, sort)
+        return query
+
+    def _get_columns_from_field_names(self,
+                                      include,
+                                      filters,
+                                      sort):
+        """Go over the optional parameters (include, filters, sort), and
+        replace column names with actual SQLA column objects
+        """
+        all_includes = [self._get_column(c) for c in include]
+        include = []
+        # Columns that are inferred from properties (Labels) should be included
+        # last for the following joins to work properly
+        for col in all_includes:
+            if isinstance(col, Label):
+                include.append(col)
+            else:
+                include.insert(0, col)
+
+        filters = dict((self._get_column(c), filters[c]) for c in filters)
+        sort = OrderedDict((self._get_column(c), sort[c]) for c in sort)
+
+        return include, filters, sort
+
+    def _get_join_models_list(self, include, filters, sort):
+        """Return a list of models on which the query should be joined, as
+        inferred from the include, filter and sort column names
+        """
+        if not self.model_cls.is_resource:
+            return []
+
+        all_column_names = include + filters.keys() + sort.keys()
+        join_columns = set(column_name for column_name in all_column_names
+                           if self._is_join_column(column_name))
+
+        # If the only columns included are the columns on which we would
+        # normally join, there isn't actually a need to join, as the FROM
+        # clause in the query will be generated from the relevant models anyway
+        if include == list(join_columns):
+            return []
+
+        # Initializing a set, because the same model can appear in several
+        # join lists
+        join_models = set()
+        for column_name in join_columns:
+            join_models.update(
+                self.model_cls.join_properties[column_name]['models']
+            )
+        # Sort the models by their correct join order
+        join_models = sorted(join_models,
+                             key=lambda model: model.join_order, reverse=True)
+
+        return join_models
+
+    def _is_join_column(self, column_name):
+        """Return False if the column name corresponds to a regular SQLA
+        column that `model_class` has.
+        Return True if the column that should be used is a join column (see
+        SQLModelBase for an explanation)
+        """
+        return self.model_cls.is_resource and \
+            column_name in self.model_cls.join_properties
+
+    def _get_column(self, column_name):
+        """Return the column on which an action (filtering, sorting, etc.)
+        would need to be performed. Can be either an attribute of the class,
+        or needs to be inferred from the class' `join_properties` property
+        """
+        if self._is_join_column(column_name):
+            return self.model_cls.join_properties[column_name]['column']
+        else:
+            return getattr(self.model_cls, column_name)
+
+    # TODO is this really needed in aria?
+    @staticmethod
+    def _paginate(query, pagination):
+        """Paginate the query by size and offset
+
+        :param query: Current SQLAlchemy query object
+        :param pagination: An optional dict with size and offset keys
+        :return: A tuple with four elements:
+        - results: `size` items starting from `offset`
+        - the total count of items
+        - `size` [default: 0]
+        - `offset` [default: 0]
+        """
+        if pagination:
+            size = pagination.get('size', 0)
+            offset = pagination.get('offset', 0)
+            total = query.order_by(None).count()  # Fastest way to count
+            results = query.limit(size).offset(offset).all()
+            return results, total, size, offset
+        else:
+            results = query.all()
+            return results, len(results), 0, 0
+
+    @staticmethod
+    def _load_properties(instance):
+        """A helper method used to overcome a problem where the properties
+        that rely on joins aren't being loaded automatically
+        """
+        if instance.is_resource:
+            for prop in instance.join_properties:
+                getattr(instance, prop)
+
+
+class ListResult(object):
+    """
+    a ListResult contains results about the requested items.
+    """
+    def __init__(self, items, metadata):
+        self.items = items
+        self.metadata = metadata
+
+    def __len__(self):
+        return len(self.items)
+
+    def __iter__(self):
+        return iter(self.items)
+
+    def __getitem__(self, item):
+        return self.items[item]

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/aria/storage/structures.py
----------------------------------------------------------------------
diff --git a/aria/storage/structures.py b/aria/storage/structures.py
index 9b120de..9bca142 100644
--- a/aria/storage/structures.py
+++ b/aria/storage/structures.py
@@ -31,8 +31,10 @@ import json
 import jsonpickle
 from sqlalchemy import VARCHAR
 from sqlalchemy.ext.mutable import Mutable
+from sqlalchemy.orm import relationship, backref
 from sqlalchemy.ext.declarative import declarative_base
 # pylint: disable=unused-import
+from sqlalchemy.ext.associationproxy import association_proxy
 from sqlalchemy import (
     schema,
     Column,
@@ -49,82 +51,40 @@ from sqlalchemy import (
     orm,
 )
 
-
 Model = declarative_base()
 
 
-def foreign_key(
-        parent_table,
-        id_col_name='storage_id',
-        nullable=False,
-        column_type=Integer
-):
+def foreign_key(foreign_key_column, nullable=False):
     """Return a ForeignKey object with the relevant
 
-    :param parent_table: SQL name of the parent table
-    :param id_col_name: Name of the parent table's ID column [default: `id`]
+    :param foreign_key_column: Unique id column in the parent table
     :param nullable: Should the column be allowed to remain empty
-    :param column_type: The type (integer/text/etc.) of the column
-    :return:
     """
     return Column(
-        column_type,
-        ForeignKey(
-            '{0}.{1}'.format(parent_table.__tablename__, id_col_name),
-            ondelete='CASCADE'
-        ),
+        ForeignKey(foreign_key_column, ondelete='CASCADE'),
         nullable=nullable
     )
 
 
-def one_to_many_relationship(
-        child_class_name,
-        column_name,
-        parent_class_name,
-        back_reference_name,
-        parent_id_name='storage_id',
-):
+def one_to_many_relationship(child_class,
+                             parent_class,
+                             foreign_key_column,
+                             backreference=None):
     """Return a one-to-many SQL relationship object
     Meant to be used from inside the *child* object
 
-    :param child_class_name: Class name of the child table
-    :param column_name: Name of the column pointing to the parent table
-    :param parent_class_name: Class name of the parent table
-    :param back_reference_name: The name to give to the reference to the child
-    :param parent_id_name: Name of the parent table's ID column [default: `id`]
-    :return:
+    :param parent_class: Class of the parent table
+    :param child_class: Class of the child table
+    :param foreign_key_column: The column of the foreign key
+    :param backreference: The name to give to the reference to the child
     """
-    return orm.relationship(
-        parent_class_name,
-        primaryjoin='{0}.{1} == {2}.{3}'.format(
-            child_class_name,
-            column_name,
-            parent_class_name,
-            parent_id_name
-        ),
+    backreference = backreference or child_class.__tablename__
+    return relationship(
+        parent_class,
+        primaryjoin=lambda: parent_class.storage_id == foreign_key_column,
         # The following line make sure that when the *parent* is
         # deleted, all its connected children are deleted as well
-        backref=orm.backref(back_reference_name, cascade='all')
-    )
-
-
-def many_to_many_relationship(
-        other_table_class_name,
-        connecting_table,
-        back_reference_name
-):
-    """Return a many-to-many SQL relationship object
-
-    :param other_table_class_name: The name of the table we're connecting to
-    :param connecting_table: The secondary table used in the relationship
-    :param back_reference_name: The name to give to the reference to the
-    current table from the other table
-    :return:
-    """
-    return orm.relationship(
-        other_table_class_name,
-        secondary=connecting_table,
-        backref=orm.backref(back_reference_name, lazy='dynamic')
+        backref=backref(backreference, cascade='all')
     )
 
 
@@ -186,12 +146,18 @@ class MutableDict(Mutable, dict):
 class SQLModelBase(Model):
     """Abstract base class for all SQL models that allows [de]serialization
     """
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
     # SQLAlchemy syntax
     __abstract__ = True
 
     # Indicates to the storage manager whether the table is a resource or not
     is_resource = False
 
+    join_properties = {}
+
     _private_fields = []
 
     # Indicates whether the `id` column in this class should be unique
@@ -211,12 +177,17 @@ class SQLModelBase(Model):
         """
         return jsonpickle.encode(self.to_dict(), unpicklable=False)
 
-    def fields(self):
+    @classmethod
+    def fields(cls):
         """Return the list of field names for this table
 
         Mostly for backwards compatibility in the code (that uses `fields`)
         """
-        return self.__table__.columns.keys()
+        fields = cls.__table__.columns.keys()
+        fields = [f for f in fields if f not in cls._private_fields]
+        properties = set(cls.join_properties.keys()) - set(cls._private_fields)
+        fields.extend(properties)
+        return fields
 
     def _get_unique_id(self):
         """A method to allow classes to override the default representation

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/aria/utils/application.py
----------------------------------------------------------------------
diff --git a/aria/utils/application.py b/aria/utils/application.py
index b1a7fcc..113e054 100644
--- a/aria/utils/application.py
+++ b/aria/utils/application.py
@@ -117,7 +117,7 @@ class StorageManager(LoggerMixin):
             updated_at=now,
             main_file_name=main_file_name,
         )
-        self.model_storage.blueprint.store(blueprint)
+        self.model_storage.blueprint.put(blueprint)
         self.logger.debug('created blueprint model storage entry')
 
     def create_nodes_storage(self):
@@ -138,7 +138,7 @@ class StorageManager(LoggerMixin):
             scalable = node_copy.pop('capabilities')['scalable']['properties']
             for index, relationship in enumerate(node_copy['relationships']):
                 relationship = self.model_storage.relationship.model_cls(**relationship)
-                self.model_storage.relationship.store(relationship)
+                self.model_storage.relationship.put(relationship)
                 node_copy['relationships'][index] = relationship
 
             node_copy = self.model_storage.node.model_cls(
@@ -149,7 +149,7 @@ class StorageManager(LoggerMixin):
                 max_number_of_instances=scalable['max_instances'],
                 number_of_instances=scalable['current_instances'],
                 **node_copy)
-            self.model_storage.node.store(node_copy)
+            self.model_storage.node.put(node_copy)
 
     def create_deployment_storage(self):
         """
@@ -190,7 +190,7 @@ class StorageManager(LoggerMixin):
             created_at=now,
             updated_at=now
         )
-        self.model_storage.deployment.store(deployment)
+        self.model_storage.deployment.put(deployment)
         self.logger.debug('created deployment model storage entry')
 
     def create_node_instances_storage(self):
@@ -213,7 +213,7 @@ class StorageManager(LoggerMixin):
                     type=relationship_instance['type'],
                     target_id=relationship_instance['target_id'])
                 relationship_instances.append(relationship_instance_model)
-                self.model_storage.relationship_instance.store(relationship_instance_model)
+                self.model_storage.relationship_instance.put(relationship_instance_model)
 
             node_instance_model = self.model_storage.node_instance.model_cls(
                 node=node_model,
@@ -224,7 +224,7 @@ class StorageManager(LoggerMixin):
                 version='1.0',
                 relationship_instances=relationship_instances)
 
-            self.model_storage.node_instance.store(node_instance_model)
+            self.model_storage.node_instance.put(node_instance_model)
         self.logger.debug('created node-instances model storage entries')
 
     def create_plugin_storage(self, plugin_id, source):
@@ -258,7 +258,7 @@ class StorageManager(LoggerMixin):
             supported_py_versions=plugin.get('supported_python_versions'),
             uploaded_at=now
         )
-        self.model_storage.plugin.store(plugin)
+        self.model_storage.plugin.put(plugin)
         self.logger.debug('created plugin model storage entry')
 
 

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/tests/mock/context.py
----------------------------------------------------------------------
diff --git a/tests/mock/context.py b/tests/mock/context.py
index 0d09bb1..0ab18bf 100644
--- a/tests/mock/context.py
+++ b/tests/mock/context.py
@@ -18,7 +18,7 @@ import pytest
 
 from aria import application_model_storage
 from aria.orchestrator import context
-from aria.storage.mapi import SQLAlchemyModelAPI
+from aria.storage.sql_mapi import SQLAlchemyModelAPI
 
 from tests.storage import get_sqlite_api_params
 
@@ -29,39 +29,39 @@ from . import models
 def simple(**kwargs):
     api_params = get_sqlite_api_params()
     model_storage = application_model_storage(SQLAlchemyModelAPI, api_params=api_params)
-    model_storage.blueprint.store(models.get_blueprint())
+    model_storage.blueprint.put(models.get_blueprint())
     blueprint = model_storage.blueprint.get(models.BLUEPRINT_ID)
     deployment = models.get_deployment(blueprint)
-    model_storage.deployment.store(deployment)
+    model_storage.deployment.put(deployment)
 
     #################################################################################
     # Creating a simple deployment with node -> node as a graph
 
     dependency_node = models.get_dependency_node(deployment)
-    model_storage.node.store(dependency_node)
+    model_storage.node.put(dependency_node)
     storage_dependency_node = model_storage.node.get(dependency_node.id)
 
     dependency_node_instance = models.get_dependency_node_instance(storage_dependency_node)
-    model_storage.node_instance.store(dependency_node_instance)
+    model_storage.node_instance.put(dependency_node_instance)
     storage_dependency_node_instance = model_storage.node_instance.get(dependency_node_instance.id)
 
     dependent_node = models.get_dependent_node(deployment)
-    model_storage.node.store(dependent_node)
+    model_storage.node.put(dependent_node)
     storage_dependent_node = model_storage.node.get(dependent_node.id)
 
     dependent_node_instance = models.get_dependent_node_instance(storage_dependent_node)
-    model_storage.node_instance.store(dependent_node_instance)
+    model_storage.node_instance.put(dependent_node_instance)
     storage_dependent_node_instance = model_storage.node_instance.get(dependent_node_instance.id)
 
     relationship = models.get_relationship(storage_dependent_node, storage_dependency_node)
-    model_storage.relationship.store(relationship)
+    model_storage.relationship.put(relationship)
     storage_relationship = model_storage.relationship.get(relationship.id)
     relationship_instance = models.get_relationship_instance(
         relationship=storage_relationship,
         target_instance=storage_dependency_node_instance,
         source_instance=storage_dependent_node_instance
     )
-    model_storage.relationship_instance.store(relationship_instance)
+    model_storage.relationship_instance.put(relationship_instance)
 
     final_kwargs = dict(
         name='simple_context',

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/tests/mock/models.py
----------------------------------------------------------------------
diff --git a/tests/mock/models.py b/tests/mock/models.py
index bdcbed9..5de3380 100644
--- a/tests/mock/models.py
+++ b/tests/mock/models.py
@@ -46,7 +46,7 @@ def get_dependency_node(deployment):
         operations=dict((key, {}) for key in operations.NODE_OPERATIONS),
         min_number_of_instances=1,
         max_number_of_instances=1,
-        deployment_storage_id=deployment.storage_id
+        deployment_fk=deployment.storage_id
     )
 
 
@@ -56,8 +56,8 @@ def get_dependency_node_instance(dependency_node):
         host_id=DEPENDENCY_NODE_INSTANCE_ID,
         runtime_properties={'ip': '1.1.1.1'},
         version=None,
-        node_storage_id=dependency_node.storage_id,
-        deployment_storage_id=dependency_node.deployment.storage_id,
+        node_fk=dependency_node.storage_id,
+        deployment_fk=dependency_node.deployment.storage_id,
         state='',
         scaling_groups={}
     )
@@ -66,8 +66,8 @@ def get_dependency_node_instance(dependency_node):
 def get_relationship(source=None, target=None):
     return models.Relationship(
         id=RELATIONSHIP_ID,
-        source_node_storage_id=source.storage_id,
-        target_node_storage_id=target.storage_id,
+        source_node_fk=source.storage_id,
+        target_node_fk=target.storage_id,
         source_interfaces={},
         source_operations=dict((key, {}) for key in operations.RELATIONSHIP_OPERATIONS),
         target_interfaces={},
@@ -81,17 +81,16 @@ def get_relationship(source=None, target=None):
 def get_relationship_instance(source_instance, target_instance, relationship):
     return models.RelationshipInstance(
         id=RELATIONSHIP_INSTANCE_ID,
-        type='some_type',
-        relationship_storage_id=relationship.storage_id,
-        target_node_instance_storage_id=target_instance.storage_id,
-        source_node_instance_storage_id=source_instance.storage_id,
+        relationship_fk=relationship.storage_id,
+        target_node_instance_fk=target_instance.storage_id,
+        source_node_instance_fk=source_instance.storage_id,
     )
 
 
 def get_dependent_node(deployment):
     return models.Node(
         id=DEPENDENT_NODE_ID,
-        deployment_storage_id=deployment.storage_id,
+        deployment_fk=deployment.storage_id,
         host_id=DEPENDENT_NODE_ID,
         type='test_node_type',
         type_hierarchy=[],
@@ -111,8 +110,8 @@ def get_dependent_node_instance(dependent_node):
         host_id=DEPENDENT_NODE_INSTANCE_ID,
         runtime_properties={},
         version=None,
-        node_storage_id=dependent_node.storage_id,
-        deployment_storage_id=dependent_node.deployment.storage_id,
+        node_fk=dependent_node.storage_id,
+        deployment_fk=dependent_node.deployment.storage_id,
         state='',
         scaling_groups={}
     )
@@ -133,7 +132,7 @@ def get_blueprint():
 def get_execution(deployment):
     return models.Execution(
         id=EXECUTION_ID,
-        deployment_storage_id=deployment.storage_id,
+        deployment_fk=deployment.storage_id,
         status=models.Execution.STARTED,
         workflow_id=WORKFLOW_ID,
         started_at=datetime.utcnow(),
@@ -145,7 +144,7 @@ def get_deployment(blueprint):
     now = datetime.utcnow()
     return models.Deployment(
         id=DEPLOYMENT_ID,
-        blueprint_storage_id=blueprint.storage_id,
+        blueprint_fk=blueprint.storage_id,
         description='',
         created_at=now,
         updated_at=now,

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/tests/orchestrator/context/test_toolbelt.py
----------------------------------------------------------------------
diff --git a/tests/orchestrator/context/test_toolbelt.py b/tests/orchestrator/context/test_toolbelt.py
index 480f289..5cad219 100644
--- a/tests/orchestrator/context/test_toolbelt.py
+++ b/tests/orchestrator/context/test_toolbelt.py
@@ -68,7 +68,7 @@ def test_host_ip(workflow_context, executor):
         'operation': op_path(host_ip, module_path=__name__)
 
     }
-    workflow_context.model.node.store(dependency_node)
+    workflow_context.model.node.put(dependency_node)
     inputs = {'putput': True}
 
     @workflow
@@ -95,7 +95,7 @@ def test_dependent_node_instances(workflow_context, executor):
         'operation': op_path(dependent_nodes, module_path=__name__)
 
     }
-    workflow_context.model.node.store(dependency_node)
+    workflow_context.model.node.put(dependency_node)
     inputs = {'putput': True}
 
     @workflow
@@ -121,7 +121,7 @@ def test_relationship_tool_belt(workflow_context, executor):
     relationship.source_operations[operation_name] = {
         'operation': op_path(relationship_operation, module_path=__name__)
     }
-    workflow_context.model.relationship.store(relationship)
+    workflow_context.model.relationship.put(relationship)
 
     inputs = {'putput': True}
 

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/tests/orchestrator/context/test_workflow.py
----------------------------------------------------------------------
diff --git a/tests/orchestrator/context/test_workflow.py b/tests/orchestrator/context/test_workflow.py
index 4c4979f..fbe5d75 100644
--- a/tests/orchestrator/context/test_workflow.py
+++ b/tests/orchestrator/context/test_workflow.py
@@ -19,10 +19,9 @@ import pytest
 
 from aria import application_model_storage
 from aria.orchestrator import context
-from aria.storage.mapi.sql import SQLAlchemyModelAPI
-
-from tests.mock import models
+from aria.storage.sql_mapi import SQLAlchemyModelAPI
 from tests import storage as test_storage
+from tests.mock import models
 
 
 class TestWorkflowContext(object):
@@ -60,7 +59,7 @@ class TestWorkflowContext(object):
 def storage():
     api_params = test_storage.get_sqlite_api_params()
     result = application_model_storage(SQLAlchemyModelAPI, api_params=api_params)
-    result.blueprint.store(models.get_blueprint())
+    result.blueprint.put(models.get_blueprint())
     blueprint = result.blueprint.get(models.BLUEPRINT_ID)
-    result.deployment.store(models.get_deployment(blueprint))
+    result.deployment.put(models.get_deployment(blueprint))
     return result

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/tests/orchestrator/workflows/api/test_task.py
----------------------------------------------------------------------
diff --git a/tests/orchestrator/workflows/api/test_task.py b/tests/orchestrator/workflows/api/test_task.py
index 4da42c1..3ae700e 100644
--- a/tests/orchestrator/workflows/api/test_task.py
+++ b/tests/orchestrator/workflows/api/test_task.py
@@ -30,7 +30,7 @@ def ctx():
     :return:
     """
     simple_context = mock.context.simple()
-    simple_context.model.execution.store(mock.models.get_execution(simple_context.deployment))
+    simple_context.model.execution.put(mock.models.get_execution(simple_context.deployment))
 
     return simple_context
 

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/tests/orchestrator/workflows/core/test_engine.py
----------------------------------------------------------------------
diff --git a/tests/orchestrator/workflows/core/test_engine.py b/tests/orchestrator/workflows/core/test_engine.py
index b58460a..45eaa27 100644
--- a/tests/orchestrator/workflows/core/test_engine.py
+++ b/tests/orchestrator/workflows/core/test_engine.py
@@ -12,7 +12,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 import time
 # TODO: fix together with the test
 # import threading

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/tests/storage/test_model_storage.py
----------------------------------------------------------------------
diff --git a/tests/storage/test_model_storage.py b/tests/storage/test_model_storage.py
index 8fdf870..4d610f3 100644
--- a/tests/storage/test_model_storage.py
+++ b/tests/storage/test_model_storage.py
@@ -23,17 +23,17 @@ from aria.storage import (
     ModelStorage,
     models,
     exceptions,
-    mapi as storage_api,
+    sql_mapi,
 )
-
-from tests import storage
+from aria import application_model_storage
+from tests.storage import get_sqlite_api_params
 
 temp_dir = tempfile.mkdtemp()
 
-APIs = [
-    ModelStorage(storage_api.SQLAlchemyModelAPI, api_params=storage.get_sqlite_api_params()),
-    # ModelStorage(storage_api.FileSystemModelAPI, api_params=dict(directory=temp_dir)),
-]
+
+@pytest.fixture
+def storage():
+    return ModelStorage(sql_mapi.SQLAlchemyModelAPI, api_params=get_sqlite_api_params())
 
 
 @pytest.fixture(autouse=True)
@@ -45,18 +45,16 @@ def cleanup():
         pass
 
 
-@pytest.mark.parametrize('storage', APIs)
 def test_storage_base(storage):
     with pytest.raises(AttributeError):
         storage.non_existent_attribute()
 
 
-@pytest.mark.parametrize('storage', APIs)
 def test_model_storage(storage):
     storage.register(models.ProviderContext)
 
     pc = models.ProviderContext(context={}, name='context_name', id='id1')
-    storage.provider_context.store(pc)
+    storage.provider_context.put(pc)
 
     assert storage.provider_context.get('id1') == pc
 
@@ -73,12 +71,11 @@ def test_model_storage(storage):
         storage.provider_context.get('id1')
 
 
-@pytest.mark.parametrize('storage', APIs)
 def test_storage_driver(storage):
     storage.register(models.ProviderContext)
 
     pc = models.ProviderContext(context={}, name='context_name', id='id2')
-    storage.registered['provider_context'].store(entry=pc)
+    storage.registered['provider_context'].put(entry=pc)
 
     assert storage.registered['provider_context'].get(entry_id='id2') == pc
 
@@ -91,17 +88,16 @@ def test_storage_driver(storage):
         storage.registered['provider_context'].get('id2')
 
 
-# @pytest.mark.parametrize('storage', APIs)
-# def test_application_storage_factory(storage):
-#     storage = application_model_storage(api, api_params=api_params)
-#     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
+def test_application_storage_factory():
+    storage = application_model_storage(sql_mapi.SQLAlchemyModelAPI,
+                                        api_params=get_sqlite_api_params())
+    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
+    assert storage.provider_context

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/2d8f1338/tests/storage/test_resource_storage.py
----------------------------------------------------------------------
diff --git a/tests/storage/test_resource_storage.py b/tests/storage/test_resource_storage.py
index 452867e..4347512 100644
--- a/tests/storage/test_resource_storage.py
+++ b/tests/storage/test_resource_storage.py
@@ -18,8 +18,8 @@ import tempfile
 
 import pytest
 
+from aria.storage.filesystem_rapi import FileSystemResourceAPI
 from aria.storage import (
-    rapi,
     exceptions,
     ResourceStorage
 )
@@ -44,12 +44,12 @@ class TestResourceStorage(TestFileSystem):
         storage.blueprint.upload(entry_id=id, source=tmp_dir)
 
     def _create_storage(self):
-        return ResourceStorage(rapi.FileSystemResourceAPI,
+        return ResourceStorage(FileSystemResourceAPI,
                                api_params=dict(directory=self.path))
 
     def test_name(self):
-        api = rapi.FileSystemResourceAPI
-        storage = ResourceStorage(rapi.FileSystemResourceAPI,
+        api = FileSystemResourceAPI
+        storage = ResourceStorage(FileSystemResourceAPI,
                                   items=['blueprint'],
                                   api_params=dict(directory=self.path))
         assert repr(storage) == 'ResourceStorage(api={api})'.format(api=api)
@@ -62,8 +62,7 @@ class TestResourceStorage(TestFileSystem):
         assert os.path.exists(os.path.join(self.path, 'blueprint'))
 
     def test_upload_file(self):
-        storage = ResourceStorage(rapi.FileSystemResourceAPI,
-                                  api_params=dict(directory=self.path))
+        storage = ResourceStorage(FileSystemResourceAPI, api_params=dict(directory=self.path))
         self._create(storage)
         tmpfile_path = tempfile.mkstemp(suffix=self.__class__.__name__, dir=self.path)[1]
         self._upload(storage, tmpfile_path, id='blueprint_id')
@@ -104,7 +103,7 @@ class TestResourceStorage(TestFileSystem):
         storage = self._create_storage()
         self._create(storage)
         with pytest.raises(exceptions.StorageError):
-            storage.blueprint.data(entry_id='blueprint_id', path='fake_path')
+            storage.blueprint.read(entry_id='blueprint_id', path='fake_path')
 
     def test_data_file(self):
         storage = self._create_storage()
@@ -112,7 +111,7 @@ class TestResourceStorage(TestFileSystem):
         tmpfile_path = tempfile.mkstemp(suffix=self.__class__.__name__, dir=self.path)[1]
         self._upload(storage, tmpfile_path, 'blueprint_id')
 
-        assert storage.blueprint.data(entry_id='blueprint_id') == 'fake context'
+        assert storage.blueprint.read(entry_id='blueprint_id') == 'fake context'
 
     def test_upload_dir(self):
         storage = self._create_storage()
@@ -189,4 +188,4 @@ class TestResourceStorage(TestFileSystem):
         storage.blueprint.upload(entry_id='blueprint_id', source=tmp_dir)
 
         with pytest.raises(exceptions.StorageError):
-            storage.blueprint.data(entry_id='blueprint_id')
+            storage.blueprint.read(entry_id='blueprint_id')



Mime
View raw message