Add scoring engines to database and API layers

A Scoring Module needs to expose a list of available
scoring engines through API and Watcher CLI. This list
is stored in database and synchronized by Decision Engine.

Partially-Implements: blueprint scoring-module
Change-Id: I32168adeaf34fd12a731204c5b58fe68434ad087
APIImpact

watcher/db/api.py

@@ -635,3 +635,83 @@ class BaseConnection(object):
         :raises: :py:class:`~.EfficacyIndicatorNotFound`
         :raises: :py:class:`~.Invalid`
         """
+
+    @abc.abstractmethod
+    def get_scoring_engine_list(
+            self, context, columns=None, filters=None, limit=None,
+            marker=None, sort_key=None, sort_dir=None):
+        """Get specific columns for matching scoring engines.
+
+        Return a list of the specified columns for all scoring engines that
+        match the specified filters.
+
+        :param context: The security context
+        :param columns: List of column names to return.
+                        Defaults to 'id' column when columns == None.
+        :param filters: Filters to apply. Defaults to None.
+        :param limit: Maximum number of scoring engines to return.
+        :param marker: the last item of the previous page; we return the next
+                       result set.
+        :param sort_key: Attribute by which results should be sorted.
+        :param sort_dir: direction in which results should be sorted.
+                         (asc, desc)
+        :returns: A list of tuples of the specified columns.
+        """
+
+    @abc.abstractmethod
+    def create_scoring_engine(self, values):
+        """Create a new scoring engine.
+
+        :param values: A dict containing several items used to identify
+                       and track the scoring engine.
+        :returns: A scoring engine.
+        :raises: :py:class:`~.ScoringEngineAlreadyExists`
+        """
+
+    @abc.abstractmethod
+    def get_scoring_engine_by_id(self, context, scoring_engine_id):
+        """Return a scoring engine by its id.
+
+        :param context: The security context
+        :param scoring_engine_id: The id of a scoring engine.
+        :returns: A scoring engine.
+        :raises: :py:class:`~.ScoringEngineNotFound`
+        """
+
+    @abc.abstractmethod
+    def get_scoring_engine_by_uuid(self, context, scoring_engine_uuid):
+        """Return a scoring engine by its uuid.
+
+        :param context: The security context
+        :param scoring_engine_uuid: The uuid of a scoring engine.
+        :returns: A scoring engine.
+        :raises: :py:class:`~.ScoringEngineNotFound`
+        """
+
+    @abc.abstractmethod
+    def get_scoring_engine_by_name(self, context, scoring_engine_name):
+        """Return a scoring engine by its name.
+
+        :param context: The security context
+        :param scoring_engine_name: The name of a scoring engine.
+        :returns: A scoring engine.
+        :raises: :py:class:`~.ScoringEngineNotFound`
+        """
+
+    @abc.abstractmethod
+    def destroy_scoring_engine(self, scoring_engine_id):
+        """Destroy a scoring engine.
+
+        :param scoring_engine_id: The id of a scoring engine.
+        :raises: :py:class:`~.ScoringEngineNotFound`
+        """
+
+    @abc.abstractmethod
+    def update_scoring_engine(self, scoring_engine_id, values):
+        """Update properties of a scoring engine.
+
+        :param scoring_engine_id: The id of a scoring engine.
+        :returns: A scoring engine.
+        :raises: :py:class:`~.ScoringEngineNotFound`
+        :raises: :py:class:`~.Invalid`
+        """

watcher/db/sqlalchemy/api.py

@@ -974,3 +974,86 @@ class Connection(api.BaseConnection):
         except exception.ResourceNotFound:
             raise exception.EfficacyIndicatorNotFound(
                 efficacy_indicator=efficacy_indicator_id)
+
+    # ### SCORING ENGINES ### #
+
+    def _add_scoring_engine_filters(self, query, filters):
+        if filters is None:
+            filters = {}
+
+        plain_fields = ['id', 'description']
+
+        return self._add_filters(
+            query=query, model=models.ScoringEngine, filters=filters,
+            plain_fields=plain_fields)
+
+    def get_scoring_engine_list(
+        self, context, columns=None, filters=None, limit=None,
+            marker=None, sort_key=None, sort_dir=None):
+        query = model_query(models.ScoringEngine)
+        query = self._add_scoring_engine_filters(query, filters)
+        if not context.show_deleted:
+            query = query.filter_by(deleted_at=None)
+
+        return _paginate_query(models.ScoringEngine, limit, marker,
+                               sort_key, sort_dir, query)
+
+    def create_scoring_engine(self, values):
+        # ensure defaults are present for new scoring engines
+        if not values.get('uuid'):
+            values['uuid'] = utils.generate_uuid()
+
+        scoring_engine = models.ScoringEngine()
+        scoring_engine.update(values)
+
+        try:
+            scoring_engine.save()
+        except db_exc.DBDuplicateEntry:
+            raise exception.ScoringEngineAlreadyExists(uuid=values['uuid'])
+        return scoring_engine
+
+    def _get_scoring_engine(self, context, fieldname, value):
+        try:
+            return self._get(context, model=models.ScoringEngine,
+                             fieldname=fieldname, value=value)
+        except exception.ResourceNotFound:
+            raise exception.ScoringEngineNotFound(scoring_engine=value)
+
+    def get_scoring_engine_by_id(self, context, scoring_engine_id):
+        return self._get_scoring_engine(
+            context, fieldname="id", value=scoring_engine_id)
+
+    def get_scoring_engine_by_uuid(self, context, scoring_engine_uuid):
+        return self._get_scoring_engine(
+            context, fieldname="uuid", value=scoring_engine_uuid)
+
+    def get_scoring_engine_by_name(self, context, scoring_engine_name):
+        return self._get_scoring_engine(
+            context, fieldname="name", value=scoring_engine_name)
+
+    def destroy_scoring_engine(self, scoring_engine_id):
+        try:
+            return self._destroy(models.ScoringEngine, scoring_engine_id)
+        except exception.ResourceNotFound:
+            raise exception.ScoringEngineNotFound(
+                scoring_engine=scoring_engine_id)
+
+    def update_scoring_engine(self, scoring_engine_id, values):
+        if 'id' in values:
+            raise exception.Invalid(
+                message=_("Cannot overwrite ID for an existing "
+                          "Scoring Engine."))
+
+        try:
+            return self._update(
+                models.ScoringEngine, scoring_engine_id, values)
+        except exception.ResourceNotFound:
+            raise exception.ScoringEngineNotFound(
+                scoring_engine=scoring_engine_id)
+
+    def soft_delete_scoring_engine(self, scoring_engine_id):
+        try:
+            return self._soft_delete(models.ScoringEngine, scoring_engine_id)
+        except exception.ResourceNotFound:
+            raise exception.ScoringEngineNotFound(
+                scoring_engine=scoring_engine_id)

watcher/db/sqlalchemy/models.py

@@ -29,6 +29,7 @@ from sqlalchemy import Integer
 from sqlalchemy import Numeric
 from sqlalchemy import schema
 from sqlalchemy import String
+from sqlalchemy import Text
 from sqlalchemy.types import TypeDecorator, TEXT
 
 from watcher.common import paths
@@ -230,3 +231,21 @@ class EfficacyIndicator(Base):
     value = Column(Numeric())
     action_plan_id = Column(Integer, ForeignKey('action_plans.id'),
                             nullable=False)
+
+
+class ScoringEngine(Base):
+    """Represents a scoring engine."""
+
+    __tablename__ = 'scoring_engines'
+    __table_args__ = (
+        schema.UniqueConstraint('uuid', name='uniq_scoring_engines0uuid'),
+        table_args()
+    )
+    id = Column(Integer, primary_key=True)
+    uuid = Column(String(36), nullable=False)
+    name = Column(String(63), nullable=False)
+    description = Column(String(255), nullable=True)
+    # Metainfo might contain some additional information about the data model.
+    # The format might vary between different models (e.g. be JSON, XML or
+    # even some custom format), the blob type should cover all scenarios.
+    metainfo = Column(Text, nullable=True)