Add support of datastore types

implements blueprint db-type-version

Change-Id: Ie87f72b898e993044803e7b37cad78372c2cd3f4

4 files changed, 292 insertions, 0 deletions

diff --git a/trove/datastore/__init__.py b/trove/datastore/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/trove/datastore/__init__.py
diff --git a/trove/datastore/models.py b/trove/datastore/models.py
new file mode 100644
index 00000000..8c962134
--- /dev/null
+++ b/trove/datastore/models.py
@@ -0,0 +1,185 @@
+from trove.common import cfg
+from trove.common import exception
+from trove.db import models as dbmodels
+from trove.db import get_db_api
+from trove.openstack.common import uuidutils
+
+
+CONF = cfg.CONF
+db_api = get_db_api()
+
+
+def persisted_models():
+    return {
+        'datastore': DBDatastore,
+        'datastore_version': DBDatastoreVersion,
+    }
+
+
+class DBDatastore(dbmodels.DatabaseModelBase):
+
+    _data_fields = ['id', 'name', 'manager', 'default_version_id']
+
+
+class DBDatastoreVersion(dbmodels.DatabaseModelBase):
+
+    _data_fields = ['id', 'datastore_id', 'name', 'image_id', 'packages',
+                    'active']
+
+
+class Datastore(object):
+
+    def __init__(self, db_info):
+        self.db_info = db_info
+
+    @classmethod
+    def load(cls, id_or_name):
+        try:
+            return cls(DBDatastore.find_by(id=id_or_name))
+        except exception.ModelNotFoundError:
+            try:
+                return cls(DBDatastore.find_by(name=id_or_name))
+            except exception.ModelNotFoundError:
+                raise exception.DatastoreNotFound(datastore=id_or_name)
+
+    @property
+    def id(self):
+        return self.db_info.id
+
+    @property
+    def name(self):
+        return self.db_info.name
+
+    @property
+    def manager(self):
+        return self.db_info.manager
+
+    @property
+    def default_version_id(self):
+        return self.db_info.default_version_id
+
+
+class Datastores(object):
+
+    def __init__(self, db_info):
+        self.db_info = db_info
+
+    @classmethod
+    def load(cls):
+        return cls(DBDatastore.find_all())
+
+    def __iter__(self):
+        for item in self.db_info:
+            yield item
+
+
+class DatastoreVersion(object):
+
+    def __init__(self, db_info):
+        self.db_info = db_info
+
+    @classmethod
+    def load(cls, id_or_name):
+        try:
+            return cls(DBDatastoreVersion.find_by(id=id_or_name))
+        except exception.ModelNotFoundError:
+            try:
+                return cls(DBDatastoreVersion.find_by(name=id_or_name))
+            except exception.ModelNotFoundError:
+                raise exception.DatastoreVersionNotFound(version=id_or_name)
+
+    @property
+    def id(self):
+        return self.db_info.id
+
+    @property
+    def datastore_id(self):
+        return self.db_info.datastore_id
+
+    @property
+    def name(self):
+        return self.db_info.name
+
+    @property
+    def image_id(self):
+        return self.db_info.image_id
+
+    @property
+    def packages(self):
+        return self.db_info.packages
+
+    @property
+    def active(self):
+        return self.db_info.active
+
+
+class DatastoreVersions(object):
+
+    def __init__(self, db_info):
+        self.db_info = db_info
+
+    @classmethod
+    def load(cls, id_or_name, active=True):
+        datastore = Datastore.load(id_or_name)
+        return cls(DBDatastoreVersion.find_all(datastore_id=datastore.id,
+                                               active=active))
+
+    def __iter__(self):
+        for item in self.db_info:
+            yield item
+
+
+def get_datastore_version(type=None, version=None):
+    datastore = type or CONF.default_datastore
+    if not datastore:
+        raise exception.DatastoreDefaultDatastoreNotFound()
+    datastore = Datastore.load(datastore)
+    version = version or datastore.default_version_id
+    if not version:
+        raise exception.DatastoreDefaultVersionNotFound(datastore=
+                                                        datastore.name)
+    datastore_version = DatastoreVersion.load(version)
+    if datastore_version.datastore_id != datastore.id:
+        raise exception.DatastoreNoVersion(datastore=datastore.name,
+                                           version=datastore_version.name)
+    if not datastore_version.active:
+        raise exception.DatastoreVersionInactive(version=
+                                                 datastore_version.name)
+    return (datastore, datastore_version)
+
+
+def update_datastore(name, manager, default_version):
+    db_api.configure_db(CONF)
+    if default_version:
+        version = DatastoreVersion.load(default_version)
+        if not version.active:
+            raise exception.DatastoreVersionInactive(version=
+                                                     version.name)
+    try:
+        datastore = DBDatastore.find_by(name=name)
+    except exception.ModelNotFoundError:
+        # Create a new one
+        datastore = DBDatastore()
+        datastore.id = uuidutils.generate_uuid()
+        datastore.name = name
+    datastore.manager = manager
+    if default_version:
+        datastore.default_version_id = version.id
+    db_api.save(datastore)
+
+
+def update_datastore_version(datastore, name, image_id, packages, active):
+    db_api.configure_db(CONF)
+    datastore = Datastore.load(datastore)
+    try:
+        version = DBDatastoreVersion.find_by(name=name)
+    except exception.ModelNotFoundError:
+        # Create a new one
+        version = DBDatastoreVersion()
+        version.id = uuidutils.generate_uuid()
+        version.name = name
+    version.datastore_id = datastore.id
+    version.image_id = image_id
+    version.packages = packages
+    version.active = active
+    db_api.save(version)
diff --git a/trove/datastore/service.py b/trove/datastore/service.py
new file mode 100644
index 00000000..8cdf2e3b
--- /dev/null
+++ b/trove/datastore/service.py
@@ -0,0 +1,31 @@
+from trove.common import cfg
+from trove.common import exception
+from trove.common import utils
+from trove.common import wsgi
+from trove.datastore import models, views
+
+
+class DatastoreController(wsgi.Controller):
+
+    def show(self, req, tenant_id, id):
+        datastore = models.Datastore.load(id)
+        return wsgi.Result(views.
+                           DatastoreView(datastore, req).data(), 200)
+
+    def index(self, req, tenant_id):
+        datastores = models.Datastores.load()
+        return wsgi.Result(views.
+                           DatastoresView(datastores, req).data(),
+                           200)
+
+    def version_show(self, req, tenant_id, datastore, id):
+        datastore, datastore_version = models.get_datastore_version(datastore,
+                                                                    id)
+        return wsgi.Result(views.DatastoreVersionView(datastore_version,
+                                                      req).data(), 200)
+
+    def version_index(self, req, tenant_id, datastore):
+        datastore_versions = models.DatastoreVersions.load(datastore)
+        return wsgi.Result(views.
+                           DatastoreVersionsView(datastore_versions,
+                                                 req).data(), 200)
diff --git a/trove/datastore/views.py b/trove/datastore/views.py
new file mode 100644
index 00000000..a2b29085
--- /dev/null
+++ b/trove/datastore/views.py
@@ -0,0 +1,76 @@
+from trove.common.views import create_links
+
+
+class DatastoreView(object):
+
+    def __init__(self, datastore, req=None):
+        self.datastore = datastore
+        self.req = req
+
+    def data(self):
+        datastore_dict = {
+            "id": self.datastore.id,
+            "name": self.datastore.name,
+            "links": self._build_links(),
+        }
+
+        return {"datastore": datastore_dict}
+
+    def _build_links(self):
+        return create_links("datastores", self.req,
+                            self.datastore.id)
+
+
+class DatastoresView(object):
+
+    def __init__(self, datastores, req=None):
+        self.datastores = datastores
+        self.req = req
+
+    def data(self):
+        data = []
+        for datastore in self.datastores:
+            data.append(self.data_for_datastore(datastore))
+        return {'datastores': data}
+
+    def data_for_datastore(self, datastore):
+        view = DatastoreView(datastore, req=self.req)
+        return view.data()['datastore']
+
+
+class DatastoreVersionView(object):
+
+    def __init__(self, datastore_version, req=None):
+        self.datastore_version = datastore_version
+        self.req = req
+
+    def data(self):
+        datastore_version_dict = {
+            "id": self.datastore_version.id,
+            "name": self.datastore_version.name,
+            "links": self._build_links(),
+        }
+
+        return {"version": datastore_version_dict}
+
+    def _build_links(self):
+        return create_links("datastores/versions",
+                            self.req, self.datastore_version.id)
+
+
+class DatastoreVersionsView(object):
+
+    def __init__(self, datastore_versions, req=None):
+        self.datastore_versions = datastore_versions
+        self.req = req
+
+    def data(self):
+        data = []
+        for datastore_version in self.datastore_versions:
+            data.append(self.
+                        data_for_datastore_version(datastore_version))
+        return {'versions': data}
+
+    def data_for_datastore_version(self, datastore_version):
+        view = DatastoreVersionView(datastore_version, req=self.req)
+        return view.data()['version']