diff --git a/kingbird/api/controllers/v1/sync_manager.py b/kingbird/api/controllers/v1/sync_manager.py index 919e722..b4cbe59 100644 --- a/kingbird/api/controllers/v1/sync_manager.py +++ b/kingbird/api/controllers/v1/sync_manager.py @@ -13,7 +13,6 @@ # License for the specific language governing permissions and limitations # under the License. -from oslo_config import cfg from oslo_log import log as logging from oslo_utils import uuidutils @@ -24,14 +23,13 @@ from pecan import request from kingbird.api.controllers import restcomm from kingbird.common import consts +from kingbird.common.endpoint_cache import EndpointCache from kingbird.common import exceptions from kingbird.common.i18n import _ from kingbird.db.sqlalchemy import api as db_api -from kingbird.drivers.openstack import sdk +from kingbird.drivers.openstack.nova_v2 import NovaClient from kingbird.rpc import client as rpc_client -CONF = cfg.CONF - LOG = logging.getLogger(__name__) @@ -57,6 +55,13 @@ class ResourceSyncController(object): @index.when(method='GET', template='json') def get(self, project, action=None): + """Get details about Sync Job. + + :param project: It's UUID of the project. + :param action: Optional. If provided, it can be + 'active' to get the list of active jobs. + 'job-id' to get the details of a job. + """ context = restcomm.extract_context_from_environ() if not uuidutils.is_uuid_like(project) or project != context.project: pecan.abort(400, _('Invalid request URL')) @@ -75,32 +80,38 @@ class ResourceSyncController(object): @index.when(method='POST', template='json') def post(self, project): + """Sync resources present in one region to another region. + + :param project: It's UUID of the project. + """ context = restcomm.extract_context_from_environ() if not uuidutils.is_uuid_like(project) or project != context.project: pecan.abort(400, _('Invalid request URL')) - if not request.body: - pecan.abort(400, _('Body required')) payload = eval(request.body) + if not payload: + pecan.abort(400, _('Body required')) payload = payload.get('resource_set') if not payload: pecan.abort(400, _('resource_set required')) + resource_type = payload.get('resource_type') target_regions = payload.get('target') if not target_regions or not isinstance(target_regions, list): pecan.abort(400, _('Target regions required')) source_region = payload.get('source') if not source_region or not isinstance(source_region, str): pecan.abort(400, _('Source region required')) - if payload.get('resource_type') == consts.KEYPAIR: - user_id = context.user - source_keys = payload.get('resources') - if not source_keys: - pecan.abort(400, _('Source keypairs required')) + source_resources = payload.get('resources') + if not source_resources: + pecan.abort(400, _('Source resources required')) + if resource_type == consts.KEYPAIR: + session = EndpointCache().get_session_from_token( + context.auth_token, context.project) # Create Source Region object - source_os_client = sdk.OpenStackDriver(source_region) + source_nova_client = NovaClient(source_region, session) # Check for keypairs in Source Region - for source_keypair in source_keys: - source_keypair = source_os_client.get_keypairs(user_id, - source_keypair) + for source_keypair in source_resources: + source_keypair = source_nova_client.\ + get_keypairs(source_keypair) if not source_keypair: pecan.abort(404) job_id = uuidutils.generate_uuid() @@ -111,20 +122,25 @@ class ResourceSyncController(object): pecan.abort(404, _('Job not found')) # Insert into the child table for region in target_regions: - for keypair in source_keys: + for keypair in source_resources: try: db_api.resource_sync_create(context, result, region, source_region, keypair, consts.KEYPAIR) except exceptions.JobNotFound: pecan.abort(404, _('Job not found')) - return self._keypair_sync(job_id, user_id, payload, context, - result) + return self._keypair_sync(job_id, payload, context, result) else: pecan.abort(400, _('Bad resource_type')) @index.when(method='delete', template='json') def delete(self, project, job_id): + """Delete the database entries of a given job_id. + + :param project: It's UUID of the project. + :param job_id: ID of the job for which the database entries + have to be deleted. + """ context = restcomm.extract_context_from_environ() if not uuidutils.is_uuid_like(project) or project != context.project: pecan.abort(400, _('Invalid request URL')) @@ -144,9 +160,16 @@ class ResourceSyncController(object): else: pecan.abort(400, _('Bad request')) - def _keypair_sync(self, job_id, user_id, payload, context, result): - self.rpc_client.keypair_sync_for_user(context, job_id, payload, - user_id) + def _keypair_sync(self, job_id, payload, context, result): + """Make an rpc call to kb-engine. + + :param job_id: ID of the job to update values in database based on + the job_id. + :param payload: payload object. + :param context: context of the request. + :param result: Result object to return an output. + """ + self.rpc_client.keypair_sync_for_user(context, job_id, payload) return {'job_status': {'id': result.id, 'status': result.sync_status, 'created_at': result.created_at}} diff --git a/kingbird/common/endpoint_cache.py b/kingbird/common/endpoint_cache.py index b14b37d..7628e6e 100644 --- a/kingbird/common/endpoint_cache.py +++ b/kingbird/common/endpoint_cache.py @@ -15,9 +15,10 @@ import collections -from keystoneclient.auth.identity import v3 as auth_identity +from keystoneauth1.identity import v3 as auth_identity +from keystoneauth1 import loading +from keystoneauth1 import session from keystoneclient.auth import token_endpoint -from keystoneclient import session from keystoneclient.v3 import client as keystone_client from oslo_config import cfg @@ -88,7 +89,7 @@ class EndpointCache(object): service] = endpoint_map[region][service] def get_endpoint(self, region, service): - """Get service endpoint url + """Get service endpoint url. :param region: region the service belongs to :param service: service type @@ -97,15 +98,29 @@ class EndpointCache(object): return self._get_endpoint(region, service, True) def update_endpoints(self): - """Update endpoint cache from Keystone + """Update endpoint cache from Keystone. :return: None """ self._update_endpoints() def get_all_regions(self): - """Get region list + """Get region list. return: List of regions """ return self.endpoint_map.keys() + + def get_session_from_token(self, token, project_id): + """Get session based on token to communicate with openstack services. + + :param token: token with which the request is triggered. + :param project_id: UUID of the project. + + :return: session object. + """ + loader = loading.get_plugin_loader('token') + auth = loader.load_from_options(auth_url=cfg.CONF.cache.auth_uri, + token=token, project_id=project_id) + sess = session.Session(auth=auth) + return sess diff --git a/kingbird/drivers/openstack/nova_v2.py b/kingbird/drivers/openstack/nova_v2.py index 2cb3ec0..7298d95 100644 --- a/kingbird/drivers/openstack/nova_v2.py +++ b/kingbird/drivers/openstack/nova_v2.py @@ -26,21 +26,23 @@ API_VERSION = '2.37' class NovaClient(base.DriverBase): - '''Nova V2.37 driver.''' - def __init__(self, region, disabled_quotas, session): + """Nova V2.37 driver.""" + + def __init__(self, region, session, disabled_quotas=None): try: self.nova_client = client.Client(API_VERSION, session=session, region_name=region) - self.enabled_quotas = list(set(consts.NOVA_QUOTA_FIELDS) - - set(disabled_quotas)) - self.no_neutron = True if 'floatingips' in self.enabled_quotas \ - or 'fixedips' in self.enabled_quotas else False + if disabled_quotas: + self.enabled_quotas = list(set(consts.NOVA_QUOTA_FIELDS) - + set(disabled_quotas)) + self.no_neutron = True if 'floatingips' in self.enabled_quotas \ + or 'fixedips' in self.enabled_quotas else False except exceptions.ServiceUnavailable: raise def get_resource_usages(self, project_id): - """Collect resource usages for a given project + """Collect resource usages for a given project. :params: project_id :return: dictionary of corresponding resources with its usage @@ -69,7 +71,7 @@ class NovaClient(base.DriverBase): raise def update_quota_limits(self, project_id, **new_quota): - """Update quota limits for a given project + """Update quota limits for a given project. :params: project_id, dictionary with the quota limits to update :return: Nothing @@ -88,7 +90,7 @@ class NovaClient(base.DriverBase): raise def delete_quota_limits(self, project_id): - """Delete/Reset quota limits for a given project + """Delete/Reset quota limits for a given project. :params: project_id :return: Nothing @@ -98,14 +100,14 @@ class NovaClient(base.DriverBase): except exceptions.InternalError: raise - def get_keypairs(self, user_id, res_id): - """Display keypair of the specified User + def get_keypairs(self, res_id): + """Display keypair of the specified User. - :params: user_id and resource_identifier + :params: resource_identifier :return: Keypair """ try: - keypair = self.nova_client.keypairs.get(res_id, user_id) + keypair = self.nova_client.keypairs.get(res_id) LOG.info("Source Keypair: %s", keypair.name) return keypair @@ -113,15 +115,15 @@ class NovaClient(base.DriverBase): LOG.error('Exception Occurred: %s', exception.message) pass - def create_keypairs(self, force, keypair, user_id): - """Create keypair for the specified User + def create_keypairs(self, force, keypair): + """Create keypair for the specified User. - :params: user_id, keypair, force + :params: keypair, force :return: Creates a Keypair """ if force: try: - self.nova_client.keypairs.delete(keypair, user_id) + self.nova_client.keypairs.delete(keypair) LOG.info("Deleted Keypair: %s", keypair.name) except Exception as exception: LOG.error('Exception Occurred: %s', exception.message) @@ -129,5 +131,4 @@ class NovaClient(base.DriverBase): LOG.info("Created Keypair: %s", keypair.name) return self.nova_client.keypairs. \ create(keypair.name, - user_id=user_id, public_key=keypair.public_key) diff --git a/kingbird/drivers/openstack/sdk.py b/kingbird/drivers/openstack/sdk.py index 566567d..129efa3 100644 --- a/kingbird/drivers/openstack/sdk.py +++ b/kingbird/drivers/openstack/sdk.py @@ -66,8 +66,8 @@ class OpenStackDriver(object): self.disabled_quotas, self.keystone_client.session) self.nova_client = NovaClient(region_name, - self.disabled_quotas, - self.keystone_client.session) + self.keystone_client.session, + self.disabled_quotas) self.cinder_client = CinderClient(region_name, self.disabled_quotas, self.keystone_client.session) @@ -182,9 +182,3 @@ class OpenStackDriver(object): return False else: return True - - def get_keypairs(self, user_id, resource_identifier): - return self.nova_client.get_keypairs(user_id, resource_identifier) - - def create_keypairs(self, force, keypair, user_id): - return self.nova_client.create_keypairs(force, keypair, user_id) diff --git a/kingbird/engine/service.py b/kingbird/engine/service.py index 93bc77c..a7cb0df 100644 --- a/kingbird/engine/service.py +++ b/kingbird/engine/service.py @@ -154,9 +154,9 @@ class EngineService(service.Service): self.qm.quota_sync_for_project(project_id) @request_context - def keypair_sync_for_user(self, ctxt, user_id, job_id, payload): + def keypair_sync_for_user(self, ctxt, job_id, payload): # Keypair Sync for a user, will be triggered by KB-API - self.sm.keypair_sync_for_user(user_id, job_id, payload) + self.sm.keypair_sync_for_user(ctxt, job_id, payload) def _stop_rpc_server(self): # Stop RPC connection to prevent new requests diff --git a/kingbird/engine/sync_manager.py b/kingbird/engine/sync_manager.py index 70b56b6..986f53f 100644 --- a/kingbird/engine/sync_manager.py +++ b/kingbird/engine/sync_manager.py @@ -1,4 +1,4 @@ -# Copyright 2017 Ericsson AB +# Copyright 2017 Ericsson AB. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -18,43 +18,42 @@ import threading from oslo_log import log as logging from kingbird.common import consts -from kingbird.common import context +from kingbird.common.endpoint_cache import EndpointCache from kingbird.common import exceptions -from kingbird.common import manager from kingbird.db.sqlalchemy import api as db_api -from kingbird.drivers.openstack import sdk +from kingbird.drivers.openstack.nova_v2 import NovaClient LOG = logging.getLogger(__name__) -class SyncManager(manager.Manager): +class SyncManager(object): """Manages tasks related to resource management""" def __init__(self, *args, **kwargs): - super(SyncManager, self).__init__(service_name="sync_manager", - *args, **kwargs) - self.context = context.get_admin_context() + super(SyncManager, self).__init__() def _create_keypairs_in_region(self, job_id, force, target_regions, - source_keypair, user_id): + source_keypair, session, context): regions_thread = list() for region in target_regions: thread = threading.Thread(target=self._create_keypairs, args=(job_id, force, region, - source_keypair, user_id,)) + source_keypair, session, + context)) regions_thread.append(thread) thread.start() for region_thread in regions_thread: region_thread.join() - def _create_keypairs(self, job_id, force, region, source_keypair, user_id): - os_client = sdk.OpenStackDriver(region) + def _create_keypairs(self, job_id, force, region, source_keypair, + session, context): + target_nova_client = NovaClient(region, session) try: - os_client.create_keypairs(force, source_keypair, user_id) + target_nova_client.create_keypairs(force, source_keypair) LOG.info('keypair %(keypair)s created in %(region)s' % {'keypair': source_keypair.name, 'region': region}) try: - db_api.resource_sync_update(self.context, job_id, region, + db_api.resource_sync_update(context, job_id, region, source_keypair.name, consts.JOB_SUCCESS) except exceptions.JobNotFound(): @@ -63,27 +62,29 @@ class SyncManager(manager.Manager): LOG.error('Exception Occurred: %(msg)s in %(region)s' % {'msg': exc.message, 'region': region}) try: - db_api.resource_sync_update(self.context, job_id, region, + db_api.resource_sync_update(context, job_id, region, source_keypair.name, consts.JOB_FAILURE) except exceptions.JobNotFound(): raise pass - def keypair_sync_for_user(self, user_id, job_id, payload): - LOG.info("Keypair sync Called for user: %s", - user_id) + def keypair_sync_for_user(self, context, job_id, payload): keypairs_thread = list() target_regions = payload['target'] force = eval(str(payload.get('force', False))) resource_ids = payload.get('resources') - source_os_client = sdk.OpenStackDriver(payload['source']) + source_region = payload['source'] + session = EndpointCache().get_session_from_token( + context.auth_token, context.project) + # Create Source Region object + source_nova_client = NovaClient(source_region, session) for keypair in resource_ids: - source_keypair = source_os_client.get_keypairs(user_id, - keypair) + source_keypair = source_nova_client.get_keypairs(keypair) thread = threading.Thread(target=self._create_keypairs_in_region, args=(job_id, force, target_regions, - source_keypair, user_id,)) + source_keypair, session, + context,)) keypairs_thread.append(thread) thread.start() for keypair_thread in keypairs_thread: @@ -92,13 +93,13 @@ class SyncManager(manager.Manager): # Update the parent_db after the sync try: resource_sync_details = db_api.\ - resource_sync_status(self.context, job_id) + resource_sync_status(context, job_id) except exceptions.JobNotFound: raise result = consts.JOB_SUCCESS if consts.JOB_FAILURE in resource_sync_details: result = consts.JOB_FAILURE try: - db_api.sync_job_update(self.context, job_id, result) + db_api.sync_job_update(context, job_id, result) except exceptions.JobNotFound: raise diff --git a/kingbird/rpc/client.py b/kingbird/rpc/client.py index 023b18a..9a594df 100644 --- a/kingbird/rpc/client.py +++ b/kingbird/rpc/client.py @@ -69,8 +69,8 @@ class EngineClient(object): return self.cast(ctxt, self.make_msg('quota_sync_for_project', project_id=project_id)) - def keypair_sync_for_user(self, ctxt, job_id, payload, user_id): + def keypair_sync_for_user(self, ctxt, job_id, payload): return self.cast( ctxt, - self.make_msg('keypair_sync_for_user', - user_id=user_id, job_id=job_id, payload=payload)) + self.make_msg('keypair_sync_for_user', job_id=job_id, + payload=payload)) diff --git a/kingbird/tests/unit/api/v1/controllers/test_sync_manager.py b/kingbird/tests/unit/api/v1/controllers/test_sync_manager.py index ba2201c..0b1f696 100644 --- a/kingbird/tests/unit/api/v1/controllers/test_sync_manager.py +++ b/kingbird/tests/unit/api/v1/controllers/test_sync_manager.py @@ -60,9 +60,11 @@ class TestResourceManager(testroot.KBApiTest): self.ctx = utils.dummy_context() @mock.patch.object(rpc_client, 'EngineClient') - @mock.patch.object(sync_manager, 'sdk') + @mock.patch.object(sync_manager, 'NovaClient') + @mock.patch.object(sync_manager, 'EndpointCache') @mock.patch.object(sync_manager, 'db_api') - def test_post_keypair_sync(self, mock_db_api, mock_sdk, mock_rpc_client): + def test_post_keypair_sync(self, mock_db_api, mock_endpoint_cache, + mock_nova, mock_rpc_client): time_now = timeutils.utcnow() data = {"resource_set": {"resources": [SOURCE_KEYPAIR], "resource_type": "keypair", @@ -71,13 +73,15 @@ class TestResourceManager(testroot.KBApiTest): "target": [FAKE_TARGET_REGION]}} fake_key = FakeKeypair('fake_name', 'fake-rsa') sync_job_result = SyncJob(FAKE_JOB, consts.JOB_PROGRESS, time_now) - mock_sdk.OpenStackDriver().get_keypairs.return_value = fake_key + mock_endpoint_cache().get_session_from_token.\ + return_value = 'fake_session' + mock_nova().get_keypairs.return_value = fake_key mock_db_api.sync_job_create.return_value = sync_job_result response = self.app.post_json(FAKE_URL, headers=FAKE_HEADERS, params=data) self.assertEqual(1, - mock_sdk.OpenStackDriver().get_keypairs.call_count) + mock_nova().get_keypairs.call_count) self.assertEqual(1, mock_db_api.resource_sync_create.call_count) self.assertEqual(1, @@ -148,14 +152,18 @@ class TestResourceManager(testroot.KBApiTest): headers=FAKE_HEADERS, params=data) @mock.patch.object(rpc_client, 'EngineClient') - @mock.patch.object(sync_manager, 'sdk') - def test_post_no_keypairs_in_region(self, mock_sdk, mock_rpc_client): + @mock.patch.object(sync_manager, 'EndpointCache') + @mock.patch.object(sync_manager, 'NovaClient') + def test_post_no_keypairs_in_region(self, mock_nova, mock_endpoint_cache, + mock_rpc_client): data = {"resource_set": {"resources": [SOURCE_KEYPAIR], "resource_type": "keypair", "force": "True", "source": FAKE_SOURCE_REGION, "target": [FAKE_TARGET_REGION]}} - mock_sdk.OpenStackDriver().get_keypairs.return_value = None + mock_endpoint_cache().get_session_from_token.\ + return_value = 'fake_session' + mock_nova().get_keypairs.return_value = None self.assertRaisesRegexp(webtest.app.AppError, "404 *", self.app.post_json, FAKE_URL, headers=FAKE_HEADERS, params=data) diff --git a/kingbird/tests/unit/drivers/test_nova_v2.py b/kingbird/tests/unit/drivers/test_nova_v2.py index d0229ce..fc10a4b 100644 --- a/kingbird/tests/unit/drivers/test_nova_v2.py +++ b/kingbird/tests/unit/drivers/test_nova_v2.py @@ -70,8 +70,8 @@ class TestNovaClient(base.KingbirdTestCase): self.user = 'fake_user' def test_init(self): - nv_client = nova_v2.NovaClient('fake_region', DISABLED_QUOTAS, - self.session) + nv_client = nova_v2.NovaClient('fake_region', self.session, + DISABLED_QUOTAS) self.assertIsNotNone(nv_client) expected_quotas = list(set(consts.NOVA_QUOTA_FIELDS) - set(DISABLED_QUOTAS)) @@ -84,8 +84,8 @@ class TestNovaClient(base.KingbirdTestCase): mock_novaclient.Client().keypairs.list.return_value = FAKE_KEYPAIRS mock_novaclient.Client().limits.get().to_dict.return_value = \ FAKE_LIMITS - nv_client = nova_v2.NovaClient('fake_region', DISABLED_QUOTAS, - self.session) + nv_client = nova_v2.NovaClient('fake_region', self.session, + DISABLED_QUOTAS) total_nova_usage = nv_client.get_resource_usages(self.project) self.assertEqual(total_nova_usage['ram'], 512 * 2) self.assertEqual(total_nova_usage['cores'], 2) @@ -94,8 +94,8 @@ class TestNovaClient(base.KingbirdTestCase): @mock.patch.object(nova_v2, 'client') def test_update_quota_limits(self, mock_novaclient): - nv_client = nova_v2.NovaClient('fake_region', DISABLED_QUOTAS, - self.session) + nv_client = nova_v2.NovaClient('fake_region', self.session, + DISABLED_QUOTAS) new_quota = {'ram': 100, 'cores': 50} nv_client.update_quota_limits(self.project, **new_quota) mock_novaclient.Client().quotas.update.assert_called_once_with( @@ -103,8 +103,8 @@ class TestNovaClient(base.KingbirdTestCase): @mock.patch.object(nova_v2, 'client') def test_delete_quota_limits(self, mock_novaclient): - nv_client = nova_v2.NovaClient('fake_region', DISABLED_QUOTAS, - self.session) + nv_client = nova_v2.NovaClient('fake_region', self.session, + DISABLED_QUOTAS) new_quota = {'ram': 100, 'cores': 50} nv_client.update_quota_limits(self.project, **new_quota) @@ -116,33 +116,33 @@ class TestNovaClient(base.KingbirdTestCase): @mock.patch.object(nova_v2, 'client') def test_get_keypairs(self, mock_novaclient): - nv_client = nova_v2.NovaClient('fake_region', DISABLED_QUOTAS, - self.session) - nv_client.get_keypairs(self.user, FAKE_RESOURCE_ID) + nv_client = nova_v2.NovaClient('fake_region', self.session, + DISABLED_QUOTAS) + nv_client.get_keypairs(FAKE_RESOURCE_ID) mock_novaclient.Client().keypairs.get.return_value = 'key1' mock_novaclient.Client().keypairs.get.\ - assert_called_once_with(FAKE_RESOURCE_ID, self.user) + assert_called_once_with(FAKE_RESOURCE_ID) @mock.patch.object(nova_v2, 'client') def test_create_keypairs_with_force_false(self, mock_novaclient): - nv_client = nova_v2.NovaClient('fake_region', DISABLED_QUOTAS, - self.session) + nv_client = nova_v2.NovaClient('fake_region', self.session, + DISABLED_QUOTAS) fake_key = FakeKeypair('fake_name', 'fake-rsa') - nv_client.create_keypairs(DEFAULT_FORCE, fake_key, self.user) + nv_client.create_keypairs(DEFAULT_FORCE, fake_key) self.assertEqual(0, mock_novaclient.Client().keypairs.delete.call_count) mock_novaclient.Client().keypairs.create.\ - assert_called_once_with(fake_key.name, user_id=self.user, + assert_called_once_with(fake_key.name, public_key=fake_key.public_key) @mock.patch.object(nova_v2, 'client') def test_create_keypairs_with_force_true(self, mock_novaclient): - nv_client = nova_v2.NovaClient('fake_region', DISABLED_QUOTAS, - self.session) + nv_client = nova_v2.NovaClient('fake_region', self.session, + DISABLED_QUOTAS) fake_key = FakeKeypair('fake_name', 'fake-rsa') - nv_client.create_keypairs(True, fake_key, self.user) + nv_client.create_keypairs(True, fake_key) mock_novaclient.Client().keypairs.delete.\ - assert_called_once_with(fake_key, self.user) + assert_called_once_with(fake_key) mock_novaclient.Client().keypairs.create.\ - assert_called_once_with(fake_key.name, user_id=self.user, + assert_called_once_with(fake_key.name, public_key=fake_key.public_key) diff --git a/kingbird/tests/unit/drivers/test_openstack_driver.py b/kingbird/tests/unit/drivers/test_openstack_driver.py index 31564ee..ccb4ea2 100644 --- a/kingbird/tests/unit/drivers/test_openstack_driver.py +++ b/kingbird/tests/unit/drivers/test_openstack_driver.py @@ -303,53 +303,3 @@ class TestOpenStackDriver(base.KingbirdTestCase): os_driver = sdk.OpenStackDriver() expected = os_driver._is_token_valid() self.assertEqual(expected, False) - - @mock.patch.object(sdk.OpenStackDriver, 'os_clients_dict') - @mock.patch.object(sdk, 'KeystoneClient') - @mock.patch.object(sdk, 'NovaClient') - @mock.patch.object(sdk, 'NeutronClient') - @mock.patch.object(sdk, 'CinderClient') - def test_get_keypairs(self, mock_cinder_client, - mock_network_client, - mock_nova_client, mock_keystone_client, - mock_os_client): - os_driver = sdk.OpenStackDriver() - os_driver.get_keypairs(FAKE_USER_ID, FAKE_RESOURCE_ID) - mock_nova_client().get_keypairs.\ - assert_called_once_with(FAKE_USER_ID, FAKE_RESOURCE_ID) - - @mock.patch.object(sdk.OpenStackDriver, 'os_clients_dict') - @mock.patch.object(sdk, 'KeystoneClient') - @mock.patch.object(sdk, 'NovaClient') - @mock.patch.object(sdk, 'NeutronClient') - @mock.patch.object(sdk, 'CinderClient') - def test_create_keypairs_with_force_false(self, mock_cinder_client, - mock_network_client, - mock_nova_client, - mock_keystone_client, - mock_os_client): - os_driver = sdk.OpenStackDriver() - fake_key = FakeKeypair('fake_name', 'fake-rsa') - os_driver.create_keypairs(False, fake_key, - FAKE_USER_ID) - mock_nova_client().create_keypairs.\ - assert_called_once_with(False, fake_key, - FAKE_USER_ID) - - @mock.patch.object(sdk.OpenStackDriver, 'os_clients_dict') - @mock.patch.object(sdk, 'KeystoneClient') - @mock.patch.object(sdk, 'NovaClient') - @mock.patch.object(sdk, 'NeutronClient') - @mock.patch.object(sdk, 'CinderClient') - def test_create_keypairs_with_force_true(self, mock_cinder_client, - mock_network_client, - mock_nova_client, - mock_keystone_client, - mock_os_client): - os_driver = sdk.OpenStackDriver() - fake_key = FakeKeypair('fake_name', 'fake-rsa') - os_driver.create_keypairs(True, fake_key, - FAKE_USER_ID) - mock_nova_client().create_keypairs.\ - assert_called_once_with(True, fake_key, - FAKE_USER_ID) diff --git a/kingbird/tests/unit/engine/test_service.py b/kingbird/tests/unit/engine/test_service.py index 3bed385..9d36e8e 100644 --- a/kingbird/tests/unit/engine/test_service.py +++ b/kingbird/tests/unit/engine/test_service.py @@ -115,7 +115,6 @@ class TestEngineService(base.KingbirdTestCase): self.service_obj.init_tgm() self.service_obj.init_sm() self.service_obj.keypair_sync_for_user( - self.context, self.user_id, - self.job_id, self.payload,) + self.context, self.job_id, self.payload,) mock_sync_manager().keypair_sync_for_user.\ - assert_called_once_with(self.user_id, self.job_id, self.payload) + assert_called_once_with(self.context, self.job_id, self.payload) diff --git a/kingbird/tests/unit/engine/test_sync_manager.py b/kingbird/tests/unit/engine/test_sync_manager.py index e90a3f9..6771dd6 100644 --- a/kingbird/tests/unit/engine/test_sync_manager.py +++ b/kingbird/tests/unit/engine/test_sync_manager.py @@ -37,58 +37,54 @@ class TestSyncManager(base.KingbirdTestCase): super(TestSyncManager, self).setUp() self.ctxt = utils.dummy_context() - @mock.patch.object(sync_manager, 'context') - def test_init(self, mock_context): - mock_context.get_admin_context.return_value = self.ctxt - sm = sync_manager.SyncManager() - self.assertIsNotNone(sm) - self.assertEqual('sync_manager', sm.service_name) - self.assertEqual('localhost', sm.host) - self.assertEqual(self.ctxt, sm.context) - - @mock.patch.object(sync_manager, 'sdk') + @mock.patch.object(sync_manager, 'NovaClient') + @mock.patch.object(sync_manager, 'EndpointCache') @mock.patch.object(sync_manager.SyncManager, '_create_keypairs') @mock.patch.object(sync_manager, 'db_api') def test_keypair_sync_force_false(self, mock_db_api, mock_create_keypair, - mock_sdk): - payload = {} + mock_endpoint_cache, mock_nova): + payload = dict() payload['target'] = [FAKE_TARGET_REGION] payload['force'] = DEFAULT_FORCE payload['source'] = FAKE_SOURCE_REGION payload['resources'] = [SOURCE_KEYPAIR] fake_key = FakeKeypair('fake_name', 'fake-rsa') - mock_sdk.OpenStackDriver().get_keypairs.return_value = fake_key + mock_endpoint_cache().get_session_from_token.\ + return_value = 'fake_session' + mock_nova().get_keypairs.return_value = fake_key sm = sync_manager.SyncManager() - sm.keypair_sync_for_user(FAKE_USER_ID, FAKE_JOB_ID, payload) + sm.keypair_sync_for_user(self.ctxt, FAKE_JOB_ID, payload) mock_create_keypair.assert_called_once_with( FAKE_JOB_ID, payload['force'], payload['target'][0], fake_key, - FAKE_USER_ID) + 'fake_session', self.ctxt) - @mock.patch.object(sync_manager, 'sdk') + @mock.patch.object(sync_manager, 'NovaClient') + @mock.patch.object(sync_manager, 'EndpointCache') @mock.patch.object(sync_manager.SyncManager, '_create_keypairs') @mock.patch.object(sync_manager, 'db_api') def test_keypair_sync_force_true(self, mock_db_api, mock_create_keypair, - mock_sdk): - + mock_endpoint_cache, mock_nova): payload = dict() payload['target'] = [FAKE_TARGET_REGION] payload['force'] = True payload['source'] = FAKE_SOURCE_REGION payload['resources'] = [SOURCE_KEYPAIR] fake_key = FakeKeypair('fake_name', 'fake-rsa') - mock_sdk.OpenStackDriver().get_keypairs.return_value = fake_key + mock_endpoint_cache().get_session_from_token.\ + return_value = 'fake_session' + mock_nova().get_keypairs.return_value = fake_key sm = sync_manager.SyncManager() - sm.keypair_sync_for_user(FAKE_USER_ID, FAKE_JOB_ID, payload) + sm.keypair_sync_for_user(self.ctxt, FAKE_JOB_ID, payload) mock_create_keypair.assert_called_once_with( - FAKE_JOB_ID, payload['force'], FAKE_TARGET_REGION, fake_key, - FAKE_USER_ID) + FAKE_JOB_ID, payload['force'], payload['target'][0], fake_key, + 'fake_session', self.ctxt) - @mock.patch.object(sync_manager, 'sdk') + @mock.patch.object(sync_manager, 'NovaClient') @mock.patch.object(sync_manager, 'db_api') - def test_create_keypair(self, mock_db_api, mock_sdk): + def test_create_keypair(self, mock_db_api, mock_nova): fake_key = FakeKeypair('fake_name', 'fake-rsa') sm = sync_manager.SyncManager() sm._create_keypairs(FAKE_JOB_ID, DEFAULT_FORCE, FAKE_TARGET_REGION, - fake_key, FAKE_USER_ID) - mock_sdk.OpenStackDriver().create_keypairs.\ - assert_called_once_with(DEFAULT_FORCE, fake_key, FAKE_USER_ID) + fake_key, 'fake_session', self.ctxt) + mock_nova().create_keypairs.\ + assert_called_once_with(DEFAULT_FORCE, fake_key)