Merge pull request #4 from sandwichcloud/regionzones

Add regions and zones

Author: rmb938

.env-sample

@@ -25,8 +25,8 @@ RABBITMQ_PASSWORD=hunter2
 # Gitlab: deli_counter.auth.drivers.gitlab.driver:GitlabAuthDriver
 # OpenID: deli_counter.auth.drivers.openid.driver:OpenIDAuthDriver
 # LDAP: deli_counter.auth_drivers.ldap.driver:LDAPAuthDriver
-# DB: deli_counter.auth_drivers.db.driver:DBAuthDriver
-AUTH_DRIVER=deli_counter.auth.drivers.github.driver:GithubAuthDriver
+# DB: deli_counter.auth_drivers.db.driver:DBAuthDriver (always enabled)
+AUTH_DRIVERS=deli_counter.auth.drivers.github.driver:GithubAuthDriver
 
 ####################
 # GITHUB AUTH      #

deli_counter/http/mounts/root/mount.py

@@ -1,7 +1,6 @@
 import arrow
 import cherrypy
 from simple_settings import settings
-from sqlalchemy.orm import Query
 
 from deli_counter.auth.manager import AuthManager
 from ingredients_db.models.authn import AuthNToken, AuthNUser
@@ -64,32 +63,6 @@ def enforce_policy(self, policy_name, resource_object=None):
             self.auth_manager.enforce_policy(policy_name, session, cherrypy.request.token, cherrypy.request.user,
                                              cherrypy.request.project, resource_object)
 
-    def paginate(self, db_cls, response_cls, limit, marker, starting_query=None):
-        if starting_query is None:
-            starting_query = Query(db_cls)
-        resp_objects = []
-        with cherrypy.request.db_session() as session:
-            starting_query.session = session
-            db_objects = starting_query.order_by(db_cls.created_at.desc())
-
-            if marker is not None:
-                marker = session.query(db_cls).filter(db_cls.id == marker).first()
-                if marker is None:
-                    raise cherrypy.HTTPError(status=400, message="Unknown marker ID")
-                db_objects = db_objects.filter(db_cls.created_at < marker.created_at)
-
-            db_objects = db_objects.limit(limit + 1)
-
-            for db_object in db_objects:
-                resp_objects.append(response_cls.from_database(db_object))
-
-        more_pages = False
-        if len(resp_objects) > limit:
-            more_pages = True
-            del resp_objects[-1]  # Remove the last item to reset back to original limit
-
-        return resp_objects, more_pages
-
     def resource_object(self, id_param, cls):
         resource_id = cherrypy.request.params[id_param]
         with cherrypy.request.db_session() as session:

deli_counter/http/mounts/root/routes/v1/auth/z/policies.py

@@ -63,7 +63,7 @@ def get(self, policy_id: uuid.UUID):
     @cherrypy.tools.model_out_pagination(cls=ResponsePolicy)
     @cherrypy.tools.enforce_policy(policy_name="policies:list")
     def list(self, limit: int, marker: uuid.UUID):
-        return self.mount.paginate(AuthZPolicy, ResponsePolicy, limit, marker)
+        return self.paginate(AuthZPolicy, ResponsePolicy, limit, marker)
 
     @Route('{policy_id}', methods=[RequestMethods.PUT])
     @cherrypy.tools.model_params(cls=ParamsPolicy)

deli_counter/http/mounts/root/routes/v1/auth/z/roles.py

@@ -50,7 +50,7 @@ def get(self, role_id: uuid.UUID):
     @cherrypy.tools.model_out_pagination(cls=ResponseRole)
     @cherrypy.tools.enforce_policy(policy_name="roles:list")
     def list(self, limit: int, marker: uuid.UUID):
-        return self.mount.paginate(AuthZRole, ResponseRole, limit, marker)
+        return self.paginate(AuthZRole, ResponseRole, limit, marker)
 
     @Route('{role_id}', methods=[RequestMethods.DELETE])
     @cherrypy.tools.model_params(cls=ParamsRole)

