http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/aria/storage/mapi/sql.py
----------------------------------------------------------------------
diff --git a/aria/storage/mapi/sql.py b/aria/storage/mapi/sql.py
new file mode 100644
index 0000000..4408aa3
--- /dev/null
+++ b/aria/storage/mapi/sql.py
@@ -0,0 +1,369 @@
+# 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 sqlite3 import DatabaseError as SQLiteDBError
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.sql.elements import Label
+
+from aria.utils.collections import OrderedDict
+
+
+try:
+    from psycopg2 import DatabaseError as Psycopg2DBError
+    sql_errors = (SQLAlchemyError, SQLiteDBError, Psycopg2DBError)
+except ImportError:
+    sql_errors = (SQLAlchemyError, SQLiteDBError)
+    Psycopg2DBError = None
+
+from ... import storage
+
+
+DEFAULT_SQL_DIALECT = 'sqlite'
+
+
+class SQLAlchemyModelAPI(storage.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 storage.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 store(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 storage.exceptions.StorageError:
+            raise storage.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.store(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 sql_errors as e:
+            self._session.rollback()
+            raise storage.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/fe944e58/aria/storage/models.py
----------------------------------------------------------------------
diff --git a/aria/storage/models.py b/aria/storage/models.py
index d24ad75..c04f7d8 100644
--- a/aria/storage/models.py
+++ b/aria/storage/models.py
@@ -36,14 +36,27 @@ classes:
     * ProviderContext - provider context implementation model.
     * Plugin - plugin implementation model.
 """
-
 from datetime import datetime
-from types import NoneType
-
-from .structures import Field, IterPointerField, Model, uuid_generator, 
PointerField
+from uuid import uuid4
+
+from .structures import (
+    SQLModelBase,
+    Column,
+    Integer,
+    Text,
+    DateTime,
+    Boolean,
+    Enum,
+    String,
+    PickleType,
+    Float,
+    MutableDict,
+    Dict,
+    foreign_key,
+    one_to_many_relationship
+)
 
 __all__ = (
-    'Model',
     'Blueprint',
     'Snapshot',
     'Deployment',
@@ -60,146 +73,111 @@ __all__ = (
 )
 
 # todo: sort this, maybe move from mgr or move from aria???
-ACTION_TYPES = ()
-ENTITY_TYPES = ()
+# TODO: this must change
+ACTION_TYPES = ('a')
+ENTITY_TYPES = ('b')
+
+
+def uuid_generator():
+    """
+    wrapper function which generates ids
+    """
+    return str(uuid4())
 
 
-class Blueprint(Model):
+class Blueprint(SQLModelBase):
     """
-    A Model which represents a blueprint
+    Blueprint model representation.
     """
-    plan = Field(type=dict)
-    id = Field(type=basestring, default=uuid_generator)
-    description = Field(type=(basestring, NoneType))
-    created_at = Field(type=datetime)
-    updated_at = Field(type=datetime)
-    main_file_name = Field(type=basestring)
+    __tablename__ = 'blueprints'
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
 
+    created_at = Column(DateTime, nullable=False, index=True)
+    main_file_name = Column(Text, nullable=False)
+    plan = Column(MutableDict.as_mutable(Dict), nullable=False)
+    updated_at = Column(DateTime)
+    description = Column(Text)
 
-class Snapshot(Model):
+
+class Snapshot(SQLModelBase):
     """
-    A Model which represents a snapshot
+    Snapshot model representation.
     """
+    __tablename__ = 'snapshots'
+
     CREATED = 'created'
     FAILED = 'failed'
     CREATING = 'creating'
     UPLOADED = 'uploaded'
+
+    STATES = [CREATED, FAILED, CREATING, UPLOADED]
     END_STATES = [CREATED, FAILED, UPLOADED]
 
-    id = Field(type=basestring, default=uuid_generator)
-    created_at = Field(type=datetime)
-    status = Field(type=basestring)
-    error = Field(type=basestring, default=None)
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
 
+    created_at = Column(DateTime, nullable=False, index=True)
+    status = Column(Enum(*STATES, name='snapshot_status'))
+    error = Column(Text)
 
-class Deployment(Model):
-    """
-    A Model which represents a deployment
-    """
-    id = Field(type=basestring, default=uuid_generator)
-    description = Field(type=(basestring, NoneType))
-    created_at = Field(type=datetime)
-    updated_at = Field(type=datetime)
-    blueprint_id = Field(type=basestring)
-    workflows = Field(type=dict)
-    inputs = Field(type=dict, default=lambda: {})
-    policy_types = Field(type=dict, default=lambda: {})
-    policy_triggers = Field(type=dict, default=lambda: {})
-    groups = Field(type=dict, default=lambda: {})
-    outputs = Field(type=dict, default=lambda: {})
-    scaling_groups = Field(type=dict, default=lambda: {})
-
-
-class DeploymentUpdateStep(Model):
+
+class Deployment(SQLModelBase):
     """
-    A Model which represents a deployment update step
+    Deployment model representation.
     """
-    id = Field(type=basestring, default=uuid_generator)
-    action = Field(type=basestring, choices=ACTION_TYPES)
-    entity_type = Field(type=basestring, choices=ENTITY_TYPES)
-    entity_id = Field(type=basestring)
-    supported = Field(type=bool, default=True)
-
-    def __hash__(self):
-        return hash((self.id, self.entity_id))
+    __tablename__ = 'deployments'
+
+    # See base class for an explanation on these properties
+    join_properties = {
+        'blueprint_id': {
+            # No need to provide the Blueprint table, as it's already joined
+            'models': [Blueprint],
+            'column': Blueprint.id.label('blueprint_id')
+        },
+    }
+    join_order = 2
+
+    _private_fields = ['blueprint_storage_id']
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
+    created_at = Column(DateTime, nullable=False, index=True)
+    description = Column(Text)
+    inputs = Column(MutableDict.as_mutable(Dict))
+    groups = Column(MutableDict.as_mutable(Dict))
+    permalink = Column(Text)
+    policy_triggers = Column(MutableDict.as_mutable(Dict))
+    policy_types = Column(MutableDict.as_mutable(Dict))
+    outputs = Column(MutableDict.as_mutable(Dict))
+    scaling_groups = Column(MutableDict.as_mutable(Dict))
+    updated_at = Column(DateTime)
+    workflows = Column(MutableDict.as_mutable(Dict))
+
+    blueprint_storage_id = foreign_key(Blueprint)
+    blueprint = one_to_many_relationship(
+        child_class_name='Deployment',
+        column_name='blueprint_storage_id',
+        parent_class_name='Blueprint',
+        back_reference_name='deployments'
+    )
 
-    def __lt__(self, other):
+    @property
+    def blueprint_id(self):
         """
-        the order is 'remove' < 'modify' < 'add'
-        :param other:
+        Returns the blueprint is
         :return:
         """
-        if not isinstance(other, self.__class__):
-            return not self >= other
-
-        if self.action != other.action:
-            if self.action == 'remove':
-                return_value = True
-            elif self.action == 'add':
-                return_value = False
-            else:
-                return_value = other.action == 'add'
-            return return_value
-
-        if self.action == 'add':
-            return self.entity_type == 'node' and other.entity_type == 
'relationship'
-        if self.action == 'remove':
-            return self.entity_type == 'relationship' and other.entity_type == 
'node'
-        return False
-
-
-class DeploymentUpdate(Model):
-    """
-    A Model which represents a deployment update
-    """
-    INITIALIZING = 'initializing'
-    SUCCESSFUL = 'successful'
-    UPDATING = 'updating'
-    FINALIZING = 'finalizing'
-    EXECUTING_WORKFLOW = 'executing_workflow'
-    FAILED = 'failed'
+        return self.blueprint.id
 
-    STATES = [
-        INITIALIZING,
-        SUCCESSFUL,
-        UPDATING,
-        FINALIZING,
-        EXECUTING_WORKFLOW,
-        FAILED,
-    ]
-
-    # '{0}-{1}'.format(kwargs['deployment_id'], uuid4())
-    id = Field(type=basestring, default=uuid_generator)
-    deployment_id = Field(type=basestring)
-    state = Field(type=basestring, choices=STATES, default=INITIALIZING)
-    deployment_plan = Field()
-    deployment_update_nodes = Field(default=None)
-    deployment_update_node_instances = Field(default=None)
-    deployment_update_deployment = Field(default=None)
-    modified_entity_ids = Field(default=None)
-    execution_id = Field(type=basestring)
-    steps = IterPointerField(type=DeploymentUpdateStep, default=())
-
-
-class Execution(Model):
+
+class Execution(SQLModelBase):
     """
-    A Model which represents an execution
+    Execution model representation.
     """
-
-    class _Validation(object):
-
-        @staticmethod
-        def execution_status_transition_validation(_, value, instance):
-            """Validation function that verifies execution status transitions 
are OK"""
-            try:
-                current_status = instance.status
-            except AttributeError:
-                return
-            valid_transitions = 
Execution.VALID_TRANSITIONS.get(current_status, [])
-            if current_status != value and value not in valid_transitions:
-                raise ValueError('Cannot change execution status from 
{current} to {new}'.format(
-                    current=current_status,
-                    new=value))
+    __tablename__ = 'executions'
 
     TERMINATED = 'terminated'
     FAILED = 'failed'
@@ -207,206 +185,500 @@ class Execution(Model):
     PENDING = 'pending'
     STARTED = 'started'
     CANCELLING = 'cancelling'
-    STATES = (
-        TERMINATED,
-        FAILED,
-        CANCELLED,
-        PENDING,
-        STARTED,
-        CANCELLING,
-    )
+    FORCE_CANCELLING = 'force_cancelling'
+
+    STATES = [TERMINATED, FAILED, CANCELLED, PENDING, STARTED,
+              CANCELLING, FORCE_CANCELLING]
     END_STATES = [TERMINATED, FAILED, CANCELLED]
     ACTIVE_STATES = [state for state in STATES if state not in END_STATES]
-    VALID_TRANSITIONS = {
-        PENDING: [STARTED, CANCELLED],
-        STARTED: END_STATES + [CANCELLING],
-        CANCELLING: END_STATES
+
+    # See base class for an explanation on these properties
+    join_properties = {
+        'blueprint_id': {
+            'models': [Deployment, Blueprint],
+            'column': Blueprint.id.label('blueprint_id')
+        },
+        'deployment_id': {
+            'models': [Deployment],
+            'column': Deployment.id.label('deployment_id')
+        }
     }
+    join_order = 3
+
+    _private_fields = ['deployment_storage_id']
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
+    created_at = Column(DateTime, index=True)
+    started_at = Column(DateTime, nullable=True, index=True)
+    ended_at = Column(DateTime, nullable=True, index=True)
+    error = Column(Text, nullable=True)
+    is_system_workflow = Column(Boolean, nullable=False, default=False)
+    parameters = Column(MutableDict.as_mutable(Dict))
+    status = Column(Enum(*STATES, name='execution_status'))
+    workflow_id = Column(Text, nullable=False)
+
+    deployment_storage_id = foreign_key(Deployment, nullable=True)
+    deployment = one_to_many_relationship(
+        child_class_name='Execution',
+        column_name='deployment_storage_id',
+        parent_class_name='Deployment',
+        back_reference_name='executions'
+    )
+
+    @property
+    def deployment_id(self):
+        """
+        Returns the deployment id
+        :return:
+        """
+        return self.deployment.id if self.deployment else None
 
-    id = Field(type=basestring, default=uuid_generator)
-    status = Field(type=basestring, choices=STATES,
-                   
validation_func=_Validation.execution_status_transition_validation)
-    deployment_id = Field(type=basestring)
-    workflow_id = Field(type=basestring)
-    blueprint_id = Field(type=basestring)
-    created_at = Field(type=datetime, default=datetime.utcnow)
-    started_at = Field(type=datetime, default=None)
-    ended_at = Field(type=datetime, default=None)
-    error = Field(type=basestring, default=None)
-    parameters = Field()
+    @property
+    def blueprint_id(self):
+        """
+        Returns the blueprint id
+        :return:
+        """
+        return self.deployment.blueprint_id if self.deployment else None
 
+    def __str__(self):
+        id_name, id_value = self._get_unique_id()
+        return '<{0} {1}=`{2}` (status={3})>'.format(
+            self.__class__.__name__,
+            id_name,
+            id_value,
+            self.status
+        )
 
-class Relationship(Model):
-    """
-    A Model which represents a relationship
-    """
-    id = Field(type=basestring, default=uuid_generator)
-    source_id = Field(type=basestring)
-    target_id = Field(type=basestring)
-    source_interfaces = Field(type=dict)
-    source_operations = Field(type=dict)
-    target_interfaces = Field(type=dict)
-    target_operations = Field(type=dict)
-    type = Field(type=basestring)
-    type_hierarchy = Field(type=list)
-    properties = Field(type=dict)
-
-
-class Node(Model):
+
+class DeploymentUpdate(SQLModelBase):
     """
-    A Model which represents a node
+    Deployment update model representation.
     """
-    id = Field(type=basestring, default=uuid_generator)
-    blueprint_id = Field(type=basestring)
-    type = Field(type=basestring)
-    type_hierarchy = Field()
-    number_of_instances = Field(type=int)
-    planned_number_of_instances = Field(type=int)
-    deploy_number_of_instances = Field(type=int)
-    host_id = Field(type=basestring, default=None)
-    properties = Field(type=dict)
-    operations = Field(type=dict)
-    plugins = Field(type=list, default=())
-    relationships = IterPointerField(type=Relationship)
-    plugins_to_install = Field(type=list, default=())
-    min_number_of_instances = Field(type=int)
-    max_number_of_instances = Field(type=int)
-
-    def relationships_by_target(self, target_id):
+    __tablename__ = 'deployment_updates'
+
+    # See base class for an explanation on these properties
+    join_properties = {
+        'execution_id': {
+            'models': [Execution],
+            'column': Execution.id.label('execution_id')
+        },
+        'deployment_id': {
+            'models': [Deployment],
+            'column': Deployment.id.label('deployment_id')
+        },
+    }
+    join_order = 4
+
+    _private_fields = ['execution_storage_id']
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
+    created_at = Column(DateTime, nullable=False, index=True)
+    deployment_plan = Column(MutableDict.as_mutable(Dict))
+    deployment_update_node_instances = Column(MutableDict.as_mutable(
+        Dict))
+    deployment_update_deployment = Column(MutableDict.as_mutable(Dict))
+    deployment_update_nodes = Column(MutableDict.as_mutable(Dict))
+    modified_entity_ids = Column(MutableDict.as_mutable(Dict))
+    state = Column(Text)
+
+    execution_storage_id = foreign_key(Execution, nullable=True)
+    execution = one_to_many_relationship(
+        child_class_name='DeploymentUpdate',
+        column_name='execution_storage_id',
+        parent_class_name='Execution',
+        back_reference_name='deployment_updates'
+    )
+
+    deployment_storage_id = foreign_key(Deployment)
+    deployment = one_to_many_relationship(
+        child_class_name='DeploymentUpdate',
+        column_name='deployment_storage_id',
+        parent_class_name='Deployment',
+        back_reference_name='deployment_updates'
+    )
+
+    @property
+    def execution_id(self):
         """
-        Retreives all of the relationship by target.
-        :param target_id: the node id of the target  of the relationship
-        :yields: a relationship which target and node with the specified 
target_id
+        Returns the execution id
+        :return:
         """
-        for relationship in self.relationships:
-            if relationship.target_id == target_id:
-                yield relationship
-        # todo: maybe add here Exception if isn't exists (didn't yield one's)
+        return self.execution.id if self.execution else None
 
+    @property
+    def deployment_id(self):
+        """
+        Rerturns the deployment id
+        :return:
+        """
+        return self.deployment.id
 
-class RelationshipInstance(Model):
-    """
-    A Model which represents a relationship instance
-    """
-    id = Field(type=basestring, default=uuid_generator)
-    target_id = Field(type=basestring)
-    target_name = Field(type=basestring)
-    source_id = Field(type=basestring)
-    source_name = Field(type=basestring)
-    type = Field(type=basestring)
-    relationship = PointerField(type=Relationship)
+    def to_dict(self, suppress_error=False, **kwargs):
+        dep_update_dict = super(DeploymentUpdate, self).to_dict(suppress_error)
+        # Taking care of the fact the DeploymentSteps are objects
+        dep_update_dict['steps'] = [step.to_dict() for step in self.steps]
+        return dep_update_dict
 
 
-class NodeInstance(Model):
+class DeploymentUpdateStep(SQLModelBase):
     """
-    A Model which represents a node instance
+    Deployment update step model representation.
     """
-    # todo: add statuses
-    UNINITIALIZED = 'uninitialized'
-    INITIALIZING = 'initializing'
-    CREATING = 'creating'
-    CONFIGURING = 'configuring'
-    STARTING = 'starting'
-    DELETED = 'deleted'
-    STOPPING = 'stopping'
-    DELETING = 'deleting'
-    STATES = (
-        UNINITIALIZED,
-        INITIALIZING,
-        CREATING,
-        CONFIGURING,
-        STARTING,
-        DELETED,
-        STOPPING,
-        DELETING
+    __tablename__ = 'deployment_update_steps'
+
+    # See base class for an explanation on these properties
+    join_properties = {
+        'deployment_update_id': {
+            'models': [DeploymentUpdate],
+            'column': DeploymentUpdate.id.label('deployment_update_id')
+        },
+    }
+    join_order = 5
+
+    _private_fields = ['deployment_update_storage_id']
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+
+    action = Column(Enum(*ACTION_TYPES, name='action_type'))
+    entity_id = Column(Text, nullable=False)
+    entity_type = Column(Enum(*ENTITY_TYPES, name='entity_type'))
+
+    deployment_update_storage_id = foreign_key(DeploymentUpdate)
+    deployment_update = one_to_many_relationship(
+        child_class_name='DeploymentUpdateStep',
+        column_name='deployment_update_storage_id',
+        parent_class_name='DeploymentUpdate',
+        back_reference_name='steps'
     )
 
-    id = Field(type=basestring, default=uuid_generator)
-    deployment_id = Field(type=basestring)
-    runtime_properties = Field(type=dict)
-    state = Field(type=basestring, choices=STATES, default=UNINITIALIZED)
-    version = Field(type=(basestring, NoneType))
-    relationship_instances = IterPointerField(type=RelationshipInstance)
-    node = PointerField(type=Node)
-    host_id = Field(type=basestring, default=None)
-    scaling_groups = Field(default=())
-
-    def relationships_by_target(self, target_id):
+    @property
+    def deployment_update_id(self):
         """
-        Retreives all of the relationship by target.
-        :param target_id: the instance id of the target of the relationship
-        :yields: a relationship instance which target and node with the 
specified target_id
+        Returns the deployment update id
+        :return:
         """
-        for relationship_instance in self.relationship_instances:
-            if relationship_instance.target_id == target_id:
-                yield relationship_instance
-        # todo: maybe add here Exception if isn't exists (didn't yield one's)
+        return self.deployment_update.id
 
 
-class DeploymentModification(Model):
+class DeploymentModification(SQLModelBase):
     """
-    A Model which represents a deployment modification
+    Deployment modification model representation.
     """
+    __tablename__ = 'deployment_modifications'
+
     STARTED = 'started'
     FINISHED = 'finished'
     ROLLEDBACK = 'rolledback'
+
+    STATES = [STARTED, FINISHED, ROLLEDBACK]
     END_STATES = [FINISHED, ROLLEDBACK]
 
-    id = Field(type=basestring, default=uuid_generator)
-    deployment_id = Field(type=basestring)
-    modified_nodes = Field(type=(dict, NoneType))
-    added_and_related = IterPointerField(type=NodeInstance)
-    removed_and_related = IterPointerField(type=NodeInstance)
-    extended_and_related = IterPointerField(type=NodeInstance)
-    reduced_and_related = IterPointerField(type=NodeInstance)
-    # before_modification = IterPointerField(type=NodeInstance)
-    status = Field(type=basestring, choices=(STARTED, FINISHED, ROLLEDBACK))
-    created_at = Field(type=datetime)
-    ended_at = Field(type=(datetime, NoneType))
-    context = Field()
-
-
-class ProviderContext(Model):
+    # See base class for an explanation on these properties
+    join_properties = {
+        'deployment_id': {
+            'models': [Deployment],
+            'column': Deployment.id.label('deployment_id')
+        },
+    }
+    join_order = 3
+
+    _private_fields = ['deployment_storage_id']
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
+    context = Column(MutableDict.as_mutable(Dict))
+    created_at = Column(DateTime, nullable=False, index=True)
+    ended_at = Column(DateTime, index=True)
+    modified_nodes = Column(MutableDict.as_mutable(Dict))
+    node_instances = Column(MutableDict.as_mutable(Dict))
+    status = Column(
+        Enum(*STATES, name='deployment_modification_status'))
+
+    deployment_storage_id = foreign_key(Deployment)
+    deployment = one_to_many_relationship(
+        child_class_name='DeploymentModification',
+        column_name='deployment_storage_id',
+        parent_class_name='Deployment',
+        back_reference_name='modifications'
+    )
+
+    @property
+    def deployment_id(self):
+        """
+        Returns the deployment id
+        :return:
+        """
+        return self.deployment.id
+
+
+class Node(SQLModelBase):
+    """
+    Node model representation.
+    """
+    __tablename__ = 'nodes'
+
+    # See base class for an explanation on these properties
+    is_id_unique = False
+    join_properties = {
+        'blueprint_id': {
+            'models': [Deployment, Blueprint],
+            'column': Blueprint.id.label('blueprint_id')
+        },
+        'deployment_id': {
+            'models': [Deployment],
+            'column': Deployment.id.label('deployment_id')
+        },
+    }
+    join_order = 3
+
+    _private_fields = ['deployment_storage_id']
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
+    deploy_number_of_instances = Column(Integer, nullable=False)
+    # TODO: This probably should be a foreign key, but there's no guarantee
+    # in the code, currently, that the host will be created beforehand
+    host_id = Column(Text)
+    max_number_of_instances = Column(Integer, nullable=False)
+    min_number_of_instances = Column(Integer, nullable=False)
+    number_of_instances = Column(Integer, nullable=False)
+    planned_number_of_instances = Column(Integer, nullable=False)
+    plugins = Column(MutableDict.as_mutable(Dict))
+    plugins_to_install = Column(MutableDict.as_mutable(Dict))
+    properties = Column(MutableDict.as_mutable(Dict))
+    operations = Column(MutableDict.as_mutable(Dict))
+    type = Column(Text, nullable=False, index=True)
+    type_hierarchy = Column(PickleType)
+
+    deployment_storage_id = foreign_key(Deployment)
+    deployment = one_to_many_relationship(
+        child_class_name='Node',
+        column_name='deployment_storage_id',
+        parent_class_name='Deployment',
+        back_reference_name='nodes'
+    )
+
+    @property
+    def deployment_id(self):
+        """
+        Returns the deployment id
+        :return:
+        """
+        return self.deployment.id
+
+    @property
+    def blueprint_id(self):
+        """
+        Returns the blueprint id
+        :return:
+        """
+        return self.deployment.blueprint_id
+
+
+class Relationship(SQLModelBase):
+    """
+    Relationship model representation.
+    """
+    __tablename__ = 'relationships'
+
+    join_properties = {
+        'blueprint_id': {
+            'models': [Node, Deployment, Blueprint],
+            'column': Blueprint.id.label('blueprint_id')
+        },
+        'deployment_id': {
+            'models': [Node, Deployment],
+            'column': Deployment.id.label('deployment_id')
+        }
+    }
+    join_order = 4
+    _private_fields = ['relationship_storage_source_node_id',
+                       'relationship_storage_target_node_id']
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
+    source_interfaces = Column(MutableDict.as_mutable(Dict))
+    source_operations = Column(MutableDict.as_mutable(Dict))
+    target_interfaces = Column(MutableDict.as_mutable(Dict))
+    target_operations = Column(MutableDict.as_mutable(Dict))
+    type = Column(String)
+    type_hierarchy = Column(PickleType)     # TODO: this should be list
+    properties = Column(MutableDict.as_mutable(Dict))
+
+    source_node_storage_id = foreign_key(Node)
+    target_node_storage_id = foreign_key(Node)
+
+    source_node = one_to_many_relationship(
+        child_class_name='Relationship',
+        column_name='source_node_storage_id',
+        parent_class_name='Node',
+        back_reference_name='relationship_source'
+    )
+    target_node = one_to_many_relationship(
+        child_class_name='Relationship',
+        column_name='target_node_storage_id',
+        parent_class_name='Node',
+        back_reference_name='relationship_target'
+    )
+
+
+class NodeInstance(SQLModelBase):
+    """
+    Node instance model representation.
+    """
+    __tablename__ = 'node_instances'
+
+    # See base class for an explanation on these properties
+    join_properties = {
+        'node_id': {
+            'models': [Node],
+            'column': Node.id.label('node_id')
+        },
+        'deployment_id': {
+            'models': [Node, Deployment],
+            'column': Deployment.id.label('deployment_id')
+        },
+    }
+    join_order = 4
+
+    _private_fields = ['node_storage_id', 'deployment_storage_id']
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
+    # TODO: This probably should be a foreign key, but there's no guarantee
+    # in the code, currently, that the host will be created beforehand
+    host_id = Column(Text)
+    runtime_properties = Column(MutableDict.as_mutable(Dict))
+    scaling_groups = Column(MutableDict.as_mutable(Dict))
+    state = Column(Text, nullable=False)
+    version = Column(Integer, default=1)
+
+    node_storage_id = foreign_key(Node)
+    node = one_to_many_relationship(
+        child_class_name='NodeInstance',
+        column_name='node_storage_id',
+        parent_class_name='Node',
+        back_reference_name='node_instances'
+    )
+
+    @property
+    def node_id(self):
+        """
+        Returns the node id
+        :return:
+        """
+        return self.node.id
+
+    deployment_storage_id = foreign_key(Deployment)
+    deployment = one_to_many_relationship(
+        child_class_name='NodeInstance',
+        column_name='deployment_storage_id',
+        parent_class_name='Deployment',
+        back_reference_name='node_instances'
+    )
+
+
+class RelationshipInstance(SQLModelBase):
+    """
+    Relationship instance model representation.
+    """
+    __tablename__ = 'relationship_instances'
+
+    join_properties = {
+        'blueprint_id': {
+            'models': [Relationship, Node, Deployment, Blueprint],
+            'column': Blueprint.id.label('blueprint_id')
+        },
+        'deployment_id': {
+            'models': [Relationship, Node, Deployment],
+            'column': Deployment.id.label('deployment_id')
+        }
+    }
+    join_order = 5
+
+    _private_fields = ['relationship_storage_id',
+                       'source_node_instance_id',
+                       'target_node_instance_id']
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
+    type = Column(String)
+
+    source_node_instance_storage_id = foreign_key(NodeInstance)
+    source_node_instance = one_to_many_relationship(
+        child_class_name='RelationshipInstance',
+        column_name='source_node_instance_storage_id',
+        parent_class_name='NodeInstance',
+        back_reference_name='relationship_instance_source'
+    )
+    target_node_instance_storage_id = foreign_key(NodeInstance)
+    target_node_instance = one_to_many_relationship(
+        child_class_name='RelationshipInstance',
+        column_name='target_node_instance_storage_id',
+        parent_class_name='NodeInstance',
+        back_reference_name='relationship_instance_target'
+    )
+    relationship_storage_id = foreign_key(Relationship)
+    relationship = one_to_many_relationship(
+        child_class_name='RelationshipInstance',
+        column_name='relationship_storage_id',
+        parent_class_name='Relationship',
+        back_reference_name='relationship_instances'
+    )
+
+
+class ProviderContext(SQLModelBase):
     """
-    A Model which represents a provider context
+    Provider context model representation.
     """
-    id = Field(type=basestring, default=uuid_generator)
-    context = Field(type=dict)
-    name = Field(type=basestring)
+    __tablename__ = 'provider_context'
+
+    id = Column(Text, primary_key=True)
+    name = Column(Text, nullable=False)
+    context = Column(MutableDict.as_mutable(Dict), nullable=False)
 
 
-class Plugin(Model):
+class Plugin(SQLModelBase):
     """
-    A Model which represents a plugin
+    Plugin model representation.
     """
-    id = Field(type=basestring, default=uuid_generator)
-    package_name = Field(type=basestring)
-    archive_name = Field(type=basestring)
-    package_source = Field(type=dict)
-    package_version = Field(type=basestring)
-    supported_platform = Field(type=basestring)
-    distribution = Field(type=basestring)
-    distribution_version = Field(type=basestring)
-    distribution_release = Field(type=basestring)
-    wheels = Field()
-    excluded_wheels = Field()
-    supported_py_versions = Field(type=list)
-    uploaded_at = Field(type=datetime)
-
-
-class Task(Model):
+    __tablename__ = 'plugins'
+
+    storage_id = Column(Integer, primary_key=True, autoincrement=True)
+    id = Column(Text, index=True)
+
+    archive_name = Column(Text, nullable=False, index=True)
+    distribution = Column(Text)
+    distribution_release = Column(Text)
+    distribution_version = Column(Text)
+    excluded_wheels = Column(MutableDict.as_mutable(Dict))
+    package_name = Column(Text, nullable=False, index=True)
+    package_source = Column(Text)
+    package_version = Column(Text)
+    supported_platform = Column(MutableDict.as_mutable(Dict))
+    supported_py_versions = Column(MutableDict.as_mutable(Dict))
+    uploaded_at = Column(DateTime, nullable=False, index=True)
+    wheels = Column(MutableDict.as_mutable(Dict), nullable=False)
+
+
+class Task(SQLModelBase):
     """
     A Model which represents an task
     """
 
-    class _Validation(object):
+    __tablename__ = 'task'
 
-        @staticmethod
-        def validate_max_attempts(_, value, *args):
-            """Validates that max attempts is either -1 or a positive number"""
-            if value < 1 and value != Task.INFINITE_RETRIES:
-                raise ValueError('Max attempts can be either -1 (infinite) or 
any positive number. '
-                                 'Got {value}'.format(value=value))
+    _private_fields = ['node_instance_storage_id', 
'relationship_instance_storage_id']
 
     PENDING = 'pending'
     RETRYING = 'retrying'
@@ -422,23 +694,75 @@ class Task(Model):
         SUCCESS,
         FAILED,
     )
+
     WAIT_STATES = [PENDING, RETRYING]
     END_STATES = [SUCCESS, FAILED]
+
+    class _Validation(object):
+
+        @staticmethod
+        def validate_max_attempts(_, value, *args):
+            """Validates that max attempts is either -1 or a positive number"""
+            if value < 1 and value != Task.INFINITE_RETRIES:
+                raise ValueError('Max attempts can be either -1 (infinite) or 
any positive number. '
+                                 'Got {value}'.format(value=value))
+
     INFINITE_RETRIES = -1
 
-    id = Field(type=basestring, default=uuid_generator)
-    status = Field(type=basestring, choices=STATES, default=PENDING)
-    execution_id = Field(type=basestring)
-    due_at = Field(type=datetime, default=datetime.utcnow)
-    started_at = Field(type=datetime, default=None)
-    ended_at = Field(type=datetime, default=None)
-    max_attempts = Field(type=int, default=1, 
validation_func=_Validation.validate_max_attempts)
-    retry_count = Field(type=int, default=0)
-    retry_interval = Field(type=(int, float), default=0)
-    ignore_failure = Field(type=bool, default=False)
+    id = Column(String, primary_key=True, default=uuid_generator)
+    status = Column(Enum(*STATES), name='status', default=PENDING)
+
+    execution_id = Column(String)
+    due_at = Column(DateTime, default=datetime.utcnow, nullable=True)
+    started_at = Column(DateTime, default=None, nullable=True)
+    ended_at = Column(DateTime, default=None, nullable=True)
+    # , validation_func=_Validation.validate_max_attempts)
+    max_attempts = Column(Integer, default=1)
+    retry_count = Column(Integer, default=0)
+    retry_interval = Column(Float, default=0)
+    ignore_failure = Column(Boolean, default=False)
 
     # Operation specific fields
-    name = Field(type=basestring)
-    operation_mapping = Field(type=basestring)
-    actor = Field()
-    inputs = Field(type=dict, default=lambda: {})
+    name = Column(String)
+    operation_mapping = Column(String)
+    inputs = Column(MutableDict.as_mutable(Dict))
+
+    node_instance_storage_id = foreign_key(NodeInstance, nullable=True)
+    relationship_instance_storage_id = foreign_key(RelationshipInstance, 
nullable=True)
+
+    node_instance = one_to_many_relationship(
+        child_class_name='Task',
+        column_name='node_instance_storage_id',
+        parent_class_name='NodeInstance',
+        back_reference_name='tasks',
+    )
+
+    relationship_instance = one_to_many_relationship(
+        child_class_name='Task',
+        column_name='relationship_instance_storage_id',
+        parent_class_name='RelationshipInstance',
+        back_reference_name='tasks',
+    )
+
+    @property
+    def actor_storage_id(self):
+        """
+        Return the actor storage id of the task
+        :return:
+        """
+        return self.node_instance_storage_id or 
self.relationship_instance_storage_id
+
+    @property
+    def actor(self):
+        """
+        Return the actor of the task
+        :return:
+        """
+        return self.node_instance or self.relationship_instance
+
+    def __init__(self, actor, **kwargs):
+        if isinstance(actor, RelationshipInstance):
+            kwargs['relationship_instance_storage_id'] = actor.storage_id
+        elif isinstance(actor, NodeInstance):
+            kwargs['node_instance_storage_id'] = actor.storage_id
+        super(Task, self).__init__(**kwargs)

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/aria/storage/rapi/__init__.py
----------------------------------------------------------------------
diff --git a/aria/storage/rapi/__init__.py b/aria/storage/rapi/__init__.py
new file mode 100644
index 0000000..2217281
--- /dev/null
+++ b/aria/storage/rapi/__init__.py
@@ -0,0 +1,18 @@
+# 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.
+"""
+A collection of RAPIs
+"""
+from .filesystem import FileSystemResourceAPI

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/aria/storage/rapi/filesystem.py
----------------------------------------------------------------------
diff --git a/aria/storage/rapi/filesystem.py b/aria/storage/rapi/filesystem.py
new file mode 100644
index 0000000..a6c4ddf
--- /dev/null
+++ b/aria/storage/rapi/filesystem.py
@@ -0,0 +1,119 @@
+# 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 RAPI
+"""
+import os
+import shutil
+from distutils import dir_util
+from functools import partial
+
+from aria.storage import (
+    api,
+    filesystem_api,
+    exceptions
+)
+
+
+class FileSystemResourceAPI(api.ResourceAPI, filesystem_api.BaseFileSystemAPI):
+    """
+    File system resource storage.
+    """
+
+    def __init__(self, directory, **kwargs):
+        """
+        File system implementation for storage api.
+        :param str directory: root dir for storage.
+        """
+        super(FileSystemResourceAPI, self).__init__(**kwargs)
+        self.directory = directory
+        self.base_path = os.path.join(self.directory, self.name)
+        self._join_path = partial(os.path.join, self.base_path)
+
+    def __repr__(self):
+        return '{cls.__name__}(directory={self.directory})'.format(
+            cls=self.__class__, self=self)
+
+    def create(self, **kwargs):
+        """
+        Create directory in storage by path.
+        tries to create the root directory as well.
+        :param str name: path of file in storage.
+        """
+        try:
+            os.makedirs(self.directory)
+        except (OSError, IOError):
+            pass
+        os.makedirs(self.base_path)
+
+    def data(self, entry_id, path=None, **_):
+        """
+        Retrieve the content of a file system storage resource.
+
+        :param str entry_type: the type of the entry.
+        :param str entry_id: the id of the entry.
+        :param str path: a path to a specific resource.
+        :return: the content of the file
+        :rtype: bytes
+        """
+        resource_relative_path = os.path.join(self.name, entry_id, path or '')
+        resource = os.path.join(self.directory, resource_relative_path)
+        if not os.path.exists(resource):
+            raise exceptions.StorageError("Resource {0} does not exist".
+                                          format(resource_relative_path))
+        if not os.path.isfile(resource):
+            resources = os.listdir(resource)
+            if len(resources) != 1:
+                raise exceptions.StorageError('No resource in path: 
{0}'.format(resource))
+            resource = os.path.join(resource, resources[0])
+        with open(resource, 'rb') as resource_file:
+            return resource_file.read()
+
+    def download(self, entry_id, destination, path=None, **_):
+        """
+        Download a specific file or dir from the file system resource storage.
+
+        :param str entry_type: the name of the entry.
+        :param str entry_id: the id of the entry
+        :param str destination: the destination of the files.
+        :param str path: a path on the remote machine relative to the root of 
the entry.
+        """
+        resource_relative_path = os.path.join(self.name, entry_id, path or '')
+        resource = os.path.join(self.directory, resource_relative_path)
+        if not os.path.exists(resource):
+            raise exceptions.StorageError("Resource {0} does not exist".
+                                          format(resource_relative_path))
+        if os.path.isfile(resource):
+            shutil.copy2(resource, destination)
+        else:
+            dir_util.copy_tree(resource, destination)                          
           # pylint: disable=no-member
+
+    def upload(self, entry_id, source, path=None, **_):
+        """
+        Uploads a specific file or dir to the file system resource storage.
+
+        :param str entry_type: the name of the entry.
+        :param str entry_id: the id of the entry
+        :param source: the source of  the files to upload.
+        :param path: the destination of the file/s relative to the entry root 
dir.
+        """
+        resource_directory = os.path.join(self.directory, self.name, entry_id)
+        if not os.path.exists(resource_directory):
+            os.makedirs(resource_directory)
+        destination = os.path.join(resource_directory, path or '')
+        if os.path.isfile(source):
+            shutil.copy2(source, destination)
+        else:
+            dir_util.copy_tree(source, destination)                            
           # pylint: disable=no-member

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/aria/storage/structures.py
----------------------------------------------------------------------
diff --git a/aria/storage/structures.py b/aria/storage/structures.py
index b02366e..b8b74fa 100644
--- a/aria/storage/structures.py
+++ b/aria/storage/structures.py
@@ -27,281 +27,237 @@ classes:
     * Model - abstract model implementation.
 """
 import json
-from itertools import count
-from uuid import uuid4
-
-from .exceptions import StorageError
-from ..logger import LoggerMixin
-from ..utils.validation import ValidatorMixin
-
-__all__ = (
-    'uuid_generator',
-    'Field',
-    'IterField',
-    'PointerField',
-    'IterPointerField',
-    'Model',
-    'Storage',
+
+import jsonpickle
+from sqlalchemy import VARCHAR
+from sqlalchemy.ext.mutable import Mutable
+from sqlalchemy.ext.declarative import declarative_base
+# pylint: disable=unused-import
+from sqlalchemy import (
+    schema,
+    Column,
+    Integer,
+    Text,
+    DateTime,
+    Boolean,
+    Enum,
+    String,
+    PickleType,
+    Float,
+    TypeDecorator,
+    ForeignKey,
+    orm,
 )
 
 
-def uuid_generator():
-    """
-    wrapper function which generates ids
-    """
-    return str(uuid4())
+Model = declarative_base()
 
+class classproperty(object):
+    """A class that acts a a decorator for class-level properties
 
-class Field(ValidatorMixin):
-    """
-    A single field implementation
-    """
-    NO_DEFAULT = 'NO_DEFAULT'
-
-    try:
-        # python 3 syntax
-        _next_id = count().__next__
-    except AttributeError:
-        # python 2 syntax
-        _next_id = count().next
-    _ATTRIBUTE_NAME = '_cache_{0}'.format
-
-    def __init__(
-            self,
-            type=None,
-            choices=(),
-            validation_func=None,
-            default=NO_DEFAULT,
-            **kwargs):
-        """
-        Simple field manager.
+    class A(object):
+        _prop1 = 1
+        _prop2 = 2
 
-        :param type: possible type of the field.
-        :param choices: a set of possible field values.
-        :param default: default field value.
-        :param kwargs: kwargs to be passed to next in line classes.
-        """
-        self.type = type
-        self.choices = choices
-        self.default = default
-        self.validation_func = validation_func
-        super(Field, self).__init__(**kwargs)
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self
-        field_name = self._field_name(instance)
-        try:
-            return getattr(instance, self._ATTRIBUTE_NAME(field_name))
-        except AttributeError as exc:
-            if self.default == self.NO_DEFAULT:
-                raise AttributeError(
-                    str(exc).replace(self._ATTRIBUTE_NAME(field_name), 
field_name))
-
-        default_value = self.default() if callable(self.default) else 
self.default
-        setattr(instance, self._ATTRIBUTE_NAME(field_name), default_value)
-        return default_value
-
-    def __set__(self, instance, value):
-        field_name = self._field_name(instance)
-        self.validate_value(field_name, value, instance)
-        setattr(instance, self._ATTRIBUTE_NAME(field_name), value)
-
-    def validate_value(self, name, value, instance):
-        """
-        Validates the value of the field.
+        @classproperty
+        def foo(cls):
+            return cls._prop1 + cls._prop2
 
-        :param name: the name of the field.
-        :param value: the value of the field.
-        :param instance: the instance containing the field.
-        """
-        if self.default != self.NO_DEFAULT and value == self.default:
-            return
-        if self.type:
-            self.validate_instance(name, value, self.type)
-        if self.choices:
-            self.validate_in_choice(name, value, self.choices)
-        if self.validation_func:
-            self.validation_func(name, value, instance)
-
-    def _field_name(self, instance):
-        """
-        retrieves the field name from the instance.
+    And use it like this:
+    print A.foo  # 3
 
-        :param Field instance: the instance which holds the field.
-        :return: name of the field
-        :rtype: basestring
-        """
-        for name, member in vars(instance.__class__).iteritems():
-            if member is self:
-                return name
+    """
+    def __init__(self, get_func):
+        self.get_func = get_func
+
+    def __get__(self, owner_self, owner_cls):
+        return self.get_func(owner_cls)
+
+
+def foreign_key(
+        parent_table,
+        id_col_name='storage_id',
+        nullable=False,
+        column_type=Integer
+):
+    """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 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'
+        ),
+        nullable=nullable
+    )
+
+
+def one_to_many_relationship(
+        child_class_name,
+        column_name,
+        parent_class_name,
+        back_reference_name,
+        parent_id_name='storage_id',
+):
+    """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:
+    """
+    return orm.relationship(
+        parent_class_name,
+        primaryjoin='{0}.{1} == {2}.{3}'.format(
+            child_class_name,
+            column_name,
+            parent_class_name,
+            parent_id_name
+        ),
+        # 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')
+    )
 
 
-class IterField(Field):
+class Dict(TypeDecorator):
     """
-    Represents an iterable field.
+    Dict representation of type.
     """
-    def __init__(self, **kwargs):
-        """
-        Simple iterable field manager.
-        This field type don't have choices option.
 
-        :param kwargs: kwargs to be passed to next in line classes.
-        """
-        super(IterField, self).__init__(choices=(), **kwargs)
+    def process_literal_param(self, value, dialect):
+        pass
 
-    def validate_value(self, name, values, *args):
-        """
-        Validates the value of each iterable value.
+    @property
+    def python_type(self):
+        return dict
 
-        :param name: the name of the field.
-        :param values: the values of the field.
-        """
-        for value in values:
-            self.validate_instance(name, value, self.type)
+    impl = VARCHAR
 
+    def process_bind_param(self, value, dialect):
+        if value is not None:
+            value = json.dumps(value)
+        return value
+
+    def process_result_value(self, value, dialect):
+        if value is not None:
+            value = json.loads(value)
+        return value
 
-class PointerField(Field):
-    """
-    A single pointer field implementation.
 
-    Any PointerField points via id to another document.
+class MutableDict(Mutable, dict):
     """
+    Enables tracking for dict values.
+    """
+    @classmethod
+    def coerce(cls, key, value):
+        "Convert plain dictionaries to MutableDict."
 
-    def __init__(self, type, **kwargs):
-        assert issubclass(type, Model)
-        super(PointerField, self).__init__(type=type, **kwargs)
+        if not isinstance(value, MutableDict):
+            if isinstance(value, dict):
+                return MutableDict(value)
 
+            # this call will raise ValueError
+            return Mutable.coerce(key, value)
+        else:
+            return value
 
-class IterPointerField(IterField, PointerField):
-    """
-    An iterable pointers field.
-
-    Any IterPointerField points via id to other documents.
-    """
-    pass
+    def __setitem__(self, key, value):
+        "Detect dictionary set events and emit change events."
 
+        dict.__setitem__(self, key, value)
+        self.changed()
 
-class Model(object):
-    """
-    Base class for all of the storage models.
-    """
-    id = None
+    def __delitem__(self, key):
+        "Detect dictionary del events and emit change events."
 
-    def __init__(self, **fields):
-        """
-        Abstract class for any model in the storage.
-        The Initializer creates attributes according to the (keyword 
arguments) that given
-        Each value is validated according to the Field.
-        Each model has to have and ID Field.
+        dict.__delitem__(self, key)
+        self.changed()
 
-        :param fields: each item is validated and transformed into instance 
attributes.
-        """
-        self._assert_model_have_id_field(**fields)
-        missing_fields, unexpected_fields = self._setup_fields(fields)
 
-        if missing_fields:
-            raise StorageError(
-                'Model {name} got missing keyword arguments: {fields}'.format(
-                    name=self.__class__.__name__, fields=missing_fields))
+class SQLModelBase(Model):
+    """Abstract base class for all SQL models that allows [de]serialization
+    """
+    # SQLAlchemy syntax
+    __abstract__ = True
 
-        if unexpected_fields:
-            raise StorageError(
-                'Model {name} got unexpected keyword arguments: 
{fields}'.format(
-                    name=self.__class__.__name__, fields=unexpected_fields))
+    # Indicates to the storage manager whether the table is a resource or not
+    is_resource = False
 
-    def __repr__(self):
-        return '{name}(fields={0})'.format(sorted(self.fields), 
name=self.__class__.__name__)
+    _private_fields = []
 
-    def __eq__(self, other):
-        return (
-            isinstance(other, self.__class__) and
-            self.fields_dict == other.fields_dict)
+    # Indicates whether the `id` column in this class should be unique
+    is_id_unique = True
 
-    @property
-    def fields(self):
+    def to_dict(self, **kwargs):
         """
-        Iterates over the fields of the model.
-        :yields: the class's field name
+        Convert the model into dict
+        :return:
         """
-        for name, field in vars(self.__class__).items():
-            if isinstance(field, Field):
-                yield name
+        return dict((field, getattr(self, field)) for field in self.fields)
 
-    @property
-    def fields_dict(self):
+    def to_json(self):
         """
-        Transforms the instance attributes into a dict.
-
-        :return: all fields in dict format.
-        :rtype dict
+        Convert the model into json.
+        :return:
         """
-        return dict((name, getattr(self, name)) for name in self.fields)
+        return jsonpickle.encode(self.to_dict(), unpicklable=False)
 
-    @property
-    def json(self):
+    @classproperty
+    def fields(cls):
+        """Return the list of field names for this table
+
+        Mostly for backwards compatibility in the code (that uses `fields`)
         """
-        Transform the dict of attributes into json
-        :return:
+        return cls.__table__.columns.keys()
+
+    def _get_unique_id(self):
+        """A method to allow classes to override the default representation
         """
-        return json.dumps(self.fields_dict)
+        return 'id', self.id
 
-    @classmethod
-    def _assert_model_have_id_field(cls, **fields_initializer_values):
-        if not getattr(cls, 'id', None):
-            raise StorageError('Model {cls.__name__} must have id 
field'.format(cls=cls))
-
-        if cls.id.default == cls.id.NO_DEFAULT and 'id' not in 
fields_initializer_values:
-            raise StorageError(
-                'Model {cls.__name__} is missing required '
-                'keyword-only argument: "id"'.format(cls=cls))
-
-    def _setup_fields(self, input_fields):
-        missing = []
-        for field_name in self.fields:
-            try:
-                field_obj = input_fields.pop(field_name)
-                setattr(self, field_name, field_obj)
-            except KeyError:
-                field = getattr(self.__class__, field_name)
-                if field.default == field.NO_DEFAULT:
-                    missing.append(field_name)
-
-        unexpected_fields = input_fields.keys()
-        return missing, unexpected_fields
-
-
-class Storage(LoggerMixin):
-    """
-    Represents the storage
-    """
-    def __init__(self, driver, items=(), **kwargs):
-        super(Storage, self).__init__(**kwargs)
-        self.driver = driver
-        self.registered = {}
-        for item in items:
-            self.register(item)
-        self.logger.debug('{name} object is ready: {0!r}'.format(
-            self, name=self.__class__.__name__))
+    def __str__(self):
+        id_name, id_value = self._get_unique_id()
+        return '<{0} {1}=`{2}`>'.format(
+            self.__class__.__name__,
+            id_name,
+            id_value
+        )
 
     def __repr__(self):
-        return '{name}(driver={self.driver})'.format(
-            name=self.__class__.__name__, self=self)
+        return str(self)
 
-    def __getattr__(self, item):
-        try:
-            return self.registered[item]
-        except KeyError:
-            return super(Storage, self).__getattribute__(item)
+    def __unicode__(self):
+        return str(self)
 
-    def setup(self):
-        """
-        Setup and create all storage items
-        """
-        for name, api in self.registered.iteritems():
-            try:
-                api.create()
-                self.logger.debug(
-                    'setup {name} in storage {self!r}'.format(name=name, 
self=self))
-            except StorageError:
-                pass
+    def __eq__(self, other):
+        return isinstance(other, self.__class__) and self.to_dict() == 
other.to_dict()

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/requirements.txt
----------------------------------------------------------------------
diff --git a/requirements.txt b/requirements.txt
index e6d5393..7e87c67 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -23,3 +23,4 @@ Jinja2==2.8
 shortuuid==0.4.3
 CacheControl[filecache]==0.11.6
 clint==0.5.1
+SQLAlchemy==1.1.4
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/tests/mock/context.py
----------------------------------------------------------------------
diff --git a/tests/mock/context.py b/tests/mock/context.py
index 5fda07e..0d09bb1 100644
--- a/tests/mock/context.py
+++ b/tests/mock/context.py
@@ -13,21 +13,59 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import pytest
+
+
 from aria import application_model_storage
 from aria.orchestrator import context
+from aria.storage.mapi import SQLAlchemyModelAPI
+
+from tests.storage import get_sqlite_api_params
 
 from . import models
-from ..storage import InMemoryModelDriver
 
 
+@pytest.fixture
 def simple(**kwargs):
-    storage = application_model_storage(InMemoryModelDriver())
-    storage.setup()
-    storage.blueprint.store(models.get_blueprint())
-    storage.deployment.store(models.get_deployment())
+    api_params = get_sqlite_api_params()
+    model_storage = application_model_storage(SQLAlchemyModelAPI, 
api_params=api_params)
+    model_storage.blueprint.store(models.get_blueprint())
+    blueprint = model_storage.blueprint.get(models.BLUEPRINT_ID)
+    deployment = models.get_deployment(blueprint)
+    model_storage.deployment.store(deployment)
+
+    
#################################################################################
+    # Creating a simple deployment with node -> node as a graph
+
+    dependency_node = models.get_dependency_node(deployment)
+    model_storage.node.store(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)
+    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)
+    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)
+    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)
+    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)
+
     final_kwargs = dict(
         name='simple_context',
-        model_storage=storage,
+        model_storage=model_storage,
         resource_storage=None,
         deployment_id=models.DEPLOYMENT_ID,
         workflow_id=models.WORKFLOW_ID,

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/tests/mock/models.py
----------------------------------------------------------------------
diff --git a/tests/mock/models.py b/tests/mock/models.py
index 327b0b9..bdcbed9 100644
--- a/tests/mock/models.py
+++ b/tests/mock/models.py
@@ -30,13 +30,13 @@ DEPENDENCY_NODE_ID = 'dependency_node'
 DEPENDENCY_NODE_INSTANCE_ID = 'dependency_node_instance'
 DEPENDENT_NODE_ID = 'dependent_node'
 DEPENDENT_NODE_INSTANCE_ID = 'dependent_node_instance'
+RELATIONSHIP_ID = 'relationship'
+RELATIONSHIP_INSTANCE_ID = 'relationship_instance'
 
-
-def get_dependency_node():
+def get_dependency_node(deployment):
     return models.Node(
         id=DEPENDENCY_NODE_ID,
         host_id=DEPENDENCY_NODE_ID,
-        blueprint_id=BLUEPRINT_ID,
         type='test_node_type',
         type_hierarchy=[],
         number_of_instances=1,
@@ -44,28 +44,30 @@ def get_dependency_node():
         deploy_number_of_instances=1,
         properties={},
         operations=dict((key, {}) for key in operations.NODE_OPERATIONS),
-        relationships=[],
         min_number_of_instances=1,
         max_number_of_instances=1,
+        deployment_storage_id=deployment.storage_id
     )
 
 
-def get_dependency_node_instance(dependency_node=None):
+def get_dependency_node_instance(dependency_node):
     return models.NodeInstance(
         id=DEPENDENCY_NODE_INSTANCE_ID,
         host_id=DEPENDENCY_NODE_INSTANCE_ID,
-        deployment_id=DEPLOYMENT_ID,
         runtime_properties={'ip': '1.1.1.1'},
         version=None,
-        relationship_instances=[],
-        node=dependency_node or get_dependency_node()
+        node_storage_id=dependency_node.storage_id,
+        deployment_storage_id=dependency_node.deployment.storage_id,
+        state='',
+        scaling_groups={}
     )
 
 
 def get_relationship(source=None, target=None):
     return models.Relationship(
-        source_id=source.id if source is not None else DEPENDENT_NODE_ID,
-        target_id=target.id if target is not None else DEPENDENCY_NODE_ID,
+        id=RELATIONSHIP_ID,
+        source_node_storage_id=source.storage_id,
+        target_node_storage_id=target.storage_id,
         source_interfaces={},
         source_operations=dict((key, {}) for key in 
operations.RELATIONSHIP_OPERATIONS),
         target_interfaces={},
@@ -76,23 +78,21 @@ def get_relationship(source=None, target=None):
     )
 
 
-def get_relationship_instance(source_instance=None, target_instance=None, 
relationship=None):
+def get_relationship_instance(source_instance, target_instance, relationship):
     return models.RelationshipInstance(
-        target_id=target_instance.id if target_instance else 
DEPENDENCY_NODE_INSTANCE_ID,
-        target_name='test_target_name',
-        source_id=source_instance.id if source_instance else 
DEPENDENT_NODE_INSTANCE_ID,
-        source_name='test_source_name',
+        id=RELATIONSHIP_INSTANCE_ID,
         type='some_type',
-        relationship=relationship or get_relationship(target_instance.node
-                                                      if target_instance else 
None)
+        relationship_storage_id=relationship.storage_id,
+        target_node_instance_storage_id=target_instance.storage_id,
+        source_node_instance_storage_id=source_instance.storage_id,
     )
 
 
-def get_dependent_node(relationship=None):
+def get_dependent_node(deployment):
     return models.Node(
         id=DEPENDENT_NODE_ID,
+        deployment_storage_id=deployment.storage_id,
         host_id=DEPENDENT_NODE_ID,
-        blueprint_id=BLUEPRINT_ID,
         type='test_node_type',
         type_hierarchy=[],
         number_of_instances=1,
@@ -100,21 +100,21 @@ def get_dependent_node(relationship=None):
         deploy_number_of_instances=1,
         properties={},
         operations=dict((key, {}) for key in operations.NODE_OPERATIONS),
-        relationships=[relationship or get_relationship()],
         min_number_of_instances=1,
         max_number_of_instances=1,
     )
 
 
-def get_dependent_node_instance(relationship_instance=None, 
dependent_node=None):
+def get_dependent_node_instance(dependent_node):
     return models.NodeInstance(
         id=DEPENDENT_NODE_INSTANCE_ID,
         host_id=DEPENDENT_NODE_INSTANCE_ID,
-        deployment_id=DEPLOYMENT_ID,
         runtime_properties={},
         version=None,
-        relationship_instances=[relationship_instance or 
get_relationship_instance()],
-        node=dependent_node or get_dependency_node()
+        node_storage_id=dependent_node.storage_id,
+        deployment_storage_id=dependent_node.deployment.storage_id,
+        state='',
+        scaling_groups={}
     )
 
 
@@ -130,25 +130,31 @@ def get_blueprint():
     )
 
 
-def get_execution():
+def get_execution(deployment):
     return models.Execution(
         id=EXECUTION_ID,
+        deployment_storage_id=deployment.storage_id,
         status=models.Execution.STARTED,
-        deployment_id=DEPLOYMENT_ID,
         workflow_id=WORKFLOW_ID,
-        blueprint_id=BLUEPRINT_ID,
         started_at=datetime.utcnow(),
         parameters=None
     )
 
 
-def get_deployment():
+def get_deployment(blueprint):
     now = datetime.utcnow()
     return models.Deployment(
         id=DEPLOYMENT_ID,
-        description=None,
+        blueprint_storage_id=blueprint.storage_id,
+        description='',
         created_at=now,
         updated_at=now,
-        blueprint_id=BLUEPRINT_ID,
-        workflows={}
+        workflows={},
+        inputs={},
+        groups={},
+        permalink='',
+        policy_triggers={},
+        policy_types={},
+        outputs={},
+        scaling_groups={},
     )

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/tests/orchestrator/context/test_operation.py
----------------------------------------------------------------------
diff --git a/tests/orchestrator/context/test_operation.py 
b/tests/orchestrator/context/test_operation.py
index 6b3e28d..ec13154 100644
--- a/tests/orchestrator/context/test_operation.py
+++ b/tests/orchestrator/context/test_operation.py
@@ -35,7 +35,9 @@ global_test_holder = {}
 
 @pytest.fixture
 def ctx():
-    return mock.context.simple()
+    context = mock.context.simple()
+    yield context
+    context.model.drop()
 
 
 @pytest.fixture
@@ -50,14 +52,13 @@ def executor():
 def test_node_operation_task_execution(ctx, executor):
     operation_name = 'aria.interfaces.lifecycle.create'
 
-    node = mock.models.get_dependency_node()
+    node = ctx.model.node.get(mock.models.DEPENDENCY_NODE_ID)
     node.operations[operation_name] = {
         'operation': op_path(my_operation, module_path=__name__)
 
     }
-    node_instance = mock.models.get_dependency_node_instance(node)
-    ctx.model.node.store(node)
-    ctx.model.node_instance.store(node_instance)
+    ctx.model.node.update(node)
+    node_instance = 
ctx.model.node_instance.get(mock.models.DEPENDENCY_NODE_INSTANCE_ID)
 
     inputs = {'putput': True}
 
@@ -91,25 +92,18 @@ def test_node_operation_task_execution(ctx, executor):
 def test_relationship_operation_task_execution(ctx, executor):
     operation_name = 'aria.interfaces.relationship_lifecycle.postconfigure'
 
-    dependency_node = mock.models.get_dependency_node()
-    dependency_node_instance = mock.models.get_dependency_node_instance()
-    relationship = mock.models.get_relationship(target=dependency_node)
+    relationship = ctx.model.relationship.get(mock.models.RELATIONSHIP_ID)
     relationship.source_operations[operation_name] = {
         'operation': op_path(my_operation, module_path=__name__)
     }
-    relationship_instance = mock.models.get_relationship_instance(
-        target_instance=dependency_node_instance,
-        relationship=relationship)
-    dependent_node = mock.models.get_dependent_node()
-    dependent_node_instance = mock.models.get_dependent_node_instance(
-        relationship_instance=relationship_instance,
-        dependent_node=dependency_node)
-    ctx.model.node.store(dependency_node)
-    ctx.model.node_instance.store(dependency_node_instance)
-    ctx.model.relationship.store(relationship)
-    ctx.model.relationship_instance.store(relationship_instance)
-    ctx.model.node.store(dependent_node)
-    ctx.model.node_instance.store(dependent_node_instance)
+    ctx.model.relationship.update(relationship)
+    relationship_instance = ctx.model.relationship_instance.get(
+        mock.models.RELATIONSHIP_INSTANCE_ID)
+
+    dependency_node = ctx.model.node.get(mock.models.DEPENDENCY_NODE_ID)
+    dependency_node_instance = 
ctx.model.node_instance.get(mock.models.DEPENDENCY_NODE_INSTANCE_ID)
+    dependent_node = ctx.model.node.get(mock.models.DEPENDENT_NODE_ID)
+    dependent_node_instance = 
ctx.model.node_instance.get(mock.models.DEPENDENT_NODE_INSTANCE_ID)
 
     inputs = {'putput': True}
 

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/tests/orchestrator/context/test_toolbelt.py
----------------------------------------------------------------------
diff --git a/tests/orchestrator/context/test_toolbelt.py 
b/tests/orchestrator/context/test_toolbelt.py
index 547e62b..480f289 100644
--- a/tests/orchestrator/context/test_toolbelt.py
+++ b/tests/orchestrator/context/test_toolbelt.py
@@ -33,7 +33,9 @@ global_test_holder = {}
 
 @pytest.fixture
 def workflow_context():
-    return mock.context.simple()
+    context = mock.context.simple()
+    yield context
+    context.model.drop()
 
 
 @pytest.fixture
@@ -45,31 +47,23 @@ def executor():
         result.close()
 
 
-def _create_simple_model_in_storage(workflow_context):
-    dependency_node = mock.models.get_dependency_node()
-    dependency_node_instance = mock.models.get_dependency_node_instance(
-        dependency_node=dependency_node)
-    relationship = mock.models.get_relationship(target=dependency_node)
-    relationship_instance = mock.models.get_relationship_instance(
-        target_instance=dependency_node_instance, relationship=relationship)
-    dependent_node = mock.models.get_dependent_node()
-    dependent_node_instance = mock.models.get_dependent_node_instance(
-        relationship_instance=relationship_instance, 
dependent_node=dependency_node)
-    workflow_context.model.node.store(dependency_node)
-    workflow_context.model.node_instance.store(dependency_node_instance)
-    workflow_context.model.relationship.store(relationship)
-    workflow_context.model.relationship_instance.store(relationship_instance)
-    workflow_context.model.node.store(dependent_node)
-    workflow_context.model.node_instance.store(dependent_node_instance)
-    return dependency_node, dependency_node_instance, \
-           dependent_node, dependent_node_instance, \
-           relationship, relationship_instance
+def _get_elements(workflow_context):
+    dependency_node = 
workflow_context.model.node.get(mock.models.DEPENDENCY_NODE_ID)
+    dependency_node_instance = workflow_context.model.node_instance.get(
+        mock.models.DEPENDENCY_NODE_INSTANCE_ID)
+    dependent_node = 
workflow_context.model.node.get(mock.models.DEPENDENT_NODE_ID)
+    dependent_node_instance = workflow_context.model.node_instance.get(
+        mock.models.DEPENDENT_NODE_INSTANCE_ID)
+    relationship = 
workflow_context.model.relationship.get(mock.models.RELATIONSHIP_ID)
+    relationship_instance = workflow_context.model.relationship_instance.get(
+        mock.models.RELATIONSHIP_INSTANCE_ID)
+    return dependency_node, dependency_node_instance, dependent_node, 
dependent_node_instance, \
+        relationship, relationship_instance
 
 
 def test_host_ip(workflow_context, executor):
     operation_name = 'aria.interfaces.lifecycle.create'
-    dependency_node, dependency_node_instance, _, _, _, _ = \
-        _create_simple_model_in_storage(workflow_context)
+    dependency_node, dependency_node_instance, _, _, _, _ = 
_get_elements(workflow_context)
     dependency_node.operations[operation_name] = {
         'operation': op_path(host_ip, module_path=__name__)
 
@@ -96,7 +90,7 @@ def test_host_ip(workflow_context, executor):
 def test_dependent_node_instances(workflow_context, executor):
     operation_name = 'aria.interfaces.lifecycle.create'
     dependency_node, dependency_node_instance, _, dependent_node_instance, _, 
_ = \
-        _create_simple_model_in_storage(workflow_context)
+        _get_elements(workflow_context)
     dependency_node.operations[operation_name] = {
         'operation': op_path(dependent_nodes, module_path=__name__)
 
@@ -116,14 +110,14 @@ def test_dependent_node_instances(workflow_context, 
executor):
 
     execute(workflow_func=basic_workflow, workflow_context=workflow_context, 
executor=executor)
 
-    assert list(global_test_holder.get('dependent_node_instances', [])) == \
-           list([dependent_node_instance])
+    assert global_test_holder.get('dependent_node_instances')[0].to_dict == \
+           dependent_node_instance.to_dict
 
 
 def test_relationship_tool_belt(workflow_context, executor):
     operation_name = 'aria.interfaces.relationship_lifecycle.postconfigure'
     _, _, _, _, relationship, relationship_instance = \
-        _create_simple_model_in_storage(workflow_context)
+        _get_elements(workflow_context)
     relationship.source_operations[operation_name] = {
         'operation': op_path(relationship_operation, module_path=__name__)
     }
@@ -152,6 +146,7 @@ def test_wrong_model_toolbelt():
     with pytest.raises(RuntimeError):
         context.toolbelt(None)
 
+
 @operation(toolbelt=True)
 def host_ip(toolbelt, **_):
     global_test_holder['host_ip'] = toolbelt.host_ip

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/fe944e58/tests/orchestrator/context/test_workflow.py
----------------------------------------------------------------------
diff --git a/tests/orchestrator/context/test_workflow.py 
b/tests/orchestrator/context/test_workflow.py
index 258f0c5..4c4979f 100644
--- a/tests/orchestrator/context/test_workflow.py
+++ b/tests/orchestrator/context/test_workflow.py
@@ -19,9 +19,10 @@ 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 tests.storage import InMemoryModelDriver
+from tests import storage as test_storage
 
 
 class TestWorkflowContext(object):
@@ -57,8 +58,9 @@ class TestWorkflowContext(object):
 
 @pytest.fixture(scope='function')
 def storage():
-    result = application_model_storage(InMemoryModelDriver())
-    result.setup()
+    api_params = test_storage.get_sqlite_api_params()
+    result = application_model_storage(SQLAlchemyModelAPI, 
api_params=api_params)
     result.blueprint.store(models.get_blueprint())
-    result.deployment.store(models.get_deployment())
+    blueprint = result.blueprint.get(models.BLUEPRINT_ID)
+    result.deployment.store(models.get_deployment(blueprint))
     return result


Reply via email to