def tearDown(self): # Remove the instance type from the database db.volume_type_purge(context.get_admin_context(), self.vol_type1['name']) db.volume_type_purge(context.get_admin_context(), self.vol_type2_noextra['name']) super(VolumeTypeExtraSpecsTestCase, self).tearDown()
def add_role(self, uid, role, project_id=None): """Add role for user (or user and project)""" if not project_id: db.user_add_role(context.get_admin_context(), uid, role) return db.user_add_project_role(context.get_admin_context(), uid, project_id, role)
def setUp(self): super(CloudpipeTest, self).setUp() self.flags(allow_admin_api=True) self.app = fakes.wsgi_app() inner_app = v2.APIRouter() adm_ctxt = context.get_admin_context() self.app = auth.InjectContext(adm_ctxt, inner_app) route = inner_app.map.match('/1234/os-cloudpipe') self.controller = route['controller'].controller fakes.stub_out_networking(self.stubs) fakes.stub_out_rate_limiting(self.stubs) self.stubs.Set(db, "instance_get_all_by_project", db_instance_get_all_by_project) self.stubs.Set(db, "security_group_exists", db_security_group_exists) self.stubs.SmartSet(self.controller.cloudpipe, "launch_vpn_instance", pipelib_launch_vpn_instance) #self.stubs.SmartSet(self.controller.auth_manager, "get_project", # auth_manager_get_project) #self.stubs.SmartSet(self.controller.auth_manager, "get_projects", # auth_manager_get_projects) # NOTE(todd): The above code (just setting the stub, not invoking it) # causes failures in AuthManagerLdapTestCase. So use a fake object. self.controller.auth_manager = FakeAuthManager() self.stubs.Set(utils, 'vpn_ping', utils_vpn_ping) self.context = context.get_admin_context() global EMPTY_INSTANCE_LIST EMPTY_INSTANCE_LIST = True
def get_projects(self, uid=None): """Retrieve list of projects""" if uid: result = db.project_get_by_user(context.get_admin_context(), uid) else: result = db.project_get_all(context.get_admin_context()) return [self._db_project_to_auth_projectuser(proj) for proj in result]
def remove_role(self, uid, role, project_id=None): """Remove role for user (or user and project)""" if not project_id: db.user_remove_role(context.get_admin_context(), uid, role) return db.user_remove_project_role(context.get_admin_context(), uid, project_id, role)
def test_volume_type_extra_specs_delete(self): expected_specs = self.vol_type1_specs.copy() del expected_specs['vol_extra2'] db.volume_type_extra_specs_delete(context.get_admin_context(), self.volume_type1_id, 'vol_extra2') actual_specs = db.volume_type_extra_specs_get( context.get_admin_context(), self.volume_type1_id) self.assertEquals(expected_specs, actual_specs)
def test_volume_type_get_with_extra_specs(self): volume_type = db.volume_type_get(context.get_admin_context(), self.volume_type1_id) self.assertEquals(volume_type['extra_specs'], self.vol_type1_specs) volume_type = db.volume_type_get(context.get_admin_context(), self.vol_type2_id) self.assertEquals(volume_type['extra_specs'], {})
def test_volume_type_get_by_name_with_extra_specs(self): volume_type = db.volume_type_get_by_name(context.get_admin_context(), self.vol_type1['name']) self.assertEquals(volume_type['extra_specs'], self.vol_type1_specs) volume_type = db.volume_type_get_by_name( context.get_admin_context(), self.vol_type2_noextra['name']) self.assertEquals(volume_type['extra_specs'], {})
def _validate_user_and_project(self, user_id, project_id): user = db.user_get(context.get_admin_context(), user_id) if not user: raise exception.UserNotFound(user_id=user_id) project = db.project_get(context.get_admin_context(), project_id) if not project: raise exception.ProjectNotFound(project_id=project_id) return user, project
def get_user_roles(self, uid, project_id=None): """Retrieve list of roles for user (or user and project)""" if project_id is None: roles = db.user_get_roles(context.get_admin_context(), uid) return roles else: roles = db.user_get_roles_for_project(context.get_admin_context(), uid, project_id) return roles
def test_volume_type_extra_specs_update(self): expected_specs = self.vol_type1_specs.copy() expected_specs['vol_extra3'] = "4" db.volume_type_extra_specs_update_or_create( context.get_admin_context(), self.volume_type1_id, dict(vol_extra3=4)) actual_specs = db.volume_type_extra_specs_get( context.get_admin_context(), self.volume_type1_id) self.assertEquals(expected_specs, actual_specs)
def test_too_many_addresses(self): address = '192.168.0.100' db.floating_ip_create(context.get_admin_context(), {'address': address, 'project_id': self.project_id}) self.assertRaises(exception.QuotaError, self.network.allocate_floating_ip, self.context, self.project_id) db.floating_ip_destroy(context.get_admin_context(), address)
def test_service_disabled_on_create_based_on_flag(self): self.flags(enable_new_services=False) host = 'foo' binary = 'engine-fake' app = service.Service.create(host=host, binary=binary) app.start() app.stop() ref = db.service_get(context.get_admin_context(), app.service_id) db.service_destroy(context.get_admin_context(), app.service_id) self.assert_(ref['disabled'])
def test_volume_type_extra_specs_create(self): expected_specs = self.vol_type1_specs.copy() expected_specs['vol_extra4'] = 'value4' expected_specs['vol_extra5'] = 'value5' db.volume_type_extra_specs_update_or_create( context.get_admin_context(), self.volume_type1_id, dict(vol_extra4="value4", vol_extra5="value5")) actual_specs = db.volume_type_extra_specs_get( context.get_admin_context(), self.volume_type1_id) self.assertEquals(expected_specs, actual_specs)
def test_too_many_addresses(self): address = '192.168.0.100' db.floating_ip_create(context.get_admin_context(), { 'address': address, 'project_id': self.project_id }) self.assertRaises(exception.QuotaError, self.network.allocate_floating_ip, self.context, self.project_id) db.floating_ip_destroy(context.get_admin_context(), address)
def test_volume_type_get_with_extra_specs(self): volume_type = db.volume_type_get( context.get_admin_context(), self.volume_type1_id) self.assertEquals(volume_type['extra_specs'], self.vol_type1_specs) volume_type = db.volume_type_get( context.get_admin_context(), self.vol_type2_id) self.assertEquals(volume_type['extra_specs'], {})
def test_volume_type_get_by_name_with_extra_specs(self): volume_type = db.volume_type_get_by_name( context.get_admin_context(), self.vol_type1['name']) self.assertEquals(volume_type['extra_specs'], self.vol_type1_specs) volume_type = db.volume_type_get_by_name( context.get_admin_context(), self.vol_type2_noextra['name']) self.assertEquals(volume_type['extra_specs'], {})
def setUp(self): super(_BaseRpcTestCase, self).setUp() self.conn = self.rpc.create_connection(True) self.receiver = TestReceiver() self.conn.create_consumer('test', self.receiver, False) self.conn.consume_in_thread() self.context = context.get_admin_context()
def setUp(self): super(VolumeTestCase, self).setUp() self.compute = utils.import_object(FLAGS.compute_manager) self.flags(connection_type='fake') self.volume = utils.import_object(FLAGS.volume_manager) self.context = context.get_admin_context() self.instance_id = db.instance_create(self.context, {})['id']
def get_instance_type_by_flavor_id(flavorid): """Retrieve instance type by flavorid.""" ctxt = context.get_admin_context() try: return db.instance_type_get_by_flavor_id(ctxt, flavorid) except exception.DBError: raise exception.ApiError(_("Unknown instance type: %s") % flavorid)
def _notify_all_volume_hosts(self, event): rpc.fanout_cast(context.get_admin_context(), FLAGS.volume_topic, { "method": "notification", "args": { "event": event } })
def notify_usage_exists(instance_ref, current_period=False): """ Generates 'exists' notification for an instance for usage auditing purposes. Generates usage for last completed period, unless 'current_period' is True.""" admin_context = context.get_admin_context() begin, end = utils.current_audit_period() bw = {} if current_period: audit_start = end audit_end = utils.utcnow() else: audit_start = begin audit_end = end for b in db.bw_usage_get_by_instance(admin_context, instance_ref['id'], audit_start): bw[b.network_label] = dict(bw_in=b.bw_in, bw_out=b.bw_out) usage_info = utils.usage_from_instance(instance_ref, audit_period_beginning=str(audit_start), audit_period_ending=str(audit_end), bandwidth=bw) notifier_api.notify('compute.%s' % FLAGS.host, 'compute.instance.exists', notifier_api.INFO, usage_info)
def create(name, memory, vcpus, local_gb, flavorid, swap=0, rxtx_factor=1): """Creates instance types.""" kwargs = {"memory_mb": memory, "vcpus": vcpus, "local_gb": local_gb, "swap": swap, "rxtx_factor": rxtx_factor} # ensure some attributes are integers and greater than or equal to 0 for option in kwargs: try: kwargs[option] = int(kwargs[option]) assert kwargs[option] >= 0 except (ValueError, AssertionError): msg = _("create arguments must be positive integers") raise exception.InvalidInput(reason=msg) # some value are required to be nonzero, not just positive for option in ["memory_mb", "vcpus"]: try: assert kwargs[option] > 0 except AssertionError: msg = _("create arguments must be positive integers") raise exception.InvalidInput(reason=msg) kwargs["name"] = name kwargs["flavorid"] = flavorid try: return db.instance_type_create(context.get_admin_context(), kwargs) except exception.DBError, e: LOG.exception(_("DB error: %s") % e) msg = _("Cannot create instance_type with name %(name)s and " "flavorid %(flavorid)s") % locals() raise exception.ApiError(msg)
def setUp(self): super(VsaTestCase, self).setUp() self.stubs = stubout.StubOutForTesting() self.vsa_api = vsa.API() self.volume_api = volume.API() FLAGS.quota_volumes = 100 FLAGS.quota_gigabytes = 10000 self.context = context.get_admin_context() volume_types.create(self.context, 'SATA_500_7200', extra_specs={ 'type': 'vsa_drive', 'drive_name': 'SATA_500_7200', 'drive_type': 'SATA', 'drive_size': '500', 'drive_rpm': '7200' }) def fake_show_by_name(meh, context, name): if name == 'wrong_image_name': LOG.debug(_("Test: Emulate wrong VSA name. Raise")) raise exception.ImageNotFound return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}} self.stubs.Set(engine.image.fake._FakeImageService, 'show_by_name', fake_show_by_name)
def kill(self): """Destroy the service object in the datastore.""" self.stop() try: db.service_destroy(context.get_admin_context(), self.service_id) except exception.NotFound: logging.warn(_('Service killed that has no database entry'))
def modify_project(self, project_id, manager_uid=None, description=None): """Modify an existing project""" if not manager_uid and not description: return values = {} if manager_uid: manager = db.user_get(context.get_admin_context(), manager_uid) if not manager: raise exception.UserNotFound(user_id=manager_uid) values['project_manager'] = manager['id'] if description: values['description'] = description db.project_update(context.get_admin_context(), project_id, values) if not self.is_in_project(manager_uid, project_id): self.add_to_project(manager_uid, project_id)
def revoke_certs_by_project(project_id): """Revoke all project certs.""" # NOTE(vish): This is somewhat useless because we can just shut down # the vpn. admin = context.get_admin_context() for cert in db.certificate_get_all_by_project(admin, project_id): revoke_cert(cert['project_id'], cert['file_name'])
def report_state(self): """Update the state of this service in the datastore.""" ctxt = context.get_admin_context() zone = FLAGS.node_availability_zone state_catalog = {} try: try: service_ref = db.service_get(ctxt, self.service_id) except exception.NotFound: logging.debug(_('The service database object disappeared, ' 'Recreating it.')) self._create_service_ref(ctxt) service_ref = db.service_get(ctxt, self.service_id) state_catalog['report_count'] = service_ref['report_count'] + 1 if zone != service_ref['availability_zone']: state_catalog['availability_zone'] = zone db.service_update(ctxt, self.service_id, state_catalog) # TODO(termie): make this pattern be more elegant. if getattr(self, 'model_disconnected', False): self.model_disconnected = False logging.error(_('Recovered model server connection!')) # TODO(vish): this should probably only catch connection errors except Exception: # pylint: disable=W0702 if not getattr(self, 'model_disconnected', False): self.model_disconnected = True logging.exception(_('model server went away'))
def notify_usage_exists(instance_ref, current_period=False): """ Generates 'exists' notification for an instance for usage auditing purposes. Generates usage for last completed period, unless 'current_period' is True.""" admin_context = context.get_admin_context() begin, end = utils.current_audit_period() bw = {} if current_period: audit_start = end audit_end = utils.utcnow() else: audit_start = begin audit_end = end for b in db.bw_usage_get_by_instance(admin_context, instance_ref['id'], audit_start): bw[b.network_label] = dict(bw_in=b.bw_in, bw_out=b.bw_out) usage_info = utils.usage_from_instance( instance_ref, audit_period_beginning=str(audit_start), audit_period_ending=str(audit_end), bandwidth=bw) notifier_api.notify('compute.%s' % FLAGS.host, 'compute.instance.exists', notifier_api.INFO, usage_info)
def _poll_task(self, instance_uuid, task_ref, done): """ Poll the given task, and fires the given Deferred if we get a result. """ try: task_info = self._call_method(vim_util, "get_dynamic_property", task_ref, "Task", "info") task_name = task_info.name action = dict( instance_uuid=instance_uuid, action=task_name[0:255], error=None) if task_info.state in ['queued', 'running']: return elif task_info.state == 'success': LOG.debug(_("Task [%(task_name)s] %(task_ref)s " "status: success") % locals()) done.send("success") else: error_info = str(task_info.error.localizedMessage) action["error"] = error_info LOG.warn(_("Task [%(task_name)s] %(task_ref)s " "status: error %(error_info)s") % locals()) done.send_exception(exception.Error(error_info)) db.instance_action_create(context.get_admin_context(), action) except Exception, excep: LOG.warn(_("In vmwareapi:_poll_task, Got this error %s") % excep) done.send_exception(excep)
def setUp(self): super(AccessTestCase, self).setUp() um = manager.AuthManager() self.context = context.get_admin_context() # Make test users self.testadmin = um.create_user('testadmin') self.testpmsys = um.create_user('testpmsys') self.testnet = um.create_user('testnet') self.testsys = um.create_user('testsys') # Assign some rules um.add_role('testadmin', 'cloudadmin') um.add_role('testpmsys', 'sysadmin') um.add_role('testnet', 'netadmin') um.add_role('testsys', 'sysadmin') # Make a test project self.project = um.create_project('testproj', 'testpmsys', 'a test project', ['testpmsys', 'testnet', 'testsys']) self.project.add_role(self.testnet, 'netadmin') self.project.add_role(self.testsys, 'sysadmin') #user is set in each test def noopWSGIApp(environ, start_response): start_response('200 OK', []) return [''] self.mw = ec2.Authorizer(noopWSGIApp) self.mw.action_roles = {'FakeControllerClass': { '_allow_all': ['all'], '_allow_none': [], '_allow_project_manager': ['projectmanager'], '_allow_sys_and_net': ['sysadmin', 'netadmin'], '_allow_sysadmin': ['sysadmin']}}
def destroy(name): """Marks instance types as deleted.""" try: assert name is not None db.instance_type_destroy(context.get_admin_context(), name) except (AssertionError, exception.NotFound): LOG.exception(_('Instance type %s not found for deletion') % name) raise exception.InstanceTypeNotFoundByName(instance_type_name=name)
def purge(name): """Removes instance types from database.""" try: assert name is not None db.instance_type_purge(context.get_admin_context(), name) except (AssertionError, exception.NotFound): LOG.exception(_('Instance type %s not found for purge') % name) raise exception.InstanceTypeNotFoundByName(instance_type_name=name)
def test_network_create_safe(self): ctxt = context.get_admin_context() values = {'host': 'localhost', 'project_id': 'project1'} network = db.network_create_safe(ctxt, values) self.assertNotEqual(None, network.uuid) self.assertEqual(36, len(network.uuid)) db_network = db.network_get(ctxt, network.id) self.assertEqual(network.uuid, db_network.uuid)
def is_vsa_object(volume_type_id): if volume_type_id is None: return False volume_type = get_volume_type(context.get_admin_context(), volume_type_id) return is_vsa_drive(volume_type_id, volume_type) or\ is_vsa_volume(volume_type_id, volume_type)
def purge(name): """Removes instance types from database.""" try: assert name is not None db.instance_type_purge(context.get_admin_context(), name) except (AssertionError, exception.NotFound): LOG.exception(_("Instance type %s not found for purge") % name) raise exception.InstanceTypeNotFoundByName(instance_type_name=name)
def setUp(self): super(VersionsTest, self).setUp() self.context = context.get_admin_context() self.stubs = stubout.StubOutForTesting() fakes.stub_out_auth(self.stubs) #Stub out VERSIONS self.old_versions = versions.VERSIONS versions.VERSIONS = VERSIONS
def destroy(name): """Marks instance types as deleted.""" try: assert name is not None db.instance_type_destroy(context.get_admin_context(), name) except (AssertionError, exception.NotFound): LOG.exception(_("Instance type %s not found for deletion") % name) raise exception.InstanceTypeNotFoundByName(instance_type_name=name)
def _create_snapshot(volume_id, size='0'): """Create a snapshot object.""" snap = {} snap['volume_size'] = size snap['user_id'] = 'fake' snap['project_id'] = 'fake' snap['volume_id'] = volume_id snap['status'] = "creating" return db.snapshot_create(context.get_admin_context(), snap)['id']
def test_instance_faults_get_by_instance_uuids_no_faults(self): """None should be returned when no faults exist""" ctxt = context.get_admin_context() instance1 = db.instance_create(ctxt, {}) instance2 = db.instance_create(ctxt, {}) uuids = [instance1['uuid'], instance2['uuid']] instance_faults = db.instance_fault_get_by_instance_uuids(ctxt, uuids) expected = {uuids[0]: [], uuids[1]: []} self.assertEqual(expected, instance_faults)
def _check(volume_id): """Make sure targets aren't duplicated.""" volume_ids.append(volume_id) admin_context = context.get_admin_context() iscsi_target = db.volume_get_iscsi_target_num( admin_context, volume_id) self.assert_(iscsi_target not in targets) targets.append(iscsi_target) LOG.debug(_("Target %s allocated"), iscsi_target)
def setUp(self): super(FixedIpTest, self).setUp() fakes.stub_out_networking(self.stubs) fakes.stub_out_rate_limiting(self.stubs) self.stubs.Set(compute.api.API, "add_fixed_ip", compute_api_add_fixed_ip) self.stubs.Set(compute.api.API, "remove_fixed_ip", compute_api_remove_fixed_ip) self.stubs.Set(compute.api.API, 'get', compute_api_get) self.context = context.get_admin_context()
def test_volume_type_get_all(self): expected_specs = self.vol_type1_specs.copy() types = db.volume_type_get_all(context.get_admin_context()) self.assertEquals(types[self.vol_type1['name']]['extra_specs'], expected_specs) self.assertEquals(types[self.vol_type2_noextra['name']]['extra_specs'], {})
def test_create_volume_from_snapshot(self): """Test volume can be created from a snapshot.""" volume_src_id = self._create_volume() self.volume.create_volume(self.context, volume_src_id) snapshot_id = self._create_snapshot(volume_src_id) self.volume.create_snapshot(self.context, volume_src_id, snapshot_id) volume_dst_id = self._create_volume(0, snapshot_id) self.volume.create_volume(self.context, volume_dst_id, snapshot_id) self.assertEqual( volume_dst_id, db.volume_get(context.get_admin_context(), volume_dst_id).id) self.assertEqual( snapshot_id, db.volume_get(context.get_admin_context(), volume_dst_id).snapshot_id) self.volume.delete_volume(self.context, volume_dst_id) self.volume.delete_snapshot(self.context, snapshot_id) self.volume.delete_volume(self.context, volume_src_id)
def delete_user(self, user): """Deletes a user Additionally deletes all users key_pairs""" uid = User.safe_id(user) LOG.audit(_("Deleting user %s"), uid) db.key_pair_destroy_all_by_user(context.get_admin_context(), uid) with self.driver() as drv: drv.delete_user(uid)
def setUp(self): super(KeypairsTest, self).setUp() self.controller = keypairs.KeypairController() fakes.stub_out_networking(self.stubs) fakes.stub_out_rate_limiting(self.stubs) self.stubs.Set(db, "key_pair_get_all_by_user", db_key_pair_get_all_by_user) self.stubs.Set(db, "key_pair_create", db_key_pair_create) self.stubs.Set(db, "key_pair_destroy", db_key_pair_destroy) self.context = context.get_admin_context()