deli_counter/http/mounts/root/routes/v1/images.py

@@ -7,6 +7,7 @@
 from deli_counter.http.mounts.root.routes.v1.validation_models.images import ParamsImage, RequestCreateImage, \
     ResponseImage, ParamsListImage
 from ingredients_db.models.images import Image, ImageVisibility, ImageState
+from ingredients_db.models.region import Region, RegionState
 from ingredients_http.request_methods import RequestMethods
 from ingredients_http.route import Route
 from ingredients_http.router import Router
@@ -44,11 +45,21 @@ def create(self):
             if image is not None:
                 raise cherrypy.HTTPError(409, 'An image with the requested file already exists.')
 
+            region = session.query(Region).filter(Region.id == request.region_id).first()
+            if region is None:
+                raise cherrypy.HTTPError(404, "A region with the requested id does not exist.")
+
+            if region.state != RegionState.CREATED:
+                raise cherrypy.HTTPError(412,
+                                         "The requested region is not in the following state: %s" %
+                                         RegionState.CREATED.value)
+
             image = Image()
             image.name = request.name
             image.file_name = request.file_name
             image.visibility = request.visibility
             image.project_id = project.id
+            image.region_id = region.id
 
             session.add(image)
             session.flush()
@@ -74,13 +85,19 @@ def get(self, image_id):
     @cherrypy.tools.model_params(cls=ParamsListImage)
     @cherrypy.tools.model_out_pagination(cls=ResponseImage)
     @cherrypy.tools.enforce_policy(policy_name="images:list")
-    def list(self, limit: int, marker: uuid.UUID):
+    def list(self, region_id, limit: int, marker: uuid.UUID):
         project = cherrypy.request.project
         starting_query = Query(Image).filter(
             or_(Image.project_id == project.id,
                 Image.visibility == ImageVisibility.PUBLIC,
                 Image.members.any(id=project.id)))
-        return self.mount.paginate(Image, ResponseImage, limit, marker, starting_query=starting_query)
+        if region_id is not None:
+            with cherrypy.request.db_session() as session:
+                region = session.query(Region).filter(Region.id == region_id).first()
+                if region is None:
+                    raise cherrypy.HTTPError(404, "A region with the requested id does not exist.")
+            starting_query = starting_query.filter(Image.region_id == region.id)
+        return self.paginate(Image, ResponseImage, limit, marker, starting_query=starting_query)
 
     @Route(route='{image_id}', methods=[RequestMethods.DELETE])
     @cherrypy.tools.project_scope()

deli_counter/http/mounts/root/routes/v1/instance.py

@@ -12,7 +12,9 @@
 from ingredients_db.models.network import Network, NetworkState
 from ingredients_db.models.network_port import NetworkPort
 from ingredients_db.models.public_key import PublicKey
+from ingredients_db.models.region import Region, RegionState
 from ingredients_db.models.task import Task
+from ingredients_db.models.zones import Zone, ZoneState
 from ingredients_http.request_methods import RequestMethods
 from ingredients_http.route import Route
 from ingredients_http.router import Router
@@ -34,19 +36,28 @@ def __init__(self):
     def create(self):
         request: RequestCreateInstance = cherrypy.request.model
 
-        # TODO: allow multiple instances to be created at once add -# to the name
-
         with cherrypy.request.db_session() as session:
             project = cherrypy.request.project
 
             instance = session.query(Instance).filter(Instance.project_id == project.id).filter(
                 Instance.name == request.name).first()
-
             if instance is not None:
                 raise cherrypy.HTTPError(409, 'An instance already exists with the requested name.')
 
