From 729c2d0ab4edc69b5727bb5b9ec88024f66db2c5 Mon Sep 17 00:00:00 2001 From: Jaycen Grant Date: Tue, 6 Sep 2016 14:17:43 -0700 Subject: [PATCH] Rename Bay DB, Object, and internal usage to Cluster This is patch 3 of 3 to change the internal usage of the terms Bay and BayModel. This patch updates Bay to Cluster in DB and Object as well as all the usages. No functionality should be changed by this patch, just naming and db updates. Change-Id: Ife04b0f944ded03ca932d70e09e6766d09cf5d9f Implements: blueprint rename-bay-to-cluster --- magnum/api/controllers/base.py | 4 +- magnum/api/controllers/v1/bay.py | 99 +++- magnum/api/controllers/v1/baymodel.py | 4 +- magnum/api/controllers/v1/certificate.py | 9 +- magnum/api/controllers/v1/cluster.py | 89 +--- magnum/api/controllers/v1/cluster_template.py | 4 +- magnum/api/validation.py | 39 +- magnum/cmd/conductor.py | 4 +- magnum/cmd/template_manage.py | 6 +- magnum/common/context.py | 12 +- magnum/common/docker_utils.py | 9 +- magnum/common/exception.py | 31 +- magnum/common/keystone.py | 22 +- magnum/common/policy.py | 6 +- magnum/common/rpc_service.py | 4 +- magnum/conductor/api.py | 30 +- ...{bay_conductor.py => cluster_conductor.py} | 266 +++++----- .../handlers/common/trust_manager.py | 35 +- magnum/conductor/k8s_api.py | 14 +- magnum/conductor/k8s_monitor.py | 6 +- magnum/conductor/mesos_monitor.py | 6 +- magnum/conductor/monitors.py | 22 +- magnum/conductor/scale_manager.py | 16 +- magnum/conductor/swarm_monitor.py | 8 +- magnum/conductor/utils.py | 40 +- magnum/db/api.py | 59 +-- ...20f640f43d1_rename_bay_table_to_cluster.py | 35 ++ magnum/db/sqlalchemy/api.py | 84 ++-- magnum/db/sqlalchemy/models.py | 10 +- magnum/drivers/common/k8s_template_def.py | 26 +- magnum/drivers/common/template_def.py | 127 ++--- .../fragments/configure-docker-storage.sh | 2 +- magnum/drivers/k8s_coreos_v1/template_def.py | 4 +- .../templates/fragments/make-cert-client.yaml | 4 +- .../templates/fragments/make-cert.yaml | 6 +- .../fragments/write-heat-params-master.yaml | 2 +- .../fragments/write-heat-params.yaml | 2 +- .../k8s_coreos_v1/templates/kubecluster.yaml | 10 +- .../k8s_coreos_v1/templates/kubemaster.yaml | 8 +- .../k8s_coreos_v1/templates/kubeminion.yaml | 6 +- .../k8s_fedora_atomic_v1/template_def.py | 20 +- .../templates/fragments/make-cert-client.sh | 6 +- .../templates/fragments/make-cert.sh | 6 +- .../fragments/write-heat-params-master.yaml | 2 +- .../fragments/write-heat-params.yaml | 2 +- .../templates/kubecluster-fedora-ironic.yaml | 10 +- .../templates/kubecluster.yaml | 12 +- .../templates/kubemaster-fedora-ironic.yaml | 8 +- .../templates/kubemaster.yaml | 8 +- .../templates/kubeminion-fedora-ironic.yaml | 6 +- .../templates/kubeminion.yaml | 6 +- .../drivers/mesos_ubuntu_v1/template_def.py | 18 +- .../templates/mesoscluster.yaml | 2 +- .../image/openvswitch/README.rst | 6 +- .../swarm_fedora_atomic_v1/template_def.py | 32 +- .../templates/cluster.yaml | 10 +- .../templates/fragments/make-cert.py | 8 +- ...aml => write-cluster-failure-service.yaml} | 0 .../fragments/write-heat-params-master.yaml | 2 +- .../fragments/write-heat-params-node.yaml | 2 +- .../templates/swarmmaster.yaml | 10 +- .../templates/swarmnode.yaml | 8 +- magnum/objects/__init__.py | 6 +- magnum/objects/{bay.py => cluster.py} | 142 +++--- magnum/objects/cluster_template.py | 5 +- magnum/objects/fields.py | 16 +- magnum/opts.py | 4 +- magnum/service/periodic.py | 175 +++---- magnum/tests/contrib/copy_instance_logs.sh | 2 +- magnum/tests/contrib/post_test_hook.sh | 2 +- .../tests/unit/api/controllers/test_root.py | 6 +- .../tests/unit/api/controllers/v1/test_bay.py | 144 ++++-- .../unit/api/controllers/v1/test_baymodel.py | 12 +- .../unit/api/controllers/v1/test_cluster.py | 80 +-- .../controllers/v1/test_cluster_template.py | 16 +- .../unit/api/controllers/v1/test_utils.py | 30 +- magnum/tests/unit/api/test_validation.py | 178 +++---- magnum/tests/unit/api/utils.py | 11 +- magnum/tests/unit/common/test_keystone.py | 12 +- .../handlers/common/test_trust_manager.py | 54 +- ...conductor.py => test_cluster_conductor.py} | 462 +++++++++--------- ...uctor.py => test_k8s_cluster_conductor.py} | 110 ++--- ...tor.py => test_mesos_cluster_conductor.py} | 66 +-- ...tor.py => test_swarm_cluster_conductor.py} | 76 +-- magnum/tests/unit/conductor/test_monitors.py | 51 +- magnum/tests/unit/conductor/test_rpcapi.py | 32 +- .../unit/conductor/test_scale_manager.py | 18 +- magnum/tests/unit/conductor/test_utils.py | 75 +-- magnum/tests/unit/db/sqlalchemy/test_types.py | 30 +- magnum/tests/unit/db/test_bay.py | 214 -------- magnum/tests/unit/db/test_cluster.py | 214 ++++++++ magnum/tests/unit/db/test_cluster_template.py | 6 +- magnum/tests/unit/db/utils.py | 28 +- .../unit/drivers/test_template_definition.py | 265 +++++----- magnum/tests/unit/objects/test_bay.py | 192 -------- magnum/tests/unit/objects/test_cluster.py | 195 ++++++++ magnum/tests/unit/objects/test_fields.py | 12 +- magnum/tests/unit/objects/test_objects.py | 4 +- magnum/tests/unit/objects/utils.py | 50 +- magnum/tests/unit/service/test_periodic.py | 222 +++++---- 100 files changed, 2357 insertions(+), 2214 deletions(-) rename magnum/conductor/handlers/{bay_conductor.py => cluster_conductor.py} (58%) create mode 100644 magnum/db/sqlalchemy/alembic/versions/720f640f43d1_rename_bay_table_to_cluster.py rename magnum/drivers/swarm_fedora_atomic_v1/templates/fragments/{write-bay-failure-service.yaml => write-cluster-failure-service.yaml} (100%) rename magnum/objects/{bay.py => cluster.py} (61%) rename magnum/tests/unit/conductor/handlers/{test_bay_conductor.py => test_cluster_conductor.py} (59%) rename magnum/tests/unit/conductor/handlers/{test_k8s_bay_conductor.py => test_k8s_cluster_conductor.py} (90%) rename magnum/tests/unit/conductor/handlers/{test_mesos_bay_conductor.py => test_mesos_cluster_conductor.py} (86%) rename magnum/tests/unit/conductor/handlers/{test_swarm_bay_conductor.py => test_swarm_cluster_conductor.py} (87%) delete mode 100644 magnum/tests/unit/db/test_bay.py create mode 100644 magnum/tests/unit/db/test_cluster.py delete mode 100644 magnum/tests/unit/objects/test_bay.py create mode 100644 magnum/tests/unit/objects/test_cluster.py diff --git a/magnum/api/controllers/base.py b/magnum/api/controllers/base.py index cb5e77a864..48a13b635c 100644 --- a/magnum/api/controllers/base.py +++ b/magnum/api/controllers/base.py @@ -143,12 +143,12 @@ class Controller(rest.RestController): Example: @base.Controller.api_version("1.1", "1.2") @expose.expose(Cluster, types.uuid_or_name) - def get_one(self, bay_ident): + def get_one(self, cluster_ident): {...code for versions 1.1 to 1.2...} @base.Controller.api_version("1.3") @expose.expose(Cluster, types.uuid_or_name) - def get_one(self, bay_ident): + def get_one(self, cluster_ident): {...code for versions 1.3 to latest} @min_ver: string representing minimum version diff --git a/magnum/api/controllers/v1/bay.py b/magnum/api/controllers/v1/bay.py index a249829529..a7ac8c0941 100644 --- a/magnum/api/controllers/v1/bay.py +++ b/magnum/api/controllers/v1/bay.py @@ -28,7 +28,7 @@ from magnum.api.controllers.v1 import collection from magnum.api.controllers.v1 import types from magnum.api import expose from magnum.api import utils as api_utils -from magnum.api.validation import validate_bay_properties +from magnum.api.validation import validate_cluster_properties from magnum.common import clients from magnum.common import exception from magnum.common import name_generator @@ -66,7 +66,7 @@ class Bay(base.APIBase): self._baymodel_id = baymodel.uuid except exception.ClusterTemplateNotFound as e: # Change error code because 404 (NotFound) is inappropriate - # response for a POST request to create a Bay + # response for a POST request to create a Cluster e.code = 400 # BadRequest raise elif value == wtypes.Unset: @@ -99,7 +99,7 @@ class Bay(base.APIBase): stack_id = wsme.wsattr(wtypes.text, readonly=True) """Stack id of the heat stack""" - status = wtypes.Enum(str, *fields.BayStatus.ALL) + status = wtypes.Enum(str, *fields.ClusterStatus.ALL) """Status of the bay from the heat stack""" status_reason = wtypes.text @@ -131,13 +131,43 @@ class Bay(base.APIBase): super(Bay, self).__init__() self.fields = [] - for field in objects.Bay.fields: + for field in objects.Cluster.fields: # Skip fields we do not expose. if not hasattr(self, field): continue self.fields.append(field) setattr(self, field, kwargs.get(field, wtypes.Unset)) + # Set the renamed attributes for bay backwards compatibility + self.fields.append('baymodel_id') + if 'baymodel_id' in kwargs.keys(): + setattr(self, 'cluster_template_id', + kwargs.get('baymodel_id', None)) + setattr(self, 'baymodel_id', + kwargs.get('baymodel_id', None)) + else: + setattr(self, 'baymodel_id', kwargs.get('cluster_template_id', + None)) + + self.fields.append('bay_create_timeout') + if 'bay_create_timeout' in kwargs.keys(): + setattr(self, 'create_timeout', + kwargs.get('bay_create_timeout', wtypes.Unset)) + setattr(self, 'bay_create_timeout', + kwargs.get('bay_create_timeout', wtypes.Unset)) + else: + setattr(self, 'bay_create_timeout', kwargs.get('create_timeout', + wtypes.Unset)) + + self.fields.append('bay_faults') + if 'bay_faults' in kwargs.keys(): + setattr(self, 'faults', + kwargs.get('bay_faults', wtypes.Unset)) + setattr(self, 'bay_faults', + kwargs.get('bay_faults', wtypes.Unset)) + else: + setattr(self, 'bay_faults', kwargs.get('faults', wtypes.Unset)) + @staticmethod def _convert_with_links(bay, url, expand=True): if not expand: @@ -167,7 +197,7 @@ class Bay(base.APIBase): master_count=1, bay_create_timeout=15, stack_id='49dc23f5-ffc9-40c3-9d34-7be7f9e34d63', - status=fields.BayStatus.CREATE_COMPLETE, + status=fields.ClusterStatus.CREATE_COMPLETE, status_reason="CREATE completed successfully", api_address='172.24.4.3', node_addresses=['172.24.4.4', '172.24.4.5'], @@ -177,6 +207,24 @@ class Bay(base.APIBase): container_version=None) return cls._convert_with_links(sample, 'http://localhost:9511', expand) + def as_dict(self): + """Render this object as a dict of its fields.""" + + # Override this for old bay values + d = super(Bay, self).as_dict() + + d['cluster_template_id'] = d['baymodel_id'] + del d['baymodel_id'] + + d['create_timeout'] = d['bay_create_timeout'] + del d['bay_create_timeout'] + + if 'bay_faults' in d.keys(): + d['faults'] = d['bay_faults'] + del d['bay_faults'] + + return d + class BayPatchType(types.JsonPatchType): _api_base = Bay @@ -239,12 +287,12 @@ class BaysController(base.Controller): marker_obj = None if marker: - marker_obj = objects.Bay.get_by_uuid(pecan.request.context, - marker) + marker_obj = objects.Cluster.get_by_uuid(pecan.request.context, + marker) - bays = objects.Bay.list(pecan.request.context, limit, - marker_obj, sort_key=sort_key, - sort_dir=sort_dir) + bays = objects.Cluster.list(pecan.request.context, limit, + marker_obj, sort_key=sort_key, + sort_dir=sort_dir) return BayCollection.convert_with_links(bays, limit, url=resource_url, @@ -323,13 +371,13 @@ class BaysController(base.Controller): :param bay_ident: UUID of a bay or logical name of the bay. """ context = pecan.request.context - bay = api_utils.get_resource('Bay', bay_ident) + bay = api_utils.get_resource('Cluster', bay_ident) policy.enforce(context, 'bay:get', bay, action='bay:get') bay = Bay.convert_with_links(bay) - if bay.status in fields.BayStatus.STATUS_FAILED: + if bay.status in fields.ClusterStatus.STATUS_FAILED: bay.bay_faults = self._collect_fault_info(context, bay) return bay @@ -342,8 +390,8 @@ class BaysController(base.Controller): :param bay: a bay within the request body. """ new_bay = self._post(bay) - res_bay = pecan.request.rpcapi.bay_create(new_bay, - bay.bay_create_timeout) + res_bay = pecan.request.rpcapi.cluster_create(new_bay, + bay.bay_create_timeout) # Set the HTTP Location Header pecan.response.location = link.build_url('bays', res_bay.uuid) @@ -357,7 +405,8 @@ class BaysController(base.Controller): :param bay: a bay within the request body. """ new_bay = self._post(bay) - pecan.request.rpcapi.bay_create_async(new_bay, bay.bay_create_timeout) + pecan.request.rpcapi.cluster_create_async(new_bay, + bay.bay_create_timeout) return BayID(new_bay.uuid) def _post(self, bay): @@ -378,7 +427,7 @@ class BaysController(base.Controller): bay_dict['coe_version'] = None bay_dict['container_version'] = None - new_bay = objects.Bay(context, **bay_dict) + new_bay = objects.Cluster(context, **bay_dict) new_bay.uuid = uuid.uuid4() return new_bay @@ -392,7 +441,7 @@ class BaysController(base.Controller): :param patch: a json PATCH document to apply to this bay. """ bay = self._patch(bay_ident, patch) - res_bay = pecan.request.rpcapi.bay_update(bay) + res_bay = pecan.request.rpcapi.cluster_update(bay) return Bay.convert_with_links(res_bay) @base.Controller.api_version("1.2", "1.2") # noqa @@ -406,7 +455,7 @@ class BaysController(base.Controller): :param patch: a json PATCH document to apply to this bay. """ bay = self._patch(bay_ident, patch) - pecan.request.rpcapi.bay_update_async(bay) + pecan.request.rpcapi.cluster_update_async(bay) return BayID(bay.uuid) @base.Controller.api_version("1.3") # noqa @@ -421,12 +470,12 @@ class BaysController(base.Controller): :param patch: a json PATCH document to apply to this bay. """ bay = self._patch(bay_ident, patch) - pecan.request.rpcapi.bay_update_async(bay, rollback=rollback) + pecan.request.rpcapi.cluster_update_async(bay, rollback=rollback) return BayID(bay.uuid) def _patch(self, bay_ident, patch): context = pecan.request.context - bay = api_utils.get_resource('Bay', bay_ident) + bay = api_utils.get_resource('Cluster', bay_ident) policy.enforce(context, 'bay:update', bay, action='bay:update') try: @@ -436,7 +485,7 @@ class BaysController(base.Controller): raise exception.PatchError(patch=patch, reason=e) # Update only the fields that have changed - for field in objects.Bay.fields: + for field in objects.Cluster.fields: try: patch_val = getattr(new_bay, field) except AttributeError: @@ -449,7 +498,7 @@ class BaysController(base.Controller): delta = bay.obj_what_changed() - validate_bay_properties(delta) + validate_cluster_properties(delta) return bay @base.Controller.api_version("1.1", "1.1") @@ -461,7 +510,7 @@ class BaysController(base.Controller): """ bay = self._delete(bay_ident) - pecan.request.rpcapi.bay_delete(bay.uuid) + pecan.request.rpcapi.cluster_delete(bay.uuid) @base.Controller.api_version("1.2") # noqa @expose.expose(None, types.uuid_or_name, status_code=204) @@ -472,11 +521,11 @@ class BaysController(base.Controller): """ bay = self._delete(bay_ident) - pecan.request.rpcapi.bay_delete_async(bay.uuid) + pecan.request.rpcapi.cluster_delete_async(bay.uuid) def _delete(self, bay_ident): context = pecan.request.context - bay = api_utils.get_resource('Bay', bay_ident) + bay = api_utils.get_resource('Cluster', bay_ident) policy.enforce(context, 'bay:delete', bay, action='bay:delete') return bay diff --git a/magnum/api/controllers/v1/baymodel.py b/magnum/api/controllers/v1/baymodel.py index 47febe2f01..41d3b2bb28 100644 --- a/magnum/api/controllers/v1/baymodel.py +++ b/magnum/api/controllers/v1/baymodel.py @@ -46,7 +46,7 @@ class BayModel(base.APIBase): name = wtypes.StringType(min_length=1, max_length=255) """The name of the Baymodel""" - coe = wtypes.Enum(str, *fields.BayType.ALL, mandatory=True) + coe = wtypes.Enum(str, *fields.ClusterType.ALL, mandatory=True) """The Container Orchestration Engine for this bay model""" image_id = wsme.wsattr(wtypes.StringType(min_length=1, max_length=255), @@ -181,7 +181,7 @@ class BayModel(base.APIBase): docker_volume_size=25, docker_storage_driver='devicemapper', cluster_distro='fedora-atomic', - coe=fields.BayType.KUBERNETES, + coe=fields.ClusterType.KUBERNETES, http_proxy='http://proxy.com:123', https_proxy='https://proxy.com:123', no_proxy='192.168.0.1,192.168.0.2,192.168.0.3', diff --git a/magnum/api/controllers/v1/certificate.py b/magnum/api/controllers/v1/certificate.py index e6e458441c..432ad18200 100644 --- a/magnum/api/controllers/v1/certificate.py +++ b/magnum/api/controllers/v1/certificate.py @@ -46,11 +46,11 @@ class Certificate(base.APIBase): def _set_cluster_uuid(self, value): if value and self._cluster_uuid != value: try: - self._cluster = api_utils.get_resource('Bay', value) + self._cluster = api_utils.get_resource('Cluster', value) self._cluster_uuid = self._cluster.uuid except exception.ClusterNotFound as e: # Change error code because 404 (NotFound) is inappropriate - # response for a POST request to create a Bay + # response for a POST request to create a Cluster e.code = 400 # BadRequest raise elif value == wtypes.Unset: @@ -90,7 +90,8 @@ class Certificate(base.APIBase): def get_cluster(self): if not self._cluster: - self._cluster = api_utils.get_resource('Bay', self.cluster_uuid) + self._cluster = api_utils.get_resource('Cluster', + self.cluster_uuid) return self._cluster @staticmethod @@ -141,7 +142,7 @@ class CertificateController(base.Controller): logical name of the cluster. """ context = pecan.request.context - cluster = api_utils.get_resource('Bay', cluster_ident) + cluster = api_utils.get_resource('Cluster', cluster_ident) policy.enforce(context, 'certificate:get', cluster, action='certificate:get') certificate = pecan.request.rpcapi.get_ca_certificate(cluster) diff --git a/magnum/api/controllers/v1/cluster.py b/magnum/api/controllers/v1/cluster.py index 15cb77a4a5..a4fe83f6a9 100644 --- a/magnum/api/controllers/v1/cluster.py +++ b/magnum/api/controllers/v1/cluster.py @@ -28,7 +28,7 @@ from magnum.api.controllers.v1 import collection from magnum.api.controllers.v1 import types from magnum.api import expose from magnum.api import utils as api_utils -from magnum.api.validation import validate_bay_properties +from magnum.api.validation import validate_cluster_properties from magnum.common import clients from magnum.common import exception from magnum.common import name_generator @@ -110,7 +110,7 @@ class Cluster(base.APIBase): stack_id = wsme.wsattr(wtypes.text, readonly=True) """Stack id of the heat stack""" - status = wtypes.Enum(str, *fields.BayStatus.ALL) + status = wtypes.Enum(str, *fields.ClusterStatus.ALL) """Status of the cluster from the heat stack""" status_reason = wtypes.text @@ -141,36 +141,13 @@ class Cluster(base.APIBase): def __init__(self, **kwargs): super(Cluster, self).__init__() self.fields = [] - for field in objects.Bay.fields: + for field in objects.Cluster.fields: # Skip fields we do not expose. if not hasattr(self, field): continue self.fields.append(field) setattr(self, field, kwargs.get(field, wtypes.Unset)) - # Set the renamed attributes for clusters - self.fields.append('cluster_template_id') - if 'cluster_template_id' in kwargs.keys(): - setattr(self, 'cluster_template_id', - kwargs.get('cluster_template_id', wtypes.Unset)) - else: - setattr(self, 'cluster_template_id', kwargs.get('baymodel_id', - wtypes.Unset)) - - self.fields.append('create_timeout') - if 'create_timeout' in kwargs.keys(): - setattr(self, 'create_timeout', kwargs.get('create_timeout', - wtypes.Unset)) - else: - setattr(self, 'create_timeout', kwargs.get('bay_create_timeout', - wtypes.Unset)) - - self.fields.append('faults') - if 'faults' in kwargs.keys(): - setattr(self, 'faults', kwargs.get('faults', wtypes.Unset)) - else: - setattr(self, 'faults', kwargs.get('bay_faults', wtypes.Unset)) - @staticmethod def _convert_with_links(cluster, url, expand=True): if not expand: @@ -180,9 +157,9 @@ class Cluster(base.APIBase): 'stack_id']) cluster.links = [link.Link.make_link('self', url, - 'bays', cluster.uuid), + 'clusters', cluster.uuid), link.Link.make_link('bookmark', url, - 'bays', cluster.uuid, + 'clusters', cluster.uuid, bookmark=True)] return cluster @@ -201,7 +178,7 @@ class Cluster(base.APIBase): master_count=1, create_timeout=15, stack_id='49dc23f5-ffc9-40c3-9d34-7be7f9e34d63', - status=fields.BayStatus.CREATE_COMPLETE, + status=fields.ClusterStatus.CREATE_COMPLETE, status_reason="CREATE completed successfully", api_address='172.24.4.3', node_addresses=['172.24.4.4', '172.24.4.5'], @@ -211,26 +188,6 @@ class Cluster(base.APIBase): container_version=None) return cls._convert_with_links(sample, 'http://localhost:9511', expand) - def as_dict(self): - """Render this object as a dict of its fields.""" - - # Override this for updated cluster values - d = super(Cluster, self).as_dict() - - if 'cluster_template_id' in d.keys(): - d['baymodel_id'] = d['cluster_template_id'] - del d['cluster_template_id'] - - if 'create_timeout' in d.keys(): - d['bay_create_timeout'] = d['create_timeout'] - del d['create_timeout'] - - if 'faults' in d.keys(): - d['bay_faults'] = d['faults'] - del d['faults'] - - return d - class ClusterPatchType(types.JsonPatchType): _api_base = Cluster @@ -295,12 +252,12 @@ class ClustersController(base.Controller): marker_obj = None if marker: - marker_obj = objects.Bay.get_by_uuid(pecan.request.context, - marker) + marker_obj = objects.Cluster.get_by_uuid(pecan.request.context, + marker) - clusters = objects.Bay.list(pecan.request.context, limit, - marker_obj, sort_key=sort_key, - sort_dir=sort_dir) + clusters = objects.Cluster.list(pecan.request.context, limit, + marker_obj, sort_key=sort_key, + sort_dir=sort_dir) return ClusterCollection.convert_with_links(clusters, limit, url=resource_url, @@ -380,13 +337,13 @@ class ClustersController(base.Controller): :param cluster_ident: UUID or logical name of the Cluster. """ context = pecan.request.context - cluster = api_utils.get_resource('Bay', cluster_ident) + cluster = api_utils.get_resource('Cluster', cluster_ident) policy.enforce(context, 'cluster:get', cluster, action='cluster:get') cluster = Cluster.convert_with_links(cluster) - if cluster.status in fields.BayStatus.STATUS_FAILED: + if cluster.status in fields.ClusterStatus.STATUS_FAILED: cluster.faults = self._collect_fault_info(context, cluster) return cluster @@ -420,10 +377,10 @@ class ClustersController(base.Controller): cluster_dict['coe_version'] = None cluster_dict['container_version'] = None - new_cluster = objects.Bay(context, **cluster_dict) + new_cluster = objects.Cluster(context, **cluster_dict) new_cluster.uuid = uuid.uuid4() - pecan.request.rpcapi.bay_create_async(new_cluster, - cluster.create_timeout) + pecan.request.rpcapi.cluster_create_async(new_cluster, + cluster.create_timeout) return ClusterID(new_cluster.uuid) @@ -438,7 +395,7 @@ class ClustersController(base.Controller): :param patch: a json PATCH document to apply to this cluster. """ cluster = self._patch(cluster_ident, patch) - pecan.request.rpcapi.bay_update_async(cluster) + pecan.request.rpcapi.cluster_update_async(cluster) return ClusterID(cluster.uuid) @base.Controller.api_version("1.3") # noqa @@ -453,12 +410,12 @@ class ClustersController(base.Controller): :param patch: a json PATCH document to apply to this cluster. """ cluster = self._patch(cluster_ident, patch) - pecan.request.rpcapi.bay_update_async(cluster, rollback) + pecan.request.rpcapi.cluster_update_async(cluster, rollback) return ClusterID(cluster.uuid) def _patch(self, cluster_ident, patch): context = pecan.request.context - cluster = api_utils.get_resource('Bay', cluster_ident) + cluster = api_utils.get_resource('Cluster', cluster_ident) policy.enforce(context, 'cluster:update', cluster, action='cluster:update') try: @@ -469,7 +426,7 @@ class ClustersController(base.Controller): raise exception.PatchError(patch=patch, reason=e) # Update only the fields that have changed - for field in objects.Bay.fields: + for field in objects.Cluster.fields: try: patch_val = getattr(new_cluster, field) except AttributeError: @@ -482,7 +439,7 @@ class ClustersController(base.Controller): delta = cluster.obj_what_changed() - validate_bay_properties(delta) + validate_cluster_properties(delta) return cluster @expose.expose(None, types.uuid_or_name, status_code=204) @@ -492,8 +449,8 @@ class ClustersController(base.Controller): :param cluster_ident: UUID of cluster or logical name of the cluster. """ context = pecan.request.context - cluster = api_utils.get_resource('Bay', cluster_ident) + cluster = api_utils.get_resource('Cluster', cluster_ident) policy.enforce(context, 'cluster:delete', cluster, action='cluster:delete') - pecan.request.rpcapi.bay_delete_async(cluster.uuid) + pecan.request.rpcapi.cluster_delete_async(cluster.uuid) diff --git a/magnum/api/controllers/v1/cluster_template.py b/magnum/api/controllers/v1/cluster_template.py index 3eab846055..bd0325d310 100644 --- a/magnum/api/controllers/v1/cluster_template.py +++ b/magnum/api/controllers/v1/cluster_template.py @@ -47,7 +47,7 @@ class ClusterTemplate(base.APIBase): name = wtypes.StringType(min_length=1, max_length=255) """The name of the ClusterTemplate""" - coe = wtypes.Enum(str, *fields.BayType.ALL, mandatory=True) + coe = wtypes.Enum(str, *fields.ClusterType.ALL, mandatory=True) """The Container Orchestration Engine for this clustertemplate""" image_id = wsme.wsattr(wtypes.StringType(min_length=1, max_length=255), @@ -185,7 +185,7 @@ class ClusterTemplate(base.APIBase): docker_volume_size=25, docker_storage_driver='devicemapper', cluster_distro='fedora-atomic', - coe=fields.BayType.KUBERNETES, + coe=fields.ClusterType.KUBERNETES, http_proxy='http://proxy.com:123', https_proxy='https://proxy.com:123', no_proxy='192.168.0.1,192.168.0.2,192.168.0.3', diff --git a/magnum/api/validation.py b/magnum/api/validation.py index 7a3fbbdfc1..8296a3e5eb 100644 --- a/magnum/api/validation.py +++ b/magnum/api/validation.py @@ -65,32 +65,35 @@ cluster_template_opts = [ cfg.CONF.register_opts(cluster_template_opts, group='cluster_template') -bay_update_allowed_properties = set(['node_count']) +cluster_update_allowed_properties = set(['node_count']) -def enforce_bay_types(*bay_types): - """Enforce that bay_type is in supported list.""" +def enforce_cluster_types(*cluster_types): + """Enforce that cluster_type is in supported list.""" @decorator.decorator def wrapper(func, *args, **kwargs): # Note(eliqiao): This decorator has some assumptions # args[1] should be an APIBase instance or - # args[2] should be a bay_ident + # args[2] should be a cluster_ident obj = args[1] - if hasattr(obj, 'bay_uuid'): - bay = objects.Bay.get_by_uuid(pecan.request.context, obj.bay_uuid) + if hasattr(obj, 'cluster_uuid'): + cluster = objects.Cluster.get_by_uuid(pecan.request.context, + obj.cluster_uuid) else: - bay_ident = args[2] - if uuidutils.is_uuid_like(bay_ident): - bay = objects.Bay.get_by_uuid(pecan.request.context, bay_ident) + cluster_ident = args[2] + if uuidutils.is_uuid_like(cluster_ident): + cluster = objects.Cluster.get_by_uuid(pecan.request.context, + cluster_ident) else: - bay = objects.Bay.get_by_name(pecan.request.context, bay_ident) + cluster = objects.Cluster.get_by_name(pecan.request.context, + cluster_ident) - if bay.cluster_template.coe not in bay_types: + if cluster.cluster_template.coe not in cluster_types: raise exception.InvalidParameterValue(_( - 'Cannot fulfill request with a %(bay_type)s bay, ' - 'expecting a %(supported_bay_types)s bay.') % - {'bay_type': bay.cluster_template.coe, - 'supported_bay_types': '/'.join(bay_types)}) + 'Cannot fulfill request with a %(cluster_type)s cluster, ' + 'expecting a %(supported_cluster_types)s cluster.') % + {'cluster_type': cluster.cluster_template.coe, + 'supported_cluster_types': '/'.join(cluster_types)}) return func(*args, **kwargs) @@ -192,11 +195,11 @@ def _enforce_volume_storage_size(cluster_template): 'driver.') % (volume_size, storage_driver) -def validate_bay_properties(delta): +def validate_cluster_properties(delta): - update_disallowed_properties = delta - bay_update_allowed_properties + update_disallowed_properties = delta - cluster_update_allowed_properties if update_disallowed_properties: - err = (_("cannot change bay property(ies) %s.") % + err = (_("cannot change cluster property(ies) %s.") % ", ".join(update_disallowed_properties)) raise exception.InvalidParameterValue(err=err) diff --git a/magnum/cmd/conductor.py b/magnum/cmd/conductor.py index 091acd491a..c33dfd9d1c 100644 --- a/magnum/cmd/conductor.py +++ b/magnum/cmd/conductor.py @@ -25,8 +25,8 @@ from oslo_service import service from magnum.common import rpc_service from magnum.common import service as magnum_service from magnum.common import short_id -from magnum.conductor.handlers import bay_conductor from magnum.conductor.handlers import ca_conductor +from magnum.conductor.handlers import cluster_conductor from magnum.conductor.handlers import conductor_listener from magnum.conductor.handlers import indirection_api from magnum.i18n import _LI @@ -49,7 +49,7 @@ def main(): conductor_id = short_id.generate_id() endpoints = [ indirection_api.Handler(), - bay_conductor.Handler(), + cluster_conductor.Handler(), conductor_listener.Handler(), ca_conductor.Handler(), ] diff --git a/magnum/cmd/template_manage.py b/magnum/cmd/template_manage.py index 0123d48b63..59064d99eb 100644 --- a/magnum/cmd/template_manage.py +++ b/magnum/cmd/template_manage.py @@ -50,7 +50,7 @@ class TemplateList(lister.Lister): parser.add_argument('-d', '--details', action='store_true', dest='details', - help=('display the bay types provided by ' + help=('display the cluster types provided by ' 'each template')) parser.add_argument('-p', '--paths', action='store_true', @@ -77,10 +77,10 @@ class TemplateList(lister.Lister): path=definition.template_path) if parsed_args.details: - for bay_type in definition.provides: + for cluster_type in definition.provides: row = dict() row.update(template) - row.update(bay_type) + row.update(cluster_type) rows.append(row) else: rows.append(template) diff --git a/magnum/common/context.py b/magnum/common/context.py index c1f52053a1..5a53250781 100644 --- a/magnum/common/context.py +++ b/magnum/common/context.py @@ -105,15 +105,15 @@ def make_admin_context(show_deleted=False, all_tenants=False): return context -def make_bay_context(bay, show_deleted=False): - """Create a user context based on a bay's stored Keystone trust. +def make_cluster_context(cluster, show_deleted=False): + """Create a user context based on a cluster's stored Keystone trust. - :param bay: the bay supplying the Keystone trust to use + :param cluster: the cluster supplying the Keystone trust to use :param show_deleted: if True, will show deleted items when query db """ - context = RequestContext(user_name=bay.trustee_username, - password=bay.trustee_password, - trust_id=bay.trust_id, + context = RequestContext(user_name=cluster.trustee_username, + password=cluster.trustee_password, + trust_id=cluster.trust_id, show_deleted=show_deleted, user_domain_id=CONF.trust.trustee_domain_id, user_domain_name=CONF.trust.trustee_domain_name) diff --git a/magnum/common/docker_utils.py b/magnum/common/docker_utils.py index fd4a52c4d9..c1aa4ae501 100644 --- a/magnum/common/docker_utils.py +++ b/magnum/common/docker_utils.py @@ -75,20 +75,21 @@ def is_docker_api_version_atleast(docker, version): @contextlib.contextmanager -def docker_for_bay(context, bay): - cluster_template = conductor_utils.retrieve_cluster_template(context, bay) +def docker_for_cluster(context, cluster): + cluster_template = conductor_utils.retrieve_cluster_template( + context, cluster) ca_cert, magnum_key, magnum_cert = None, None, None client_kwargs = dict() if not cluster_template.tls_disabled: (ca_cert, magnum_key, - magnum_cert) = cert_manager.create_client_files(bay) + magnum_cert) = cert_manager.create_client_files(cluster) client_kwargs['ca_cert'] = ca_cert.name client_kwargs['client_key'] = magnum_key.name client_kwargs['client_cert'] = magnum_cert.name yield DockerHTTPClient( - bay.api_address, + cluster.api_address, CONF.docker.docker_remote_api_version, CONF.docker.default_timeout, **client_kwargs diff --git a/magnum/common/exception.py b/magnum/common/exception.py index da62e2577a..66b10b410c 100644 --- a/magnum/common/exception.py +++ b/magnum/common/exception.py @@ -154,7 +154,7 @@ class GetDiscoveryUrlFailed(MagnumException): message = _("Failed to get discovery url from '%(discovery_endpoint)s'.") -class InvalidBayDiscoveryURL(Invalid): +class InvalidClusterDiscoveryURL(Invalid): message = _("Invalid discovery URL '%(discovery_url)s'.") @@ -271,11 +271,11 @@ class PodAlreadyExists(Conflict): class PodListNotFound(ResourceNotFound): - message = _("Pod list could not be found for Bay %(bay_uuid)s.") + message = _("Pod list could not be found for Cluster %(cluster_uuid)s.") class PodCreationFailed(Invalid): - message = _("Pod creation failed in Bay %(bay_uuid)s.") + message = _("Pod creation failed in Cluster %(cluster_uuid)s.") class ServiceNotFound(ResourceNotFound): @@ -287,11 +287,12 @@ class ServiceAlreadyExists(Conflict): class ServiceListNotFound(ResourceNotFound): - message = _("Service list could not be found for Bay %(bay_uuid)s.") + message = _("Service list could not be found for Cluster " + "%(cluster_uuid)s.") class ServiceCreationFailed(Invalid): - message = _("Service creation failed for Bay %(bay_uuid)s.") + message = _("Service creation failed for Cluster %(cluster_uuid)s.") class ContainerException(Exception): @@ -303,13 +304,13 @@ class NotSupported(MagnumException): code = 400 -class BayTypeNotSupported(MagnumException): - message = _("Bay type (%(server_type)s, %(os)s, %(coe)s)" +class ClusterTypeNotSupported(MagnumException): + message = _("Cluster type (%(server_type)s, %(os)s, %(coe)s)" " not supported.") -class BayTypeNotEnabled(MagnumException): - message = _("Bay type (%(server_type)s, %(os)s, %(coe)s)" +class ClusterTypeNotEnabled(MagnumException): + message = _("Cluster type (%(server_type)s, %(os)s, %(coe)s)" " not enabled.") @@ -322,7 +323,8 @@ class Urllib2InvalidScheme(MagnumException): class OperationInProgress(Invalid): - message = _("Bay %(bay_name)s already has an operation in progress.") + message = _("Cluster %(cluster_name)s already has an operation in " + "progress.") class ImageNotFound(ResourceNotFound): @@ -383,11 +385,11 @@ class MagnumServiceAlreadyExists(Conflict): class UnsupportedK8sQuantityFormat(MagnumException): - message = _("Unsupported quantity format for k8s bay.") + message = _("Unsupported quantity format for k8s cluster.") class UnsupportedDockerQuantityFormat(MagnumException): - message = _("Unsupported quantity format for Swarm bay.") + message = _("Unsupported quantity format for Swarm cluster.") class FlavorNotFound(ResourceNotFound): @@ -429,8 +431,9 @@ class RegionsListFailed(MagnumException): message = _("Failed to list regions.") -class TrusteeOrTrustToBayFailed(MagnumException): - message = _("Failed to create trustee or trust for Bay: %(bay_uuid)s") +class TrusteeOrTrustToClusterFailed(MagnumException): + message = _("Failed to create trustee or trust for Cluster: " + "%(cluster_uuid)s") class CertificatesToClusterFailed(MagnumException): diff --git a/magnum/common/keystone.py b/magnum/common/keystone.py index c31188256a..3e1dc202f7 100644 --- a/magnum/common/keystone.py +++ b/magnum/common/keystone.py @@ -32,9 +32,9 @@ LOG = logging.getLogger(__name__) trust_opts = [ cfg.StrOpt('trustee_domain_id', - help=_('Id of the domain to create trustee for bays')), + help=_('Id of the domain to create trustee for clusters')), cfg.StrOpt('trustee_domain_name', - help=_('Name of the domain to create trustee for bays')), + help=_('Name of the domain to create trustee for s')), cfg.StrOpt('trustee_domain_admin_id', help=_('Id of the admin with roles sufficient to manage users' ' in the trustee_domain')), @@ -256,21 +256,21 @@ class KeystoneClientV3(object): trustee_user_id=trustee_user) return trust - def delete_trust(self, context, bay): - if bay.trust_id is None: + def delete_trust(self, context, cluster): + if cluster.trust_id is None: return # Trust can only be deleted by the user who creates it. So when - # other users in the same project want to delete the bay, we need + # other users in the same project want to delete the cluster, we need # use the trustee which can impersonate the trustor to delete the # trust. - if context.user_id == bay.user_id: + if context.user_id == cluster.user_id: client = self.client else: auth = ka_v3.Password(auth_url=self.auth_url, - user_id=bay.trustee_user_id, - password=bay.trustee_password, - trust_id=bay.trust_id) + user_id=cluster.trustee_user_id, + password=cluster.trustee_password, + trust_id=cluster.trust_id) sess = ka_loading.session.Session().load_from_options( auth=auth, @@ -280,12 +280,12 @@ class KeystoneClientV3(object): cert=CONF[CFG_LEGACY_GROUP].certfile) client = kc_v3.Client(session=sess) try: - client.trusts.delete(bay.trust_id) + client.trusts.delete(cluster.trust_id) except kc_exception.NotFound: pass except Exception: LOG.exception(_LE('Failed to delete trust')) - raise exception.TrustDeleteFailed(trust_id=bay.trust_id) + raise exception.TrustDeleteFailed(trust_id=cluster.trust_id) def create_trustee(self, username, password): domain_id = self.trustee_domain_id diff --git a/magnum/common/policy.py b/magnum/common/policy.py index dcf1375534..980691f7a3 100644 --- a/magnum/common/policy.py +++ b/magnum/common/policy.py @@ -104,11 +104,11 @@ def enforce_wsgi(api_name, act=None): example: from magnum.common import policy - class BaysController(rest.RestController): + class ClustersController(rest.RestController): .... - @policy.enforce_wsgi("bay", "delete") + @policy.enforce_wsgi("cluster", "delete") @wsme_pecan.wsexpose(None, types.uuid_or_name, status_code=204) - def delete(self, bay_ident): + def delete(self, cluster_ident): ... """ @decorator.decorator diff --git a/magnum/common/rpc_service.py b/magnum/common/rpc_service.py index b363eafbc1..cbe551dfb9 100644 --- a/magnum/common/rpc_service.py +++ b/magnum/common/rpc_service.py @@ -44,8 +44,8 @@ TRANSPORT_ALIASES = { periodic_opts = [ cfg.BoolOpt('periodic_global_stack_list', default=False, - help="List Heat stacks globally when syncing bays. " - "Default is to do retrieve each bay's stack " + help="List Heat stacks globally when syncing clusters. " + "Default is to do retrieve each cluster's stack " "individually. Reduces number of requests against " "Heat API if enabled but requires changes to Heat's " "policy.json."), diff --git a/magnum/conductor/api.py b/magnum/conductor/api.py index ab977b205a..0e10975ef1 100644 --- a/magnum/conductor/api.py +++ b/magnum/conductor/api.py @@ -28,27 +28,27 @@ class API(rpc_service.API): super(API, self).__init__(transport, context, topic=cfg.CONF.conductor.topic) - # Bay Operations + # Cluster Operations - def bay_create(self, bay, bay_create_timeout): - return self._call('bay_create', bay=bay, - bay_create_timeout=bay_create_timeout) + def cluster_create(self, cluster, create_timeout): + return self._call('cluster_create', cluster=cluster, + create_timeout=create_timeout) - def bay_create_async(self, bay, bay_create_timeout): - self._cast('bay_create', bay=bay, - bay_create_timeout=bay_create_timeout) + def cluster_create_async(self, cluster, create_timeout): + self._cast('cluster_create', cluster=cluster, + create_timeout=create_timeout) - def bay_delete(self, uuid): - return self._call('bay_delete', uuid=uuid) + def cluster_delete(self, uuid): + return self._call('cluster_delete', uuid=uuid) - def bay_delete_async(self, uuid): - self._cast('bay_delete', uuid=uuid) + def cluster_delete_async(self, uuid): + self._cast('cluster_delete', uuid=uuid) - def bay_update(self, bay): - return self._call('bay_update', bay=bay) + def cluster_update(self, cluster): + return self._call('cluster_update', cluster=cluster) - def bay_update_async(self, bay, rollback=False): - self._cast('bay_update', bay=bay, rollback=rollback) + def cluster_update_async(self, cluster, rollback=False): + self._cast('cluster_update', cluster=cluster, rollback=rollback) # CA operations diff --git a/magnum/conductor/handlers/bay_conductor.py b/magnum/conductor/handlers/cluster_conductor.py similarity index 58% rename from magnum/conductor/handlers/bay_conductor.py rename to magnum/conductor/handlers/cluster_conductor.py index cebb7bac1c..fae20f906e 100644 --- a/magnum/conductor/handlers/bay_conductor.py +++ b/magnum/conductor/handlers/cluster_conductor.py @@ -68,8 +68,9 @@ CONF.register_opts(cluster_heat_opts, group='cluster_heat') LOG = logging.getLogger(__name__) -def _extract_template_definition(context, bay, scale_manager=None): - cluster_template = conductor_utils.retrieve_cluster_template(context, bay) +def _extract_template_definition(context, cluster, scale_manager=None): + cluster_template = conductor_utils.retrieve_cluster_template(context, + cluster) cluster_distro = cluster_template.cluster_distro cluster_coe = cluster_template.coe cluster_server_type = cluster_template.server_type @@ -77,7 +78,7 @@ def _extract_template_definition(context, bay, scale_manager=None): cluster_server_type, cluster_distro, cluster_coe) - return definition.extract_definition(context, cluster_template, bay, + return definition.extract_definition(context, cluster_template, cluster, scale_manager=scale_manager) @@ -91,9 +92,9 @@ def _get_env_files(template_path, env_rel_paths): return environment_files, env_map -def _create_stack(context, osc, bay, bay_create_timeout): +def _create_stack(context, osc, cluster, create_timeout): template_path, heat_params, env_files = ( - _extract_template_definition(context, bay)) + _extract_template_definition(context, cluster)) tpl_files, template = template_utils.get_template_contents(template_path) @@ -101,11 +102,11 @@ def _create_stack(context, osc, bay, bay_create_timeout): tpl_files.update(env_map) # Make sure no duplicate stack name - stack_name = '%s-%s' % (bay.name, short_id.generate_id()) - if bay_create_timeout: - heat_timeout = bay_create_timeout + stack_name = '%s-%s' % (cluster.name, short_id.generate_id()) + if create_timeout: + heat_timeout = create_timeout else: - # no bay_create_timeout value was passed in to the request + # no create_timeout value was passed in to the request # so falling back on configuration file value heat_timeout = cfg.CONF.cluster_heat.create_timeout fields = { @@ -121,9 +122,9 @@ def _create_stack(context, osc, bay, bay_create_timeout): return created_stack -def _update_stack(context, osc, bay, scale_manager=None, rollback=False): +def _update_stack(context, osc, cluster, scale_manager=None, rollback=False): template_path, heat_params, env_files = _extract_template_definition( - context, bay, scale_manager=scale_manager) + context, cluster, scale_manager=scale_manager) tpl_files, template = template_utils.get_template_contents(template_path) environment_files, env_map = _get_env_files(template_path, env_files) @@ -137,7 +138,7 @@ def _update_stack(context, osc, bay, scale_manager=None, rollback=False): 'disable_rollback': not rollback } - return osc.heat().stacks.update(bay.stack_id, **fields) + return osc.heat().stacks.update(cluster.stack_id, **fields) class Handler(object): @@ -145,26 +146,28 @@ class Handler(object): def __init__(self): super(Handler, self).__init__() - # Bay Operations + # Cluster Operations - def bay_create(self, context, bay, bay_create_timeout): - LOG.debug('bay_heat bay_create') + def cluster_create(self, context, cluster, create_timeout): + LOG.debug('cluster_heat cluster_create') osc = clients.OpenStackClients(context) try: - # Create trustee/trust and set them to bay - trust_manager.create_trustee_and_trust(osc, bay) - # Generate certificate and set the cert reference to bay - cert_manager.generate_certificates_to_cluster(bay, context=context) - conductor_utils.notify_about_bay_operation( + # Create trustee/trust and set them to cluster + trust_manager.create_trustee_and_trust(osc, cluster) + # Generate certificate and set the cert reference to cluster + cert_manager.generate_certificates_to_cluster(cluster, + context=context) + conductor_utils.notify_about_cluster_operation( context, taxonomy.ACTION_CREATE, taxonomy.OUTCOME_PENDING) - created_stack = _create_stack(context, osc, bay, - bay_create_timeout) + created_stack = _create_stack(context, osc, cluster, + create_timeout) except Exception as e: - cert_manager.delete_certificates_from_cluster(bay, context=context) - trust_manager.delete_trustee_and_trust(osc, context, bay) - conductor_utils.notify_about_bay_operation( + cert_manager.delete_certificates_from_cluster(cluster, + context=context) + trust_manager.delete_trustee_and_trust(osc, context, cluster) + conductor_utils.notify_about_cluster_operation( context, taxonomy.ACTION_CREATE, taxonomy.OUTCOME_FAILURE) if isinstance(e, exc.HTTPBadRequest): @@ -173,111 +176,112 @@ class Handler(object): raise e raise - bay.stack_id = created_stack['stack']['id'] - bay.status = fields.BayStatus.CREATE_IN_PROGRESS - bay.create() + cluster.stack_id = created_stack['stack']['id'] + cluster.status = fields.ClusterStatus.CREATE_IN_PROGRESS + cluster.create() - self._poll_and_check(osc, bay) + self._poll_and_check(osc, cluster) - return bay + return cluster - def bay_update(self, context, bay, rollback=False): - LOG.debug('bay_heat bay_update') + def cluster_update(self, context, cluster, rollback=False): + LOG.debug('cluster_heat cluster_update') osc = clients.OpenStackClients(context) - stack = osc.heat().stacks.get(bay.stack_id) + stack = osc.heat().stacks.get(cluster.stack_id) allow_update_status = ( - fields.BayStatus.CREATE_COMPLETE, - fields.BayStatus.UPDATE_COMPLETE, - fields.BayStatus.RESUME_COMPLETE, - fields.BayStatus.RESTORE_COMPLETE, - fields.BayStatus.ROLLBACK_COMPLETE, - fields.BayStatus.SNAPSHOT_COMPLETE, - fields.BayStatus.CHECK_COMPLETE, - fields.BayStatus.ADOPT_COMPLETE + fields.ClusterStatus.CREATE_COMPLETE, + fields.ClusterStatus.UPDATE_COMPLETE, + fields.ClusterStatus.RESUME_COMPLETE, + fields.ClusterStatus.RESTORE_COMPLETE, + fields.ClusterStatus.ROLLBACK_COMPLETE, + fields.ClusterStatus.SNAPSHOT_COMPLETE, + fields.ClusterStatus.CHECK_COMPLETE, + fields.ClusterStatus.ADOPT_COMPLETE ) if stack.stack_status not in allow_update_status: - conductor_utils.notify_about_bay_operation( + conductor_utils.notify_about_cluster_operation( context, taxonomy.ACTION_UPDATE, taxonomy.OUTCOME_FAILURE) - operation = _('Updating a bay when stack status is ' + operation = _('Updating a cluster when stack status is ' '"%s"') % stack.stack_status raise exception.NotSupported(operation=operation) - delta = bay.obj_what_changed() + delta = cluster.obj_what_changed() if not delta: - return bay + return cluster - manager = scale_manager.ScaleManager(context, osc, bay) + manager = scale_manager.ScaleManager(context, osc, cluster) - conductor_utils.notify_about_bay_operation( + conductor_utils.notify_about_cluster_operation( context, taxonomy.ACTION_UPDATE, taxonomy.OUTCOME_PENDING) - _update_stack(context, osc, bay, manager, rollback) - self._poll_and_check(osc, bay) + _update_stack(context, osc, cluster, manager, rollback) + self._poll_and_check(osc, cluster) - return bay + return cluster - def bay_delete(self, context, uuid): - LOG.debug('bay_heat bay_delete') + def cluster_delete(self, context, uuid): + LOG.debug('cluster_heat cluster_delete') osc = clients.OpenStackClients(context) - bay = objects.Bay.get_by_uuid(context, uuid) + cluster = objects.Cluster.get_by_uuid(context, uuid) - stack_id = bay.stack_id + stack_id = cluster.stack_id # NOTE(sdake): This will execute a stack_delete operation. This will # Ignore HTTPNotFound exceptions (stack wasn't present). In the case - # that Heat couldn't find the stack representing the bay, likely a user - # has deleted the stack outside the context of Magnum. Therefore the - # contents of the bay are forever lost. + # that Heat couldn't find the stack representing the cluster, likely a + # user has deleted the stack outside the context of Magnum. Therefore + # the contents of the cluster are forever lost. # # If the exception is unhandled, the original exception will be raised. try: - conductor_utils.notify_about_bay_operation( + conductor_utils.notify_about_cluster_operation( context, taxonomy.ACTION_DELETE, taxonomy.OUTCOME_PENDING) osc.heat().stacks.delete(stack_id) except exc.HTTPNotFound: - LOG.info(_LI('The stack %s was not found during bay' + LOG.info(_LI('The stack %s was not found during cluster' ' deletion.'), stack_id) try: - trust_manager.delete_trustee_and_trust(osc, context, bay) - cert_manager.delete_certificates_from_cluster(bay, + trust_manager.delete_trustee_and_trust(osc, context, cluster) + cert_manager.delete_certificates_from_cluster(cluster, context=context) - bay.destroy() + cluster.destroy() except exception.ClusterNotFound: - LOG.info(_LI('The bay %s has been deleted by others.'), uuid) - conductor_utils.notify_about_bay_operation( + LOG.info(_LI('The cluster %s has been deleted by others.'), + uuid) + conductor_utils.notify_about_cluster_operation( context, taxonomy.ACTION_DELETE, taxonomy.OUTCOME_SUCCESS) return None except exc.HTTPConflict: - conductor_utils.notify_about_bay_operation( + conductor_utils.notify_about_cluster_operation( context, taxonomy.ACTION_DELETE, taxonomy.OUTCOME_FAILURE) - raise exception.OperationInProgress(bay_name=bay.name) + raise exception.OperationInProgress(cluster_name=cluster.name) except Exception: - conductor_utils.notify_about_bay_operation( + conductor_utils.notify_about_cluster_operation( context, taxonomy.ACTION_DELETE, taxonomy.OUTCOME_FAILURE) raise - bay.status = fields.BayStatus.DELETE_IN_PROGRESS - bay.save() + cluster.status = fields.ClusterStatus.DELETE_IN_PROGRESS + cluster.save() - self._poll_and_check(osc, bay) + self._poll_and_check(osc, cluster) return None - def _poll_and_check(self, osc, bay): - poller = HeatPoller(osc, bay) + def _poll_and_check(self, osc, cluster): + poller = HeatPoller(osc, cluster) lc = loopingcall.FixedIntervalLoopingCall(f=poller.poll_and_check) lc.start(cfg.CONF.cluster_heat.wait_interval, True) class HeatPoller(object): - def __init__(self, openstack_client, bay): + def __init__(self, openstack_client, cluster): self.openstack_client = openstack_client self.context = self.openstack_client.context - self.bay = bay + self.cluster = cluster self.attempts = 0 self.cluster_template = conductor_utils.retrieve_cluster_template( - self.context, bay) + self.context, cluster) self.template_def = \ template_def.TemplateDefinition.get_template_definition( self.cluster_template.server_type, @@ -286,97 +290,97 @@ class HeatPoller(object): def poll_and_check(self): # TODO(yuanying): temporary implementation to update api_address, - # node_addresses and bay status - stack = self.openstack_client.heat().stacks.get(self.bay.stack_id) + # node_addresses and cluster status + stack = self.openstack_client.heat().stacks.get(self.cluster.stack_id) self.attempts += 1 status_to_event = { - fields.BayStatus.DELETE_COMPLETE: taxonomy.ACTION_DELETE, - fields.BayStatus.CREATE_COMPLETE: taxonomy.ACTION_CREATE, - fields.BayStatus.UPDATE_COMPLETE: taxonomy.ACTION_UPDATE, - fields.BayStatus.ROLLBACK_COMPLETE: taxonomy.ACTION_UPDATE, - fields.BayStatus.CREATE_FAILED: taxonomy.ACTION_CREATE, - fields.BayStatus.DELETE_FAILED: taxonomy.ACTION_DELETE, - fields.BayStatus.UPDATE_FAILED: taxonomy.ACTION_UPDATE, - fields.BayStatus.ROLLBACK_FAILED: taxonomy.ACTION_UPDATE + fields.ClusterStatus.DELETE_COMPLETE: taxonomy.ACTION_DELETE, + fields.ClusterStatus.CREATE_COMPLETE: taxonomy.ACTION_CREATE, + fields.ClusterStatus.UPDATE_COMPLETE: taxonomy.ACTION_UPDATE, + fields.ClusterStatus.ROLLBACK_COMPLETE: taxonomy.ACTION_UPDATE, + fields.ClusterStatus.CREATE_FAILED: taxonomy.ACTION_CREATE, + fields.ClusterStatus.DELETE_FAILED: taxonomy.ACTION_DELETE, + fields.ClusterStatus.UPDATE_FAILED: taxonomy.ACTION_UPDATE, + fields.ClusterStatus.ROLLBACK_FAILED: taxonomy.ACTION_UPDATE } # poll_and_check is detached and polling long time to check status, - # so another user/client can call delete bay/stack. - if stack.stack_status == fields.BayStatus.DELETE_COMPLETE: + # so another user/client can call delete cluster/stack. + if stack.stack_status == fields.ClusterStatus.DELETE_COMPLETE: self._delete_complete() - conductor_utils.notify_about_bay_operation( + conductor_utils.notify_about_cluster_operation( self.context, status_to_event[stack.stack_status], taxonomy.OUTCOME_SUCCESS) raise loopingcall.LoopingCallDone() - if stack.stack_status in (fields.BayStatus.CREATE_COMPLETE, - fields.BayStatus.UPDATE_COMPLETE): - self._sync_bay_and_template_status(stack) - conductor_utils.notify_about_bay_operation( + if stack.stack_status in (fields.ClusterStatus.CREATE_COMPLETE, + fields.ClusterStatus.UPDATE_COMPLETE): + self._sync_cluster_and_template_status(stack) + conductor_utils.notify_about_cluster_operation( self.context, status_to_event[stack.stack_status], taxonomy.OUTCOME_SUCCESS) raise loopingcall.LoopingCallDone() - elif stack.stack_status != self.bay.status: - self._sync_bay_status(stack) + elif stack.stack_status != self.cluster.status: + self._sync_cluster_status(stack) - if stack.stack_status in (fields.BayStatus.CREATE_FAILED, - fields.BayStatus.DELETE_FAILED, - fields.BayStatus.UPDATE_FAILED, - fields.BayStatus.ROLLBACK_COMPLETE, - fields.BayStatus.ROLLBACK_FAILED): - self._sync_bay_and_template_status(stack) - self._bay_failed(stack) - conductor_utils.notify_about_bay_operation( + if stack.stack_status in (fields.ClusterStatus.CREATE_FAILED, + fields.ClusterStatus.DELETE_FAILED, + fields.ClusterStatus.UPDATE_FAILED, + fields.ClusterStatus.ROLLBACK_COMPLETE, + fields.ClusterStatus.ROLLBACK_FAILED): + self._sync_cluster_and_template_status(stack) + self._cluster_failed(stack) + conductor_utils.notify_about_cluster_operation( self.context, status_to_event[stack.stack_status], taxonomy.OUTCOME_FAILURE) raise loopingcall.LoopingCallDone() # only check max attempts when the stack is being created when # the timeout hasn't been set. If the timeout has been set then # the loop will end when the stack completes or the timeout occurs - if stack.stack_status == fields.BayStatus.CREATE_IN_PROGRESS: + if stack.stack_status == fields.ClusterStatus.CREATE_IN_PROGRESS: if (stack.timeout_mins is None and self.attempts > cfg.CONF.cluster_heat.max_attempts): - LOG.error(_LE('Bay check exit after %(attempts)s attempts,' + LOG.error(_LE('Cluster check exit after %(attempts)s attempts,' 'stack_id: %(id)s, stack_status: %(status)s') % {'attempts': cfg.CONF.cluster_heat.max_attempts, - 'id': self.bay.stack_id, + 'id': self.cluster.stack_id, 'status': stack.stack_status}) raise loopingcall.LoopingCallDone() else: if self.attempts > cfg.CONF.cluster_heat.max_attempts: - LOG.error(_LE('Bay check exit after %(attempts)s attempts,' + LOG.error(_LE('Cluster check exit after %(attempts)s attempts,' 'stack_id: %(id)s, stack_status: %(status)s') % {'attempts': cfg.CONF.cluster_heat.max_attempts, - 'id': self.bay.stack_id, + 'id': self.cluster.stack_id, 'status': stack.stack_status}) raise loopingcall.LoopingCallDone() def _delete_complete(self): - LOG.info(_LI('Bay has been deleted, stack_id: %s') - % self.bay.stack_id) + LOG.info(_LI('Cluster has been deleted, stack_id: %s') + % self.cluster.stack_id) try: trust_manager.delete_trustee_and_trust(self.openstack_client, self.context, - self.bay) - cert_manager.delete_certificates_from_cluster(self.bay, + self.cluster) + cert_manager.delete_certificates_from_cluster(self.cluster, context=self.context) - self.bay.destroy() + self.cluster.destroy() except exception.ClusterNotFound: - LOG.info(_LI('The bay %s has been deleted by others.') - % self.bay.uuid) + LOG.info(_LI('The cluster %s has been deleted by others.') + % self.cluster.uuid) - def _sync_bay_status(self, stack): - self.bay.status = stack.stack_status - self.bay.status_reason = stack.stack_status_reason + def _sync_cluster_status(self, stack): + self.cluster.status = stack.stack_status + self.cluster.status_reason = stack.stack_status_reason stack_nc_param = self.template_def.get_heat_param( - bay_attr='node_count') - self.bay.node_count = stack.parameters[stack_nc_param] - self.bay.save() + cluster_attr='node_count') + self.cluster.node_count = stack.parameters[stack_nc_param] + self.cluster.save() def get_version_info(self, stack): stack_param = self.template_def.get_heat_param( - bay_attr='coe_version') + cluster_attr='coe_version') if stack_param: - self.bay.coe_version = stack.parameters[stack_param] + self.cluster.coe_version = stack.parameters[stack_param] tdef = template_def.TemplateDefinition.get_template_definition( self.cluster_template.server_type, @@ -388,18 +392,18 @@ class HeatPoller(object): container_version = ver.container_version except Exception: container_version = None - self.bay.container_version = container_version + self.cluster.container_version = container_version - def _sync_bay_and_template_status(self, stack): + def _sync_cluster_and_template_status(self, stack): self.template_def.update_outputs(stack, self.cluster_template, - self.bay) + self.cluster) self.get_version_info(stack) - self._sync_bay_status(stack) + self._sync_cluster_status(stack) - def _bay_failed(self, stack): - LOG.error(_LE('Bay error, stack status: %(bay_status)s, ' + def _cluster_failed(self, stack): + LOG.error(_LE('Cluster error, stack status: %(cluster_status)s, ' 'stack_id: %(stack_id)s, ' 'reason: %(reason)s') % - {'bay_status': stack.stack_status, - 'stack_id': self.bay.stack_id, - 'reason': self.bay.status_reason}) + {'cluster_status': stack.stack_status, + 'stack_id': self.cluster.stack_id, + 'reason': self.cluster.status_reason}) diff --git a/magnum/conductor/handlers/common/trust_manager.py b/magnum/conductor/handlers/common/trust_manager.py index f5b4d42478..287953fbfa 100644 --- a/magnum/conductor/handlers/common/trust_manager.py +++ b/magnum/conductor/handlers/common/trust_manager.py @@ -19,36 +19,39 @@ from magnum.i18n import _LE LOG = logging.getLogger(__name__) -def create_trustee_and_trust(osc, bay): +def create_trustee_and_trust(osc, cluster): try: password = utils.generate_password(length=18) trustee = osc.keystone().create_trustee( - bay.uuid, + cluster.uuid, password, ) - bay.trustee_username = trustee.name - bay.trustee_user_id = trustee.id - bay.trustee_password = password + cluster.trustee_username = trustee.name + cluster.trustee_user_id = trustee.id + cluster.trustee_password = password trust = osc.keystone().create_trust(trustee.id) - bay.trust_id = trust.id + cluster.trust_id = trust.id except Exception: - LOG.exception(_LE('Failed to create trustee and trust for Bay: %s'), - bay.uuid) - raise exception.TrusteeOrTrustToBayFailed(bay_uuid=bay.uuid) + LOG.exception( + _LE('Failed to create trustee and trust for Cluster: %s'), + cluster.uuid) + raise exception.TrusteeOrTrustToClusterFailed( + cluster_uuid=cluster.uuid) -def delete_trustee_and_trust(osc, context, bay): +def delete_trustee_and_trust(osc, context, cluster): try: - # The bay which is upgraded from Liberty doesn't have trust_id - if bay.trust_id: - osc.keystone().delete_trust(context, bay) + # The cluster which is upgraded from Liberty doesn't have trust_id + if cluster.trust_id: + osc.keystone().delete_trust(context, cluster) except Exception: # Exceptions are already logged by keystone().delete_trust pass try: - # The bay which is upgraded from Liberty doesn't have trustee_user_id - if bay.trustee_user_id: - osc.keystone().delete_trustee(bay.trustee_user_id) + # The cluster which is upgraded from Liberty doesn't have + # trustee_user_id + if cluster.trustee_user_id: + osc.keystone().delete_trustee(cluster.trustee_user_id) except Exception: # Exceptions are already logged by keystone().delete_trustee pass diff --git a/magnum/conductor/k8s_api.py b/magnum/conductor/k8s_api.py index 487edf230b..aa036ff419 100644 --- a/magnum/conductor/k8s_api.py +++ b/magnum/conductor/k8s_api.py @@ -41,17 +41,17 @@ class K8sAPI(apiv_api.ApivApi): raise return tmp - def __init__(self, context, bay): + def __init__(self, context, cluster): self.ca_file = None self.cert_file = None self.key_file = None - if bay.magnum_cert_ref: + if cluster.magnum_cert_ref: (self.ca_file, self.key_file, - self.cert_file) = create_client_files(bay, context) + self.cert_file) = create_client_files(cluster, context) # build a connection with Kubernetes master - client = api_client.ApiClient(bay.api_address, + client = api_client.ApiClient(cluster.api_address, key_file=self.key_file.name, cert_file=self.cert_file.name, ca_certs=self.ca_file.name) @@ -67,13 +67,13 @@ class K8sAPI(apiv_api.ApivApi): self.key_file.close() -def create_k8s_api(context, bay): +def create_k8s_api(context, cluster): """Create a kubernetes API client Creates connection with Kubernetes master and creates ApivApi instance to call Kubernetes APIs. :param context: The security context - :param bay: Bay object + :param cluster: Cluster object """ - return K8sAPI(context, bay) + return K8sAPI(context, cluster) diff --git a/magnum/conductor/k8s_monitor.py b/magnum/conductor/k8s_monitor.py index 91b8fd0659..0de63a9688 100644 --- a/magnum/conductor/k8s_monitor.py +++ b/magnum/conductor/k8s_monitor.py @@ -19,8 +19,8 @@ from magnum.conductor import monitors class K8sMonitor(monitors.MonitorBase): - def __init__(self, context, bay): - super(K8sMonitor, self).__init__(context, bay) + def __init__(self, context, cluster): + super(K8sMonitor, self).__init__(context, cluster) self.data = {} self.data['nodes'] = [] self.data['pods'] = [] @@ -39,7 +39,7 @@ class K8sMonitor(monitors.MonitorBase): } def pull_data(self): - k8s_api = k8s.create_k8s_api(self.context, self.bay) + k8s_api = k8s.create_k8s_api(self.context, self.cluster) nodes = k8s_api.list_namespaced_node() self.data['nodes'] = self._parse_node_info(nodes) pods = k8s_api.list_namespaced_pod('default') diff --git a/magnum/conductor/mesos_monitor.py b/magnum/conductor/mesos_monitor.py index 39338d1eeb..a520e2e168 100644 --- a/magnum/conductor/mesos_monitor.py +++ b/magnum/conductor/mesos_monitor.py @@ -18,8 +18,8 @@ from magnum.conductor import monitors class MesosMonitor(monitors.MonitorBase): - def __init__(self, context, bay): - super(MesosMonitor, self).__init__(context, bay) + def __init__(self, context, cluster): + super(MesosMonitor, self).__init__(context, cluster) self.data = {} @property @@ -46,7 +46,7 @@ class MesosMonitor(monitors.MonitorBase): self.data['mem_used'] = 0 self.data['cpu_total'] = 0 self.data['cpu_used'] = 0 - for master_addr in self.bay.master_addresses: + for master_addr in self.cluster.master_addresses: mesos_master_url = self._build_url(master_addr, port='5050', path='/state') master = jsonutils.loads(urlfetch.get(mesos_master_url)) diff --git a/magnum/conductor/monitors.py b/magnum/conductor/monitors.py index 2cf57d1f76..0a8668a98b 100644 --- a/magnum/conductor/monitors.py +++ b/magnum/conductor/monitors.py @@ -34,18 +34,18 @@ CONF.import_opt('default_timeout', group='docker') COE_CLASS_PATH = { - fields.BayType.SWARM: 'magnum.conductor.swarm_monitor.SwarmMonitor', - fields.BayType.KUBERNETES: 'magnum.conductor.k8s_monitor.K8sMonitor', - fields.BayType.MESOS: 'magnum.conductor.mesos_monitor.MesosMonitor' + fields.ClusterType.SWARM: 'magnum.conductor.swarm_monitor.SwarmMonitor', + fields.ClusterType.KUBERNETES: 'magnum.conductor.k8s_monitor.K8sMonitor', + fields.ClusterType.MESOS: 'magnum.conductor.mesos_monitor.MesosMonitor' } @six.add_metaclass(abc.ABCMeta) class MonitorBase(object): - def __init__(self, context, bay): + def __init__(self, context, cluster): self.context = context - self.bay = bay + self.cluster = cluster @abc.abstractproperty def metrics_spec(self): @@ -67,12 +67,12 @@ class MonitorBase(object): return func() -def create_monitor(context, bay): - if bay.cluster_template.coe in COE_CLASS_PATH: +def create_monitor(context, cluster): + if cluster.cluster_template.coe in COE_CLASS_PATH: coe_cls = importutils.import_class( - COE_CLASS_PATH[bay.cluster_template.coe]) - return coe_cls(context, bay) + COE_CLASS_PATH[cluster.cluster_template.coe]) + return coe_cls(context, cluster) - LOG.debug("Cannot create monitor with bay type '%s'", - bay.cluster_template.coe) + LOG.debug("Cannot create monitor with cluster type '%s'", + cluster.cluster_template.coe) return None diff --git a/magnum/conductor/scale_manager.py b/magnum/conductor/scale_manager.py index 72bd448c4e..584eba1366 100644 --- a/magnum/conductor/scale_manager.py +++ b/magnum/conductor/scale_manager.py @@ -27,18 +27,18 @@ LOG = logging.getLogger(__name__) class ScaleManager(object): - def __init__(self, context, osclient, bay): + def __init__(self, context, osclient, cluster): self.context = context self.osclient = osclient - self.old_bay = objects.Bay.get_by_uuid(context, bay.uuid) - self.new_bay = bay + self.old_cluster = objects.Cluster.get_by_uuid(context, cluster.uuid) + self.new_cluster = cluster def get_removal_nodes(self, hosts_output): if not self._is_scale_down(): return list() - bay = self.new_bay - stack = self.osclient.heat().stacks.get(bay.stack_id) + cluster = self.new_cluster + stack = self.osclient.heat().stacks.get(cluster.stack_id) hosts = hosts_output.get_output_value(stack) if hosts is None: raise exception.MagnumException(_( @@ -47,7 +47,7 @@ class ScaleManager(object): 'stack_id': stack.id}) hosts_no_container = list(hosts) - k8s_api = k8s.create_k8s_api(self.context, bay) + k8s_api = k8s.create_k8s_api(self.context, cluster) for pod in k8s_api.list_namespaced_pod(namespace='default').items: host = pod.spec.node_name if host in hosts_no_container: @@ -72,7 +72,7 @@ class ScaleManager(object): return hosts_to_remove def _is_scale_down(self): - return self.new_bay.node_count < self.old_bay.node_count + return self.new_cluster.node_count < self.old_cluster.node_count def _get_num_of_removal(self): - return self.old_bay.node_count - self.new_bay.node_count + return self.old_cluster.node_count - self.new_cluster.node_count diff --git a/magnum/conductor/swarm_monitor.py b/magnum/conductor/swarm_monitor.py index ce7cd84855..6f3f1d96cf 100644 --- a/magnum/conductor/swarm_monitor.py +++ b/magnum/conductor/swarm_monitor.py @@ -24,8 +24,8 @@ LOG = log.getLogger(__name__) class SwarmMonitor(monitors.MonitorBase): - def __init__(self, context, bay): - super(SwarmMonitor, self).__init__(context, bay) + def __init__(self, context, cluster): + super(SwarmMonitor, self).__init__(context, cluster) self.data = {} self.data['nodes'] = [] self.data['containers'] = [] @@ -40,8 +40,8 @@ class SwarmMonitor(monitors.MonitorBase): } def pull_data(self): - with docker_utils.docker_for_bay(self.context, - self.bay) as docker: + with docker_utils.docker_for_cluster(self.context, + self.cluster) as docker: system_info = docker.info() self.data['nodes'] = self._parse_node_info(system_info) diff --git a/magnum/conductor/utils.py b/magnum/conductor/utils.py index fa37d2eebd..f7eb2e7b42 100644 --- a/magnum/conductor/utils.py +++ b/magnum/conductor/utils.py @@ -20,33 +20,33 @@ from pycadf import resource from magnum.common import clients from magnum.common import rpc -from magnum.objects import bay +from magnum.objects import cluster from magnum.objects import cluster_template -def retrieve_bay(context, bay_ident): - if not uuidutils.is_uuid_like(bay_ident): - return bay.Bay.get_by_name(context, bay_ident) +def retrieve_cluster(context, cluster_ident): + if not uuidutils.is_uuid_like(cluster_ident): + return cluster.Cluster.get_by_name(context, cluster_ident) else: - return bay.Bay.get_by_uuid(context, bay_ident) + return cluster.Cluster.get_by_uuid(context, cluster_ident) -def retrieve_cluster_template(context, bay): - return cluster_template.ClusterTemplate.get_by_uuid(context, - bay.baymodel_id) +def retrieve_cluster_template(context, cluster): + return cluster_template.ClusterTemplate.get_by_uuid( + context, cluster.cluster_template_id) -def retrieve_bay_uuid(context, bay_ident): - if not uuidutils.is_uuid_like(bay_ident): - bay_obj = bay.Bay.get_by_name(context, bay_ident) - return bay_obj.uuid +def retrieve_cluster_uuid(context, cluster_ident): + if not uuidutils.is_uuid_like(cluster_ident): + cluster_obj = cluster.Cluster.get_by_name(context, cluster_ident) + return cluster_obj.uuid else: - return bay_ident + return cluster_ident -def object_has_stack(context, bay_uuid): +def object_has_stack(context, cluster_uuid): osc = clients.OpenStackClients(context) - obj = retrieve_bay(context, bay_uuid) + obj = retrieve_cluster(context, cluster_uuid) stack = osc.heat().stacks.get(obj.stack_id) if (stack.stack_status == 'DELETE_COMPLETE' or @@ -86,8 +86,8 @@ def _get_request_audit_info(context): return initiator -def notify_about_bay_operation(context, action, outcome): - """Send a notification about bay operation. +def notify_about_cluster_operation(context, action, outcome): + """Send a notification about cluster operation. :param action: CADF action being audited :param outcome: CADF outcome @@ -98,10 +98,10 @@ def notify_about_bay_operation(context, action, outcome): outcome=outcome, action=action, initiator=_get_request_audit_info(context), - target=resource.Resource(typeURI='service/magnum/bay'), - observer=resource.Resource(typeURI='service/magnum/bay')) + target=resource.Resource(typeURI='service/magnum/cluster'), + observer=resource.Resource(typeURI='service/magnum/cluster')) service = 'magnum' - event_type = '%(service)s.bay.%(action)s' % { + event_type = '%(service)s.cluster.%(action)s' % { 'service': service, 'action': action} payload = event.as_dict() diff --git a/magnum/db/api.py b/magnum/db/api.py index 880d7cdcbe..19b70e32be 100644 --- a/magnum/db/api.py +++ b/magnum/db/api.py @@ -41,17 +41,17 @@ class Connection(object): """Constructor.""" @abc.abstractmethod - def get_bay_list(self, context, filters=None, limit=None, - marker=None, sort_key=None, sort_dir=None): - """Get matching bays. + def get_cluster_list(self, context, filters=None, limit=None, + marker=None, sort_key=None, sort_dir=None): + """Get matching clusters. - Return a list of the specified columns for all bays that match the + Return a list of the specified columns for all clusters that match the specified filters. :param context: The security context :param filters: Filters to apply. Defaults to None. - :param limit: Maximum number of bays to return. + :param limit: Maximum number of clusters 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. @@ -61,12 +61,13 @@ class Connection(object): """ @abc.abstractmethod - def create_bay(self, values): - """Create a new bay. + def create_cluster(self, values): + """Create a new cluster. :param values: A dict containing several items used to identify - and track the bay, and several dicts which are passed - into the Drivers when managing this bay. For example: + and track the cluster, and several dicts which are + passed into the Drivers when managing this cluster. + For example: :: @@ -75,49 +76,49 @@ class Connection(object): 'name': 'example', 'type': 'virt' } - :returns: A bay. + :returns: A cluster. """ @abc.abstractmethod - def get_bay_by_id(self, context, bay_id): - """Return a bay. + def get_cluster_by_id(self, context, cluster_id): + """Return a cluster. :param context: The security context - :param bay_id: The id of a bay. - :returns: A bay. + :param cluster_id: The id of a cluster. + :returns: A cluster. """ @abc.abstractmethod - def get_bay_by_uuid(self, context, bay_uuid): - """Return a bay. + def get_cluster_by_uuid(self, context, cluster_uuid): + """Return a cluster. :param context: The security context - :param bay_uuid: The uuid of a bay. - :returns: A bay. + :param cluster_uuid: The uuid of a cluster. + :returns: A cluster. """ @abc.abstractmethod - def get_bay_by_name(self, context, bay_name): - """Return a bay. + def get_cluster_by_name(self, context, cluster_name): + """Return a cluster. :param context: The security context - :param bay_name: The name of a bay. - :returns: A bay. + :param cluster_name: The name of a cluster. + :returns: A cluster. """ @abc.abstractmethod - def destroy_bay(self, bay_id): - """Destroy a bay and all associated interfaces. + def destroy_cluster(self, cluster_id): + """Destroy a cluster and all associated interfaces. - :param bay_id: The id or uuid of a bay. + :param cluster_id: The id or uuid of a cluster. """ @abc.abstractmethod - def update_bay(self, bay_id, values): - """Update properties of a bay. + def update_cluster(self, cluster_id, values): + """Update properties of a cluster. - :param bay_id: The id or uuid of a bay. - :returns: A bay. + :param cluster_id: The id or uuid of a cluster. + :returns: A cluster. :raises: ClusterNotFound """ diff --git a/magnum/db/sqlalchemy/alembic/versions/720f640f43d1_rename_bay_table_to_cluster.py b/magnum/db/sqlalchemy/alembic/versions/720f640f43d1_rename_bay_table_to_cluster.py new file mode 100644 index 0000000000..2fed785c24 --- /dev/null +++ b/magnum/db/sqlalchemy/alembic/versions/720f640f43d1_rename_bay_table_to_cluster.py @@ -0,0 +1,35 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +"""rename bay table to cluster + +Revision ID: 720f640f43d1 +Revises: fb03fdef8919 +Create Date: 2016-09-02 09:43:41.485934 + +""" + +# revision identifiers, used by Alembic. +revision = '720f640f43d1' +down_revision = 'fb03fdef8919' + +from alembic import op +import sqlalchemy as sa + + +def upgrade(): + op.alter_column('bay', 'baymodel_id', + new_column_name='cluster_template_id', + existing_type=sa.String(255)) + op.alter_column('bay', 'bay_create_timeout', + new_column_name='create_timeout', + existing_type=sa.Integer()) + op.rename_table('bay', 'cluster') diff --git a/magnum/db/sqlalchemy/api.py b/magnum/db/sqlalchemy/api.py index e3ca61bbd3..488474545f 100644 --- a/magnum/db/sqlalchemy/api.py +++ b/magnum/db/sqlalchemy/api.py @@ -120,11 +120,11 @@ class Connection(api.Connection): return query - def _add_bays_filters(self, query, filters): + def _add_clusters_filters(self, query, filters): if filters is None: filters = {} - possible_filters = ["baymodel_id", "name", "node_count", + possible_filters = ["cluster_template_id", "name", "node_count", "master_count", "stack_id", "api_address", "node_addresses", "project_id", "user_id"] @@ -135,91 +135,91 @@ class Connection(api.Connection): query = query.filter_by(**filter_dict) if 'status' in filters: - query = query.filter(models.Bay.status.in_(filters['status'])) + query = query.filter(models.Cluster.status.in_(filters['status'])) return query - def get_bay_list(self, context, filters=None, limit=None, marker=None, - sort_key=None, sort_dir=None): - query = model_query(models.Bay) + def get_cluster_list(self, context, filters=None, limit=None, marker=None, + sort_key=None, sort_dir=None): + query = model_query(models.Cluster) query = self._add_tenant_filters(context, query) - query = self._add_bays_filters(query, filters) - return _paginate_query(models.Bay, limit, marker, + query = self._add_clusters_filters(query, filters) + return _paginate_query(models.Cluster, limit, marker, sort_key, sort_dir, query) - def create_bay(self, values): - # ensure defaults are present for new bays + def create_cluster(self, values): + # ensure defaults are present for new clusters if not values.get('uuid'): values['uuid'] = uuidutils.generate_uuid() - bay = models.Bay() - bay.update(values) + cluster = models.Cluster() + cluster.update(values) try: - bay.save() + cluster.save() except db_exc.DBDuplicateEntry: raise exception.ClusterAlreadyExists(uuid=values['uuid']) - return bay + return cluster - def get_bay_by_id(self, context, bay_id): - query = model_query(models.Bay) + def get_cluster_by_id(self, context, cluster_id): + query = model_query(models.Cluster) query = self._add_tenant_filters(context, query) - query = query.filter_by(id=bay_id) + query = query.filter_by(id=cluster_id) try: return query.one() except NoResultFound: - raise exception.ClusterNotFound(cluster=bay_id) + raise exception.ClusterNotFound(cluster=cluster_id) - def get_bay_by_name(self, context, bay_name): - query = model_query(models.Bay) + def get_cluster_by_name(self, context, cluster_name): + query = model_query(models.Cluster) query = self._add_tenant_filters(context, query) - query = query.filter_by(name=bay_name) + query = query.filter_by(name=cluster_name) try: return query.one() except MultipleResultsFound: - raise exception.Conflict('Multiple bays exist with same name.' - ' Please use the bay uuid instead.') + raise exception.Conflict('Multiple clusters exist with same name.' + ' Please use the cluster uuid instead.') except NoResultFound: - raise exception.ClusterNotFound(cluster=bay_name) + raise exception.ClusterNotFound(cluster=cluster_name) - def get_bay_by_uuid(self, context, bay_uuid): - query = model_query(models.Bay) + def get_cluster_by_uuid(self, context, cluster_uuid): + query = model_query(models.Cluster) query = self._add_tenant_filters(context, query) - query = query.filter_by(uuid=bay_uuid) + query = query.filter_by(uuid=cluster_uuid) try: return query.one() except NoResultFound: - raise exception.ClusterNotFound(cluster=bay_uuid) + raise exception.ClusterNotFound(cluster=cluster_uuid) - def destroy_bay(self, bay_id): + def destroy_cluster(self, cluster_id): session = get_session() with session.begin(): - query = model_query(models.Bay, session=session) - query = add_identity_filter(query, bay_id) + query = model_query(models.Cluster, session=session) + query = add_identity_filter(query, cluster_id) try: query.one() except NoResultFound: - raise exception.ClusterNotFound(cluster=bay_id) + raise exception.ClusterNotFound(cluster=cluster_id) query.delete() - def update_bay(self, bay_id, values): + def update_cluster(self, cluster_id, values): # NOTE(dtantsur): this can lead to very strange errors if 'uuid' in values: - msg = _("Cannot overwrite UUID for an existing Bay.") + msg = _("Cannot overwrite UUID for an existing Cluster.") raise exception.InvalidParameterValue(err=msg) - return self._do_update_bay(bay_id, values) + return self._do_update_cluster(cluster_id, values) - def _do_update_bay(self, bay_id, values): + def _do_update_cluster(self, cluster_id, values): session = get_session() with session.begin(): - query = model_query(models.Bay, session=session) - query = add_identity_filter(query, bay_id) + query = model_query(models.Cluster, session=session) + query = add_identity_filter(query, cluster_id) try: ref = query.with_lockmode('update').one() except NoResultFound: - raise exception.ClusterNotFound(cluster=bay_id) + raise exception.ClusterNotFound(cluster=cluster_id) if 'provision_state' in values: values['provision_updated_at'] = timeutils.utcnow() @@ -309,9 +309,9 @@ class Connection(api.Connection): def _is_cluster_template_referenced(self, session, cluster_template_uuid): """Checks whether the ClusterTemplate is referenced by cluster(s).""" - query = model_query(models.Bay, session=session) - query = self._add_bays_filters(query, {'baymodel_id': - cluster_template_uuid}) + query = model_query(models.Cluster, session=session) + query = self._add_clusters_filters(query, {'cluster_template_id': + cluster_template_uuid}) return query.count() != 0 def _is_publishing_cluster_template(self, values): diff --git a/magnum/db/sqlalchemy/models.py b/magnum/db/sqlalchemy/models.py index d5d64cec64..621fa0ab5d 100644 --- a/magnum/db/sqlalchemy/models.py +++ b/magnum/db/sqlalchemy/models.py @@ -99,10 +99,10 @@ class MagnumBase(models.TimestampMixin, Base = declarative_base(cls=MagnumBase) -class Bay(Base): - """Represents a bay.""" +class Cluster(Base): + """Represents a Cluster.""" - __tablename__ = 'bay' + __tablename__ = 'cluster' __table_args__ = ( schema.UniqueConstraint('uuid', name='uniq_bay0uuid'), table_args() @@ -112,7 +112,7 @@ class Bay(Base): user_id = Column(String(255)) uuid = Column(String(36)) name = Column(String(255)) - baymodel_id = Column(String(255)) + cluster_template_id = Column(String(255)) stack_id = Column(String(255)) api_address = Column(String(255)) node_addresses = Column(JSONEncodedList) @@ -120,7 +120,7 @@ class Bay(Base): master_count = Column(Integer()) status = Column(String(20)) status_reason = Column(Text) - bay_create_timeout = Column(Integer()) + create_timeout = Column(Integer()) discovery_url = Column(String(255)) master_addresses = Column(JSONEncodedList) # TODO(wanghua): encrypt trust_id in db diff --git a/magnum/drivers/common/k8s_template_def.py b/magnum/drivers/common/k8s_template_def.py index a34517dbed..dba44175f3 100644 --- a/magnum/drivers/common/k8s_template_def.py +++ b/magnum/drivers/common/k8s_template_def.py @@ -24,8 +24,8 @@ KUBE_INSECURE_PORT = '8080' class K8sApiAddressOutputMapping(template_def.OutputMapping): - def set_output(self, stack, cluster_template, bay): - if self.bay_attr is None: + def set_output(self, stack, cluster_template, cluster): + if self.cluster_attr is None: return output_value = self.get_output_value(stack) @@ -43,7 +43,7 @@ class K8sApiAddressOutputMapping(template_def.OutputMapping): 'port': port, } value = "%(protocol)s://%(address)s:%(port)s" % params - setattr(bay, self.bay_attr, value) + setattr(cluster, self.cluster_attr, value) class K8sTemplateDefinition(template_def.BaseTemplateDefinition): @@ -56,7 +56,7 @@ class K8sTemplateDefinition(template_def.BaseTemplateDefinition): self.add_parameter('minion_flavor', cluster_template_attr='flavor_id') self.add_parameter('number_of_minions', - bay_attr='node_count') + cluster_attr='node_count') self.add_parameter('external_network', cluster_template_attr='external_network_id', required=True) @@ -69,23 +69,23 @@ class K8sTemplateDefinition(template_def.BaseTemplateDefinition): required=True) self.add_parameter('registry_enabled', cluster_template_attr='registry_enabled') - self.add_parameter('bay_uuid', - bay_attr='uuid', + self.add_parameter('cluster_uuid', + cluster_attr='uuid', param_type=str) self.add_parameter('insecure_registry_url', cluster_template_attr='insecure_registry') self.add_parameter('kube_version', - bay_attr='coe_version') + cluster_attr='coe_version') self.add_output('api_address', - bay_attr='api_address', + cluster_attr='api_address', mapping_type=K8sApiAddressOutputMapping) self.add_output('kube_minions_private', - bay_attr=None) + cluster_attr=None) self.add_output('kube_masters_private', - bay_attr=None) + cluster_attr=None) - def get_params(self, context, cluster_template, bay, **kwargs): + def get_params(self, context, cluster_template, cluster, **kwargs): extra_params = kwargs.pop('extra_params', {}) scale_mgr = kwargs.pop('scale_manager', None) if scale_mgr: @@ -93,7 +93,7 @@ class K8sTemplateDefinition(template_def.BaseTemplateDefinition): extra_params['minions_to_remove'] = ( scale_mgr.get_removal_nodes(hosts)) - extra_params['discovery_url'] = self.get_discovery_url(bay) + extra_params['discovery_url'] = self.get_discovery_url(cluster) osc = self.get_osc(context) extra_params['magnum_url'] = osc.magnum_url() @@ -112,6 +112,6 @@ class K8sTemplateDefinition(template_def.BaseTemplateDefinition): CONF.docker_registry.swift_registry_container) return super(K8sTemplateDefinition, - self).get_params(context, cluster_template, bay, + self).get_params(context, cluster_template, cluster, extra_params=extra_params, **kwargs) diff --git a/magnum/drivers/common/template_def.py b/magnum/drivers/common/template_def.py index 8848341152..d956fbaa3b 100644 --- a/magnum/drivers/common/template_def.py +++ b/magnum/drivers/common/template_def.py @@ -62,37 +62,37 @@ CONF.import_opt('trustee_domain_id', 'magnum.common.keystone', group='trust') class ParameterMapping(object): - """A mapping associating heat param and bay/cluster_template attr. + """A mapping associating heat param and cluster_template attr. A ParameterMapping is an association of a Heat parameter name with - an attribute on a Bay, ClusterTemplate, or both. + an attribute on a Cluster, ClusterTemplate, or both. - In the case of both cluster_template_attr and bay_attr being set, the - ClusterTemplate will be checked first and then Bay if the attribute isn't - set on the ClusterTemplate. + In the case of both cluster_template_attr and cluster_attr being set, the + ClusterTemplate will be checked first and then Cluster if the attribute + isn't set on the ClusterTemplate. Parameters can also be set as 'required'. If a required parameter isn't set, a RequiredArgumentNotProvided exception will be raised. """ def __init__(self, heat_param, cluster_template_attr=None, - bay_attr=None, required=False, + cluster_attr=None, required=False, param_type=lambda x: x): self.heat_param = heat_param self.cluster_template_attr = cluster_template_attr - self.bay_attr = bay_attr + self.cluster_attr = cluster_attr self.required = required self.param_type = param_type - def set_param(self, params, cluster_template, bay): + def set_param(self, params, cluster_template, cluster): value = None if (self.cluster_template_attr and getattr(cluster_template, self.cluster_template_attr, None) is not None): value = getattr(cluster_template, self.cluster_template_attr) - elif (self.bay_attr and - getattr(bay, self.bay_attr, None) is not None): - value = getattr(bay, self.bay_attr) + elif (self.cluster_attr and + getattr(cluster, self.cluster_attr, None) is not None): + value = getattr(cluster, self.cluster_attr) elif self.required: kwargs = dict(heat_param=self.heat_param) raise exception.RequiredParameterNotProvided(**kwargs) @@ -103,23 +103,23 @@ class ParameterMapping(object): class OutputMapping(object): - """A mapping associating heat outputs and bay attr. + """A mapping associating heat outputs and cluster attr. An OutputMapping is an association of a Heat output with a key Magnum understands. """ - def __init__(self, heat_output, bay_attr=None): - self.bay_attr = bay_attr + def __init__(self, heat_output, cluster_attr=None): + self.cluster_attr = cluster_attr self.heat_output = heat_output - def set_output(self, stack, cluster_template, bay): - if self.bay_attr is None: + def set_output(self, stack, cluster_template, cluster): + if self.cluster_attr is None: return output_value = self.get_output_value(stack) if output_value is not None: - setattr(bay, self.bay_attr, output_value) + setattr(cluster, self.cluster_attr, output_value) def matched(self, output_key): return self.heat_output == output_key @@ -155,7 +155,7 @@ class TemplateDefinition(object): @classmethod def get_template_definitions(cls): - '''Retrieves bay definitions from python entry_points. + '''Retrieves cluster definitions from python entry_points. Example: @@ -190,11 +190,11 @@ class TemplateDefinition(object): if not cls.definitions: cls.definitions = dict() for entry_point, def_class in cls.load_entry_points(): - for bay_type in def_class.provides: - bay_type_tuple = (bay_type['server_type'], - bay_type['os'], - bay_type['coe']) - providers = cls.definitions.setdefault(bay_type_tuple, + for cluster_type in def_class.provides: + cluster_type_tuple = (cluster_type['server_type'], + cluster_type['os'], + cluster_type['coe']) + providers = cls.definitions.setdefault(cluster_type_tuple, dict()) providers[entry_point.name] = def_class @@ -205,7 +205,7 @@ class TemplateDefinition(object): '''Get enabled TemplateDefinitions. Returns the enabled TemplateDefinition class for the provided - bay_type. + cluster_type. With the following classes: class TemplateDefinition1(TemplateDefinition): @@ -227,30 +227,30 @@ class TemplateDefinition(object): get_template_name_1_definition('server_type2', 'os2', 'coe2') will return: TemplateDefinition2 - :param server_type: The server_type the bay definition + :param server_type: The server_type the cluster definition will build on - :param os: The operating system the bay definition will build on - :param coe: The Container Orchestration Environment the bay will + :param os: The operating system the cluster definition will build on + :param coe: The Container Orchestration Environment the cluster will produce :return: class ''' definition_map = cls.get_template_definitions() - bay_type = (server_type, os, coe) + cluster_type = (server_type, os, coe) - if bay_type not in definition_map: - raise exception.BayTypeNotSupported( + if cluster_type not in definition_map: + raise exception.ClusterTypeNotSupported( server_type=server_type, os=os, coe=coe) - type_definitions = definition_map[bay_type] + type_definitions = definition_map[cluster_type] for name in cfg.CONF.cluster.enabled_definitions: if name in type_definitions: return type_definitions[name]() - raise exception.BayTypeNotEnabled( + raise exception.ClusterTypeNotEnabled( server_type=server_type, os=os, coe=coe) def add_parameter(self, *args, **kwargs): @@ -269,13 +269,13 @@ class TemplateDefinition(object): return None - def get_params(self, context, cluster_template, bay, **kwargs): - """Pulls template parameters from ClusterTemplate and/or Bay. + def get_params(self, context, cluster_template, cluster, **kwargs): + """Pulls template parameters from ClusterTemplate. :param context: Context to pull template parameters for :param cluster_template: ClusterTemplate to pull template parameters from - :param bay: Bay to pull template parameters from + :param cluster: Cluster to pull template parameters from :param extra_params: Any extra params to be provided to the template :return: dict of template parameters @@ -283,7 +283,7 @@ class TemplateDefinition(object): template_params = dict() for mapping in self.param_mappings: - mapping.set_param(template_params, cluster_template, bay) + mapping.set_param(template_params, cluster_template, cluster) if 'extra_params' in kwargs: template_params.update(kwargs.get('extra_params')) @@ -302,26 +302,27 @@ class TemplateDefinition(object): """ return [] - def get_heat_param(self, bay_attr=None, cluster_template_attr=None): + def get_heat_param(self, cluster_attr=None, cluster_template_attr=None): """Returns stack param name. - Return stack param name using bay and cluster_template attributes - :param bay_attr bay attribute from which it maps to stack attribute + Return stack param name using cluster and cluster_template attributes + :param cluster_attr cluster attribute from which it maps to stack + attribute :param cluster_template_attr cluster_template attribute from which it maps to stack attribute :return stack parameter name or None """ for mapping in self.param_mappings: - if (mapping.bay_attr == bay_attr and + if (mapping.cluster_attr == cluster_attr and mapping.cluster_template_attr == cluster_template_attr): return mapping.heat_param return None - def update_outputs(self, stack, cluster_template, bay): + def update_outputs(self, stack, cluster_template, cluster): for output in self.output_mappings: - output.set_output(stack, cluster_template, bay) + output.set_output(stack, cluster_template, cluster) @abc.abstractproperty def driver_module_path(self): @@ -331,9 +332,9 @@ class TemplateDefinition(object): def template_path(self): pass - def extract_definition(self, context, cluster_template, bay, **kwargs): + def extract_definition(self, context, cluster_template, cluster, **kwargs): return (self.template_path, - self.get_params(context, cluster_template, bay, **kwargs), + self.get_params(context, cluster_template, cluster, **kwargs), self.get_env_files(cluster_template)) @@ -356,7 +357,7 @@ class BaseTemplateDefinition(TemplateDefinition): self.add_parameter('no_proxy', cluster_template_attr='no_proxy') self.add_parameter('number_of_masters', - bay_attr='master_count') + cluster_attr='master_count') @property def driver_module_path(self): @@ -371,19 +372,19 @@ class BaseTemplateDefinition(TemplateDefinition): self._osc = clients.OpenStackClients(context) return self._osc - def get_params(self, context, cluster_template, bay, **kwargs): + def get_params(self, context, cluster_template, cluster, **kwargs): osc = self.get_osc(context) extra_params = kwargs.pop('extra_params', {}) extra_params['trustee_domain_id'] = osc.keystone().trustee_domain_id - extra_params['trustee_user_id'] = bay.trustee_user_id - extra_params['trustee_username'] = bay.trustee_username - extra_params['trustee_password'] = bay.trustee_password - extra_params['trust_id'] = bay.trust_id + extra_params['trustee_user_id'] = cluster.trustee_user_id + extra_params['trustee_username'] = cluster.trustee_username + extra_params['trustee_password'] = cluster.trustee_password + extra_params['trust_id'] = cluster.trust_id extra_params['auth_url'] = context.auth_url return super(BaseTemplateDefinition, - self).get_params(context, cluster_template, bay, + self).get_params(context, cluster_template, cluster, extra_params=extra_params, **kwargs) @@ -404,17 +405,17 @@ class BaseTemplateDefinition(TemplateDefinition): try: result = ast.literal_eval(result) except (ValueError, SyntaxError): - raise exception.InvalidBayDiscoveryURL( + raise exception.InvalidClusterDiscoveryURL( discovery_url=discovery_url) node_value = result.get('node', None) if node_value is None: - raise exception.InvalidBayDiscoveryURL( + raise exception.InvalidClusterDiscoveryURL( discovery_url=discovery_url) value = node_value.get('value', None) if value is None: - raise exception.InvalidBayDiscoveryURL( + raise exception.InvalidClusterDiscoveryURL( discovery_url=discovery_url) elif int(value) != expect_size: raise exception.InvalidClusterSize( @@ -422,18 +423,18 @@ class BaseTemplateDefinition(TemplateDefinition): size=int(value), discovery_url=discovery_url) - def get_discovery_url(self, bay): - if hasattr(bay, 'discovery_url') and bay.discovery_url: - if getattr(bay, 'master_count', None) is not None: - self.validate_discovery_url(bay.discovery_url, - bay.master_count) + def get_discovery_url(self, cluster): + if hasattr(cluster, 'discovery_url') and cluster.discovery_url: + if getattr(cluster, 'master_count', None) is not None: + self.validate_discovery_url(cluster.discovery_url, + cluster.master_count) else: - self.validate_discovery_url(bay.discovery_url, 1) - discovery_url = bay.discovery_url + self.validate_discovery_url(cluster.discovery_url, 1) + discovery_url = cluster.discovery_url else: discovery_endpoint = ( cfg.CONF.cluster.etcd_discovery_service_endpoint_format % - {'size': bay.master_count}) + {'size': cluster.master_count}) try: discovery_url = requests.get(discovery_endpoint).text except req_exceptions.RequestException as err: @@ -445,5 +446,5 @@ class BaseTemplateDefinition(TemplateDefinition): discovery_url=discovery_url, discovery_endpoint=discovery_endpoint) else: - bay.discovery_url = discovery_url + cluster.discovery_url = discovery_url return discovery_url diff --git a/magnum/drivers/common/templates/fragments/configure-docker-storage.sh b/magnum/drivers/common/templates/fragments/configure-docker-storage.sh index 5695b184fd..e52dbc5058 100644 --- a/magnum/drivers/common/templates/fragments/configure-docker-storage.sh +++ b/magnum/drivers/common/templates/fragments/configure-docker-storage.sh @@ -33,7 +33,7 @@ $configure_docker_storage_driver if [ "$DOCKER_STORAGE_DRIVER" = "overlay" ]; then if [ $(echo -e "$(uname -r)\n3.18" | sort -V | head -1) \ = $(uname -r) ]; then - ERROR_MESSAGE="OverlayFS requires at least Linux kernel 3.18. Bay node kernel version: $(uname -r)" + ERROR_MESSAGE="OverlayFS requires at least Linux kernel 3.18. Cluster node kernel version: $(uname -r)" echo "ERROR: ${ERROR_MESSAGE}" >&2 sh -c "${WAIT_CURL} --data-binary '{\"status\": \"FAILURE\", \"reason\": \"${ERROR_MESSAGE}\"}'" else diff --git a/magnum/drivers/k8s_coreos_v1/template_def.py b/magnum/drivers/k8s_coreos_v1/template_def.py index 0e96a255af..df65284dd2 100644 --- a/magnum/drivers/k8s_coreos_v1/template_def.py +++ b/magnum/drivers/k8s_coreos_v1/template_def.py @@ -32,9 +32,9 @@ class CoreOSK8sTemplateDefinition(k8s_template_def.K8sTemplateDefinition): def __init__(self): super(CoreOSK8sTemplateDefinition, self).__init__() self.add_output('kube_minions', - bay_attr='node_addresses') + cluster_attr='node_addresses') self.add_output('kube_masters', - bay_attr='master_addresses') + cluster_attr='master_addresses') def get_env_files(self, cluster_template): if cluster_template.master_lb_enabled: diff --git a/magnum/drivers/k8s_coreos_v1/templates/fragments/make-cert-client.yaml b/magnum/drivers/k8s_coreos_v1/templates/fragments/make-cert-client.yaml index ba0a51dc20..3c0da542cb 100644 --- a/magnum/drivers/k8s_coreos_v1/templates/fragments/make-cert-client.yaml +++ b/magnum/drivers/k8s_coreos_v1/templates/fragments/make-cert-client.yaml @@ -85,7 +85,7 @@ write_files: ca_cert_json=$(curl -X GET \ -H "X-Auth-Token: $USER_TOKEN" \ - $MAGNUM_URL/certificates/$BAY_UUID) + $MAGNUM_URL/certificates/$CLUSTER_UUID) parse_json_response "${ca_cert_json}" > ${CA_CERT} # Create config for client's csr @@ -117,7 +117,7 @@ write_files: # encode newline (\n) characters csr=$(cat $CLIENT_CSR | sed -e ':a' -e 'N' -e '$!ba' -e 's/\n/\\n/g') - csr_req="{\"bay_uuid\": \"$BAY_UUID\", \"csr\": \"$csr\"}" + csr_req="{\"cluster_uuid\": \"$CLUSTER_UUID\", \"csr\": \"$csr\"}" # Send csr to Magnum to have it signed client_cert_json=$(curl -X POST \ -H "X-Auth-Token: $USER_TOKEN" \ diff --git a/magnum/drivers/k8s_coreos_v1/templates/fragments/make-cert.yaml b/magnum/drivers/k8s_coreos_v1/templates/fragments/make-cert.yaml index ced17a82ce..196b8941c2 100644 --- a/magnum/drivers/k8s_coreos_v1/templates/fragments/make-cert.yaml +++ b/magnum/drivers/k8s_coreos_v1/templates/fragments/make-cert.yaml @@ -106,10 +106,10 @@ write_files: rm -rf auth.json - # Get CA certificate for this bay + # Get CA certificate for this cluster ca_cert_json=$(curl -X GET \ -H "X-Auth-Token: $USER_TOKEN" \ - $MAGNUM_URL/certificates/$BAY_UUID) + $MAGNUM_URL/certificates/$CLUSTER_UUID) parse_json_response "${ca_cert_json}" > ${CA_CERT} # Create config for server's csr @@ -136,7 +136,7 @@ write_files: # encode newline (\n) characters csr=$(cat $SERVER_CSR | sed -e ':a' -e 'N' -e '$!ba' -e 's/\n/\\n/g') - csr_req="{\"bay_uuid\": \"$BAY_UUID\", \"csr\": \"$csr\"}" + csr_req="{\"cluster_uuid\": \"$CLUSTER_UUID\", \"csr\": \"$csr\"}" # Send csr to Magnum to have it signed server_cert_json=$(curl -X POST \ -H "X-Auth-Token: $USER_TOKEN" \ diff --git a/magnum/drivers/k8s_coreos_v1/templates/fragments/write-heat-params-master.yaml b/magnum/drivers/k8s_coreos_v1/templates/fragments/write-heat-params-master.yaml index 2e00009164..d1875b886a 100644 --- a/magnum/drivers/k8s_coreos_v1/templates/fragments/write-heat-params-master.yaml +++ b/magnum/drivers/k8s_coreos_v1/templates/fragments/write-heat-params-master.yaml @@ -24,7 +24,7 @@ write_files: TENANT_NAME="$TENANT_NAME" CLUSTER_SUBNET="$CLUSTER_SUBNET" TLS_DISABLED="$TLS_DISABLED" - BAY_UUID="$BAY_UUID" + CLUSTER_UUID="$CLUSTER_UUID" MAGNUM_URL="$MAGNUM_URL" HTTP_PROXY="$HTTP_PROXY" HTTPS_PROXY="$HTTPS_PROXY" diff --git a/magnum/drivers/k8s_coreos_v1/templates/fragments/write-heat-params.yaml b/magnum/drivers/k8s_coreos_v1/templates/fragments/write-heat-params.yaml index c9726f447d..254cd93e74 100644 --- a/magnum/drivers/k8s_coreos_v1/templates/fragments/write-heat-params.yaml +++ b/magnum/drivers/k8s_coreos_v1/templates/fragments/write-heat-params.yaml @@ -21,7 +21,7 @@ write_files: REGISTRY_INSECURE="$REGISTRY_INSECURE" REGISTRY_CHUNKSIZE="$REGISTRY_CHUNKSIZE" TLS_DISABLED="$TLS_DISABLED" - BAY_UUID="$BAY_UUID" + CLUSTER_UUID="$CLUSTER_UUID" MAGNUM_URL="$MAGNUM_URL" AUTH_URL="$AUTH_URL" USERNAME="$USERNAME" diff --git a/magnum/drivers/k8s_coreos_v1/templates/kubecluster.yaml b/magnum/drivers/k8s_coreos_v1/templates/kubecluster.yaml index bb94c94076..d4b02b429d 100644 --- a/magnum/drivers/k8s_coreos_v1/templates/kubecluster.yaml +++ b/magnum/drivers/k8s_coreos_v1/templates/kubecluster.yaml @@ -123,9 +123,9 @@ parameters: service. default: 6443 - bay_uuid: + cluster_uuid: type: string - description: identifier for the bay this template is generating + description: identifier for the cluster this template is generating magnum_url: type: string @@ -286,7 +286,7 @@ resources: ###################################################################### # # resources that expose the IPs of either the kube master or a given - # LBaaS pool depending on whether LBaaS is enabled for the bay. + # LBaaS pool depending on whether LBaaS is enabled for the cluster. # api_address_switch: @@ -340,7 +340,7 @@ resources: no_proxy: {get_param: no_proxy} kube_version: {get_param: kube_version} wait_condition_timeout: {get_param: wait_condition_timeout} - bay_uuid: {get_param: bay_uuid} + cluster_uuid: {get_param: cluster_uuid} api_pool_id: {get_resource: api_pool} etcd_pool_id: {get_resource: etcd_pool} magnum_url: {get_param: magnum_url} @@ -384,7 +384,7 @@ resources: kube_version: {get_param: kube_version} etcd_server_ip: {get_attr: [etcd_address_switch, private_ip]} wait_condition_timeout: {get_param: wait_condition_timeout} - bay_uuid: {get_param: bay_uuid} + cluster_uuid: {get_param: cluster_uuid} magnum_url: {get_param: magnum_url} trustee_user_id: {get_param: trustee_user_id} trustee_password: {get_param: trustee_password} diff --git a/magnum/drivers/k8s_coreos_v1/templates/kubemaster.yaml b/magnum/drivers/k8s_coreos_v1/templates/kubemaster.yaml index 721c037e9b..0a9ed07e1f 100644 --- a/magnum/drivers/k8s_coreos_v1/templates/kubemaster.yaml +++ b/magnum/drivers/k8s_coreos_v1/templates/kubemaster.yaml @@ -95,9 +95,9 @@ parameters: type: string description: version of kubernetes used for kubernetes cluster - bay_uuid: + cluster_uuid: type: string - description: identifier for the bay this template is generating + description: identifier for the cluster this template is generating magnum_url: type: string @@ -161,7 +161,7 @@ resources: ###################################################################### # # resource that exposes the IPs of either the kube master or the API - # LBaaS pool depending on whether LBaaS is enabled for the bay. + # LBaaS pool depending on whether LBaaS is enabled for the cluster. # api_address_switch: @@ -237,7 +237,7 @@ resources: "$KUBE_API_PORT": {get_param: kubernetes_port} "$TLS_DISABLED": {get_param: tls_disabled} "$KUBE_VERSION": {get_param: kube_version} - "$BAY_UUID": {get_param: bay_uuid} + "$CLUSTER_UUID": {get_param: cluster_uuid} "$MAGNUM_URL": {get_param: magnum_url} "$HTTP_PROXY": {get_param: http_proxy} "$HTTPS_PROXY": {get_param: https_proxy} diff --git a/magnum/drivers/k8s_coreos_v1/templates/kubeminion.yaml b/magnum/drivers/k8s_coreos_v1/templates/kubeminion.yaml index 993fb69066..305ee00aa9 100644 --- a/magnum/drivers/k8s_coreos_v1/templates/kubeminion.yaml +++ b/magnum/drivers/k8s_coreos_v1/templates/kubeminion.yaml @@ -45,9 +45,9 @@ parameters: service. default: 6443 - bay_uuid: + cluster_uuid: type: string - description: identifier for the bay this template is generating + description: identifier for the cluster this template is generating magnum_url: type: string @@ -165,7 +165,7 @@ resources: "$NETWORK_DRIVER": {get_param: network_driver} "$ETCD_SERVER_IP": {get_param: etcd_server_ip} "$KUBE_VERSION": {get_param: kube_version} - "$BAY_UUID": {get_param: bay_uuid} + "$CLUSTER_UUID": {get_param: cluster_uuid} "$MAGNUM_URL": {get_param: magnum_url} "$HTTP_PROXY": {get_param: http_proxy} "$HTTPS_PROXY": {get_param: https_proxy} diff --git a/magnum/drivers/k8s_fedora_atomic_v1/template_def.py b/magnum/drivers/k8s_fedora_atomic_v1/template_def.py index 6ee5a6cef2..ad9db4bf4c 100644 --- a/magnum/drivers/k8s_fedora_atomic_v1/template_def.py +++ b/magnum/drivers/k8s_fedora_atomic_v1/template_def.py @@ -32,17 +32,17 @@ class ServerAddressOutputMapping(template_def.OutputMapping): public_ip_output_key = None private_ip_output_key = None - def __init__(self, dummy_arg, bay_attr=None): - self.bay_attr = bay_attr + def __init__(self, dummy_arg, cluster_attr=None): + self.cluster_attr = cluster_attr self.heat_output = self.public_ip_output_key - def set_output(self, stack, cluster_template, bay): + def set_output(self, stack, cluster_template, cluster): if not cluster_template.floating_ip_enabled: self.heat_output = self.private_ip_output_key LOG.debug("Using heat_output: %s", self.heat_output) super(ServerAddressOutputMapping, - self).set_output(stack, cluster_template, bay) + self).set_output(stack, cluster_template, cluster) class MasterAddressOutputMapping(ServerAddressOutputMapping): @@ -71,13 +71,13 @@ class AtomicK8sTemplateDefinition(k8s_template_def.K8sTemplateDefinition): self.add_parameter('docker_storage_driver', cluster_template_attr='docker_storage_driver') self.add_output('kube_minions', - bay_attr='node_addresses', + cluster_attr='node_addresses', mapping_type=NodeAddressOutputMapping) self.add_output('kube_masters', - bay_attr='master_addresses', + cluster_attr='master_addresses', mapping_type=MasterAddressOutputMapping) - def get_params(self, context, cluster_template, bay, **kwargs): + def get_params(self, context, cluster_template, cluster, **kwargs): extra_params = kwargs.pop('extra_params', {}) extra_params['username'] = context.user_name @@ -86,7 +86,7 @@ class AtomicK8sTemplateDefinition(k8s_template_def.K8sTemplateDefinition): extra_params['region_name'] = osc.cinder_region_name() return super(AtomicK8sTemplateDefinition, - self).get_params(context, cluster_template, bay, + self).get_params(context, cluster_template, cluster, extra_params=extra_params, **kwargs) @@ -156,14 +156,14 @@ class FedoraK8sIronicTemplateDefinition(AtomicK8sTemplateDefinition): return subnet['network_id'] - def get_params(self, context, cluster_template, bay, **kwargs): + def get_params(self, context, cluster_template, cluster, **kwargs): ep = kwargs.pop('extra_params', {}) osc = self.get_osc(context) ep['fixed_network'] = self.get_fixed_network_id(osc, cluster_template) return super(FedoraK8sIronicTemplateDefinition, - self).get_params(context, cluster_template, bay, + self).get_params(context, cluster_template, cluster, extra_params=ep, **kwargs) diff --git a/magnum/drivers/k8s_fedora_atomic_v1/templates/fragments/make-cert-client.sh b/magnum/drivers/k8s_fedora_atomic_v1/templates/fragments/make-cert-client.sh index 68fba9ceff..d19d8c2744 100644 --- a/magnum/drivers/k8s_fedora_atomic_v1/templates/fragments/make-cert-client.sh +++ b/magnum/drivers/k8s_fedora_atomic_v1/templates/fragments/make-cert-client.sh @@ -67,10 +67,10 @@ url="$AUTH_URL/auth/tokens" USER_TOKEN=`curl -s -i -X POST -H "$content_type" -d "$auth_json" $url \ | grep X-Subject-Token | awk '{print $2}' | tr -d '[[:space:]]'` -# Get CA certificate for this bay +# Get CA certificate for this cluster curl -X GET \ -H "X-Auth-Token: $USER_TOKEN" \ - $MAGNUM_URL/certificates/$BAY_UUID | python -c 'import sys, json; print json.load(sys.stdin)["pem"]' > $CA_CERT + $MAGNUM_URL/certificates/$CLUSTER_UUID | python -c 'import sys, json; print json.load(sys.stdin)["pem"]' > $CA_CERT # Create config for client's csr cat > ${cert_conf_dir}/client.conf < ${CA_CERT} + $MAGNUM_URL/certificates/$CLUSTER_UUID | python -c 'import sys, json; print json.load(sys.stdin)["pem"]' > ${CA_CERT} # Create config for server's csr cat > ${cert_conf_dir}/server.conf < 0: mock_create_k8s_api.assert_called_once_with(mock_context, - mock_bay) + mock_cluster) - @mock.patch('magnum.objects.Bay.get_by_uuid') + @mock.patch('magnum.objects.Cluster.get_by_uuid') @mock.patch('magnum.conductor.scale_manager.ScaleManager._is_scale_down') @mock.patch('magnum.conductor.scale_manager.ScaleManager.' '_get_num_of_removal') @@ -82,7 +82,7 @@ class TestScaleManager(base.TestCase): mock_get_by_uuid, is_scale_down, num_of_removal, hosts, pods, expected_removal_hosts) - @mock.patch('magnum.objects.Bay.get_by_uuid') + @mock.patch('magnum.objects.Cluster.get_by_uuid') @mock.patch('magnum.conductor.scale_manager.ScaleManager._is_scale_down') @mock.patch('magnum.conductor.scale_manager.ScaleManager.' '_get_num_of_removal') @@ -101,7 +101,7 @@ class TestScaleManager(base.TestCase): mock_get_by_uuid, is_scale_down, num_of_removal, hosts, pods, expected_removal_hosts) - @mock.patch('magnum.objects.Bay.get_by_uuid') + @mock.patch('magnum.objects.Cluster.get_by_uuid') @mock.patch('magnum.conductor.scale_manager.ScaleManager._is_scale_down') @mock.patch('magnum.conductor.scale_manager.ScaleManager.' '_get_num_of_removal') @@ -120,7 +120,7 @@ class TestScaleManager(base.TestCase): mock_get_by_uuid, is_scale_down, num_of_removal, hosts, pods, expected_removal_hosts) - @mock.patch('magnum.objects.Bay.get_by_uuid') + @mock.patch('magnum.objects.Cluster.get_by_uuid') @mock.patch('magnum.conductor.scale_manager.ScaleManager._is_scale_down') @mock.patch('magnum.conductor.scale_manager.ScaleManager.' '_get_num_of_removal') @@ -139,7 +139,7 @@ class TestScaleManager(base.TestCase): mock_get_by_uuid, is_scale_down, num_of_removal, hosts, pods, expected_removal_hosts) - @mock.patch('magnum.objects.Bay.get_by_uuid') + @mock.patch('magnum.objects.Cluster.get_by_uuid') @mock.patch('magnum.conductor.scale_manager.ScaleManager._is_scale_down') @mock.patch('magnum.conductor.scale_manager.ScaleManager.' '_get_num_of_removal') @@ -158,7 +158,7 @@ class TestScaleManager(base.TestCase): mock_get_by_uuid, is_scale_down, num_of_removal, hosts, pods, expected_removal_hosts) - @mock.patch('magnum.objects.Bay.get_by_uuid') + @mock.patch('magnum.objects.Cluster.get_by_uuid') @mock.patch('magnum.conductor.scale_manager.ScaleManager._is_scale_down') @mock.patch('magnum.conductor.scale_manager.ScaleManager.' '_get_num_of_removal') diff --git a/magnum/tests/unit/conductor/test_utils.py b/magnum/tests/unit/conductor/test_utils.py index efe43ca473..95e712b421 100644 --- a/magnum/tests/unit/conductor/test_utils.py +++ b/magnum/tests/unit/conductor/test_utils.py @@ -22,11 +22,12 @@ from magnum.tests import base class TestConductorUtils(base.TestCase): - def _test_retrieve_bay(self, expected_bay_uuid, mock_bay_get_by_uuid): + def _test_retrieve_cluster(self, expected_cluster_uuid, + mock_cluster_get_by_uuid): expected_context = 'context' - utils.retrieve_bay(expected_context, expected_bay_uuid) - mock_bay_get_by_uuid.assert_called_once_with(expected_context, - expected_bay_uuid) + utils.retrieve_cluster(expected_context, expected_cluster_uuid) + mock_cluster_get_by_uuid.assert_called_once_with( + expected_context, expected_cluster_uuid) def get_fake_id(self): return '5d12f6fd-a196-4bf0-ae4c-1f639a523a52' @@ -40,38 +41,39 @@ class TestConductorUtils(base.TestCase): expected_context = 'context' expected_cluster_template_uuid = 'ClusterTemplate_uuid' - bay = objects.Bay({}) - bay.baymodel_id = expected_cluster_template_uuid + cluster = objects.Cluster({}) + cluster.cluster_template_id = expected_cluster_template_uuid - utils.retrieve_cluster_template(expected_context, bay) + utils.retrieve_cluster_template(expected_context, cluster) mock_cluster_template_get_by_uuid.assert_called_once_with( expected_context, expected_cluster_template_uuid) @patch('oslo_utils.uuidutils.is_uuid_like') - @patch('magnum.objects.Bay.get_by_name') - def test_retrieve_bay_uuid_from_name(self, mock_bay_get_by_name, - mock_uuid_like): - bay = objects.Bay(uuid='5d12f6fd-a196-4bf0-ae4c-1f639a523a52') + @patch('magnum.objects.Cluster.get_by_name') + def test_retrieve_cluster_uuid_from_name(self, mock_cluster_get_by_name, + mock_uuid_like): + cluster = objects.Cluster(uuid='5d12f6fd-a196-4bf0-ae4c-1f639a523a52') mock_uuid_like.return_value = False - mock_bay_get_by_name.return_value = bay - bay_uuid = utils.retrieve_bay_uuid('context', 'fake_name') - self.assertEqual('5d12f6fd-a196-4bf0-ae4c-1f639a523a52', bay_uuid) + mock_cluster_get_by_name.return_value = cluster + cluster_uuid = utils.retrieve_cluster_uuid('context', 'fake_name') + self.assertEqual('5d12f6fd-a196-4bf0-ae4c-1f639a523a52', cluster_uuid) mock_uuid_like.assert_called_once_with('fake_name') - mock_bay_get_by_name.assert_called_once_with('context', 'fake_name') + mock_cluster_get_by_name.assert_called_once_with('context', + 'fake_name') @patch('oslo_utils.uuidutils.is_uuid_like') - @patch('magnum.objects.Bay.get_by_name') - def test_retrieve_bay_uuid_from_uuid(self, mock_bay_get_by_name, - mock_uuid_like): - bay_uuid = utils.retrieve_bay_uuid( + @patch('magnum.objects.Cluster.get_by_name') + def test_retrieve_cluster_uuid_from_uuid(self, mock_cluster_get_by_name, + mock_uuid_like): + cluster_uuid = utils.retrieve_cluster_uuid( 'context', '5d12f6fd-a196-4bf0-ae4c-1f639a523a52') - self.assertEqual('5d12f6fd-a196-4bf0-ae4c-1f639a523a52', bay_uuid) + self.assertEqual('5d12f6fd-a196-4bf0-ae4c-1f639a523a52', cluster_uuid) mock_uuid_like.return_value = True - mock_bay_get_by_name.assert_not_called() + mock_cluster_get_by_name.assert_not_called() def _get_heat_stacks_get_mock_obj(self, status): mock_stack = mock.MagicMock() @@ -84,45 +86,46 @@ class TestConductorUtils(base.TestCase): mock_osc.heat.return_value = mock_stack return mock_osc - @patch('magnum.conductor.utils.retrieve_bay') + @patch('magnum.conductor.utils.retrieve_cluster') @patch('magnum.conductor.utils.clients.OpenStackClients') def test_object_has_stack_invalid_status(self, mock_oscs, - mock_retrieve_bay): + mock_retrieve_cluster): mock_osc = self._get_heat_stacks_get_mock_obj("INVALID_STATUS") mock_oscs.return_value = mock_osc self.assertTrue(utils.object_has_stack('context', self.get_fake_id())) - mock_retrieve_bay.assert_called_with('context', self.get_fake_id()) + mock_retrieve_cluster.assert_called_with('context', self.get_fake_id()) - @patch('magnum.conductor.utils.retrieve_bay') + @patch('magnum.conductor.utils.retrieve_cluster') @patch('magnum.conductor.utils.clients.OpenStackClients') def test_object_has_stack_delete_in_progress(self, mock_oscs, - mock_retrieve_bay): + mock_retrieve_cluster): mock_osc = self._get_heat_stacks_get_mock_obj("DELETE_IN_PROGRESS") mock_oscs.return_value = mock_osc self.assertFalse(utils.object_has_stack('context', self.get_fake_id())) - mock_retrieve_bay.assert_called_with('context', self.get_fake_id()) + mock_retrieve_cluster.assert_called_with('context', self.get_fake_id()) - @patch('magnum.conductor.utils.retrieve_bay') + @patch('magnum.conductor.utils.retrieve_cluster') @patch('magnum.conductor.utils.clients.OpenStackClients') def test_object_has_stack_delete_complete_status(self, mock_oscs, - mock_retrieve_bay): + mock_retrieve_cluster): mock_osc = self._get_heat_stacks_get_mock_obj("DELETE_COMPLETE") mock_oscs.return_value = mock_osc self.assertFalse(utils.object_has_stack('context', self.get_fake_id())) - mock_retrieve_bay.assert_called_with('context', self.get_fake_id()) + mock_retrieve_cluster.assert_called_with('context', self.get_fake_id()) - @patch('magnum.objects.Bay.get_by_uuid') - def test_retrieve_bay_uuid(self, mock_get_by_uuid): + @patch('magnum.objects.Cluster.get_by_uuid') + def test_retrieve_cluster_uuid(self, mock_get_by_uuid): mock_get_by_uuid.return_value = True - utils.retrieve_bay('context', '5d12f6fd-a196-4bf0-ae4c-1f639a523a52') + utils.retrieve_cluster('context', + '5d12f6fd-a196-4bf0-ae4c-1f639a523a52') self.assertTrue(mock_get_by_uuid.called) - @patch('magnum.objects.Bay.get_by_name') - def test_retrieve_bay_name(self, mock_get_by_name): + @patch('magnum.objects.Cluster.get_by_name') + def test_retrieve_cluster_name(self, mock_get_by_name): mock_get_by_name.return_value = mock.MagicMock() - utils.retrieve_bay('context', '1') + utils.retrieve_cluster('context', '1') self.assertTrue(mock_get_by_name.called) @patch('magnum.conductor.utils.resource.Resource') diff --git a/magnum/tests/unit/db/sqlalchemy/test_types.py b/magnum/tests/unit/db/sqlalchemy/test_types.py index 1b65f99c60..f0dfe24d9e 100644 --- a/magnum/tests/unit/db/sqlalchemy/test_types.py +++ b/magnum/tests/unit/db/sqlalchemy/test_types.py @@ -45,25 +45,25 @@ class SqlAlchemyCustomTypesTestCase(base.DbTestCase): ['this is not a dict']}) def test_JSONEncodedList_default_value(self): - # Create bay w/o master_addresses - bay1_id = uuidutils.generate_uuid() - self.dbapi.create_bay({'uuid': bay1_id}) - bay1 = sa_api.model_query( - models.Bay).filter_by(uuid=bay1_id).one() - self.assertEqual([], bay1.master_addresses) + # Create cluster w/o master_addresses + cluster1_id = uuidutils.generate_uuid() + self.dbapi.create_cluster({'uuid': cluster1_id}) + cluster1 = sa_api.model_query( + models.Cluster).filter_by(uuid=cluster1_id).one() + self.assertEqual([], cluster1.master_addresses) - # Create bay with master_addresses - bay2_id = uuidutils.generate_uuid() - self.dbapi.create_bay({'uuid': bay2_id, - 'master_addresses': ['mymaster_address1', - 'mymaster_address2']}) - bay2 = sa_api.model_query( - models.Bay).filter_by(uuid=bay2_id).one() + # Create cluster with master_addresses + cluster2_id = uuidutils.generate_uuid() + self.dbapi.create_cluster({'uuid': cluster2_id, + 'master_addresses': ['mymaster_address1', + 'mymaster_address2']}) + cluster2 = sa_api.model_query( + models.Cluster).filter_by(uuid=cluster2_id).one() self.assertEqual(['mymaster_address1', 'mymaster_address2'], - bay2.master_addresses) + cluster2.master_addresses) def test_JSONEncodedList_type_check(self): self.assertRaises(db_exc.DBError, - self.dbapi.create_bay, + self.dbapi.create_cluster, {'master_addresses': {'this is not a list': 'test'}}) diff --git a/magnum/tests/unit/db/test_bay.py b/magnum/tests/unit/db/test_bay.py deleted file mode 100644 index 76c9eaf0ae..0000000000 --- a/magnum/tests/unit/db/test_bay.py +++ /dev/null @@ -1,214 +0,0 @@ -# Copyright 2015 OpenStack Foundation -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -"""Tests for manipulating Bays via the DB API""" -from oslo_utils import uuidutils -import six - -from magnum.common import context -from magnum.common import exception -from magnum.objects.fields import BayStatus as bay_status -from magnum.tests.unit.db import base -from magnum.tests.unit.db import utils - - -class DbBayTestCase(base.DbTestCase): - - def test_create_bay(self): - utils.create_test_bay() - - def test_create_bay_nullable_baymodel_id(self): - utils.create_test_bay(baymodel_id=None) - - def test_create_bay_already_exists(self): - utils.create_test_bay() - self.assertRaises(exception.ClusterAlreadyExists, - utils.create_test_bay) - - def test_get_bay_by_id(self): - bay = utils.create_test_bay() - res = self.dbapi.get_bay_by_id(self.context, bay.id) - self.assertEqual(bay.id, res.id) - self.assertEqual(bay.uuid, res.uuid) - - def test_get_bay_by_name(self): - bay = utils.create_test_bay() - res = self.dbapi.get_bay_by_name(self.context, bay.name) - self.assertEqual(bay.name, res.name) - self.assertEqual(bay.uuid, res.uuid) - - def test_get_bay_by_uuid(self): - bay = utils.create_test_bay() - res = self.dbapi.get_bay_by_uuid(self.context, bay.uuid) - self.assertEqual(bay.id, res.id) - self.assertEqual(bay.uuid, res.uuid) - - def test_get_bay_that_does_not_exist(self): - self.assertRaises(exception.ClusterNotFound, - self.dbapi.get_bay_by_id, - self.context, 999) - self.assertRaises(exception.ClusterNotFound, - self.dbapi.get_bay_by_uuid, - self.context, - '12345678-9999-0000-aaaa-123456789012') - - def test_get_bay_list(self): - uuids = [] - for i in range(1, 6): - bay = utils.create_test_bay(uuid=uuidutils.generate_uuid()) - uuids.append(six.text_type(bay['uuid'])) - res = self.dbapi.get_bay_list(self.context) - res_uuids = [r.uuid for r in res] - self.assertEqual(sorted(uuids), sorted(res_uuids)) - - def test_get_bay_list_sorted(self): - uuids = [] - for _ in range(5): - bay = utils.create_test_bay(uuid=uuidutils.generate_uuid()) - uuids.append(six.text_type(bay.uuid)) - res = self.dbapi.get_bay_list(self.context, sort_key='uuid') - res_uuids = [r.uuid for r in res] - self.assertEqual(sorted(uuids), res_uuids) - - self.assertRaises(exception.InvalidParameterValue, - self.dbapi.get_bay_list, - self.context, - sort_key='foo') - - def test_get_bay_list_with_filters(self): - ct1 = utils.get_test_cluster_template(id=1, - uuid=uuidutils.generate_uuid()) - ct2 = utils.get_test_cluster_template(id=2, - uuid=uuidutils.generate_uuid()) - self.dbapi.create_cluster_template(ct1) - self.dbapi.create_cluster_template(ct2) - - bay1 = utils.create_test_bay( - name='bay-one', - uuid=uuidutils.generate_uuid(), - baymodel_id=ct1['uuid'], - status=bay_status.CREATE_IN_PROGRESS) - bay2 = utils.create_test_bay( - name='bay-two', - uuid=uuidutils.generate_uuid(), - baymodel_id=ct2['uuid'], - node_count=1, - master_count=1, - status=bay_status.UPDATE_IN_PROGRESS) - bay3 = utils.create_test_bay( - name='bay-three', - node_count=2, - master_count=5, - status=bay_status.DELETE_IN_PROGRESS) - - res = self.dbapi.get_bay_list(self.context, - filters={'baymodel_id': ct1['uuid']}) - self.assertEqual([bay1.id], [r.id for r in res]) - - res = self.dbapi.get_bay_list(self.context, - filters={'baymodel_id': ct2['uuid']}) - self.assertEqual([bay2.id], [r.id for r in res]) - - res = self.dbapi.get_bay_list(self.context, - filters={'name': 'bay-one'}) - self.assertEqual([bay1.id], [r.id for r in res]) - - res = self.dbapi.get_bay_list(self.context, - filters={'name': 'bad-bay'}) - self.assertEqual([], [r.id for r in res]) - - res = self.dbapi.get_bay_list(self.context, - filters={'node_count': 3}) - self.assertEqual([bay1.id], [r.id for r in res]) - - res = self.dbapi.get_bay_list(self.context, - filters={'node_count': 1}) - self.assertEqual([bay2.id], [r.id for r in res]) - - res = self.dbapi.get_bay_list(self.context, - filters={'master_count': 3}) - self.assertEqual([bay1.id], [r.id for r in res]) - - res = self.dbapi.get_bay_list(self.context, - filters={'master_count': 1}) - self.assertEqual([bay2.id], [r.id for r in res]) - - filters = {'status': [bay_status.CREATE_IN_PROGRESS, - bay_status.DELETE_IN_PROGRESS]} - res = self.dbapi.get_bay_list(self.context, - filters=filters) - self.assertEqual([bay1.id, bay3.id], [r.id for r in res]) - - def test_get_bay_list_by_admin_all_tenants(self): - uuids = [] - for i in range(1, 6): - bay = utils.create_test_bay( - uuid=uuidutils.generate_uuid(), - project_id=uuidutils.generate_uuid(), - user_id=uuidutils.generate_uuid()) - uuids.append(six.text_type(bay['uuid'])) - ctx = context.make_admin_context(all_tenants=True) - res = self.dbapi.get_bay_list(ctx) - res_uuids = [r.uuid for r in res] - self.assertEqual(sorted(uuids), sorted(res_uuids)) - - def test_get_bay_list_baymodel_not_exist(self): - utils.create_test_bay() - self.assertEqual(1, len(self.dbapi.get_bay_list(self.context))) - res = self.dbapi.get_bay_list(self.context, filters={ - 'baymodel_id': uuidutils.generate_uuid()}) - self.assertEqual(0, len(res)) - - def test_destroy_bay(self): - bay = utils.create_test_bay() - self.assertIsNotNone(self.dbapi.get_bay_by_id(self.context, - bay.id)) - self.dbapi.destroy_bay(bay.id) - self.assertRaises(exception.ClusterNotFound, - self.dbapi.get_bay_by_id, - self.context, bay.id) - - def test_destroy_bay_by_uuid(self): - bay = utils.create_test_bay() - self.assertIsNotNone(self.dbapi.get_bay_by_uuid(self.context, - bay.uuid)) - self.dbapi.destroy_bay(bay.uuid) - self.assertRaises(exception.ClusterNotFound, - self.dbapi.get_bay_by_uuid, self.context, - bay.uuid) - - def test_destroy_bay_that_does_not_exist(self): - self.assertRaises(exception.ClusterNotFound, - self.dbapi.destroy_bay, - '12345678-9999-0000-aaaa-123456789012') - - def test_update_bay(self): - bay = utils.create_test_bay() - old_nc = bay.node_count - new_nc = 5 - self.assertNotEqual(old_nc, new_nc) - res = self.dbapi.update_bay(bay.id, {'node_count': new_nc}) - self.assertEqual(new_nc, res.node_count) - - def test_update_bay_not_found(self): - bay_uuid = uuidutils.generate_uuid() - self.assertRaises(exception.ClusterNotFound, self.dbapi.update_bay, - bay_uuid, {'node_count': 5}) - - def test_update_bay_uuid(self): - bay = utils.create_test_bay() - self.assertRaises(exception.InvalidParameterValue, - self.dbapi.update_bay, bay.id, - {'uuid': ''}) diff --git a/magnum/tests/unit/db/test_cluster.py b/magnum/tests/unit/db/test_cluster.py new file mode 100644 index 0000000000..0111455834 --- /dev/null +++ b/magnum/tests/unit/db/test_cluster.py @@ -0,0 +1,214 @@ +# Copyright 2015 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +"""Tests for manipulating Clusters via the DB API""" +from oslo_utils import uuidutils +import six + +from magnum.common import context +from magnum.common import exception +from magnum.objects.fields import ClusterStatus as cluster_status +from magnum.tests.unit.db import base +from magnum.tests.unit.db import utils + + +class DbClusterTestCase(base.DbTestCase): + + def test_create_cluster(self): + utils.create_test_cluster() + + def test_create_cluster_nullable_cluster_template_id(self): + utils.create_test_cluster(cluster_template_id=None) + + def test_create_cluster_already_exists(self): + utils.create_test_cluster() + self.assertRaises(exception.ClusterAlreadyExists, + utils.create_test_cluster) + + def test_get_cluster_by_id(self): + cluster = utils.create_test_cluster() + res = self.dbapi.get_cluster_by_id(self.context, cluster.id) + self.assertEqual(cluster.id, res.id) + self.assertEqual(cluster.uuid, res.uuid) + + def test_get_cluster_by_name(self): + cluster = utils.create_test_cluster() + res = self.dbapi.get_cluster_by_name(self.context, cluster.name) + self.assertEqual(cluster.name, res.name) + self.assertEqual(cluster.uuid, res.uuid) + + def test_get_cluster_by_uuid(self): + cluster = utils.create_test_cluster() + res = self.dbapi.get_cluster_by_uuid(self.context, cluster.uuid) + self.assertEqual(cluster.id, res.id) + self.assertEqual(cluster.uuid, res.uuid) + + def test_get_cluster_that_does_not_exist(self): + self.assertRaises(exception.ClusterNotFound, + self.dbapi.get_cluster_by_id, + self.context, 999) + self.assertRaises(exception.ClusterNotFound, + self.dbapi.get_cluster_by_uuid, + self.context, + '12345678-9999-0000-aaaa-123456789012') + + def test_get_cluster_list(self): + uuids = [] + for i in range(1, 6): + cluster = utils.create_test_cluster(uuid=uuidutils.generate_uuid()) + uuids.append(six.text_type(cluster['uuid'])) + res = self.dbapi.get_cluster_list(self.context) + res_uuids = [r.uuid for r in res] + self.assertEqual(sorted(uuids), sorted(res_uuids)) + + def test_get_cluster_list_sorted(self): + uuids = [] + for _ in range(5): + cluster = utils.create_test_cluster(uuid=uuidutils.generate_uuid()) + uuids.append(six.text_type(cluster.uuid)) + res = self.dbapi.get_cluster_list(self.context, sort_key='uuid') + res_uuids = [r.uuid for r in res] + self.assertEqual(sorted(uuids), res_uuids) + + self.assertRaises(exception.InvalidParameterValue, + self.dbapi.get_cluster_list, + self.context, + sort_key='foo') + + def test_get_cluster_list_with_filters(self): + ct1 = utils.get_test_cluster_template(id=1, + uuid=uuidutils.generate_uuid()) + ct2 = utils.get_test_cluster_template(id=2, + uuid=uuidutils.generate_uuid()) + self.dbapi.create_cluster_template(ct1) + self.dbapi.create_cluster_template(ct2) + + cluster1 = utils.create_test_cluster( + name='cluster-one', + uuid=uuidutils.generate_uuid(), + cluster_template_id=ct1['uuid'], + status=cluster_status.CREATE_IN_PROGRESS) + cluster2 = utils.create_test_cluster( + name='cluster-two', + uuid=uuidutils.generate_uuid(), + cluster_template_id=ct2['uuid'], + node_count=1, + master_count=1, + status=cluster_status.UPDATE_IN_PROGRESS) + cluster3 = utils.create_test_cluster( + name='cluster-three', + node_count=2, + master_count=5, + status=cluster_status.DELETE_IN_PROGRESS) + + res = self.dbapi.get_cluster_list( + self.context, filters={'cluster_template_id': ct1['uuid']}) + self.assertEqual([cluster1.id], [r.id for r in res]) + + res = self.dbapi.get_cluster_list( + self.context, filters={'cluster_template_id': ct2['uuid']}) + self.assertEqual([cluster2.id], [r.id for r in res]) + + res = self.dbapi.get_cluster_list(self.context, + filters={'name': 'cluster-one'}) + self.assertEqual([cluster1.id], [r.id for r in res]) + + res = self.dbapi.get_cluster_list(self.context, + filters={'name': 'bad-cluster'}) + self.assertEqual([], [r.id for r in res]) + + res = self.dbapi.get_cluster_list(self.context, + filters={'node_count': 3}) + self.assertEqual([cluster1.id], [r.id for r in res]) + + res = self.dbapi.get_cluster_list(self.context, + filters={'node_count': 1}) + self.assertEqual([cluster2.id], [r.id for r in res]) + + res = self.dbapi.get_cluster_list(self.context, + filters={'master_count': 3}) + self.assertEqual([cluster1.id], [r.id for r in res]) + + res = self.dbapi.get_cluster_list(self.context, + filters={'master_count': 1}) + self.assertEqual([cluster2.id], [r.id for r in res]) + + filters = {'status': [cluster_status.CREATE_IN_PROGRESS, + cluster_status.DELETE_IN_PROGRESS]} + res = self.dbapi.get_cluster_list(self.context, + filters=filters) + self.assertEqual([cluster1.id, cluster3.id], [r.id for r in res]) + + def test_get_cluster_list_by_admin_all_tenants(self): + uuids = [] + for i in range(1, 6): + cluster = utils.create_test_cluster( + uuid=uuidutils.generate_uuid(), + project_id=uuidutils.generate_uuid(), + user_id=uuidutils.generate_uuid()) + uuids.append(six.text_type(cluster['uuid'])) + ctx = context.make_admin_context(all_tenants=True) + res = self.dbapi.get_cluster_list(ctx) + res_uuids = [r.uuid for r in res] + self.assertEqual(sorted(uuids), sorted(res_uuids)) + + def test_get_cluster_list_cluster_template_not_exist(self): + utils.create_test_cluster() + self.assertEqual(1, len(self.dbapi.get_cluster_list(self.context))) + res = self.dbapi.get_cluster_list(self.context, filters={ + 'cluster_template_id': uuidutils.generate_uuid()}) + self.assertEqual(0, len(res)) + + def test_destroy_cluster(self): + cluster = utils.create_test_cluster() + self.assertIsNotNone(self.dbapi.get_cluster_by_id(self.context, + cluster.id)) + self.dbapi.destroy_cluster(cluster.id) + self.assertRaises(exception.ClusterNotFound, + self.dbapi.get_cluster_by_id, + self.context, cluster.id) + + def test_destroy_cluster_by_uuid(self): + cluster = utils.create_test_cluster() + self.assertIsNotNone(self.dbapi.get_cluster_by_uuid(self.context, + cluster.uuid)) + self.dbapi.destroy_cluster(cluster.uuid) + self.assertRaises(exception.ClusterNotFound, + self.dbapi.get_cluster_by_uuid, self.context, + cluster.uuid) + + def test_destroy_cluster_that_does_not_exist(self): + self.assertRaises(exception.ClusterNotFound, + self.dbapi.destroy_cluster, + '12345678-9999-0000-aaaa-123456789012') + + def test_update_cluster(self): + cluster = utils.create_test_cluster() + old_nc = cluster.node_count + new_nc = 5 + self.assertNotEqual(old_nc, new_nc) + res = self.dbapi.update_cluster(cluster.id, {'node_count': new_nc}) + self.assertEqual(new_nc, res.node_count) + + def test_update_cluster_not_found(self): + cluster_uuid = uuidutils.generate_uuid() + self.assertRaises(exception.ClusterNotFound, self.dbapi.update_cluster, + cluster_uuid, {'node_count': 5}) + + def test_update_cluster_uuid(self): + cluster = utils.create_test_cluster() + self.assertRaises(exception.InvalidParameterValue, + self.dbapi.update_cluster, cluster.id, + {'uuid': ''}) diff --git a/magnum/tests/unit/db/test_cluster_template.py b/magnum/tests/unit/db/test_cluster_template.py index c3e5d3cdd4..54b0a6a0fa 100644 --- a/magnum/tests/unit/db/test_cluster_template.py +++ b/magnum/tests/unit/db/test_cluster_template.py @@ -178,10 +178,10 @@ class DbClusterTemplateTestCase(base.DbTestCase): self.assertRaises(exception.ClusterTemplateNotFound, self.dbapi.destroy_cluster_template, 666) - def test_destroy_cluster_template_that_referenced_by_bays(self): + def test_destroy_cluster_template_that_referenced_by_clusters(self): ct = utils.create_test_cluster_template() - bay = utils.create_test_bay(cluster_template_id=ct['uuid']) - self.assertEqual(ct['uuid'], bay.baymodel_id) + cluster = utils.create_test_cluster(cluster_template_id=ct['uuid']) + self.assertEqual(ct['uuid'], cluster.cluster_template_id) self.assertRaises(exception.ClusterTemplateReferenced, self.dbapi.destroy_cluster_template, ct['id']) diff --git a/magnum/tests/unit/db/utils.py b/magnum/tests/unit/db/utils.py index b8f53fd93d..8e025d1ce6 100644 --- a/magnum/tests/unit/db/utils.py +++ b/magnum/tests/unit/db/utils.py @@ -24,7 +24,7 @@ def get_test_cluster_template(**kw): 'project_id': kw.get('project_id', 'fake_project'), 'user_id': kw.get('user_id', 'fake_user'), 'uuid': kw.get('uuid', 'e74c40e0-d825-11e2-a28f-0800200c9a66'), - 'name': kw.get('name', 'baymodel1'), + 'name': kw.get('name', 'clustermodel1'), 'image_id': kw.get('image_id', 'ubuntu'), 'flavor_id': kw.get('flavor_id', 'm1.small'), 'master_flavor_id': kw.get('master_flavor_id', 'm1.small'), @@ -73,22 +73,22 @@ def create_test_cluster_template(**kw): return dbapi.create_cluster_template(cluster_template) -def get_test_bay(**kw): +def get_test_cluster(**kw): attrs = { 'id': kw.get('id', 42), 'uuid': kw.get('uuid', '5d12f6fd-a196-4bf0-ae4c-1f639a523a52'), - 'name': kw.get('name', 'bay1'), + 'name': kw.get('name', 'cluster1'), 'discovery_url': kw.get('discovery_url', None), 'ca_cert_ref': kw.get('ca_cert_ref', None), 'magnum_cert_ref': kw.get('magnum_cert_ref', None), 'project_id': kw.get('project_id', 'fake_project'), 'user_id': kw.get('user_id', 'fake_user'), - 'baymodel_id': kw.get('baymodel_id', - 'e74c40e0-d825-11e2-a28f-0800200c9a66'), + 'cluster_template_id': kw.get('cluster_template_id', + 'e74c40e0-d825-11e2-a28f-0800200c9a66'), 'stack_id': kw.get('stack_id', '047c6319-7abd-4bd9-a033-8c6af0173cd0'), 'status': kw.get('status', 'CREATE_IN_PROGRESS'), 'status_reason': kw.get('status_reason', 'Completed successfully'), - 'bay_create_timeout': kw.get('bay_create_timeout', 60), + 'create_timeout': kw.get('create_timeout', 60), 'api_address': kw.get('api_address', '172.17.2.3'), 'node_addresses': kw.get('node_addresses', ['172.17.2.4']), 'node_count': kw.get('node_count', 3), @@ -107,19 +107,19 @@ def get_test_bay(**kw): return attrs -def create_test_bay(**kw): - """Create test bay entry in DB and return Bay DB object. +def create_test_cluster(**kw): + """Create test cluster entry in DB and return Cluster DB object. - Function to be used to create test Bay objects in the database. - :param kw: kwargs with overriding values for bay's attributes. - :returns: Test Bay DB object. + Function to be used to create test Cluster objects in the database. + :param kw: kwargs with overriding values for cluster's attributes. + :returns: Test Cluster DB object. """ - bay = get_test_bay(**kw) + cluster = get_test_cluster(**kw) # Let DB generate ID if it isn't specified explicitly if 'id' not in kw: - del bay['id'] + del cluster['id'] dbapi = db_api.get_instance() - return dbapi.create_bay(bay) + return dbapi.create_cluster(cluster) def get_test_x509keypair(**kw): diff --git a/magnum/tests/unit/drivers/test_template_definition.py b/magnum/tests/unit/drivers/test_template_definition.py index 28cabb0bb7..f2feca6933 100644 --- a/magnum/tests/unit/drivers/test_template_definition.py +++ b/magnum/tests/unit/drivers/test_template_definition.py @@ -104,7 +104,7 @@ class TemplateDefinitionTestCase(base.TestCase): mesos_tdef.UbuntuMesosTemplateDefinition) def test_get_definition_not_supported(self): - self.assertRaises(exception.BayTypeNotSupported, + self.assertRaises(exception.ClusterTypeNotSupported, cmn_tdef.TemplateDefinition.get_template_definition, 'vm', 'not_supported', 'kubernetes') @@ -112,18 +112,18 @@ class TemplateDefinitionTestCase(base.TestCase): cfg.CONF.set_override('enabled_definitions', ['magnum_vm_atomic_k8s'], group='cluster') - self.assertRaises(exception.BayTypeNotEnabled, + self.assertRaises(exception.ClusterTypeNotEnabled, cmn_tdef.TemplateDefinition.get_template_definition, 'vm', 'coreos', 'kubernetes') def test_required_param_not_set(self): param = cmn_tdef.ParameterMapping('test', cluster_template_attr='test', required=True) - mock_baymodel = mock.MagicMock() - mock_baymodel.test = None + mock_cluster_template = mock.MagicMock() + mock_cluster_template.test = None self.assertRaises(exception.RequiredParameterNotProvided, - param.set_param, {}, mock_baymodel, None) + param.set_param, {}, mock_cluster_template, None) def test_output_mapping(self): heat_outputs = [ @@ -191,7 +191,7 @@ class BaseTemplateDefinitionTestCase(base.TestCase): floating_ip_enabled=True, public_ip_output_key='kube_masters', private_ip_output_key='kube_masters_private', - bay_attr='master_addresses', + cluster_attr='master_addresses', ): definition = self.get_definition() @@ -211,13 +211,14 @@ class BaseTemplateDefinitionTestCase(base.TestCase): ] mock_stack = mock.MagicMock() mock_stack.to_dict.return_value = {'outputs': outputs} - mock_bay = mock.MagicMock() - mock_baymodel = mock.MagicMock() - mock_baymodel.floating_ip_enabled = floating_ip_enabled + mock_cluster = mock.MagicMock() + mock_cluster_template = mock.MagicMock() + mock_cluster_template.floating_ip_enabled = floating_ip_enabled - definition.update_outputs(mock_stack, mock_baymodel, mock_bay) + definition.update_outputs(mock_stack, mock_cluster_template, + mock_cluster) - self.assertEqual(expected_address, getattr(mock_bay, bay_attr)) + self.assertEqual(expected_address, getattr(mock_cluster, cluster_attr)) class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): @@ -240,12 +241,12 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): mock_get_discovery_url, mock_osc_class): mock_context = mock.MagicMock() mock_context.auth_token = 'AUTH_TOKEN' - mock_baymodel = mock.MagicMock() - mock_baymodel.tls_disabled = False - mock_baymodel.registry_enabled = False - mock_bay = mock.MagicMock() - mock_bay.uuid = '5d12f6fd-a196-4bf0-ae4c-1f639a523a52' - del mock_bay.stack_id + mock_cluster_template = mock.MagicMock() + mock_cluster_template.tls_disabled = False + mock_cluster_template.registry_enabled = False + mock_cluster = mock.MagicMock() + mock_cluster.uuid = '5d12f6fd-a196-4bf0-ae4c-1f639a523a52' + del mock_cluster.stack_id mock_scale_manager = mock.MagicMock() mock_osc = mock.MagicMock() mock_osc.magnum_url.return_value = 'http://127.0.0.1:9511/v1' @@ -260,13 +261,14 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): mock_context.user_name = 'fake_user' mock_context.tenant = 'fake_tenant' - flannel_cidr = mock_baymodel.labels.get('flannel_network_cidr') - flannel_subnet = mock_baymodel.labels.get('flannel_network_subnetlen') - flannel_backend = mock_baymodel.labels.get('flannel_backend') + flannel_cidr = mock_cluster_template.labels.get('flannel_network_cidr') + flannel_subnet = mock_cluster_template.labels.get( + 'flannel_network_subnetlen') + flannel_backend = mock_cluster_template.labels.get('flannel_backend') k8s_def = k8sa_tdef.AtomicK8sTemplateDefinition() - k8s_def.get_params(mock_context, mock_baymodel, mock_bay, + k8s_def.get_params(mock_context, mock_cluster_template, mock_cluster, scale_manager=mock_scale_manager) expected_kwargs = {'extra_params': { @@ -279,8 +281,10 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): 'tenant_name': 'fake_tenant', 'magnum_url': mock_osc.magnum_url.return_value, 'region_name': mock_osc.cinder_region_name.return_value}} - mock_get_params.assert_called_once_with(mock_context, mock_baymodel, - mock_bay, **expected_kwargs) + mock_get_params.assert_called_once_with(mock_context, + mock_cluster_template, + mock_cluster, + **expected_kwargs) @mock.patch('magnum.common.clients.OpenStackClients') @mock.patch('magnum.drivers.common.template_def' @@ -293,12 +297,12 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): mock_get_discovery_url, mock_osc_class): mock_context = mock.MagicMock() mock_context.auth_token = 'AUTH_TOKEN' - mock_baymodel = mock.MagicMock() - mock_baymodel.tls_disabled = True - mock_baymodel.registry_enabled = False - mock_bay = mock.MagicMock() - mock_bay.uuid = '5d12f6fd-a196-4bf0-ae4c-1f639a523a52' - del mock_bay.stack_id + mock_cluster_template = mock.MagicMock() + mock_cluster_template.tls_disabled = True + mock_cluster_template.registry_enabled = False + mock_cluster = mock.MagicMock() + mock_cluster.uuid = '5d12f6fd-a196-4bf0-ae4c-1f639a523a52' + del mock_cluster.stack_id mock_scale_manager = mock.MagicMock() mock_osc = mock.MagicMock() mock_osc.magnum_url.return_value = 'http://127.0.0.1:9511/v1' @@ -313,13 +317,14 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): mock_context.user_name = 'fake_user' mock_context.tenant = 'fake_tenant' - flannel_cidr = mock_baymodel.labels.get('flannel_network_cidr') - flannel_subnet = mock_baymodel.labels.get('flannel_network_subnetlen') - flannel_backend = mock_baymodel.labels.get('flannel_backend') + flannel_cidr = mock_cluster_template.labels.get('flannel_network_cidr') + flannel_subnet = mock_cluster_template.labels.get( + 'flannel_network_subnetlen') + flannel_backend = mock_cluster_template.labels.get('flannel_backend') k8s_def = k8sa_tdef.AtomicK8sTemplateDefinition() - k8s_def.get_params(mock_context, mock_baymodel, mock_bay, + k8s_def.get_params(mock_context, mock_cluster_template, mock_cluster, scale_manager=mock_scale_manager) expected_kwargs = {'extra_params': { @@ -334,8 +339,10 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): 'region_name': mock_osc.cinder_region_name.return_value, 'loadbalancing_protocol': 'HTTP', 'kubernetes_port': 8080}} - mock_get_params.assert_called_once_with(mock_context, mock_baymodel, - mock_bay, **expected_kwargs) + mock_get_params.assert_called_once_with(mock_context, + mock_cluster_template, + mock_cluster, + **expected_kwargs) @mock.patch('requests.get') def test_k8s_validate_discovery_url(self, mock_get): @@ -364,7 +371,7 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): mock_get.return_value = mock_resp k8s_def = k8sa_tdef.AtomicK8sTemplateDefinition() - self.assertRaises(exception.InvalidBayDiscoveryURL, + self.assertRaises(exception.InvalidClusterDiscoveryURL, k8s_def.validate_discovery_url, 'http://etcd/test', 1) @@ -390,15 +397,15 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): mock_resp = mock.MagicMock() mock_resp.text = expected_discovery_url mock_get.return_value = mock_resp - mock_bay = mock.MagicMock() - mock_bay.master_count = 10 - mock_bay.discovery_url = None + mock_cluster = mock.MagicMock() + mock_cluster.master_count = 10 + mock_cluster.discovery_url = None k8s_def = k8sa_tdef.AtomicK8sTemplateDefinition() - discovery_url = k8s_def.get_discovery_url(mock_bay) + discovery_url = k8s_def.get_discovery_url(mock_cluster) mock_get.assert_called_once_with('http://etcd/test?size=10') - self.assertEqual(expected_discovery_url, mock_bay.discovery_url) + self.assertEqual(expected_discovery_url, mock_cluster.discovery_url) self.assertEqual(expected_discovery_url, discovery_url) @mock.patch('requests.get') @@ -407,19 +414,19 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): 'http://etcd/test?size=%(size)d', group='cluster') mock_get.side_effect = req_exceptions.RequestException() - mock_bay = mock.MagicMock() - mock_bay.master_count = 10 - mock_bay.discovery_url = None + mock_cluster = mock.MagicMock() + mock_cluster.master_count = 10 + mock_cluster.discovery_url = None k8s_def = k8sa_tdef.AtomicK8sTemplateDefinition() self.assertRaises(exception.GetDiscoveryUrlFailed, - k8s_def.get_discovery_url, mock_bay) + k8s_def.get_discovery_url, mock_cluster) def test_k8s_get_heat_param(self): k8s_def = k8sa_tdef.AtomicK8sTemplateDefinition() - heat_param = k8s_def.get_heat_param(bay_attr='node_count') + heat_param = k8s_def.get_heat_param(cluster_attr='node_count') self.assertEqual('number_of_minions', heat_param) @mock.patch('requests.get') @@ -428,13 +435,13 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): mock_resp.text = '' mock_get.return_value = mock_resp - fake_bay = mock.MagicMock() - fake_bay.discovery_url = None + fake_cluster = mock.MagicMock() + fake_cluster.discovery_url = None self.assertRaises( exception.InvalidDiscoveryURL, k8sa_tdef.AtomicK8sTemplateDefinition().get_discovery_url, - fake_bay) + fake_cluster) def _test_update_outputs_api_address(self, coe, params, tls=True): @@ -451,13 +458,14 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): ] mock_stack = mock.MagicMock() mock_stack.to_dict.return_value = {'outputs': outputs} - mock_bay = mock.MagicMock() - mock_baymodel = mock.MagicMock() - mock_baymodel.tls_disabled = tls + mock_cluster = mock.MagicMock() + mock_cluster_template = mock.MagicMock() + mock_cluster_template.tls_disabled = tls - definition.update_outputs(mock_stack, mock_baymodel, mock_bay) + definition.update_outputs(mock_stack, mock_cluster_template, + mock_cluster) - self.assertEqual(expected_api_address, mock_bay.api_address) + self.assertEqual(expected_api_address, mock_cluster.api_address) def test_update_k8s_outputs_api_address(self): address = 'updated_address' @@ -481,7 +489,7 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): } self._test_update_outputs_api_address('swarm', params) - def test_update_k8s_outputs_if_baymodel_is_secure(self): + def test_update_k8s_outputs_if_cluster_template_is_secure(self): address = 'updated_address' protocol = 'https' port = '6443' @@ -492,7 +500,7 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): } self._test_update_outputs_api_address('kubernetes', params, tls=False) - def test_update_swarm_outputs_if_baymodel_is_secure(self): + def test_update_swarm_outputs_if_cluster_template_is_secure(self): address = 'updated_address' protocol = 'tcp' port = '2376' @@ -517,14 +525,15 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): ] mock_stack = mock.MagicMock() mock_stack.to_dict.return_value = {'outputs': outputs} - mock_bay = mock.MagicMock() - mock_bay.api_address = 'none_api_address' - mock_baymodel = mock.MagicMock() - mock_baymodel.tls_disabled = tls + mock_cluster = mock.MagicMock() + mock_cluster.api_address = 'none_api_address' + mock_cluster_template = mock.MagicMock() + mock_cluster_template.tls_disabled = tls - definition.update_outputs(mock_stack, mock_baymodel, mock_bay) + definition.update_outputs(mock_stack, mock_cluster_template, + mock_cluster) - self.assertEqual('none_api_address', mock_bay.api_address) + self.assertEqual('none_api_address', mock_cluster.api_address) def test_update_k8s_outputs_none_api_address(self): protocol = 'http' @@ -550,14 +559,14 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): self._test_update_outputs_server_addrtess( public_ip_output_key='kube_masters', private_ip_output_key='kube_masters_private', - bay_attr='master_addresses', + cluster_attr='master_addresses', ) def test_update_outputs_node_address(self): self._test_update_outputs_server_addrtess( public_ip_output_key='kube_minions', private_ip_output_key='kube_minions_private', - bay_attr='node_addresses', + cluster_attr='node_addresses', ) def test_update_outputs_master_address_fip_disabled(self): @@ -565,7 +574,7 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): floating_ip_enabled=False, public_ip_output_key='kube_masters', private_ip_output_key='kube_masters_private', - bay_attr='master_addresses', + cluster_attr='master_addresses', ) def test_update_outputs_node_address_fip_disabled(self): @@ -573,7 +582,7 @@ class AtomicK8sTemplateDefinitionTestCase(BaseTemplateDefinitionTestCase): floating_ip_enabled=False, public_ip_output_key='kube_minions', private_ip_output_key='kube_minions_private', - bay_attr='node_addresses', + cluster_attr='node_addresses', ) @@ -586,11 +595,12 @@ class FedoraK8sIronicTemplateDefinitionTestCase(base.TestCase): 'kubernetes' ) - def assert_neutron_find(self, mock_neutron_v20_find, osc, baymodel): + def assert_neutron_find(self, mock_neutron_v20_find, + osc, cluster_template): mock_neutron_v20_find.assert_called_once_with( osc.neutron(), 'subnet', - baymodel.fixed_subnet + cluster_template.fixed_subnet ) def assert_raises_from_get_fixed_network_id( @@ -601,14 +611,14 @@ class FedoraK8sIronicTemplateDefinitionTestCase(base.TestCase): ): definition = self.get_definition() osc = mock.MagicMock() - baymodel = mock.MagicMock() + cluster_template = mock.MagicMock() mock_neutron_v20_find.side_effect = exeption_from_neutron_client self.assertRaises( expected_exception_class, definition.get_fixed_network_id, osc, - baymodel + cluster_template ) @mock.patch('neutronclient.neutron.v2_0.find_resource_by_name_or_id') @@ -616,7 +626,7 @@ class FedoraK8sIronicTemplateDefinitionTestCase(base.TestCase): expected_network_id = 'expected_network_id' osc = mock.MagicMock() - baymodel = mock.MagicMock() + cluster_template = mock.MagicMock() definition = self.get_definition() mock_neutron_v20_find.return_value = { 'ip_version': 4, @@ -625,15 +635,15 @@ class FedoraK8sIronicTemplateDefinitionTestCase(base.TestCase): self.assertEqual( expected_network_id, - definition.get_fixed_network_id(osc, baymodel) + definition.get_fixed_network_id(osc, cluster_template) ) - self.assert_neutron_find(mock_neutron_v20_find, osc, baymodel) + self.assert_neutron_find(mock_neutron_v20_find, osc, cluster_template) @mock.patch('neutronclient.neutron.v2_0.find_resource_by_name_or_id') def test_get_fixed_network_id_with_invalid_ip_ver(self, mock_neutron_v20_find): osc = mock.MagicMock() - baymodel = mock.MagicMock() + cluster_template = mock.MagicMock() definition = self.get_definition() mock_neutron_v20_find.return_value = { 'ip_version': 6, @@ -644,7 +654,7 @@ class FedoraK8sIronicTemplateDefinitionTestCase(base.TestCase): exception.InvalidSubnet, definition.get_fixed_network_id, osc, - baymodel + cluster_template ) @mock.patch('neutronclient.neutron.v2_0.find_resource_by_name_or_id') @@ -697,12 +707,12 @@ class AtomicSwarmTemplateDefinitionTestCase(base.TestCase): mock_get_discovery_url, mock_osc_class): mock_context = mock.MagicMock() mock_context.auth_token = 'AUTH_TOKEN' - mock_baymodel = mock.MagicMock() - mock_baymodel.tls_disabled = False - mock_baymodel.registry_enabled = False - mock_bay = mock.MagicMock() - mock_bay.uuid = '5d12f6fd-a196-4bf0-ae4c-1f639a523a52' - del mock_bay.stack_id + mock_cluster_template = mock.MagicMock() + mock_cluster_template.tls_disabled = False + mock_cluster_template.registry_enabled = False + mock_cluster = mock.MagicMock() + mock_cluster.uuid = '5d12f6fd-a196-4bf0-ae4c-1f639a523a52' + del mock_cluster.stack_id mock_osc = mock.MagicMock() mock_osc.magnum_url.return_value = 'http://127.0.0.1:9511/v1' mock_osc_class.return_value = mock_osc @@ -713,14 +723,15 @@ class AtomicSwarmTemplateDefinitionTestCase(base.TestCase): mock_context.user_name = 'fake_user' mock_context.tenant = 'fake_tenant' - flannel_cidr = mock_baymodel.labels.get('flannel_network_cidr') - flannel_subnet = mock_baymodel.labels.get('flannel_network_subnetlen') - flannel_backend = mock_baymodel.labels.get('flannel_backend') - rexray_preempt = mock_baymodel.labels.get('rexray_preempt') + flannel_cidr = mock_cluster_template.labels.get('flannel_network_cidr') + flannel_subnet = mock_cluster_template.labels.get( + 'flannel_network_subnetlen') + flannel_backend = mock_cluster_template.labels.get('flannel_backend') + rexray_preempt = mock_cluster_template.labels.get('rexray_preempt') swarm_def = swarm_tdef.AtomicSwarmTemplateDefinition() - swarm_def.get_params(mock_context, mock_baymodel, mock_bay) + swarm_def.get_params(mock_context, mock_cluster_template, mock_cluster) expected_kwargs = {'extra_params': { 'discovery_url': 'fake_discovery_url', @@ -730,8 +741,10 @@ class AtomicSwarmTemplateDefinitionTestCase(base.TestCase): 'flannel_network_subnetlen': flannel_subnet, 'auth_url': 'http://192.168.10.10:5000/v3', 'rexray_preempt': rexray_preempt}} - mock_get_params.assert_called_once_with(mock_context, mock_baymodel, - mock_bay, **expected_kwargs) + mock_get_params.assert_called_once_with(mock_context, + mock_cluster_template, + mock_cluster, + **expected_kwargs) @mock.patch('requests.get') def test_swarm_validate_discovery_url(self, mock_get): @@ -760,7 +773,7 @@ class AtomicSwarmTemplateDefinitionTestCase(base.TestCase): mock_get.return_value = mock_resp k8s_def = k8sa_tdef.AtomicK8sTemplateDefinition() - self.assertRaises(exception.InvalidBayDiscoveryURL, + self.assertRaises(exception.InvalidClusterDiscoveryURL, k8s_def.validate_discovery_url, 'http://etcd/test', 1) @@ -786,14 +799,14 @@ class AtomicSwarmTemplateDefinitionTestCase(base.TestCase): mock_resp = mock.MagicMock() mock_resp.text = expected_discovery_url mock_get.return_value = mock_resp - mock_bay = mock.MagicMock() - mock_bay.discovery_url = None + mock_cluster = mock.MagicMock() + mock_cluster.discovery_url = None swarm_def = swarm_tdef.AtomicSwarmTemplateDefinition() - discovery_url = swarm_def.get_discovery_url(mock_bay) + discovery_url = swarm_def.get_discovery_url(mock_cluster) mock_get.assert_called_once_with('http://etcd/test?size=1') - self.assertEqual(mock_bay.discovery_url, expected_discovery_url) + self.assertEqual(mock_cluster.discovery_url, expected_discovery_url) self.assertEqual(discovery_url, expected_discovery_url) @mock.patch('requests.get') @@ -802,18 +815,18 @@ class AtomicSwarmTemplateDefinitionTestCase(base.TestCase): mock_resp.text = '' mock_get.return_value = mock_resp - fake_bay = mock.MagicMock() - fake_bay.discovery_url = None + fake_cluster = mock.MagicMock() + fake_cluster.discovery_url = None self.assertRaises( exception.InvalidDiscoveryURL, k8sa_tdef.AtomicK8sTemplateDefinition().get_discovery_url, - fake_bay) + fake_cluster) def test_swarm_get_heat_param(self): swarm_def = swarm_tdef.AtomicSwarmTemplateDefinition() - heat_param = swarm_def.get_heat_param(bay_attr='node_count') + heat_param = swarm_def.get_heat_param(cluster_attr='node_count') self.assertEqual('number_of_nodes', heat_param) def test_update_outputs(self): @@ -841,13 +854,14 @@ class AtomicSwarmTemplateDefinitionTestCase(base.TestCase): ] mock_stack = mock.MagicMock() mock_stack.to_dict.return_value = {'outputs': outputs} - mock_bay = mock.MagicMock() - mock_baymodel = mock.MagicMock() + mock_cluster = mock.MagicMock() + mock_cluster_template = mock.MagicMock() - swarm_def.update_outputs(mock_stack, mock_baymodel, mock_bay) + swarm_def.update_outputs(mock_stack, mock_cluster_template, + mock_cluster) expected_api_address = "tcp://%s:2376" % expected_api_address - self.assertEqual(expected_api_address, mock_bay.api_address) - self.assertEqual(expected_node_addresses, mock_bay.node_addresses) + self.assertEqual(expected_api_address, mock_cluster.api_address) + self.assertEqual(expected_node_addresses, mock_cluster.node_addresses) class UbuntuMesosTemplateDefinitionTestCase(base.TestCase): @@ -864,19 +878,20 @@ class UbuntuMesosTemplateDefinitionTestCase(base.TestCase): mock_context.user_name = 'mesos_user' mock_context.tenant = 'admin' mock_context.domain_name = 'domainname' - mock_baymodel = mock.MagicMock() - mock_baymodel.tls_disabled = False - rexray_preempt = mock_baymodel.labels.get('rexray_preempt') - mesos_slave_isolation = mock_baymodel.labels.get( + mock_cluster_template = mock.MagicMock() + mock_cluster_template.tls_disabled = False + rexray_preempt = mock_cluster_template.labels.get('rexray_preempt') + mesos_slave_isolation = mock_cluster_template.labels.get( 'mesos_slave_isolation') - mesos_slave_work_dir = mock_baymodel.labels.get('mesos_slave_work_dir') - mesos_slave_image_providers = mock_baymodel.labels.get( + mesos_slave_work_dir = mock_cluster_template.labels.get( + 'mesos_slave_work_dir') + mesos_slave_image_providers = mock_cluster_template.labels.get( 'image_providers') - mesos_slave_executor_env_variables = mock_baymodel.labels.get( + mesos_slave_executor_env_variables = mock_cluster_template.labels.get( 'mesos_slave_executor_env_variables') - mock_bay = mock.MagicMock() - mock_bay.uuid = '5d12f6fd-a196-4bf0-ae4c-1f639a523a52' - del mock_bay.stack_id + mock_cluster = mock.MagicMock() + mock_cluster.uuid = '5d12f6fd-a196-4bf0-ae4c-1f639a523a52' + del mock_cluster.stack_id mock_osc = mock.MagicMock() mock_osc.cinder_region_name.return_value = 'RegionOne' mock_osc_class.return_value = mock_osc @@ -887,7 +902,7 @@ class UbuntuMesosTemplateDefinitionTestCase(base.TestCase): mesos_def = mesos_tdef.UbuntuMesosTemplateDefinition() - mesos_def.get_params(mock_context, mock_baymodel, mock_bay, + mesos_def.get_params(mock_context, mock_cluster_template, mock_cluster, scale_manager=mock_scale_manager) expected_kwargs = {'extra_params': { @@ -903,16 +918,18 @@ class UbuntuMesosTemplateDefinitionTestCase(base.TestCase): mesos_slave_executor_env_variables, 'mesos_slave_image_providers': mesos_slave_image_providers, 'slaves_to_remove': removal_nodes}} - mock_get_params.assert_called_once_with(mock_context, mock_baymodel, - mock_bay, **expected_kwargs) + mock_get_params.assert_called_once_with(mock_context, + mock_cluster_template, + mock_cluster, + **expected_kwargs) def test_mesos_get_heat_param(self): mesos_def = mesos_tdef.UbuntuMesosTemplateDefinition() - heat_param = mesos_def.get_heat_param(bay_attr='node_count') + heat_param = mesos_def.get_heat_param(cluster_attr='node_count') self.assertEqual('number_of_slaves', heat_param) - heat_param = mesos_def.get_heat_param(bay_attr='master_count') + heat_param = mesos_def.get_heat_param(cluster_attr='master_count') self.assertEqual('number_of_masters', heat_param) def test_update_outputs(self): @@ -941,11 +958,13 @@ class UbuntuMesosTemplateDefinitionTestCase(base.TestCase): ] mock_stack = mock.MagicMock() mock_stack.to_dict.return_value = {'outputs': outputs} - mock_bay = mock.MagicMock() - mock_baymodel = mock.MagicMock() + mock_cluster = mock.MagicMock() + mock_cluster_template = mock.MagicMock() - mesos_def.update_outputs(mock_stack, mock_baymodel, mock_bay) + mesos_def.update_outputs(mock_stack, mock_cluster_template, + mock_cluster) - self.assertEqual(expected_api_address, mock_bay.api_address) - self.assertEqual(expected_node_addresses, mock_bay.node_addresses) - self.assertEqual(expected_master_addresses, mock_bay.master_addresses) + self.assertEqual(expected_api_address, mock_cluster.api_address) + self.assertEqual(expected_node_addresses, mock_cluster.node_addresses) + self.assertEqual(expected_master_addresses, + mock_cluster.master_addresses) diff --git a/magnum/tests/unit/objects/test_bay.py b/magnum/tests/unit/objects/test_bay.py deleted file mode 100644 index 7dc4c770dd..0000000000 --- a/magnum/tests/unit/objects/test_bay.py +++ /dev/null @@ -1,192 +0,0 @@ -# Copyright 2015 OpenStack Foundation -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -import mock -from oslo_utils import uuidutils -from testtools.matchers import HasLength - -from magnum.common import exception -from magnum import objects -from magnum.tests.unit.db import base -from magnum.tests.unit.db import utils - - -class TestBayObject(base.DbTestCase): - - def setUp(self): - super(TestBayObject, self).setUp() - self.fake_bay = utils.get_test_bay() - self.fake_bay['trust_id'] = 'trust_id' - self.fake_bay['trustee_username'] = 'trustee_user' - self.fake_bay['trustee_user_id'] = 'trustee_user_id' - self.fake_bay['trustee_password'] = 'password' - self.fake_bay['coe_version'] = 'fake-coe-version' - self.fake_bay['container_version'] = 'fake-container-version' - cluster_template_id = self.fake_bay['baymodel_id'] - self.fake_cluster_template = objects.ClusterTemplate( - uuid=cluster_template_id) - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_get_by_id(self, mock_cluster_template_get): - bay_id = self.fake_bay['id'] - with mock.patch.object(self.dbapi, 'get_bay_by_id', - autospec=True) as mock_get_bay: - mock_cluster_template_get.return_value = self.fake_cluster_template - mock_get_bay.return_value = self.fake_bay - bay = objects.Bay.get(self.context, bay_id) - mock_get_bay.assert_called_once_with(self.context, bay_id) - self.assertEqual(self.context, bay._context) - self.assertEqual(bay.baymodel_id, bay.cluster_template.uuid) - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_get_by_uuid(self, mock_cluster_template_get): - uuid = self.fake_bay['uuid'] - with mock.patch.object(self.dbapi, 'get_bay_by_uuid', - autospec=True) as mock_get_bay: - mock_cluster_template_get.return_value = self.fake_cluster_template - mock_get_bay.return_value = self.fake_bay - bay = objects.Bay.get(self.context, uuid) - mock_get_bay.assert_called_once_with(self.context, uuid) - self.assertEqual(self.context, bay._context) - self.assertEqual(bay.baymodel_id, bay.cluster_template.uuid) - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_get_by_name(self, mock_cluster_template_get): - name = self.fake_bay['name'] - with mock.patch.object(self.dbapi, 'get_bay_by_name', - autospec=True) as mock_get_bay: - mock_cluster_template_get.return_value = self.fake_cluster_template - mock_get_bay.return_value = self.fake_bay - bay = objects.Bay.get_by_name(self.context, name) - mock_get_bay.assert_called_once_with(self.context, name) - self.assertEqual(self.context, bay._context) - self.assertEqual(bay.baymodel_id, bay.cluster_template.uuid) - - def test_get_bad_id_and_uuid(self): - self.assertRaises(exception.InvalidIdentity, - objects.Bay.get, self.context, 'not-a-uuid') - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_list(self, mock_cluster_template_get): - with mock.patch.object(self.dbapi, 'get_bay_list', - autospec=True) as mock_get_list: - mock_get_list.return_value = [self.fake_bay] - mock_cluster_template_get.return_value = self.fake_cluster_template - bays = objects.Bay.list(self.context) - self.assertEqual(1, mock_get_list.call_count) - self.assertThat(bays, HasLength(1)) - self.assertIsInstance(bays[0], objects.Bay) - self.assertEqual(self.context, bays[0]._context) - self.assertEqual(bays[0].baymodel_id, - bays[0].cluster_template.uuid) - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_list_all(self, mock_cluster_template_get): - with mock.patch.object(self.dbapi, 'get_bay_list', - autospec=True) as mock_get_list: - mock_get_list.return_value = [self.fake_bay] - mock_cluster_template_get.return_value = self.fake_cluster_template - self.context.all_tenants = True - bays = objects.Bay.list(self.context) - mock_get_list.assert_called_once_with( - self.context, limit=None, marker=None, filters=None, - sort_dir=None, sort_key=None) - self.assertEqual(1, mock_get_list.call_count) - self.assertThat(bays, HasLength(1)) - self.assertIsInstance(bays[0], objects.Bay) - self.assertEqual(self.context, bays[0]._context) - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_list_with_filters(self, mock_cluster_template_get): - with mock.patch.object(self.dbapi, 'get_bay_list', - autospec=True) as mock_get_list: - mock_get_list.return_value = [self.fake_bay] - mock_cluster_template_get.return_value = self.fake_cluster_template - filters = {'name': 'bay1'} - bays = objects.Bay.list(self.context, filters=filters) - - mock_get_list.assert_called_once_with(self.context, sort_key=None, - sort_dir=None, - filters=filters, limit=None, - marker=None) - self.assertEqual(1, mock_get_list.call_count) - self.assertThat(bays, HasLength(1)) - self.assertIsInstance(bays[0], objects.Bay) - self.assertEqual(self.context, bays[0]._context) - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_create(self, mock_cluster_template_get): - with mock.patch.object(self.dbapi, 'create_bay', - autospec=True) as mock_create_bay: - mock_cluster_template_get.return_value = self.fake_cluster_template - mock_create_bay.return_value = self.fake_bay - bay = objects.Bay(self.context, **self.fake_bay) - bay.create() - mock_create_bay.assert_called_once_with(self.fake_bay) - self.assertEqual(self.context, bay._context) - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_destroy(self, mock_cluster_template_get): - uuid = self.fake_bay['uuid'] - with mock.patch.object(self.dbapi, 'get_bay_by_uuid', - autospec=True) as mock_get_bay: - mock_get_bay.return_value = self.fake_bay - mock_cluster_template_get.return_value = self.fake_cluster_template - with mock.patch.object(self.dbapi, 'destroy_bay', - autospec=True) as mock_destroy_bay: - bay = objects.Bay.get_by_uuid(self.context, uuid) - bay.destroy() - mock_get_bay.assert_called_once_with(self.context, uuid) - mock_destroy_bay.assert_called_once_with(uuid) - self.assertEqual(self.context, bay._context) - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_save(self, mock_cluster_template_get): - uuid = self.fake_bay['uuid'] - with mock.patch.object(self.dbapi, 'get_bay_by_uuid', - autospec=True) as mock_get_bay: - mock_cluster_template_get.return_value = self.fake_cluster_template - mock_get_bay.return_value = self.fake_bay - with mock.patch.object(self.dbapi, 'update_bay', - autospec=True) as mock_update_bay: - bay = objects.Bay.get_by_uuid(self.context, uuid) - bay.node_count = 10 - bay.master_count = 5 - bay.save() - - mock_get_bay.assert_called_once_with(self.context, uuid) - mock_update_bay.assert_called_once_with( - uuid, {'node_count': 10, 'master_count': 5, - 'cluster_template': self.fake_cluster_template}) - self.assertEqual(self.context, bay._context) - - @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') - def test_refresh(self, mock_cluster_template_get): - uuid = self.fake_bay['uuid'] - new_uuid = uuidutils.generate_uuid() - returns = [dict(self.fake_bay, uuid=uuid), - dict(self.fake_bay, uuid=new_uuid)] - expected = [mock.call(self.context, uuid), - mock.call(self.context, uuid)] - with mock.patch.object(self.dbapi, 'get_bay_by_uuid', - side_effect=returns, - autospec=True) as mock_get_bay: - mock_cluster_template_get.return_value = self.fake_cluster_template - bay = objects.Bay.get_by_uuid(self.context, uuid) - self.assertEqual(uuid, bay.uuid) - bay.refresh() - self.assertEqual(new_uuid, bay.uuid) - self.assertEqual(expected, mock_get_bay.call_args_list) - self.assertEqual(self.context, bay._context) diff --git a/magnum/tests/unit/objects/test_cluster.py b/magnum/tests/unit/objects/test_cluster.py new file mode 100644 index 0000000000..0b62700e76 --- /dev/null +++ b/magnum/tests/unit/objects/test_cluster.py @@ -0,0 +1,195 @@ +# Copyright 2015 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import mock +from oslo_utils import uuidutils +from testtools.matchers import HasLength + +from magnum.common import exception +from magnum import objects +from magnum.tests.unit.db import base +from magnum.tests.unit.db import utils + + +class TestClusterObject(base.DbTestCase): + + def setUp(self): + super(TestClusterObject, self).setUp() + self.fake_cluster = utils.get_test_cluster() + self.fake_cluster['trust_id'] = 'trust_id' + self.fake_cluster['trustee_username'] = 'trustee_user' + self.fake_cluster['trustee_user_id'] = 'trustee_user_id' + self.fake_cluster['trustee_password'] = 'password' + self.fake_cluster['coe_version'] = 'fake-coe-version' + self.fake_cluster['container_version'] = 'fake-container-version' + cluster_template_id = self.fake_cluster['cluster_template_id'] + self.fake_cluster_template = objects.ClusterTemplate( + uuid=cluster_template_id) + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_get_by_id(self, mock_cluster_template_get): + cluster_id = self.fake_cluster['id'] + with mock.patch.object(self.dbapi, 'get_cluster_by_id', + autospec=True) as mock_get_cluster: + mock_cluster_template_get.return_value = self.fake_cluster_template + mock_get_cluster.return_value = self.fake_cluster + cluster = objects.Cluster.get(self.context, cluster_id) + mock_get_cluster.assert_called_once_with(self.context, cluster_id) + self.assertEqual(self.context, cluster._context) + self.assertEqual(cluster.cluster_template_id, + cluster.cluster_template.uuid) + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_get_by_uuid(self, mock_cluster_template_get): + uuid = self.fake_cluster['uuid'] + with mock.patch.object(self.dbapi, 'get_cluster_by_uuid', + autospec=True) as mock_get_cluster: + mock_cluster_template_get.return_value = self.fake_cluster_template + mock_get_cluster.return_value = self.fake_cluster + cluster = objects.Cluster.get(self.context, uuid) + mock_get_cluster.assert_called_once_with(self.context, uuid) + self.assertEqual(self.context, cluster._context) + self.assertEqual(cluster.cluster_template_id, + cluster.cluster_template.uuid) + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_get_by_name(self, mock_cluster_template_get): + name = self.fake_cluster['name'] + with mock.patch.object(self.dbapi, 'get_cluster_by_name', + autospec=True) as mock_get_cluster: + mock_cluster_template_get.return_value = self.fake_cluster_template + mock_get_cluster.return_value = self.fake_cluster + cluster = objects.Cluster.get_by_name(self.context, name) + mock_get_cluster.assert_called_once_with(self.context, name) + self.assertEqual(self.context, cluster._context) + self.assertEqual(cluster.cluster_template_id, + cluster.cluster_template.uuid) + + def test_get_bad_id_and_uuid(self): + self.assertRaises(exception.InvalidIdentity, + objects.Cluster.get, self.context, 'not-a-uuid') + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_list(self, mock_cluster_template_get): + with mock.patch.object(self.dbapi, 'get_cluster_list', + autospec=True) as mock_get_list: + mock_get_list.return_value = [self.fake_cluster] + mock_cluster_template_get.return_value = self.fake_cluster_template + clusters = objects.Cluster.list(self.context) + self.assertEqual(1, mock_get_list.call_count) + self.assertThat(clusters, HasLength(1)) + self.assertIsInstance(clusters[0], objects.Cluster) + self.assertEqual(self.context, clusters[0]._context) + self.assertEqual(clusters[0].cluster_template_id, + clusters[0].cluster_template.uuid) + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_list_all(self, mock_cluster_template_get): + with mock.patch.object(self.dbapi, 'get_cluster_list', + autospec=True) as mock_get_list: + mock_get_list.return_value = [self.fake_cluster] + mock_cluster_template_get.return_value = self.fake_cluster_template + self.context.all_tenants = True + clusters = objects.Cluster.list(self.context) + mock_get_list.assert_called_once_with( + self.context, limit=None, marker=None, filters=None, + sort_dir=None, sort_key=None) + self.assertEqual(1, mock_get_list.call_count) + self.assertThat(clusters, HasLength(1)) + self.assertIsInstance(clusters[0], objects.Cluster) + self.assertEqual(self.context, clusters[0]._context) + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_list_with_filters(self, mock_cluster_template_get): + with mock.patch.object(self.dbapi, 'get_cluster_list', + autospec=True) as mock_get_list: + mock_get_list.return_value = [self.fake_cluster] + mock_cluster_template_get.return_value = self.fake_cluster_template + filters = {'name': 'cluster1'} + clusters = objects.Cluster.list(self.context, filters=filters) + + mock_get_list.assert_called_once_with(self.context, sort_key=None, + sort_dir=None, + filters=filters, limit=None, + marker=None) + self.assertEqual(1, mock_get_list.call_count) + self.assertThat(clusters, HasLength(1)) + self.assertIsInstance(clusters[0], objects.Cluster) + self.assertEqual(self.context, clusters[0]._context) + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_create(self, mock_cluster_template_get): + with mock.patch.object(self.dbapi, 'create_cluster', + autospec=True) as mock_create_cluster: + mock_cluster_template_get.return_value = self.fake_cluster_template + mock_create_cluster.return_value = self.fake_cluster + cluster = objects.Cluster(self.context, **self.fake_cluster) + cluster.create() + mock_create_cluster.assert_called_once_with(self.fake_cluster) + self.assertEqual(self.context, cluster._context) + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_destroy(self, mock_cluster_template_get): + uuid = self.fake_cluster['uuid'] + with mock.patch.object(self.dbapi, 'get_cluster_by_uuid', + autospec=True) as mock_get_cluster: + mock_get_cluster.return_value = self.fake_cluster + mock_cluster_template_get.return_value = self.fake_cluster_template + with mock.patch.object(self.dbapi, 'destroy_cluster', + autospec=True) as mock_destroy_cluster: + cluster = objects.Cluster.get_by_uuid(self.context, uuid) + cluster.destroy() + mock_get_cluster.assert_called_once_with(self.context, uuid) + mock_destroy_cluster.assert_called_once_with(uuid) + self.assertEqual(self.context, cluster._context) + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_save(self, mock_cluster_template_get): + uuid = self.fake_cluster['uuid'] + with mock.patch.object(self.dbapi, 'get_cluster_by_uuid', + autospec=True) as mock_get_cluster: + mock_cluster_template_get.return_value = self.fake_cluster_template + mock_get_cluster.return_value = self.fake_cluster + with mock.patch.object(self.dbapi, 'update_cluster', + autospec=True) as mock_update_cluster: + cluster = objects.Cluster.get_by_uuid(self.context, uuid) + cluster.node_count = 10 + cluster.master_count = 5 + cluster.save() + + mock_get_cluster.assert_called_once_with(self.context, uuid) + mock_update_cluster.assert_called_once_with( + uuid, {'node_count': 10, 'master_count': 5, + 'cluster_template': self.fake_cluster_template}) + self.assertEqual(self.context, cluster._context) + + @mock.patch('magnum.objects.ClusterTemplate.get_by_uuid') + def test_refresh(self, mock_cluster_template_get): + uuid = self.fake_cluster['uuid'] + new_uuid = uuidutils.generate_uuid() + returns = [dict(self.fake_cluster, uuid=uuid), + dict(self.fake_cluster, uuid=new_uuid)] + expected = [mock.call(self.context, uuid), + mock.call(self.context, uuid)] + with mock.patch.object(self.dbapi, 'get_cluster_by_uuid', + side_effect=returns, + autospec=True) as mock_get_cluster: + mock_cluster_template_get.return_value = self.fake_cluster_template + cluster = objects.Cluster.get_by_uuid(self.context, uuid) + self.assertEqual(uuid, cluster.uuid) + cluster.refresh() + self.assertEqual(new_uuid, cluster.uuid) + self.assertEqual(expected, mock_get_cluster.call_args_list) + self.assertEqual(self.context, cluster._context) diff --git a/magnum/tests/unit/objects/test_fields.py b/magnum/tests/unit/objects/test_fields.py index 2eea8923bc..f2713dc13f 100644 --- a/magnum/tests/unit/objects/test_fields.py +++ b/magnum/tests/unit/objects/test_fields.py @@ -17,10 +17,10 @@ from oslo_versionedobjects.tests import test_fields from magnum.objects import fields -class TestBayStatus(test_fields.TestField): +class TestClusterStatus(test_fields.TestField): def setUp(self): - super(TestBayStatus, self).setUp() - self.field = fields.BayStatusField() + super(TestClusterStatus, self).setUp() + self.field = fields.ClusterStatusField() self.coerce_good_values = [('CREATE_IN_PROGRESS', 'CREATE_IN_PROGRESS'), ('CREATE_FAILED', 'CREATE_FAILED'), @@ -71,10 +71,10 @@ class TestContainerStatus(test_fields.TestField): self.assertRaises(ValueError, self.field.stringify, 'DELETED') -class TestBayType(test_fields.TestField): +class TestClusterType(test_fields.TestField): def setUp(self): - super(TestBayType, self).setUp() - self.field = fields.BayTypeField() + super(TestClusterType, self).setUp() + self.field = fields.ClusterTypeField() self.coerce_good_values = [('kubernetes', 'kubernetes'), ('swarm', 'swarm'), ('mesos', 'mesos'), ] diff --git a/magnum/tests/unit/objects/test_objects.py b/magnum/tests/unit/objects/test_objects.py index e179ae0394..5d689ec311 100644 --- a/magnum/tests/unit/objects/test_objects.py +++ b/magnum/tests/unit/objects/test_objects.py @@ -362,8 +362,8 @@ class TestObject(test_base.TestCase, _TestObject): # For more information on object version testing, read # http://docs.openstack.org/developer/magnum/objects.html object_data = { - 'Bay': '1.8-a6109e08d32dc59d3ad100697e06d8da', - 'ClusterTemplate': '1.16-29dfb88bff54a412b05f9a651f4758a6', + 'Cluster': '1.9-f9838e23eef5f1a7d9606c1ccce21800', + 'ClusterTemplate': '1.17-65a95ef932dd08800a83871eb3cf312b', 'Certificate': '1.1-1924dc077daa844f0f9076332ef96815', 'MyObj': '1.0-b43567e512438205e32f4e95ca616697', 'MyObj': '1.0-34c4b1aadefd177b13f9a2f894cc23cd', diff --git a/magnum/tests/unit/objects/utils.py b/magnum/tests/unit/objects/utils.py index 02e7864c3a..d8cbbe280a 100644 --- a/magnum/tests/unit/objects/utils.py +++ b/magnum/tests/unit/objects/utils.py @@ -60,51 +60,33 @@ def create_test_cluster_template(context, **kw): return cluster_template -def get_test_bay(context, **kw): - """Return a Bay object with appropriate attributes. +def get_test_cluster(context, **kw): + """Return a Cluster object with appropriate attributes. NOTE: The object leaves the attributes marked as changed, such that a create() could be used to commit it to the DB. """ - db_bay = db_utils.get_test_bay(**kw) + db_cluster = db_utils.get_test_cluster(**kw) # Let DB generate ID if it isn't specified explicitly if 'id' not in kw: - del db_bay['id'] - bay = objects.Bay(context) - for key in db_bay: - setattr(bay, key, db_bay[key]) - return bay - - -def create_test_bay(context, **kw): - """Create and return a test bay object. - - Create a bay in the DB and return a Bay object with appropriate - attributes. - """ - bay = get_test_bay(context, **kw) - create_test_cluster_template(context, uuid=bay['baymodel_id'], - coe=kw.get('coe', 'swarm')) - bay.create() - return bay - - -def get_test_cluster(context, **kw): - """Return a Cluster object with appropriate attributes. - - NOTE: Object model is the same for Cluster and - Bay - """ - return get_test_bay(context, **kw) + del db_cluster['id'] + cluster = objects.Cluster(context) + for key in db_cluster: + setattr(cluster, key, db_cluster[key]) + return cluster def create_test_cluster(context, **kw): - """Create and return a test cluster object. + """Create and return a test Cluster object. - NOTE: Object model is the same for Cluster and - Bay + Create a Cluster in the DB and return a Cluster object with appropriate + attributes. """ - return create_test_bay(context, **kw) + cluster = get_test_cluster(context, **kw) + create_test_cluster_template(context, uuid=cluster['cluster_template_id'], + coe=kw.get('coe', 'swarm')) + cluster.create() + return cluster def get_test_x509keypair(context, **kw): diff --git a/magnum/tests/unit/service/test_periodic.py b/magnum/tests/unit/service/test_periodic.py index 0b6dc41e92..7b85ccb44d 100644 --- a/magnum/tests/unit/service/test_periodic.py +++ b/magnum/tests/unit/service/test_periodic.py @@ -19,7 +19,7 @@ from magnum.common import context from magnum.common.rpc_service import CONF from magnum.db.sqlalchemy import api as dbapi from magnum import objects -from magnum.objects.fields import BayStatus as bay_status +from magnum.objects.fields import ClusterStatus as cluster_status from magnum.service import periodic from magnum.tests import base from magnum.tests.unit.db import utils @@ -38,7 +38,7 @@ class PeriodicTestCase(base.TestCase): ctx = context.make_admin_context() - # Can be identical for all bays. + # Can be identical for all clusters. trust_attrs = { 'trustee_username': '5d12f6fd-a196-4bf0-ae4c-1f639a523a52', 'trustee_password': 'ain7einaebooVaig6d', @@ -46,40 +46,43 @@ class PeriodicTestCase(base.TestCase): } trust_attrs.update({'id': 1, 'stack_id': '11', - 'status': bay_status.CREATE_IN_PROGRESS}) - bay1 = utils.get_test_bay(**trust_attrs) + 'status': cluster_status.CREATE_IN_PROGRESS}) + cluster1 = utils.get_test_cluster(**trust_attrs) trust_attrs.update({'id': 2, 'stack_id': '22', - 'status': bay_status.DELETE_IN_PROGRESS}) - bay2 = utils.get_test_bay(**trust_attrs) + 'status': cluster_status.DELETE_IN_PROGRESS}) + cluster2 = utils.get_test_cluster(**trust_attrs) trust_attrs.update({'id': 3, 'stack_id': '33', - 'status': bay_status.UPDATE_IN_PROGRESS}) - bay3 = utils.get_test_bay(**trust_attrs) + 'status': cluster_status.UPDATE_IN_PROGRESS}) + cluster3 = utils.get_test_cluster(**trust_attrs) trust_attrs.update({'id': 4, 'stack_id': '44', - 'status': bay_status.CREATE_COMPLETE}) - bay4 = utils.get_test_bay(**trust_attrs) + 'status': cluster_status.CREATE_COMPLETE}) + cluster4 = utils.get_test_cluster(**trust_attrs) trust_attrs.update({'id': 5, 'stack_id': '55', - 'status': bay_status.ROLLBACK_IN_PROGRESS}) - bay5 = utils.get_test_bay(**trust_attrs) + 'status': cluster_status.ROLLBACK_IN_PROGRESS}) + cluster5 = utils.get_test_cluster(**trust_attrs) - self.bay1 = objects.Bay(ctx, **bay1) - self.bay2 = objects.Bay(ctx, **bay2) - self.bay3 = objects.Bay(ctx, **bay3) - self.bay4 = objects.Bay(ctx, **bay4) - self.bay5 = objects.Bay(ctx, **bay5) + self.cluster1 = objects.Cluster(ctx, **cluster1) + self.cluster2 = objects.Cluster(ctx, **cluster2) + self.cluster3 = objects.Cluster(ctx, **cluster3) + self.cluster4 = objects.Cluster(ctx, **cluster4) + self.cluster5 = objects.Cluster(ctx, **cluster5) - @mock.patch.object(objects.Bay, 'list') + @mock.patch.object(objects.Cluster, 'list') @mock.patch('magnum.common.clients.OpenStackClients') - @mock.patch.object(dbapi.Connection, 'destroy_bay') - @mock.patch.object(dbapi.Connection, 'update_bay') - def test_sync_bay_status_changes(self, mock_db_update, mock_db_destroy, - mock_oscc, mock_bay_list): + @mock.patch.object(dbapi.Connection, 'destroy_cluster') + @mock.patch.object(dbapi.Connection, 'update_cluster') + def test_sync_cluster_status_changes(self, mock_db_update, mock_db_destroy, + mock_oscc, mock_cluster_list): mock_heat_client = mock.MagicMock() - stack1 = fake_stack(id='11', stack_status=bay_status.CREATE_COMPLETE, - stack_status_reason='fake_reason_11') - stack3 = fake_stack(id='33', stack_status=bay_status.UPDATE_COMPLETE, - stack_status_reason='fake_reason_33') - stack5 = fake_stack(id='55', stack_status=bay_status.ROLLBACK_COMPLETE, - stack_status_reason='fake_reason_55') + stack1 = fake_stack( + id='11', stack_status=cluster_status.CREATE_COMPLETE, + stack_status_reason='fake_reason_11') + stack3 = fake_stack( + id='33', stack_status=cluster_status.UPDATE_COMPLETE, + stack_status_reason='fake_reason_33') + stack5 = fake_stack( + id='55', stack_status=cluster_status.ROLLBACK_COMPLETE, + stack_status_reason='fake_reason_55') mock_heat_client.stacks.list.return_value = [stack1, stack3, stack5] get_stacks = {'11': stack1, '33': stack3, '55': stack5} @@ -91,35 +94,36 @@ class PeriodicTestCase(base.TestCase): mock_heat_client.stacks.get.side_effect = stack_get_sideefect mock_osc = mock_oscc.return_value mock_osc.heat.return_value = mock_heat_client - mock_bay_list.return_value = [self.bay1, self.bay2, self.bay3, - self.bay5] + mock_cluster_list.return_value = [self.cluster1, self.cluster2, + self.cluster3, self.cluster5] mock_keystone_client = mock.MagicMock() mock_keystone_client.client.project_id = "fake_project" mock_osc.keystone.return_value = mock_keystone_client - periodic.MagnumPeriodicTasks(CONF).sync_bay_status(None) + periodic.MagnumPeriodicTasks(CONF).sync_cluster_status(None) - self.assertEqual(bay_status.CREATE_COMPLETE, self.bay1.status) - self.assertEqual('fake_reason_11', self.bay1.status_reason) - mock_db_destroy.assert_called_once_with(self.bay2.uuid) - self.assertEqual(bay_status.UPDATE_COMPLETE, self.bay3.status) - self.assertEqual('fake_reason_33', self.bay3.status_reason) - self.assertEqual(bay_status.ROLLBACK_COMPLETE, self.bay5.status) - self.assertEqual('fake_reason_55', self.bay5.status_reason) + self.assertEqual(cluster_status.CREATE_COMPLETE, self.cluster1.status) + self.assertEqual('fake_reason_11', self.cluster1.status_reason) + mock_db_destroy.assert_called_once_with(self.cluster2.uuid) + self.assertEqual(cluster_status.UPDATE_COMPLETE, self.cluster3.status) + self.assertEqual('fake_reason_33', self.cluster3.status_reason) + self.assertEqual(cluster_status.ROLLBACK_COMPLETE, + self.cluster5.status) + self.assertEqual('fake_reason_55', self.cluster5.status_reason) - @mock.patch.object(objects.Bay, 'list') + @mock.patch.object(objects.Cluster, 'list') @mock.patch('magnum.common.clients.OpenStackClients') - def test_sync_auth_fail(self, mock_oscc, mock_bay_list): - """Tests handling for unexpected exceptions in _get_bay_stacks() + def test_sync_auth_fail(self, mock_oscc, mock_cluster_list): + """Tests handling for unexpected exceptions in _get_cluster_stacks() It does this by raising an a HTTPUnauthorized exception in Heat client. The affected stack thus missing from the stack list should not lead to - bay state changing in this case. Likewise, subsequent bays should still - change state, despite the affected bay being skipped. + cluster state changing in this case. Likewise, subsequent clusters + should still change state, despite the affected cluster being skipped. """ stack1 = fake_stack(id='11', - stack_status=bay_status.CREATE_COMPLETE) + stack_status=cluster_status.CREATE_COMPLETE) mock_heat_client = mock.MagicMock() @@ -130,23 +134,25 @@ class PeriodicTestCase(base.TestCase): mock_heat_client.stacks.list.return_value = [stack1] mock_osc = mock_oscc.return_value mock_osc.heat.return_value = mock_heat_client - mock_bay_list.return_value = [self.bay1] - periodic.MagnumPeriodicTasks(CONF).sync_bay_status(None) + mock_cluster_list.return_value = [self.cluster1] + periodic.MagnumPeriodicTasks(CONF).sync_cluster_status(None) - self.assertEqual(bay_status.CREATE_IN_PROGRESS, self.bay1.status) + self.assertEqual(cluster_status.CREATE_IN_PROGRESS, + self.cluster1.status) - @mock.patch.object(objects.Bay, 'list') + @mock.patch.object(objects.Cluster, 'list') @mock.patch('magnum.common.clients.OpenStackClients') - def test_sync_bay_status_not_changes(self, mock_oscc, mock_bay_list): + def test_sync_cluster_status_not_changes(self, mock_oscc, + mock_cluster_list): mock_heat_client = mock.MagicMock() stack1 = fake_stack(id='11', - stack_status=bay_status.CREATE_IN_PROGRESS) + stack_status=cluster_status.CREATE_IN_PROGRESS) stack2 = fake_stack(id='22', - stack_status=bay_status.DELETE_IN_PROGRESS) + stack_status=cluster_status.DELETE_IN_PROGRESS) stack3 = fake_stack(id='33', - stack_status=bay_status.UPDATE_IN_PROGRESS) + stack_status=cluster_status.UPDATE_IN_PROGRESS) stack5 = fake_stack(id='55', - stack_status=bay_status.ROLLBACK_IN_PROGRESS) + stack_status=cluster_status.ROLLBACK_IN_PROGRESS) get_stacks = {'11': stack1, '22': stack2, '33': stack3, '55': stack5} def stack_get_sideefect(arg): @@ -159,63 +165,69 @@ class PeriodicTestCase(base.TestCase): stack5] mock_osc = mock_oscc.return_value mock_osc.heat.return_value = mock_heat_client - mock_bay_list.return_value = [self.bay1, self.bay2, self.bay3, - self.bay5] - periodic.MagnumPeriodicTasks(CONF).sync_bay_status(None) + mock_cluster_list.return_value = [self.cluster1, self.cluster2, + self.cluster3, self.cluster5] + periodic.MagnumPeriodicTasks(CONF).sync_cluster_status(None) - self.assertEqual(bay_status.CREATE_IN_PROGRESS, self.bay1.status) - self.assertEqual(bay_status.DELETE_IN_PROGRESS, self.bay2.status) - self.assertEqual(bay_status.UPDATE_IN_PROGRESS, self.bay3.status) - self.assertEqual(bay_status.ROLLBACK_IN_PROGRESS, self.bay5.status) + self.assertEqual(cluster_status.CREATE_IN_PROGRESS, + self.cluster1.status) + self.assertEqual(cluster_status.DELETE_IN_PROGRESS, + self.cluster2.status) + self.assertEqual(cluster_status.UPDATE_IN_PROGRESS, + self.cluster3.status) + self.assertEqual(cluster_status.ROLLBACK_IN_PROGRESS, + self.cluster5.status) - @mock.patch.object(objects.Bay, 'list') + @mock.patch.object(objects.Cluster, 'list') @mock.patch('magnum.common.clients.OpenStackClients') - @mock.patch.object(dbapi.Connection, 'destroy_bay') - @mock.patch.object(dbapi.Connection, 'update_bay') - def test_sync_bay_status_heat_not_found(self, mock_db_update, - mock_db_destroy, mock_oscc, - mock_bay_list): + @mock.patch.object(dbapi.Connection, 'destroy_cluster') + @mock.patch.object(dbapi.Connection, 'update_cluster') + def test_sync_cluster_status_heat_not_found(self, mock_db_update, + mock_db_destroy, mock_oscc, + mock_cluster_list): mock_heat_client = mock.MagicMock() mock_heat_client.stacks.list.return_value = [] mock_osc = mock_oscc.return_value mock_osc.heat.return_value = mock_heat_client - mock_bay_list.return_value = [self.bay1, self.bay2, self.bay3] + mock_cluster_list.return_value = [self.cluster1, self.cluster2, + self.cluster3] mock_keystone_client = mock.MagicMock() mock_keystone_client.client.project_id = "fake_project" mock_osc.keystone.return_value = mock_keystone_client - periodic.MagnumPeriodicTasks(CONF).sync_bay_status(None) + periodic.MagnumPeriodicTasks(CONF).sync_cluster_status(None) - self.assertEqual(bay_status.CREATE_FAILED, self.bay1.status) + self.assertEqual(cluster_status.CREATE_FAILED, self.cluster1.status) self.assertEqual('Stack with id 11 not found in Heat.', - self.bay1.status_reason) - mock_db_destroy.assert_called_once_with(self.bay2.uuid) - self.assertEqual(bay_status.UPDATE_FAILED, self.bay3.status) + self.cluster1.status_reason) + mock_db_destroy.assert_called_once_with(self.cluster2.uuid) + self.assertEqual(cluster_status.UPDATE_FAILED, self.cluster3.status) self.assertEqual('Stack with id 33 not found in Heat.', - self.bay3.status_reason) + self.cluster3.status_reason) @mock.patch('magnum.conductor.monitors.create_monitor') - @mock.patch('magnum.objects.Bay.list') + @mock.patch('magnum.objects.Cluster.list') @mock.patch('magnum.common.rpc.get_notifier') @mock.patch('magnum.common.context.make_admin_context') - def test_send_bay_metrics(self, mock_make_admin_context, mock_get_notifier, - mock_bay_list, mock_create_monitor): + def test_send_cluster_metrics(self, mock_make_admin_context, + mock_get_notifier, mock_cluster_list, + mock_create_monitor): """Test if RPC notifier receives the expected message""" mock_make_admin_context.return_value = self.context notifier = mock.MagicMock() mock_get_notifier.return_value = notifier - mock_bay_list.return_value = [self.bay1, self.bay2, self.bay3, - self.bay4] + mock_cluster_list.return_value = [self.cluster1, self.cluster2, + self.cluster3, self.cluster4] monitor = mock.MagicMock() monitor.get_metric_names.return_value = ['metric1', 'metric2'] monitor.compute_metric_value.return_value = 30 monitor.get_metric_unit.return_value = '%' mock_create_monitor.return_value = monitor - periodic.MagnumPeriodicTasks(CONF)._send_bay_metrics(self.context) + periodic.MagnumPeriodicTasks(CONF)._send_cluster_metrics(self.context) - expected_event_type = 'magnum.bay.metrics.update' + expected_event_type = 'magnum.cluster.metrics.update' expected_metrics = [ { 'name': 'metric1', @@ -229,9 +241,9 @@ class PeriodicTestCase(base.TestCase): }, ] expected_msg = { - 'user_id': self.bay4.user_id, - 'project_id': self.bay4.project_id, - 'resource_id': self.bay4.uuid, + 'user_id': self.cluster4.user_id, + 'project_id': self.cluster4.project_id, + 'resource_id': self.cluster4.uuid, 'metrics': expected_metrics } @@ -240,29 +252,29 @@ class PeriodicTestCase(base.TestCase): self.context, expected_event_type, expected_msg) @mock.patch('magnum.conductor.monitors.create_monitor') - @mock.patch('magnum.objects.Bay.list') + @mock.patch('magnum.objects.Cluster.list') @mock.patch('magnum.common.rpc.get_notifier') @mock.patch('magnum.common.context.make_admin_context') - def test_send_bay_metrics_compute_metric_raise( - self, mock_make_admin_context, mock_get_notifier, mock_bay_list, - mock_create_monitor): + def test_send_cluster_metrics_compute_metric_raise( + self, mock_make_admin_context, mock_get_notifier, + mock_cluster_list, mock_create_monitor): mock_make_admin_context.return_value = self.context notifier = mock.MagicMock() mock_get_notifier.return_value = notifier - mock_bay_list.return_value = [self.bay4] + mock_cluster_list.return_value = [self.cluster4] monitor = mock.MagicMock() monitor.get_metric_names.return_value = ['metric1', 'metric2'] monitor.compute_metric_value.side_effect = Exception( "error on computing metric") mock_create_monitor.return_value = monitor - periodic.MagnumPeriodicTasks(CONF)._send_bay_metrics(self.context) + periodic.MagnumPeriodicTasks(CONF)._send_cluster_metrics(self.context) - expected_event_type = 'magnum.bay.metrics.update' + expected_event_type = 'magnum.cluster.metrics.update' expected_msg = { - 'user_id': self.bay4.user_id, - 'project_id': self.bay4.project_id, - 'resource_id': self.bay4.uuid, + 'user_id': self.cluster4.user_id, + 'project_id': self.cluster4.project_id, + 'resource_id': self.cluster4.uuid, 'metrics': [] } self.assertEqual(1, mock_create_monitor.call_count) @@ -270,39 +282,39 @@ class PeriodicTestCase(base.TestCase): self.context, expected_event_type, expected_msg) @mock.patch('magnum.conductor.monitors.create_monitor') - @mock.patch('magnum.objects.Bay.list') + @mock.patch('magnum.objects.Cluster.list') @mock.patch('magnum.common.rpc.get_notifier') @mock.patch('magnum.common.context.make_admin_context') - def test_send_bay_metrics_pull_data_raise( - self, mock_make_admin_context, mock_get_notifier, mock_bay_list, - mock_create_monitor): + def test_send_cluster_metrics_pull_data_raise( + self, mock_make_admin_context, mock_get_notifier, + mock_cluster_list, mock_create_monitor): mock_make_admin_context.return_value = self.context notifier = mock.MagicMock() mock_get_notifier.return_value = notifier - mock_bay_list.return_value = [self.bay4] + mock_cluster_list.return_value = [self.cluster4] monitor = mock.MagicMock() monitor.pull_data.side_effect = Exception("error on pulling data") mock_create_monitor.return_value = monitor - periodic.MagnumPeriodicTasks(CONF)._send_bay_metrics(self.context) + periodic.MagnumPeriodicTasks(CONF)._send_cluster_metrics(self.context) self.assertEqual(1, mock_create_monitor.call_count) self.assertEqual(0, notifier.info.call_count) @mock.patch('magnum.conductor.monitors.create_monitor') - @mock.patch('magnum.objects.Bay.list') + @mock.patch('magnum.objects.Cluster.list') @mock.patch('magnum.common.rpc.get_notifier') @mock.patch('magnum.common.context.make_admin_context') - def test_send_bay_metrics_monitor_none( - self, mock_make_admin_context, mock_get_notifier, mock_bay_list, - mock_create_monitor): + def test_send_cluster_metrics_monitor_none( + self, mock_make_admin_context, mock_get_notifier, + mock_cluster_list, mock_create_monitor): mock_make_admin_context.return_value = self.context notifier = mock.MagicMock() mock_get_notifier.return_value = notifier - mock_bay_list.return_value = [self.bay4] + mock_cluster_list.return_value = [self.cluster4] mock_create_monitor.return_value = None - periodic.MagnumPeriodicTasks(CONF)._send_bay_metrics(self.context) + periodic.MagnumPeriodicTasks(CONF)._send_cluster_metrics(self.context) self.assertEqual(1, mock_create_monitor.call_count) self.assertEqual(0, notifier.info.call_count)