def setUp(self): util.init_db() self.fake_tenantid = 'fake_fore_1231242345' self.fake_context = fake() self.fake_context.limit = 1000 self.fake_context.is_admin = False self.fake_context.marker = None self.fake_context['tenant'] = self.fake_tenantid self.fake_environ = {wsgi.CONTEXT_KEY : self.fake_context} self.fake_request = fake() self.fake_request.url = "http://fore.com/***" self.fake_request.environ = self.fake_environ self.cnf_controller = conf_service.ConfigurationsController() self.para_controller = conf_service.ParametersController() self.base_body = { "configuration": { "values": {}, "name": "test", "description":"desc....", "datastore": { "type": "test_type", "version": "test_version" } } } self.fake_dsname = "test_type" self.fake_dsversion = "test_version" ds_models.update_datastore(self.fake_dsname) ds = ds_models.Datastore.load(self.fake_dsname) ds_models.update_datastore_version(ds.name, self.fake_dsversion, "mysql", "None","None", '1','1')
def setUp(self): # Basic setup and mock/fake structures for testing only super(TestDatastoreBase, self).setUp() util.init_db() self.rand_id = str(uuid.uuid4()) self.ds_name = "my-test-datastore" + self.rand_id self.ds_version = "my-test-version" + self.rand_id self.capability_name = "root_on_create" + self.rand_id self.capability_desc = "Enables root on create" self.capability_enabled = True self.datastore_version_id = str(uuid.uuid4()) self.flavor_id = 1 datastore_models.update_datastore(self.ds_name, False) self.datastore = Datastore.load(self.ds_name) datastore_models.update_datastore_version(self.ds_name, self.ds_version, "mysql", "", "", True) DatastoreVersionMetadata.add_datastore_version_flavor_association( self.ds_name, self.ds_version, [self.flavor_id] ) self.datastore_version = DatastoreVersion.load(self.datastore, self.ds_version) self.test_id = self.datastore_version.id self.cap1 = Capability.create(self.capability_name, self.capability_desc, True) self.cap2 = Capability.create("require_volume" + self.rand_id, "Require external volume", True) self.cap3 = Capability.create("test_capability" + self.rand_id, "Test capability", False)
def setUpClass(cls): util.init_db() cls.ds_name = cls.random_name('datastore', prefix='TestConfigurationsController') ds_models.update_datastore(name=cls.ds_name, default_version=None) cls.ds = ds_models.Datastore.load(cls.ds_name) ds_version_name = cls.random_name( 'version', prefix='TestConfigurationsController') ds_models.update_datastore_version(cls.ds_name, ds_version_name, 'mysql', '', ['trove'], '', 1, version='5.7.29') cls.ds_version = ds_models.DatastoreVersion.load(cls.ds, ds_version_name, version='5.7.29') cls.tenant_id = cls.random_uuid() cls.config = config_models.Configuration.create( cls.random_name('configuration'), '', cls.tenant_id, None, cls.ds_version.id) cls.config_id = cls.config.id cls.controller = service.ConfigurationsController() super(TestConfigurationsController, cls).setUpClass()
def datastore_update(self, datastore_name, default_version): try: datastore_models.update_datastore(datastore_name, default_version) print("Datastore '%s' updated." % datastore_name) except exception.DatastoreVersionNotFound as e: print(e)
def setUpClass(cls): util.init_db() cls.controller = ins_service.MgmtInstanceController() cls.ds_name = cls.random_name('datastore') ds_models.update_datastore(name=cls.ds_name, default_version=None) ds_models.update_datastore_version(cls.ds_name, 'test_version', 'mysql', cls.random_uuid(), '', '', 1) cls.ds = ds_models.Datastore.load(cls.ds_name) cls.ds_version = ds_models.DatastoreVersion.load( cls.ds, 'test_version') cls.ins_name = cls.random_name('instance') cls.project_id = cls.random_uuid() cls.server_id = cls.random_uuid() cls.instance = ins_models.DBInstance.create( name=cls.ins_name, flavor_id=cls.random_uuid(), tenant_id=cls.project_id, volume_size=1, datastore_version_id=cls.ds_version.id, task_status=ins_models.InstanceTasks.BUILDING, compute_instance_id=cls.server_id) ins_models.InstanceServiceStatus.create( instance_id=cls.instance.id, status=srvstatus.ServiceStatuses.NEW) super(TestMgmtInstanceController, cls).setUpClass()
def delete(self, req, tenant_id, id): """Remove an existing datastore version.""" instances = instance_model.DBInstance.find_all(datastore_version_id=id, deleted=0).all() if len(instances) > 0: raise exception.DatastoreVersionsInUse(resource='instance') backups = backup_model.DBBackup.find_all(datastore_version_id=id, deleted=0).all() if len(backups) > 0: raise exception.DatastoreVersionsInUse(resource='backup') configs = config_model.DBConfiguration.find_all( datastore_version_id=id, deleted=0).all() if len(configs) > 0: raise exception.DatastoreVersionsInUse(resource='configuration') datastore_version = models.DatastoreVersion.load_by_uuid(id) datastore = models.Datastore.load(datastore_version.datastore_id) LOG.info( "Tenant: '%(tenant)s' is removing the datastore " "version: '%(version)s' for datastore: '%(datastore)s'", { 'tenant': tenant_id, 'version': datastore_version.name, 'datastore': datastore.name }) if datastore.default_version_id == datastore_version.id: models.update_datastore(datastore.name, None) datastore_version.delete() return wsgi.Result(None, 202)
def setUp(self): # Basic setup and mock/fake structures for testing only super(TestDatastoreBase, self).setUp() util.init_db() self.rand_id = str(uuid.uuid4()) self.ds_name = "my-test-datastore" + self.rand_id self.ds_version = "my-test-version" + self.rand_id self.capability_name = "root_on_create" + self.rand_id self.capability_desc = "Enables root on create" self.capability_enabled = True datastore_models.update_datastore(self.ds_name, False) self.datastore = Datastore.load(self.ds_name) datastore_models.update_datastore_version( self.ds_name, self.ds_version, "mysql", "", "", True) self.datastore_version = DatastoreVersion.load(self.datastore, self.ds_version) self.test_id = self.datastore_version.id self.cap1 = Capability.create(self.capability_name, self.capability_desc, True) self.cap2 = Capability.create("require_volume" + self.rand_id, "Require external volume", True) self.cap3 = Capability.create("test_capability" + self.rand_id, "Test capability", False)
def create(self, req, body, tenant_id): """Adds a new datastore version.""" context = req.environ[wsgi.CONTEXT_KEY] datastore_name = body['version']['datastore_name'] version_name = body['version']['name'] manager = body['version']['datastore_manager'] image_id = body['version'].get('image') image_tags = body['version'].get('image_tags') packages = body['version'].get('packages') if type(packages) is list: packages = ','.join(packages) active = body['version']['active'] default = body['version'].get('default', False) # For backward compatibility, use name as default value for version if # not specified version_str = body['version'].get('version', version_name) LOG.info("Tenant: '%(tenant)s' is adding the datastore " "version: '%(version)s' to datastore: '%(datastore)s'", {'tenant': tenant_id, 'version': version_name, 'datastore': datastore_name}) if not image_id and not image_tags: raise exception.BadRequest("Image must be specified.") client = clients.create_glance_client(context) common_glance.get_image_id(client, image_id, image_tags) try: datastore = models.Datastore.load(datastore_name) except exception.DatastoreNotFound: # Create the datastore if datastore_name does not exists. LOG.info("Creating datastore %s", datastore_name) datastore = models.DBDatastore() datastore.id = utils.generate_uuid() datastore.name = datastore_name datastore.save() try: models.DatastoreVersion.load(datastore, version_name, version=version_str) raise exception.DatastoreVersionAlreadyExists( name=version_name, version=version_str) except exception.DatastoreVersionNotFound: models.update_datastore_version(datastore.name, version_name, manager, image_id, image_tags, packages, active, version=version_str) if default: models.update_datastore(datastore.name, version_name) return wsgi.Result(None, 202)
def edit(self, req, body, tenant_id, id): """Updates the attributes of a datastore version.""" context = req.environ[wsgi.CONTEXT_KEY] datastore_version = models.DatastoreVersion.load_by_uuid(id) LOG.info("Tenant: '%(tenant)s' is updating the datastore " "version: '%(id)s' for datastore: '%(datastore)s'", {'tenant': tenant_id, 'id': id, 'datastore': datastore_version.datastore_name}) name = body.get('name', datastore_version.name) manager = body.get('datastore_manager', datastore_version.manager) image_id = body.get('image') image_tags = body.get('image_tags') active = body.get('active', datastore_version.active) default = body.get('default', None) packages = body.get('packages', datastore_version.packages) if type(packages) is list: packages = ','.join(packages) if image_id or image_tags: client = clients.create_glance_client(context) common_glance.get_image_id(client, image_id, image_tags) if not image_id and image_tags: # Remove the image ID from the datastore version. image_id = "" if image_id is None: image_id = datastore_version.image_id if image_tags is None: image_tags = datastore_version.image_tags if type(image_tags) is str: image_tags = image_tags.split(',') if not image_id and not image_tags: raise exception.BadRequest("Image must be specified.") models.update_datastore_version(datastore_version.datastore_name, datastore_version.name, manager, image_id, image_tags, packages, active, version=datastore_version.version, new_name=name) if default: models.update_datastore(datastore_version.datastore_name, datastore_version.name) elif (default is False and datastore_version.default is True): models.update_datastore(datastore_version.datastore_name, None) return wsgi.Result(None, 202)
def delete(self, req, tenant_id, id): """Remove an existing datastore version.""" datastore_version = models.DatastoreVersion.load_by_uuid(id) datastore = models.Datastore.load(datastore_version.datastore_id) LOG.info(_("Tenant: '%(tenant)s' is removing the datastore " "version: '%(version)s' for datastore: '%(datastore)s'") % {'tenant': tenant_id, 'version': datastore_version.name, 'datastore': datastore.name}) if datastore.default_version_id == datastore_version.id: models.update_datastore(datastore.name, None) datastore_version.delete() return wsgi.Result(None, 202)
def delete(self, req, tenant_id, id): """Remove an existing datastore version.""" datastore_version = models.DatastoreVersion.load_by_uuid(id) datastore = models.Datastore.load(datastore_version.datastore_id) LOG.info("Tenant: '%(tenant)s' is removing the datastore " "version: '%(version)s' for datastore: '%(datastore)s'", {'tenant': tenant_id, 'version': datastore_version.name, 'datastore': datastore.name}) if datastore.default_version_id == datastore_version.id: models.update_datastore(datastore.name, None) datastore_version.delete() return wsgi.Result(None, 202)
def create(self, req, body, tenant_id): """Adds a new datastore version.""" context = req.environ[wsgi.CONTEXT_KEY] datastore_name = body['version']['datastore_name'] version_name = body['version']['name'] manager = body['version']['datastore_manager'] image_id = body['version']['image'] packages = body['version']['packages'] if type(packages) is list: packages = ','.join(packages) active = body['version']['active'] default = body['version']['default'] LOG.info( "Tenant: '%(tenant)s' is adding the datastore " "version: '%(version)s' to datastore: '%(datastore)s'", { 'tenant': tenant_id, 'version': version_name, 'datastore': datastore_name }) client = clients.create_glance_client(context) try: client.images.get(image_id) except glance_exceptions.HTTPNotFound: raise exception.ImageNotFound(uuid=image_id) try: datastore = models.Datastore.load(datastore_name) except exception.DatastoreNotFound: # Create the datastore if datastore_name does not exists. LOG.info("Creating datastore %s", datastore_name) datastore = models.DBDatastore() datastore.id = utils.generate_uuid() datastore.name = datastore_name datastore.save() try: models.DatastoreVersion.load(datastore, version_name) raise exception.DatastoreVersionAlreadyExists(name=version_name) except exception.DatastoreVersionNotFound: models.update_datastore_version(datastore.name, version_name, manager, image_id, packages, active) if default: models.update_datastore(datastore.name, version_name) return wsgi.Result(None, 202)
def setUpClass(cls): util.init_db() cls.ds_name = cls.random_name('datastore', prefix='TestBackupController') ds_models.update_datastore(name=cls.ds_name, default_version=None) cls.ds = ds_models.Datastore.load(cls.ds_name) ds_models.update_datastore_version(cls.ds_name, 'fake-ds-version', 'mysql', '', ['trove', 'mysql'], '', 1) cls.ds_version = ds_models.DatastoreVersion.load( cls.ds, 'fake-ds-version') cls.controller = service.BackupController() super(TestBackupController, cls).setUpClass()
def create(self, req, body, tenant_id): """Adds a new datastore version.""" context = req.environ[wsgi.CONTEXT_KEY] datastore_name = body['version']['datastore_name'] version_name = body['version']['name'] manager = body['version']['datastore_manager'] image_id = body['version']['image'] packages = body['version']['packages'] if type(packages) is list: packages = ','.join(packages) active = body['version']['active'] default = body['version']['default'] LOG.info(_("Tenant: '%(tenant)s' is adding the datastore " "version: '%(version)s' to datastore: '%(datastore)s'") % {'tenant': tenant_id, 'version': version_name, 'datastore': datastore_name}) client = remote.create_nova_client(context) try: client.images.get(image_id) except nova_exceptions.NotFound: raise exception.ImageNotFound(uuid=image_id) try: datastore = models.Datastore.load(datastore_name) except exception.DatastoreNotFound: # Create the datastore if datastore_name does not exists. LOG.info(_("Creating datastore %s") % datastore_name) datastore = models.DBDatastore() datastore.id = utils.generate_uuid() datastore.name = datastore_name datastore.save() try: models.DatastoreVersion.load(datastore, version_name) raise exception.DatastoreVersionAlreadyExists(name=version_name) except exception.DatastoreVersionNotFound: models.update_datastore_version(datastore.name, version_name, manager, image_id, packages, active) if default: models.update_datastore(datastore.name, version_name) return wsgi.Result(None, 202)
def setUp(self): util.init_db() ds_models.update_datastore("mysql") self.datastore = ds_models.Datastore.load("mysql") ds_models.update_datastore_version(self.datastore.id, "mysql-55", "mysql", "None", "None", True) self.ds_version = ds_models.DatastoreVersion.load(self.datastore, "mysql-55") test_time = utils.utcnow() self.conf_name = "test_name_%s " %test_time self.conf_desc = "test_desc_%s " %test_time self.configuration = None self.defaultConfiguration = None self.tanant_id = "fake_fore_1231242345" self.context = TroveContext(tenant = self.tanant_id) self.default_tanant_id = CONF.default_template_tenant_id
def setUp(self): super(TestDatastoreVersion, self).setUp() util.init_db() models.update_datastore(name='test_ds', default_version=None) models.update_datastore_version( 'test_ds', 'test_vr1', 'mysql', '154b350d-4d86-4214-9067-9c54b230c0da', 'pkg-1', 1) models.update_datastore_version( 'test_ds', 'test_vr2', 'mysql', '154b350d-4d86-4214-9067-9c54b230c0da', 'pkg-1', 1) self.ds = models.Datastore.load('test_ds') self.ds_version2 = models.DatastoreVersion.load(self.ds, 'test_vr2') self.context = trove_testtools.TroveTestContext(self) self.req = Mock() self.req.environ = Mock() self.req.environ.__getitem__ = Mock(return_value=self.context) self.tenant_id = Mock() self.version_controller = DatastoreVersionController()
def setUp(self): super(TestDatastoreVersion, self).setUp() util.init_db() models.update_datastore(name='test_ds', default_version=None) models.update_datastore_version( 'test_ds', 'test_vr1', 'mysql', '154b350d-4d86-4214-9067-9c54b230c0da', 'pkg-1', '1') models.update_datastore_version( 'test_ds', 'test_vr2', 'mysql', '154b350d-4d86-4214-9067-9c54b230c0da', 'pkg-1', '1') self.ds = models.Datastore.load('test_ds') self.ds_version2 = models.DatastoreVersion.load(self.ds, 'test_vr2') self.context = Mock() self.req = Mock() self.req.environ = Mock() self.req.environ.__getitem__ = Mock(return_value=self.context) self.tenant_id = Mock() self.version_controller = DatastoreVersionController()
def setUpClass(cls): util.init_db() cls.ds_name = cls.random_name('datastore', prefix='TestInstanceController') ds_models.update_datastore(name=cls.ds_name, default_version=None) cls.ds = ds_models.Datastore.load(cls.ds_name) ds_models.update_datastore_version(cls.ds_name, 'test_image_id', 'mysql', cls.random_uuid(), [], '', 1) ds_models.update_datastore_version(cls.ds_name, 'test_image_tags', 'mysql', '', ['trove', 'mysql'], '', 1, version='test_image_tags version') ds_models.update_datastore_version(cls.ds_name, 'test_version', 'mysql', '', ['trove'], '', 1, version='version 1') ds_models.update_datastore_version(cls.ds_name, 'test_version', 'mysql', '', ['trove'], '', 1, version='version 2') cls.ds_version_imageid = ds_models.DatastoreVersion.load( cls.ds, 'test_image_id') cls.ds_version_imagetags = ds_models.DatastoreVersion.load( cls.ds, 'test_image_tags') cls.controller = service.InstanceController() super(TestInstanceController, cls).setUpClass()
def edit(self, req, body, tenant_id, id): """Updates the attributes of a datastore version.""" context = req.environ[wsgi.CONTEXT_KEY] datastore_version = models.DatastoreVersion.load_by_uuid(id) LOG.info( "Tenant: '%(tenant)s' is updating the datastore " "version: '%(version)s' for datastore: '%(datastore)s'", { 'tenant': tenant_id, 'version': datastore_version.name, 'datastore': datastore_version.datastore_name }) manager = body.get('datastore_manager', datastore_version.manager) image_id = body.get('image', datastore_version.image_id) active = body.get('active', datastore_version.active) default = body.get('default', None) packages = body.get('packages', datastore_version.packages) if type(packages) is list: packages = ','.join(packages) client = clients.create_glance_client(context) try: client.images.get(image_id) except glance_exceptions.HTTPNotFound: raise exception.ImageNotFound(uuid=image_id) models.update_datastore_version(datastore_version.datastore_name, datastore_version.name, manager, image_id, packages, active) if default: models.update_datastore(datastore_version.datastore_name, datastore_version.name) elif (default is False and datastore_version.default is True): models.update_datastore(datastore_version.datastore_name, None) return wsgi.Result(None, 202)
def setUpClass(cls): util.init_db() cls.ds_name = cls.random_name(name='test-datastore') cls.ds_version_name = cls.random_name(name='test-version') cls.capability_name = cls.random_name(name='root_on_create', prefix='TestDatastoreBase') cls.capability_desc = "Enables root on create" cls.capability_enabled = True cls.flavor_id = 1 cls.volume_type = 'some-valid-volume-type' datastore_models.update_datastore(cls.ds_name, False) cls.datastore = Datastore.load(cls.ds_name) datastore_models.update_datastore_version(cls.ds_name, cls.ds_version_name, "mysql", "", "", "", True) cls.datastore_version = DatastoreVersion.load(cls.datastore, cls.ds_version_name) cls.test_id = cls.datastore_version.id DatastoreVersionMetadata.add_datastore_version_flavor_association( cls.datastore_version.id, [cls.flavor_id]) DatastoreVersionMetadata.add_datastore_version_volume_type_association( cls.datastore_version.id, [cls.volume_type]) cls.cap1 = Capability.create(cls.capability_name, cls.capability_desc, True) cls.cap2 = Capability.create( cls.random_name(name='require_volume', prefix='TestDatastoreBase'), "Require external volume", True) cls.cap3 = Capability.create( cls.random_name(name='test_capability', prefix='TestDatastoreBase'), "Test capability", False) super(TestDatastoreBase, cls).setUpClass()
def setUpClass(cls): util.init_db() cls.ds_name = cls.random_name('datastore') cls.ds_version_number = '5.7.30' models.update_datastore(name=cls.ds_name, default_version=None) models.update_datastore_version(cls.ds_name, 'test_vr1', 'mysql', cls.random_uuid(), '', 'pkg-1', 1) models.update_datastore_version(cls.ds_name, 'test_vr2', 'mysql', cls.random_uuid(), '', 'pkg-1', 1, version=cls.ds_version_number) cls.ds = models.Datastore.load(cls.ds_name) cls.ds_version1 = models.DatastoreVersion.load(cls.ds, 'test_vr1') cls.ds_version2 = models.DatastoreVersion.load( cls.ds, 'test_vr2', version=cls.ds_version_number) cls.version_controller = DatastoreVersionController() super(TestDatastoreVersionController, cls).setUpClass()
def edit(self, req, body, tenant_id, id): """Updates the attributes of a datastore version.""" context = req.environ[wsgi.CONTEXT_KEY] datastore_version = models.DatastoreVersion.load_by_uuid(id) LOG.info(_("Tenant: '%(tenant)s' is updating the datastore " "version: '%(version)s' for datastore: '%(datastore)s'") % {'tenant': tenant_id, 'version': datastore_version.name, 'datastore': datastore_version.datastore_name}) manager = body.get('datastore_manager', datastore_version.manager) image_id = body.get('image', datastore_version.image_id) active = body.get('active', datastore_version.active) default = body.get('default', None) packages = body.get('packages', datastore_version.packages) if type(packages) is list: packages = ','.join(packages) client = remote.create_nova_client(context) try: client.images.get(image_id) except nova_exceptions.NotFound: raise exception.ImageNotFound(uuid=image_id) models.update_datastore_version(datastore_version.datastore_name, datastore_version.name, manager, image_id, packages, active) if default: models.update_datastore(datastore_version.datastore_name, datastore_version.name) elif (default is False and datastore_version.default is True): models.update_datastore(datastore_version.datastore_name, None) return wsgi.Result(None, 202)