-            image = session.query(Image).filter(Image.id == request.image_id).first()
+            region = session.query(Region).filter(Region.id == request.region_id).first()
+            if region is None:
+                raise cherrypy.HTTPError(404, "A region with the requested id does not exist.")
+
+            if region.state != RegionState.CREATED:
+                raise cherrypy.HTTPError(412,
+                                         "The requested region is not in the following state: %s" %
+                                         RegionState.CREATED.value)
 
+            if region.schedulable is False:
+                raise cherrypy.HTTPError(412, "The requested region is not currently schedulable.")
+
+            image = session.query(Image).filter(Image.id == request.image_id).filter(
+                Image.region_id == region.id).first()
             if image is None:
                 raise cherrypy.HTTPError(404, "An image with the requested id does not exist.")
 
@@ -64,15 +75,30 @@ def create(self):
                     # Image is public so don't error
                     pass
 
-            network = session.query(Network).filter(Network.id == request.network_id).first()
-
+            network = session.query(Network).filter(Network.id == request.network_id).filter(
+                Network.region_id == region.id).first()
             if network is None:
                 raise cherrypy.HTTPError(404, "A network with the requested id does not exist.")
 
             if network.state != NetworkState.CREATED:
                 raise cherrypy.HTTPError(412, "The requested network is not in the '%s' state" % (
                     NetworkState.CREATED.value))
 
+            zone = None
+            if request.zone_id is not None:
+                zone = session.query(Zone).filter(Zone.id == request.zone_id).filter(
+                    Zone.region_id == region.id).first()
+                if zone is None:
+                    raise cherrypy.HTTPError(404, "A zone with the requested id does not exist.")
+
+                if zone.state != ZoneState.CREATED:
+                    raise cherrypy.HTTPError(412,
+                                             "The requested zone is not in the following state: %s" %
+                                             ZoneState.CREATED.value)
+
+                if zone.schedulable is False:
+                    raise cherrypy.HTTPError(412, "The requested zone is not currently schedulable.")
+
             network_port = NetworkPort()
             network_port.network_id = network.id
             session.add(network_port)
@@ -84,6 +110,11 @@ def create(self):
             instance.project_id = project.id
             instance.network_port_id = network_port.id
             instance.tags = request.tags
+
+            instance.region_id = region.id
+            if zone is not None:
+                instance.zone_id = zone.id
+
             session.add(instance)
             session.flush()
 
@@ -120,11 +151,25 @@ def get(self, instance_id: uuid.UUID):
     @cherrypy.tools.model_params(cls=ParamsListInstance)
     @cherrypy.tools.model_out_pagination(cls=ResponseInstance)
     @cherrypy.tools.enforce_policy(policy_name="instances:list")
-    def list(self, image_id: uuid.UUID, limit: int, marker: uuid.UUID):
+    def list(self, image_id, region_id, zone_id, limit: int, marker: uuid.UUID):
         # TODO: allow filtering by tags
         project = cherrypy.request.project
         starting_query = Query(Instance).filter(Instance.project_id == project.id)
-        return self.mount.paginate(Instance, ResponseInstance, limit, marker, starting_query=starting_query)
+        if image_id is not None:
+            starting_query = starting_query.filter(Instance.image_id == image_id)
+        if region_id is not None:
+            with cherrypy.request.db_session() as session:
+                region = session.query(Region).filter(Region.id == region_id).first()
+                if region is None:
+                    raise cherrypy.HTTPError(404, "A region with the requested id does not exist.")
+            starting_query = starting_query.filter(Instance.region_id == region.id)
+        if zone_id is not None:
+            with cherrypy.request.db_session() as session:
+                zone = session.query(Zone).filter(Zone.id == zone_id).first()
+                if zone is None:
+                    raise cherrypy.HTTPError(404, "A zone with the requested id does not exist.")
+            starting_query = starting_query.filter(Instance.zone_id == zone_id)
+        return self.paginate(Instance, ResponseInstance, limit, marker, starting_query=starting_query)
 
     @Route(route='{instance_id}', methods=[RequestMethods.DELETE])
     @cherrypy.tools.project_scope()
