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()
예제 #2
0
 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)
예제 #3
0
 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
예제 #4
0
 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]
예제 #5
0
 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)
예제 #6
0
 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 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 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'], {})
예제 #11
0
 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
예제 #12
0
 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)
예제 #14
0
 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)
예제 #15
0
 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_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)
예제 #18
0
 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_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_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 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)
예제 #23
0
 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()
예제 #24
0
 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()
예제 #25
0
 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']
예제 #26
0
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)
예제 #27
0
 def _notify_all_volume_hosts(self, event):
     rpc.fanout_cast(context.get_admin_context(), FLAGS.volume_topic, {
         "method": "notification",
         "args": {
             "event": event
         }
     })
예제 #28
0
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)
예제 #29
0
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)
예제 #30
0
    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)
예제 #31
0
 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'))
예제 #32
0
    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)
예제 #33
0
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)
예제 #34
0
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'])
예제 #35
0
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'])
예제 #36
0
    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'))
예제 #37
0
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)
예제 #38
0
 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)
예제 #39
0
 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']
예제 #40
0
    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']}}
예제 #41
0
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)
예제 #42
0
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)
예제 #43
0
 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)
예제 #44
0
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)
예제 #45
0
 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)
예제 #46
0
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)
예제 #47
0
 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
예제 #48
0
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)
예제 #49
0
 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
예제 #50
0
 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']
예제 #51
0
 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)
예제 #52
0
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)
예제 #53
0
 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)
예제 #54
0
 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'],
                          {})
예제 #56
0
    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)
예제 #57
0
    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)
예제 #58
0
 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()