Refactor DB layer

Refactors include mostly renames of Replica into Transfer, and Migration into
Deployment. They also include some DB column refactoring (removing unnecessary
ones).

coriolis/conductor/rpc/server.py

@@ -487,7 +487,7 @@ class ConductorServerEndpoint(object):
 
     @endpoint_synchronized
     def delete_endpoint(self, ctxt, endpoint_id):
-        q_replicas_count = db_api.get_endpoint_replicas_count(
+        q_replicas_count = db_api.get_endpoint_transfers_count(
             ctxt, endpoint_id)
         if q_replicas_count != 0:
             raise exception.NotAuthorized("%s replicas would be orphaned!" %
@@ -1102,7 +1102,7 @@ class ConductorServerEndpoint(object):
                 ctxt, replica.id, instance, replica.info[instance])
 
         # add new execution to DB:
-        db_api.add_replica_tasks_execution(ctxt, execution)
+        db_api.add_transfer_tasks_execution(ctxt, execution)
         LOG.info("Replica tasks execution added to DB: %s", execution.id)
 
         uses_minion_pools = any([
@@ -1124,7 +1124,7 @@ class ConductorServerEndpoint(object):
     def get_replica_tasks_executions(self, ctxt, replica_id,
                                      include_tasks=False,
                                      include_task_info=False):
-        return db_api.get_replica_tasks_executions(
+        return db_api.get_transfer_tasks_executions(
             ctxt, replica_id, include_tasks,
             include_task_info=include_task_info, to_dict=True)
 
@@ -1144,7 +1144,7 @@ class ConductorServerEndpoint(object):
                 "Cannot delete execution '%s' for Replica '%s' as it is "
                 "currently in '%s' state." % (
                     execution_id, replica_id, execution.status))
-        db_api.delete_replica_tasks_execution(ctxt, execution_id)
+        db_api.delete_transfer_tasks_execution(ctxt, execution_id)
 
     @tasks_execution_synchronized
     def cancel_replica_tasks_execution(self, ctxt, replica_id, execution_id,
@@ -1165,7 +1165,7 @@ class ConductorServerEndpoint(object):
 
     def _get_replica_tasks_execution(self, ctxt, replica_id, execution_id,
                                      include_task_info=False, to_dict=False):
-        execution = db_api.get_replica_tasks_execution(
+        execution = db_api.get_transfer_tasks_execution(
             ctxt, replica_id, execution_id,
             include_task_info=include_task_info, to_dict=to_dict)
         if not execution:
@@ -1176,7 +1176,7 @@ class ConductorServerEndpoint(object):
 
     def get_replicas(self, ctxt, include_tasks_executions=False,
                      include_task_info=False):
-        return db_api.get_replicas(
+        return db_api.get_transfers(
             ctxt, include_tasks_executions,
             include_task_info=include_task_info, to_dict=True)
 
@@ -1191,7 +1191,7 @@ class ConductorServerEndpoint(object):
         replica = self._get_replica(ctxt, replica_id)
         self._check_replica_running_executions(ctxt, replica)
         self._check_delete_reservation_for_transfer(replica)
-        db_api.delete_replica(ctxt, replica_id)
+        db_api.delete_transfer(ctxt, replica_id)
 
     @replica_synchronized
     def delete_replica_disks(self, ctxt, replica_id):
@@ -1238,7 +1238,7 @@ class ConductorServerEndpoint(object):
         for instance in replica.instances:
             db_api.update_transfer_action_info_for_instance(
                 ctxt, replica.id, instance, replica.info[instance])
-        db_api.add_replica_tasks_execution(ctxt, execution)
+        db_api.add_transfer_tasks_execution(ctxt, execution)
         LOG.info("Replica tasks execution created: %s", execution.id)
 
         self._begin_tasks(ctxt, replica, execution)
@@ -1281,7 +1281,7 @@ class ConductorServerEndpoint(object):
             ctxt, destination_endpoint_id)
         self._check_endpoints(ctxt, origin_endpoint, destination_endpoint)
 
-        replica = models.Replica()
+        replica = models.Transfer()
         replica.id = str(uuid.uuid4())
         replica.base_id = replica.id
         replica.scenario = replica_scenario
@@ -1307,13 +1307,13 @@ class ConductorServerEndpoint(object):
 
         self._create_reservation_for_replica(replica)
 
-        db_api.add_replica(ctxt, replica)
+        db_api.add_transfer(ctxt, replica)
         LOG.info("Replica created: %s", replica.id)
         return self.get_replica(ctxt, replica.id)
 
     def _get_replica(self, ctxt, replica_id, include_task_info=False,
                      to_dict=False):
-        replica = db_api.get_replica(
+        replica = db_api.get_transfer(
             ctxt, replica_id, include_task_info=include_task_info,
             to_dict=to_dict)
         if not replica:
@@ -1329,10 +1329,9 @@ class ConductorServerEndpoint(object):
 
     def get_deployments(self, ctxt, include_tasks,
                         include_task_info=False):
-        return db_api.get_migrations(
+        return db_api.get_deployments(
             ctxt, include_tasks,
             include_task_info=include_task_info,
-            replica_migrations_only=True,
             to_dict=True)
 
     @deployment_synchronized
@@ -1343,7 +1342,7 @@ class ConductorServerEndpoint(object):
 
     @staticmethod
     def _check_running_replica_migrations(ctxt, replica_id):
-        migrations = db_api.get_replica_migrations(ctxt, replica_id)
+        migrations = db_api.get_transfer_deployments(ctxt, replica_id)
         if [m.id for m in migrations if m.executions[0].status in (
                 constants.ACTIVE_EXECUTION_STATUSES)]:
             raise exception.InvalidReplicaState(
@@ -1411,7 +1410,7 @@ class ConductorServerEndpoint(object):
 
         instances = replica.instances
 
-        migration = models.Migration()
+        migration = models.Deployment()
         migration.id = str(uuid.uuid4())
         migration.base_id = migration.id
         migration.origin_endpoint_id = replica.origin_endpoint_id
@@ -1612,7 +1611,7 @@ class ConductorServerEndpoint(object):
                     on_error=True)
 
         self._check_execution_tasks_sanity(execution, migration.info)
-        db_api.add_migration(ctxt, migration)
+        db_api.add_deployment(ctxt, migration)
         LOG.info("Migration created: %s", migration.id)
 
         if not skip_os_morphing and (
@@ -1755,7 +1754,7 @@ class ConductorServerEndpoint(object):
         self._update_task_info_for_minion_allocations(
             ctxt, replica, minion_machine_allocations)
 
-        last_replica_execution = db_api.get_replica_tasks_execution(
+        last_replica_execution = db_api.get_transfer_tasks_execution(
             ctxt, replica.id, last_replica_execution.id)
         self._begin_tasks(
             ctxt, replica, last_replica_execution)
@@ -1832,7 +1831,7 @@ class ConductorServerEndpoint(object):
 
     def _get_migration(self, ctxt, migration_id, include_task_info=False,
                        to_dict=False):
-        migration = db_api.get_migration(
+        migration = db_api.get_deployment(
             ctxt, migration_id, include_task_info=include_task_info,
             to_dict=to_dict)
         if not migration:
@@ -1847,7 +1846,7 @@ class ConductorServerEndpoint(object):
             raise exception.InvalidMigrationState(
                 "Cannot delete Migration '%s' as it is currently in "
                 "'%s' state." % (migration_id, execution.status))
-        db_api.delete_migration(ctxt, migration_id)
+        db_api.delete_deployment(ctxt, migration_id)
 
     @deployment_synchronized
     def delete_deployment(self, ctxt, deployment_id):
@@ -2078,7 +2077,7 @@ class ConductorServerEndpoint(object):
         transfer_id = transfer_action.base_id
         if transfer_action.type == constants.TRANSFER_ACTION_TYPE_MIGRATION:
             deployment = self._get_migration(ctxt, transfer_id)
-            transfer_id = deployment.replica_id
+            transfer_id = deployment.transfer_id
             transfer_action = self._get_replica(
                 ctxt, transfer_id, include_task_info=False)
         else:
@@ -2633,8 +2632,8 @@ class ConductorServerEndpoint(object):
 
     def _update_volumes_info_for_migration_parent_replica(
             self, ctxt, migration_id, instance, updated_task_info):
-        migration = db_api.get_migration(ctxt, migration_id)
-        replica_id = migration.replica_id
+        migration = db_api.get_deployment(ctxt, migration_id)
+        replica_id = migration.transfer_id
 
         with lockutils.lock(
                 constants.REPLICA_LOCK_NAME_FORMAT % replica_id,
@@ -2751,7 +2750,7 @@ class ConductorServerEndpoint(object):
                     # NOTE: considering all the instances of the Replica get
                     # the same params, it doesn't matter which instance's
                     # update task finishes last:
-                    db_api.update_replica(
+                    db_api.update_transfer(
                         ctxt, execution.action_id, task_info)
 
         elif task_type in (
@@ -3242,7 +3241,7 @@ class ConductorServerEndpoint(object):
 
     def _get_replica_schedule(self, ctxt, replica_id,
                               schedule_id, expired=True):
-        schedule = db_api.get_replica_schedule(
+        schedule = db_api.get_transfer_schedule(
             ctxt, replica_id, schedule_id, expired=expired)
         if not schedule:
             raise exception.NotFound(
@@ -3255,17 +3254,17 @@ class ConductorServerEndpoint(object):
                                 shutdown_instance):
         keystone.create_trust(ctxt)
         replica = self._get_replica(ctxt, replica_id)
-        replica_schedule = models.ReplicaSchedule()
+        replica_schedule = models.TransferSchedule()
         replica_schedule.id = str(uuid.uuid4())
-        replica_schedule.replica = replica
-        replica_schedule.replica_id = replica_id
+        replica_schedule.transfer = replica
+        replica_schedule.transfer_id = replica_id
         replica_schedule.schedule = schedule
         replica_schedule.expiration_date = exp_date
         replica_schedule.enabled = enabled
         replica_schedule.shutdown_instance = shutdown_instance
         replica_schedule.trust_id = ctxt.trust_id
 
-        db_api.add_replica_schedule(
+        db_api.add_transfer_schedule(
             ctxt, replica_schedule,
             lambda ctxt, sched: self._replica_cron_client.register(
                 ctxt, sched))
@@ -3275,7 +3274,7 @@ class ConductorServerEndpoint(object):
     @schedule_synchronized
     def update_replica_schedule(self, ctxt, replica_id, schedule_id,
                                 updated_values):
-        db_api.update_replica_schedule(
+        db_api.update_transfer_schedule(
             ctxt, replica_id, schedule_id, updated_values, None,
             lambda ctxt, sched: self._replica_cron_client.register(
                 ctxt, sched))
@@ -3300,15 +3299,15 @@ class ConductorServerEndpoint(object):
                 'Replica Schedule cannot be deleted while the Replica is in '
                 '%s state. Please wait for the Replica execution to finish' %
                 (replica_status))
-        db_api.delete_replica_schedule(
+        db_api.delete_transfer_schedule(
             ctxt, replica_id, schedule_id, None,
             lambda ctxt, sched: self._cleanup_schedule_resources(
                 ctxt, sched))
 
     @replica_synchronized
     def get_replica_schedules(self, ctxt, replica_id=None, expired=True):
-        return db_api.get_replica_schedules(
-            ctxt, replica_id=replica_id, expired=expired)
+        return db_api.get_transfer_schedules(
+            ctxt, transfer_id=replica_id, expired=expired)
 
     @schedule_synchronized
     def get_replica_schedule(self, ctxt, replica_id,
@@ -3326,7 +3325,7 @@ class ConductorServerEndpoint(object):
             "instance_osmorphing_minion_pool_mappings"]
         if any([mpf in updated_properties for mpf in minion_pool_fields]):
             # NOTE: this is just a dummy Replica model to use for validation:
-            dummy = models.Replica()
+            dummy = models.Transfer()
             dummy.id = replica.id
             dummy.instances = replica.instances
             dummy.origin_endpoint_id = replica.origin_endpoint_id
@@ -3409,7 +3408,7 @@ class ConductorServerEndpoint(object):
             db_api.update_transfer_action_info_for_instance(
                 ctxt, replica.id, instance, replica.info[instance])
 
-        db_api.add_replica_tasks_execution(ctxt, execution)
+        db_api.add_transfer_tasks_execution(ctxt, execution)
         LOG.debug("Execution for Replica update tasks created: %s",
                   execution.id)
 

coriolis/db/api.py

@@ -98,26 +98,26 @@ def _update_sqlalchemy_object_fields(
         "of type '%s': %s" % (type(obj), values_to_update.keys()))
 
 
-def _get_replica_schedules_filter(context, replica_id=None,
-                                  schedule_id=None, expired=True):
+def _get_transfer_schedules_filter(context, transfer_id=None,
+                                   schedule_id=None, expired=True):
     now = timeutils.utcnow()
-    q = _soft_delete_aware_query(context, models.ReplicaSchedule)
-    q = q.join(models.Replica)
+    q = _soft_delete_aware_query(context, models.TransferSchedule)
+    q = q.join(models.Transfer)
     sched_filter = q.filter()
     if is_user_context(context):
         sched_filter = sched_filter.filter(
-            models.Replica.project_id == context.project_id)
+            models.Transfer.project_id == context.project_id)
 
-    if replica_id:
+    if transfer_id:
         sched_filter = sched_filter.filter(
-            models.Replica.id == replica_id)
+            models.Transfer.id == transfer_id)
     if schedule_id:
         sched_filter = sched_filter.filter(
-            models.ReplicaSchedule.id == schedule_id)
+            models.TransferSchedule.id == schedule_id)
     if not expired:
         sched_filter = sched_filter.filter(
-            or_(models.ReplicaSchedule.expiration_date == null(),
-                models.ReplicaSchedule.expiration_date > now))
+            or_(models.TransferSchedule.expiration_date == null(),
+                models.TransferSchedule.expiration_date > now))
     return sched_filter
 
 
@@ -274,37 +274,37 @@ def delete_endpoint(context, endpoint_id):
 
 
 @enginefacade.reader
-def get_replica_tasks_executions(context, replica_id, include_tasks=False,
-                                 include_task_info=False, to_dict=False):
+def get_transfer_tasks_executions(context, transfer_id, include_tasks=False,
+                                  include_task_info=False, to_dict=False):
     q = _soft_delete_aware_query(context, models.TasksExecution)
-    q = q.join(models.Replica)
+    q = q.join(models.Transfer)
     if include_task_info:
         q = q.options(orm.joinedload('action').undefer('info'))
     if include_tasks:
         q = _get_tasks_with_details_options(q)
     if is_user_context(context):
-        q = q.filter(models.Replica.project_id == context.project_id)
+        q = q.filter(models.Transfer.project_id == context.project_id)
 
     db_result = q.filter(
-        models.Replica.id == replica_id).all()
+        models.Transfer.id == transfer_id).all()
     if to_dict:
         return [e.to_dict() for e in db_result]
     return db_result
 
 
 @enginefacade.reader
-def get_replica_tasks_execution(context, replica_id, execution_id,
-                                include_task_info=False, to_dict=False):
+def get_transfer_tasks_execution(context, transfer_id, execution_id,
+                                 include_task_info=False, to_dict=False):
     q = _soft_delete_aware_query(context, models.TasksExecution).join(
-        models.Replica)
+        models.Transfer)
     if include_task_info:
         q = q.options(orm.joinedload('action').undefer('info'))
     q = _get_tasks_with_details_options(q)
     if is_user_context(context):
-        q = q.filter(models.Replica.project_id == context.project_id)
+        q = q.filter(models.Transfer.project_id == context.project_id)
 
     db_result = q.filter(
-        models.Replica.id == replica_id,
+        models.Transfer.id == transfer_id,
         models.TasksExecution.id == execution_id).first()
     if to_dict and db_result is not None:
         return db_result.to_dict()
@@ -312,7 +312,7 @@ def get_replica_tasks_execution(context, replica_id, execution_id,
 
 
 @enginefacade.writer
-def add_replica_tasks_execution(context, execution):
+def add_transfer_tasks_execution(context, execution):
     if is_user_context(context):
         if execution.action.project_id != context.project_id:
             raise exception.NotAuthorized()
@@ -330,12 +330,12 @@ def add_replica_tasks_execution(context, execution):
 
 
 @enginefacade.writer
-def delete_replica_tasks_execution(context, execution_id):
+def delete_transfer_tasks_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.Replica).filter(
-                models.Replica.project_id == context.project_id).first():
+        if not q.join(models.Transfer).filter(
+                models.Transfer.project_id == context.project_id).first():
             raise exception.NotAuthorized()
     count = q.soft_delete()
     if count == 0:
@@ -343,28 +343,28 @@ def delete_replica_tasks_execution(context, execution_id):
 
 
 @enginefacade.reader
-def get_replica_schedules(context, replica_id=None, expired=True):
-    sched_filter = _get_replica_schedules_filter(
-        context, replica_id=replica_id, expired=expired)
+def get_transfer_schedules(context, transfer_id=None, expired=True):
+    sched_filter = _get_transfer_schedules_filter(
+        context, transfer_id=transfer_id, expired=expired)
     return sched_filter.all()
 
 
 @enginefacade.reader
-def get_replica_schedule(context, replica_id, schedule_id, expired=True):
-    sched_filter = _get_replica_schedules_filter(
-        context, replica_id=replica_id, schedule_id=schedule_id,
+def get_transfer_schedule(context, transfer_id, schedule_id, expired=True):
+    sched_filter = _get_transfer_schedules_filter(
+        context, transfer_id=transfer_id, schedule_id=schedule_id,
         expired=expired)
     return sched_filter.first()
 
 
 @enginefacade.writer
-def update_replica_schedule(context, replica_id, schedule_id,
-                            updated_values, pre_update_callable=None,
-                            post_update_callable=None):
+def update_transfer_schedule(context, transfer_id, schedule_id,
+                             updated_values, pre_update_callable=None,
+                             post_update_callable=None):
     # NOTE(gsamfira): we need to refactor the DB layer a bit to allow
     # two-phase transactions or at least allow running these functions
     # inside a single transaction block.
-    schedule = get_replica_schedule(context, replica_id, schedule_id)
+    schedule = get_transfer_schedule(context, transfer_id, schedule_id)
     if pre_update_callable:
         pre_update_callable(schedule=schedule)
     for val in ["schedule", "expiration_date", "enabled", "shutdown_instance"]:
@@ -378,23 +378,23 @@ def update_replica_schedule(context, replica_id, schedule_id,
 
 
 @enginefacade.writer
-def delete_replica_schedule(context, replica_id,
-                            schedule_id, pre_delete_callable=None,
-                            post_delete_callable=None):
+def delete_transfer_schedule(context, transfer_id,
+                             schedule_id, pre_delete_callable=None,
+                             post_delete_callable=None):
     # NOTE(gsamfira): we need to refactor the DB layer a bit to allow
     # two-phase transactions or at least allow running these functions
     # inside a single transaction block.
 
-    q = _soft_delete_aware_query(context, models.ReplicaSchedule).filter(
-        models.ReplicaSchedule.id == schedule_id,
-        models.ReplicaSchedule.replica_id == replica_id)
+    q = _soft_delete_aware_query(context, models.TransferSchedule).filter(
+        models.TransferSchedule.id == schedule_id,
+        models.TransferSchedule.transfer_id == transfer_id)
     schedule = q.first()
     if not schedule:
         raise exception.NotFound(
             "No such schedule")
     if is_user_context(context):
-        if not q.join(models.Replica).filter(
-                models.Replica.project_id == context.project_id).first():
+        if not q.join(models.Transfer).filter(
+                models.Transfer.project_id == context.project_id).first():
             raise exception.NotAuthorized()
     if pre_delete_callable:
         pre_delete_callable(context, schedule)
@@ -406,39 +406,39 @@ def delete_replica_schedule(context, replica_id,
 
 
 @enginefacade.writer
-def add_replica_schedule(context, schedule, post_create_callable=None):
+def add_transfer_schedule(context, schedule, post_create_callable=None):
     # NOTE(gsamfira): we need to refactor the DB layer a bit to allow
     # two-phase transactions or at least allow running these functions
     # inside a single transaction block.
 
-    if schedule.replica.project_id != context.project_id:
+    if schedule.transfer.project_id != context.project_id:
         raise exception.NotAuthorized()
     _session(context).add(schedule)
     if post_create_callable:
         post_create_callable(context, schedule)
 
 
-def _get_replica_with_tasks_executions_options(q):
-    return q.options(orm.joinedload(models.Replica.executions))
+def _get_transfer_with_tasks_executions_options(q):
+    return q.options(orm.joinedload(models.Transfer.executions))
 
 
 @enginefacade.reader
-def get_replicas(context,
-                 replica_scenario=None,
-                 include_tasks_executions=False,
-                 include_task_info=False,
-                 to_dict=False):
-    q = _soft_delete_aware_query(context, models.Replica)
+def get_transfers(context,
+                  transfer_scenario=None,
+                  include_tasks_executions=False,
+                  include_task_info=False,
+                  to_dict=False):
+    q = _soft_delete_aware_query(context, models.Transfer)
     if include_tasks_executions:
-        q = _get_replica_with_tasks_executions_options(q)
+        q = _get_transfer_with_tasks_executions_options(q)
     if include_task_info:
         q = q.options(orm.undefer('info'))
     q = q.filter()
-    if replica_scenario:
-        q.filter(models.Replica.scenario == replica_scenario)
+    if transfer_scenario:
+        q.filter(models.Transfer.scenario == transfer_scenario)
     if is_user_context(context):
         q = q.filter(
-            models.Replica.project_id == context.project_id)
+            models.Transfer.project_id == context.project_id)
     db_result = q.all()
     if to_dict:
         return [
@@ -450,55 +450,55 @@ def get_replicas(context,
 
 
 @enginefacade.reader
-def get_replica(context, replica_id,
-                replica_scenario=None,
-                include_task_info=False,
-                to_dict=False):
-    q = _soft_delete_aware_query(context, models.Replica)
-    q = _get_replica_with_tasks_executions_options(q)
+def get_transfer(context, transfer_id,
+                 transfer_scenario=None,
+                 include_task_info=False,
+                 to_dict=False):
+    q = _soft_delete_aware_query(context, models.Transfer)
+    q = _get_transfer_with_tasks_executions_options(q)
     if include_task_info:
         q = q.options(orm.undefer('info'))
-    if replica_scenario:
+    if transfer_scenario:
         q = q.filter(
-            models.Replica.scenario == replica_scenario)
+            models.Transfer.scenario == transfer_scenario)
     if is_user_context(context):
         q = q.filter(
-            models.Replica.project_id == context.project_id)
+            models.Transfer.project_id == context.project_id)
 
-    replica = q.filter(
-        models.Replica.id == replica_id).first()
-    if to_dict and replica is not None:
-        return replica.to_dict(include_task_info=include_task_info)
+    transfer = q.filter(
+        models.Transfer.id == transfer_id).first()
+    if to_dict and transfer is not None:
+        return transfer.to_dict(include_task_info=include_task_info)
 
-    return replica
+    return transfer
 
 
 @enginefacade.reader
-def get_endpoint_replicas_count(
-        context, endpoint_id, replica_scenario=None):
+def get_endpoint_transfers_count(
+        context, endpoint_id, transfer_scenario=None):
 
     scenario_filter_kwargs = {}
-    if replica_scenario:
-        scenario_filter_kwargs = {"scenario": replica_scenario}
+    if transfer_scenario:
+        scenario_filter_kwargs = {"scenario": transfer_scenario}
 
     origin_args = {'origin_endpoint_id': endpoint_id}
     origin_args.update(scenario_filter_kwargs)
     q_origin_count = _soft_delete_aware_query(
-        context, models.Replica).filter_by(**origin_args).count()
+        context, models.Transfer).filter_by(**origin_args).count()
 
     destination_args = {'destination_endpoint_id': endpoint_id}
     destination_args.update(scenario_filter_kwargs)
     q_destination_count = _soft_delete_aware_query(
-        context, models.Replica).filter_by(**destination_args).count()
+        context, models.Transfer).filter_by(**destination_args).count()
 
     return q_origin_count + q_destination_count
 
 
 @enginefacade.writer
-def add_replica(context, replica):
-    replica.user_id = context.user
-    replica.project_id = context.project_id
-    _session(context).add(replica)
+def add_transfer(context, transfer):
+    transfer.user_id = context.user
+    transfer.project_id = context.project_id
+    _session(context).add(transfer)
 
 
 @enginefacade.writer
@@ -516,39 +516,35 @@ def _delete_transfer_action(context, cls, id):
 
 
 @enginefacade.writer
-def delete_replica(context, replica_id):
-    _delete_transfer_action(context, models.Replica, replica_id)
+def delete_transfer(context, transfer_id):
+    _delete_transfer_action(context, models.Transfer, transfer_id)
 
 
 @enginefacade.reader
-def get_replica_migrations(context, replica_id):
-    q = _soft_delete_aware_query(context, models.Migration)
-    q = q.join("replica")
+def get_transfer_deployments(context, transfer_id):
+    q = _soft_delete_aware_query(context, models.Deployment)
+    q = q.join("transfer")
     q = q.options(orm.joinedload("executions"))
     if is_user_context(context):
         q = q.filter(
-            models.Migration.project_id == context.project_id)
+            models.Deployment.project_id == context.project_id)
     return q.filter(
-        models.Replica.id == replica_id).all()
+        models.Transfer.id == transfer_id).all()
 
 
 @enginefacade.reader
-def get_migrations(context,
-                   include_tasks=False,
-                   include_task_info=False,
-                   to_dict=False,
-                   replica_migrations_only=False):
-    q = _soft_delete_aware_query(context, models.Migration)
+def get_deployments(context,
+                    include_tasks=False,
+                    include_task_info=False,
+                    to_dict=False):
+    q = _soft_delete_aware_query(context, models.Deployment)
     if include_tasks:
-        q = _get_migration_task_query_options(q)
+        q = _get_deployment_task_query_options(q)
     else:
         q = q.options(orm.joinedload("executions"))
     if include_task_info:
         q = q.options(orm.undefer('info'))
 
-    if replica_migrations_only:
-        q.filter(models.Migration.replica_id is not None)
-
     args = {}
     if is_user_context(context):
         args["project_id"] = context.project_id
@@ -569,7 +565,7 @@ def _get_tasks_with_details_options(query):
                 joinedload("events"))
 
 
-def _get_migration_task_query_options(query):
+def _get_deployment_task_query_options(query):
     return query.options(
         orm.joinedload("executions").
         joinedload("tasks").
@@ -582,13 +578,13 @@ def _get_migration_task_query_options(query):
 
 
 @enginefacade.reader
-def get_migration(context, migration_id, include_task_info=False,
-                  to_dict=False):
-    q = _soft_delete_aware_query(context, models.Migration)
-    q = _get_migration_task_query_options(q)
+def get_deployment(context, deployment_id, include_task_info=False,
+                   to_dict=False):
+    q = _soft_delete_aware_query(context, models.Deployment)
+    q = _get_deployment_task_query_options(q)
     if include_task_info:
         q = q.options(orm.undefer('info'))
-    args = {"id": migration_id}
+    args = {"id": deployment_id}
     if is_user_context(context):
         args["project_id"] = context.project_id
     db_result = q.filter_by(**args).first()
@@ -599,15 +595,15 @@ def get_migration(context, migration_id, include_task_info=False,
 
 
 @enginefacade.writer
-def add_migration(context, migration):
-    migration.user_id = context.user
-    migration.project_id = context.project_id
-    _session(context).add(migration)
+def add_deployment(context, deployment):
+    deployment.user_id = context.user
+    deployment.project_id = context.project_id
+    _session(context).add(deployment)
 
 
 @enginefacade.writer
-def delete_migration(context, migration_id):
-    _delete_transfer_action(context, models.Migration, migration_id)
+def delete_deployment(context, deployment_id):
+    _delete_transfer_action(context, models.Deployment, deployment_id)
 
 
 @enginefacade.writer
@@ -941,10 +937,10 @@ def update_task_progress_update(
 
 
 @enginefacade.writer
-def update_replica(context, replica_id, updated_values):
-    replica = get_replica(context, replica_id)
-    if not replica:
-        raise exception.NotFound("Replica not found")
+def update_transfer(context, transfer_id, updated_values):
+    transfer = get_transfer(context, transfer_id)
+    if not transfer:
+        raise exception.NotFound("Transfer not found")
 
     mapped_info_fields = {
         'destination_environment': 'target_environment'}
@@ -957,11 +953,11 @@ def update_replica(context, replica_id, updated_values):
     for field in updateable_fields:
         if mapped_info_fields.get(field, field) in updated_values:
             LOG.debug(
-                "Updating the '%s' field of Replica '%s' to: '%s'",
-                field, replica_id, updated_values[
+                "Updating the '%s' field of Transfer '%s' to: '%s'",
+                field, transfer_id, updated_values[
                     mapped_info_fields.get(field, field)])
             setattr(
-                replica, field,
+                transfer, field,
                 updated_values[mapped_info_fields.get(field, field)])
 
     non_updateable_fields = set(
@@ -970,12 +966,12 @@ def update_replica(context, replica_id, updated_values):
             for field in updateable_fields})
     if non_updateable_fields:
         LOG.warn(
-            "The following Replica fields can NOT be updated: %s",
+            "The following Transfer 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(replica, 'updated_at', timeutils.utcnow())
+    setattr(transfer, 'updated_at', timeutils.utcnow())
 
 
 @enginefacade.writer

coriolis/db/sqlalchemy/migrate_repo/versions/020_rename_tables.py

@@ -0,0 +1,30 @@
+import sqlalchemy
+
+
+def upgrade(migrate_engine):
+    meta = sqlalchemy.MetaData()
+    meta.bind = migrate_engine
+
+    replica = sqlalchemy.Table('replica', meta, autoload=True)
+    replica.rename('transfer')
+
+    migration = sqlalchemy.Table('migration', meta, autoload=True)
+    migration.rename('deployment')
+    migration.c.replica_id.alter(name='transfer_id', nullable=False)
+    migration.c.replication_count.drop()
+
+    replica_schedule = sqlalchemy.Table(
+        'replica_schedules', meta, autoload=True)
+    replica_schedule.rename('transfer_schedules')
+    replica_schedule.c.replica_id.alter(name='transfer_id')
+
+    # NOTE(dvincze): Update models polymorphic identity
+    # Due to the model code changes, this cannot be done using the ORM.
+    # Had to resort to using raw SQL statements.
+    with migrate_engine.connect() as conn:
+        conn.execute(
+            'UPDATE base_transfer_action SET type = "transfer" '
+            'WHERE type = "replica";')
+        conn.execute(
+            'UPDATE base_transfer_action SET type = "deployment" '
+            'WHERE type = "migration";')

coriolis/db/sqlalchemy/models.py

@@ -323,23 +323,23 @@ class BaseTransferAction(BASE, models.TimestampMixin, models.ModelBase,
         return result
 
 
-class Replica(BaseTransferAction):
-    __tablename__ = 'replica'
+class Transfer(BaseTransferAction):
+    __tablename__ = 'transfer'
 
     id = sqlalchemy.Column(
         sqlalchemy.String(36),
         sqlalchemy.ForeignKey(
             'base_transfer_action.base_id'), primary_key=True)
     scenario = sqlalchemy.Column(
-        sqlalchemy.String(255),
+        sqlalchemy.String(255), nullable=False,
         default=constants.REPLICA_SCENARIO_REPLICA)
 
     __mapper_args__ = {
-        'polymorphic_identity': 'replica',
+        'polymorphic_identity': 'transfer',
     }
 
     def to_dict(self, include_task_info=True, include_executions=True):
-        base = super(Replica, self).to_dict(
+        base = super(Transfer, self).to_dict(
             include_task_info=include_task_info,
             include_executions=include_executions)
         base.update({
@@ -348,40 +348,36 @@ class Replica(BaseTransferAction):
         return base
 
 
-class Migration(BaseTransferAction):
-    __tablename__ = 'migration'
+class Deployment(BaseTransferAction):
+    __tablename__ = 'deployment'
 
     id = sqlalchemy.Column(
         sqlalchemy.String(36),
         sqlalchemy.ForeignKey(
             'base_transfer_action.base_id'), primary_key=True)
-    replica_id = sqlalchemy.Column(
+    transfer_id = sqlalchemy.Column(
         sqlalchemy.String(36),
-        sqlalchemy.ForeignKey('replica.id'), nullable=True)
-    replica = orm.relationship(
-        Replica, backref=orm.backref("migrations"), foreign_keys=[replica_id])
+        sqlalchemy.ForeignKey('transfer.id'), nullable=False)
+    transfer = orm.relationship(
+        Transfer, backref=orm.backref("deployments"),
+        foreign_keys=[transfer_id])
     shutdown_instances = sqlalchemy.Column(
         sqlalchemy.Boolean, nullable=False, default=False)
-    replication_count = sqlalchemy.Column(
-        sqlalchemy.Integer, nullable=False, default=2)
 
     __mapper_args__ = {
-        'polymorphic_identity': 'migration',
+        'polymorphic_identity': 'deployment',
     }
 
     def to_dict(self, include_task_info=True, include_tasks=True):
-        base = super(Migration, self).to_dict(
+        base = super(Deployment, self).to_dict(
             include_task_info=include_task_info,
             include_executions=include_tasks)
-        replica_scenario_type = None
-        if self.replica:
-            replica_scenario_type = self.replica.scenario
+
         base.update({
             "id": self.id,
-            "replica_id": self.replica_id,
-            "replica_scenario_type": replica_scenario_type,
+            "transfer_id": self.transfer_id,
+            "transfer_scenario_type": self.transfer.scenario,
             "shutdown_instances": self.shutdown_instances,
-            "replication_count": self.replication_count,
         })
         return base
 
@@ -667,18 +663,18 @@ class Endpoint(BASE, models.TimestampMixin, models.ModelBase,
         secondary="endpoint_region_mapping")
 
 
-class ReplicaSchedule(BASE, models.TimestampMixin, models.ModelBase,
-                      models.SoftDeleteMixin):
-    __tablename__ = "replica_schedules"
+class TransferSchedule(BASE, models.TimestampMixin, models.ModelBase,
+                       models.SoftDeleteMixin):
+    __tablename__ = "transfer_schedules"
 
     id = sqlalchemy.Column(sqlalchemy.String(36),
                            default=lambda: str(uuid.uuid4()),
                            primary_key=True)
-    replica_id = sqlalchemy.Column(
+    transfer_id = sqlalchemy.Column(
         sqlalchemy.String(36),
-        sqlalchemy.ForeignKey('replica.id'), nullable=False)
-    replica = orm.relationship(
-        Replica, backref=orm.backref("schedules"), foreign_keys=[replica_id])
+        sqlalchemy.ForeignKey('transfer.id'), nullable=False)
+    transfer = orm.relationship(
+        Transfer, backref=orm.backref("schedules"), foreign_keys=[transfer_id])
     schedule = sqlalchemy.Column(types.Json, nullable=False)
     expiration_date = sqlalchemy.Column(
         sqlalchemy.types.DateTime, nullable=True)

coriolis/tests/api/v1/test_replica_schedules.py

@@ -33,7 +33,7 @@ class ReplicaScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
         id = mock.sentinel.id
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
 
         result = self.replica_schedules.show(mock_req, replica_id, id)
 
@@ -58,7 +58,7 @@ class ReplicaScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
         id = mock.sentinel.id
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         mock_get_schedule.return_value = None
 
         self.assertRaises(
@@ -84,7 +84,7 @@ class ReplicaScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         mock_req.GET = {"show_expired": "False"}
 
         result = self.replica_schedules.index(mock_req, replica_id)
@@ -338,7 +338,7 @@ class ReplicaScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         body = mock.sentinel.body
         schedule = mock.sentinel.schedule
         exp_date = mock.sentinel.exp_date
@@ -368,7 +368,7 @@ class ReplicaScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         body = mock.sentinel.body
         mock_validate_create_body.side_effect = Exception("err")
 
@@ -397,7 +397,7 @@ class ReplicaScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         id = mock.sentinel.id
         body = mock.sentinel.body
 
@@ -425,7 +425,7 @@ class ReplicaScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         id = mock.sentinel.id
         body = mock.sentinel.body
         mock_validate_update_body.side_effect = Exception("err")
@@ -451,7 +451,7 @@ class ReplicaScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         id = mock.sentinel.id
 
         self.assertRaises(

coriolis/tests/api/v1/test_replica_tasks_execution_actions.py

@@ -37,7 +37,7 @@ class ReplicaTasksExecutionActionsControllerTestCase(
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
         id = mock.sentinel.id
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         body = config["body"]
         if exception_raised:
             mock_cancel.side_effect = getattr(exception, exception_raised)(

coriolis/tests/api/v1/test_replica_tasks_executions.py

@@ -29,7 +29,7 @@ class ReplicaTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         id = mock.sentinel.id
 
         result = self.replica_api.show(mock_req, replica_id, id)
@@ -55,7 +55,7 @@ class ReplicaTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         id = mock.sentinel.id
         mock_get_execution.return_value = None
 
@@ -83,7 +83,7 @@ class ReplicaTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
 
         result = self.replica_api.index(mock_req, replica_id)
 
@@ -109,7 +109,7 @@ class ReplicaTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
 
         result = self.replica_api.detail(mock_req, replica_id)
 
@@ -135,7 +135,7 @@ class ReplicaTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         execution = {"shutdown_instances": True}
         mock_body = {"execution": execution}
 
@@ -162,7 +162,7 @@ class ReplicaTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         mock_body = {}
 
         result = self.replica_api.create(mock_req, replica_id, mock_body)
@@ -186,7 +186,7 @@ class ReplicaTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         id = mock.sentinel.id
 
         self.assertRaises(
@@ -209,7 +209,7 @@ class ReplicaTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_req = mock.Mock()
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
-        replica_id = mock.sentinel.replica_id
+        replica_id = mock.sentinel.transfer_id
         id = mock.sentinel.id
         mock_delete.side_effect = exception.NotFound()
 

coriolis/tests/replica_cron/rpc/test_server.py

@@ -27,10 +27,10 @@ class TriggerReplicaTestCase(test_base.CoriolisBaseTestCase):
         result = server._trigger_replica(
             mock.sentinel.ctxt,
             mock_conductor_client,
-            mock.sentinel.replica_id, False)
+            mock.sentinel.transfer_id, False)
 
         mock_conductor_client.execute_replica_tasks.assert_called_once_with(
-            mock.sentinel.ctxt, mock.sentinel.replica_id, False)
+            mock.sentinel.ctxt, mock.sentinel.transfer_id, False)
 
         self.assertEqual(
             result, 'Execution %s for Replica %s' % (

coriolis/tests/replica_cron/test_api.py

@@ -16,7 +16,7 @@ class APITestCase(test_base.CoriolisBaseTestCase):
         self.rpc_client = mock.MagicMock()
         self.api._rpc_client = self.rpc_client
         self.ctxt = mock.sentinel.ctxt
-        self.replica_id = mock.sentinel.replica_id
+        self.replica_id = mock.sentinel.transfer_id
         self.schedule_id = mock.sentinel.schedule_id
 
     def test_create(self):

coriolis/tests/replica_tasks_executions/test_api.py

@@ -16,7 +16,7 @@ class APITestCase(test_base.CoriolisBaseTestCase):
         self.rpc_client = mock.MagicMock()
         self.api._rpc_client = self.rpc_client
         self.ctxt = mock.sentinel.ctxt
-        self.replica_id = mock.sentinel.replica_id
+        self.replica_id = mock.sentinel.transfer_id
         self.execution_id = mock.sentinel.execution_id
 
     def test_create(self):

coriolis/tests/replicas/test_api.py

@@ -16,7 +16,7 @@ class APITestCase(test_base.CoriolisBaseTestCase):
         self.rpc_client = mock.MagicMock()
         self.api._rpc_client = self.rpc_client
         self.ctxt = mock.sentinel.ctxt
-        self.replica_id = mock.sentinel.replica_id
+        self.replica_id = mock.sentinel.transfer_id
 
     def test_create(self):
         origin_endpoint_id = mock.sentinel.origin_endpoint_id