Model Minion Pools directly on trasnfer actions.

coriolis/db/api.py

@@ -1189,6 +1189,17 @@ def add_minion_pool_lifecycle(context, lifecycle):
     _session(context).add(lifecycle)
 
 
+@enginefacade.reader
+def get_minion_pool_lifecycle(context, minion_pool_id):
+    q = _soft_delete_aware_query(context, models.MinionPoolLifecycle)
+    q = q.options(orm.joinedload(models.MinionPoolLifecycle.executions))
+    if is_user_context(context):
+        q = q.filter(
+            models.MinionPoolLifecycle.project_id == context.tenant)
+    return q.filter(
+        models.MinionPoolLifecycle.id == minion_pool_id).first()
+
+
 @enginefacade.writer
 def add_minion_pool_lifecycle_execution(context, execution):
     if is_user_context(context):
@@ -1204,10 +1215,38 @@ def add_minion_pool_lifecycle_execution(context, execution):
     _session(context).add(execution)
 
 
+@enginefacade.writer
+def update_minion_pool_lifecycle(context, minion_pool_id, updated_values):
+    lifecycle = get_minion_pool_lifecycle(context, minion_pool_id)
+    if not lifecycle:
+        raise exception.NotFound(
+            "Minion pool '%s' not found" % minion_pool_id)
+
+    updateable_fields = [
+        "source_environment", "destination_environment",
+        "minimum_minions", "maximum_minions", "minion_max_idle_time",
+        "minion_retention_strategy"]
+    for field in updateable_fields:
+        if field in updated_values:
+            LOG.debug(
+                "Updating the '%s' field of Minion Pool '%s' to: '%s'",
+                field, minion_pool_id, updated_values[field])
+            setattr(lifecycle, field, updated_values[field])
+
+    non_updateable_fields = set(
+        updated_values.keys()).difference(updateable_fields)
+    if non_updateable_fields:
+        LOG.warn(
+            "The following Replica fields can NOT be updated: %s",
+            non_updateable_fields)
+
+    # the oslo_db library uses this method for both the `created_at` and
+    # `updated_at` fields
+    setattr(lifecycle, 'updated_at', timeutils.utcnow())
+
 @enginefacade.reader
-def get_lifecycle_executions_for_minion_pool(
-        context, minion_pool_id, include_tasks=True):
-    minion_pool = get_minion_pool(context, minion_pool_id)
+def get_minion_pool_lifecycle_executions(
+        context, lifecycle_id, include_tasks=True):
     q = _soft_delete_aware_query(context, models.TasksExecution)
     q = q.join(models.MinionPoolLifecycle)
     if include_tasks:
@@ -1215,4 +1254,28 @@ def get_lifecycle_executions_for_minion_pool(
     if is_user_context(context):
         q = q.filter(models.MinionPoolLifecycle.project_id == context.tenant)
     return q.filter(
-        models.MinionPoolLifecycle.id == minion_pool.lifecycle_action.id).all()
+        models.MinionPoolLifecycle.id == lifecycle_id).all()
+
+@enginefacade.reader
+def get_minion_pool_lifecycle_execution(context, lifecycle_id, execution_id):
+    q = _soft_delete_aware_query(context, models.TasksExecution).join(
+        models.Replica)
+    q = _get_tasks_with_details_options(q)
+    if is_user_context(context):
+        q = q.filter(models.MinionPoolLifecycle.project_id == context.tenant)
+    return q.filter(
+        models.MinionPoolLifecycle.id == lifecycle_id,
+        models.TasksExecution.id == execution_id).first()
+
+@enginefacade.writer
+def delete_minion_pool_lifecycle_execution(context, execution_id):
+    q = _soft_delete_aware_query(context, models.TasksExecution).filter(
+        models.TasksExecution.id == execution_id)
+    if is_user_context(context):
+        if not q.join(models.MinionPoolLifecycle).filter(
+                models.MinionPoolLifecycle.project_id == (
+                    context.tenant)).first():
+            raise exception.NotAuthorized()
+    count = q.soft_delete()
+    if count == 0:
+        raise exception.NotFound("0 entries were soft deleted")