@@ -240,13 +285,17 @@ def action_image(self, instance_id: uuid.UUID):
                 raise cherrypy.HTTPError(409, "Can only image an instance in the following state: %s" %
                                          InstanceState.STOPPED.value)
 
+            region = session.query(Region).join(Zone, Region.id == Zone.region_id).filter(
+                Zone.id == instance.zone_id).one()
+
             instance.state = InstanceState.IMAGING
 
             image = Image()
             image.name = request.name
             image.file_name = str(instance.id)
             image.visibility = request.visibility
             image.project_id = instance.project_id
+            image.region_id = region.id
 
             session.add(image)
             session.flush()

deli_counter/http/mounts/root/routes/v1/networks.py

@@ -1,11 +1,13 @@
 import uuid
 
 import cherrypy
+from sqlalchemy.orm import Query
 
 from deli_counter.http.mounts.root.routes.v1.validation_models.networks import RequestCreateNetwork, ResponseNetwork, \
     ParamsNetwork, ParamsListNetwork
 from ingredients_db.models.network import Network, NetworkState
 from ingredients_db.models.network_port import NetworkPort
+from ingredients_db.models.region import Region, RegionState
 from ingredients_http.request_methods import RequestMethods
 from ingredients_http.route import Route
 from ingredients_http.router import Router
@@ -36,6 +38,15 @@ def create(self):
             if network is not None:
                 raise cherrypy.HTTPError(409, "A network with the requested port group already exists.")
 
+            region = session.query(Region).filter(Region.id == request.region_id).first()
+            if region is None:
+                raise cherrypy.HTTPError(404, "A region with the requested id does not exist.")
+
+            if region.state != RegionState.CREATED:
+                raise cherrypy.HTTPError(412,
+                                         "The requested region is not in the following state: %s" %
+                                         RegionState.CREATED.value)
+
             # TODO: make sure cidr doesn't overlap with another network
 
             network = Network()
@@ -46,6 +57,7 @@ def create(self):
             network.dns_servers = request.dns_servers
             network.pool_start = request.pool_start
             network.pool_end = request.pool_end
+            network.region_id = region.id
 
             session.add(network)
             session.flush()
@@ -69,8 +81,15 @@ def get(self, network_id):
     @cherrypy.tools.model_params(cls=ParamsListNetwork)
     @cherrypy.tools.model_out_pagination(cls=ResponseNetwork)
     @cherrypy.tools.enforce_policy(policy_name="networks:list")
-    def list(self, limit: int, marker: uuid.UUID):
-        return self.mount.paginate(Network, ResponseNetwork, limit, marker)
+    def list(self, region_id, limit: int, marker: uuid.UUID):
+        starting_query = Query(Network)
+        if region_id is not None:
+            with cherrypy.request.db_session() as session:
+                region = session.query(Region).filter(Region.id == region_id).first()
+                if region is None:
+                    raise cherrypy.HTTPError(404, "A region with the requested id does not exist.")
+            starting_query = starting_query.filter(Network.region_id == region.id)
+        return self.paginate(Network, ResponseNetwork, limit, marker, starting_query=starting_query)
 
     @Route(route='{network_id}', methods=[RequestMethods.DELETE])
     @cherrypy.tools.model_params(cls=ParamsNetwork)

deli_counter/http/mounts/root/routes/v1/projects.py

@@ -55,7 +55,7 @@ def get(self, project_id):
     def list(self, name: str, limit: int, marker: uuid.UUID):
         # TODO: only list projects that we are a member of
         # optional param to list all
-        return self.mount.paginate(Project, ResponseProject, limit, marker)
+        return self.paginate(Project, ResponseProject, limit, marker)
 
     @Route(route='{project_id}', methods=[RequestMethods.DELETE])
     @cherrypy.tools.model_params(cls=ParamsProject)