From 7e18bc10ea5621d2f51d257969cb2c7cc877e674 Mon Sep 17 00:00:00 2001 From: Goutham Pratapa Date: Mon, 22 May 2017 14:07:49 +0530 Subject: [PATCH] Create keypairs in other regions using context. Currently, in Kingbird if a non-admin user sends a request to sync keypairs from one region to other, the resources are created with the nova client formed, using the admin credentials. This commit fixes the internal issues and creates keypairs for the same user based on the context object. -Used Keystoneauth1 instead of keystoneclient -Used loading to get session in order to communicate with other openstack drivers in kingbird. Modified test-cases for the same. Closes-Bug: #1692012 Change-Id: I66fbf4ab207a6615f8070d3a22ea7561e608dcd9 --- kingbird/api/controllers/v1/sync_manager.py | 65 +++++++++++++------ kingbird/common/endpoint_cache.py | 25 +++++-- kingbird/drivers/openstack/nova_v2.py | 37 ++++++----- kingbird/drivers/openstack/sdk.py | 10 +-- kingbird/engine/service.py | 4 +- kingbird/engine/sync_manager.py | 49 +++++++------- kingbird/rpc/client.py | 6 +- .../api/v1/controllers/test_sync_manager.py | 22 +++++-- kingbird/tests/unit/drivers/test_nova_v2.py | 42 ++++++------ .../unit/drivers/test_openstack_driver.py | 50 -------------- kingbird/tests/unit/engine/test_service.py | 5 +- .../tests/unit/engine/test_sync_manager.py | 50 +++++++------- 12 files changed, 176 insertions(+), 189 deletions(-) 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)