coriolis/db/sqlalchemy/migrate_repo/versions/015_adds_minion_vm_pools.py

@@ -17,28 +17,15 @@ def upgrade(migrate_engine):
 
     tables = []
 
-    # declare minion pool table:
+    # add table for pool lifecycles:
     tables.append(
         sqlalchemy.Table(
-            'minion_pool',
+            'minion_pool_lifecycle',
             meta,
-            sqlalchemy.Column('id', sqlalchemy.String(36), primary_key=True,
-                              default=lambda: str(uuid.uuid4())),
             sqlalchemy.Column(
-                "user_id", sqlalchemy.String(255), nullable=False),
-            sqlalchemy.Column(
-                "project_id", sqlalchemy.String(255), nullable=False),
-
-            sqlalchemy.Column('name', sqlalchemy.String(255), nullable=False),
-            sqlalchemy.Column('created_at', sqlalchemy.DateTime),
-            sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
-            sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
-            sqlalchemy.Column('deleted', sqlalchemy.String(36)),
-            sqlalchemy.Column(
-                'endpoint_id', sqlalchemy.String(36),
-                sqlalchemy.ForeignKey('endpoint.id'), nullable=False),
-            sqlalchemy.Column(
-                'environment_options', sqlalchemy.Text, nullable=False),
+                "id", sqlalchemy.String(36),
+                sqlalchemy.ForeignKey('base_transfer_action.base_id'),
+                primary_key=True),
             sqlalchemy.Column(
                 'minimum_minions', sqlalchemy.Integer, nullable=False),
             sqlalchemy.Column(
@@ -68,19 +55,6 @@ def upgrade(migrate_engine):
             sqlalchemy.Column('connection_info', sqlalchemy.Text),
             sqlalchemy.Column('provider_properties', sqlalchemy.Text)))
 
-    # add table for pool lifecycles:
-    tables.append(
-        sqlalchemy.Table(
-            'minion_pool_lifecycle',
-            meta,
-            sqlalchemy.Column(
-                "id", sqlalchemy.String(36),
-                sqlalchemy.ForeignKey('base_transfer_action.base_id'),
-                primary_key=True),
-            sqlalchemy.Column(
-                "minion_pool_id", sqlalchemy.String(36),
-                sqlalchemy.ForeignKey('minion_pool.id'), nullable=False)))
-
     for index, table in enumerate(tables):
         try:
             table.create()
@@ -94,9 +68,9 @@ def upgrade(migrate_engine):
     columns = [
         sqlalchemy.Column(
             "source_minion_pool_id", sqlalchemy.String(36),
-            sqlalchemy.ForeignKey('minion_pool.id'), nullable=True),
+            sqlalchemy.ForeignKey('minion_pool_lifecycle.id'), nullable=True),
         sqlalchemy.Column(
             "destination_minion_pool_id", sqlalchemy.String(36),
-            sqlalchemy.ForeignKey('minion_pool.id'), nullable=True)]
+            sqlalchemy.ForeignKey('minion_pool_lifecycle.id'), nullable=True)]
     for col in columns:
         base_transfer_action.create_column(col)

coriolis/db/sqlalchemy/models.py

@@ -197,10 +197,12 @@ class BaseTransferAction(BASE, models.TimestampMixin, models.ModelBase,
     storage_mappings = sqlalchemy.Column(types.Json, nullable=True)
     source_environment = sqlalchemy.Column(types.Json, nullable=True)
     source_minion_pool_id = sqlalchemy.Column(
-        sqlalchemy.String(36), sqlalchemy.ForeignKey('minion_pool.id'),
+        sqlalchemy.String(36),
+        sqlalchemy.ForeignKey('minion_pool_lifecycle.id'),
         nullable=True, default=lambda: None)
     destination_minion_pool_id = sqlalchemy.Column(
-        sqlalchemy.String(36), sqlalchemy.ForeignKey('minion_pool.id'),
+        sqlalchemy.String(36),
+        sqlalchemy.ForeignKey('minion_pool_lifecycle.id'),
         nullable=True, default=lambda: None)
 
     __mapper_args__ = {
@@ -250,13 +252,21 @@ class MinionPoolLifecycle(BaseTransferAction):
         sqlalchemy.ForeignKey(
             'base_transfer_action.base_id'), primary_key=True)
 
-    minion_pool_id = sqlalchemy.Column(
-        sqlalchemy.String(36),
-        sqlalchemy.ForeignKey('minion_pool.id'), nullable=False)
+    name = sqlalchemy.Column(
+        sqlalchemy.String(255),
+        nullable=False)
+
+    minimum_minions = sqlalchemy.Column(
+        sqlalchemy.Integer, nullable=False)
+    maximum_minions = sqlalchemy.Column(
+        sqlalchemy.Integer, nullable=False)
+    minion_max_idle_time = sqlalchemy.Column(
+        sqlalchemy.Integer, nullable=False)
+    minion_retention_strategy = sqlalchemy.Column(
+        sqlalchemy.String(255), nullable=False)
 
     __mapper_args__ = {
-        'polymorphic_identity': 'minion_pool_lifecycle',
-    }
+        'polymorphic_identity': 'minion_pool_lifecycle'}
 
     def to_dict(self, include_info=True):
         base = super(MinionPoolLifecycle, self).to_dict(
@@ -470,41 +480,6 @@ class ReplicaSchedule(BASE, models.TimestampMixin, models.ModelBase,
     trust_id = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
 
 
-class MinionPool(BASE, models.TimestampMixin, models.ModelBase,
-                 models.SoftDeleteMixin):
-    __tablename__ = "minion_pool"
-
-    id = sqlalchemy.Column(sqlalchemy.String(36),
-                           default=lambda: str(uuid.uuid4()),
-                           primary_key=True)
-    user_id = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
-    project_id = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
-
-    name = sqlalchemy.Column(
-        sqlalchemy.String(255),
-        nullable=False)
-
-    endpoint_id = sqlalchemy.Column(
-        sqlalchemy.String(36),
-        sqlalchemy.ForeignKey('endpoint.id'),
-        nullable=False)
-    endpoint = orm.relationship(
-        Endpoint, backref=orm.backref("minion_pools"),
-        foreign_keys=[endpoint_id])
-
-    environment_options = sqlalchemy.Column(
-        types.Json, nullable=False)
-
-    minimum_minions = sqlalchemy.Column(
-        sqlalchemy.Integer, nullable=False)
-    maximum_minions = sqlalchemy.Column(
-        sqlalchemy.Integer, nullable=False)
-    minion_max_idle_time = sqlalchemy.Column(
-        sqlalchemy.Integer, nullable=False)
-    minion_retention_strategy = sqlalchemy.Column(
-        sqlalchemy.String(255), nullable=False)
-
-
 class MinionMachine(BASE, models.TimestampMixin, models.ModelBase,
                     models.SoftDeleteMixin):
     __tablename__ = "minion_machine"
@@ -517,10 +492,10 @@ class MinionMachine(BASE, models.TimestampMixin, models.ModelBase,
 
     pool_id = sqlalchemy.Column(
         sqlalchemy.String(36),
-        sqlalchemy.ForeignKey('minion_pool.id'),
+        sqlalchemy.ForeignKey('minion_pool_lifecycle.id'),
         nullable=False)
     pool = orm.relationship(
-        MinionPool, backref=orm.backref("minion_machines"),
+        MinionPoolLifecycle, backref=orm.backref("minion_machines"),
         foreign_keys=[pool_id])
 
     status = sqlalchemy.Column(