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 __check_config_is_right(self): config = KSC_Configuration.load(utils.get_context(), self.config.id) if not config: raise Exception("create config, not write in db") if self.name != config.name or self.description != config.description: raise Exception("create config, name or description bad value") if self.config.config_type != '1': raise Exception("create config, config_type bad value") overrides = KSC_Configuration.get_configuration_overrides(utils.get_context(), self.config.id) diffs = {} for k, v in self.values.iteritems(): if overrides[k] != v and float(overrides[k]) != float(v): diffs[k] = (v, overrides[k]) if len(diffs): raise Exception("create config, values error") # # if overrides != self.values: # raise Exception("create config, values error") datastore_version = DatastoreVersion.load_by_uuid(self.config.datastore_version_id) if not datastore_version: raise Exception("create config, bad value of datastore_version_id") if datastore_version.name != self.datastore_version: raise Exception("create config, bad value of datastore_version_id")
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): LOG.debug("Creating a Security Group Rule for tenant '%s'" % tenant_id) context = req.environ[wsgi.CONTEXT_KEY] self._validate_create_body(body) sec_group_id = body['security_group_rule']['group_id'] sec_group = models.SecurityGroup.find_by(id=sec_group_id, tenant_id=tenant_id, deleted=False) instance_id = (models.SecurityGroupInstanceAssociation. get_instance_id_by_security_group_id(sec_group_id)) db_info = instance_models.get_db_info(context, id=instance_id) manager = (DatastoreVersion.load_by_uuid( db_info.datastore_version_id).manager) tcp_ports = CONF.get(manager).tcp_ports udp_ports = CONF.get(manager).udp_ports def _create_rules(sec_group, ports, protocol): rules = [] try: for port_or_range in set(ports): from_, to_ = utils.gen_ports(port_or_range) rule = models.SecurityGroupRule.create_sec_group_rule( sec_group, protocol, int(from_), int(to_), body['security_group_rule']['cidr'], context, CONF.os_region_name) rules.append(rule) except (ValueError, AttributeError) as e: raise exception.BadRequest(msg=str(e)) return rules tcp_rules = _create_rules(sec_group, tcp_ports, 'tcp') udp_rules = _create_rules(sec_group, udp_ports, 'udp') sec_group.save() all_rules = tcp_rules + udp_rules view = views.SecurityGroupRulesView( all_rules, req, tenant_id).create() return wsgi.Result(view, 201)
def create(self, req, body, tenant_id): LOG.debug("Creating a Security Group Rule for tenant '%s'" % tenant_id) context = req.environ[wsgi.CONTEXT_KEY] self._validate_create_body(body) sec_group_id = body['security_group_rule']['group_id'] sec_group = models.SecurityGroup.find_by(id=sec_group_id, tenant_id=tenant_id, deleted=False) instance_id = (models.SecurityGroupInstanceAssociation. get_instance_id_by_security_group_id(sec_group_id)) db_info = instance_models.get_db_info(context, id=instance_id) manager = (DatastoreVersion.load_by_uuid( db_info.datastore_version_id).manager) tcp_ports = CONF.get(manager).tcp_ports udp_ports = CONF.get(manager).udp_ports def _create_rules(sec_group, ports, protocol): rules = [] try: for port_or_range in set(ports): from_, to_ = utils.gen_ports(port_or_range) rule = models.SecurityGroupRule.create_sec_group_rule( sec_group, protocol, int(from_), int(to_), body['security_group_rule']['cidr'], context) rules.append(rule) except (ValueError, AttributeError) as e: raise exception.BadRequest(msg=str(e)) return rules tcp_rules = _create_rules(sec_group, tcp_ports, 'tcp') udp_rules = _create_rules(sec_group, udp_ports, 'udp') sec_group.save() all_rules = tcp_rules + udp_rules view = views.SecurityGroupRulesView( all_rules, req, tenant_id).create() return wsgi.Result(view, 201)
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 test_datastore_version_capabilities(self): self.datastore_version.capabilities.add(self.cap1, enabled=False) test_filtered_capabilities = self.capability_name_filter( self.datastore_version.capabilities) self.assertEqual(3, len(test_filtered_capabilities), 'Capabilities the test thinks it has are: %s, ' 'Filtered capabilities: %s' % (self.datastore_version.capabilities, test_filtered_capabilities)) # Test a fresh reloading of the datastore self.datastore_version = DatastoreVersion.load(self.datastore, self.ds_version) test_filtered_capabilities = self.capability_name_filter( self.datastore_version.capabilities) self.assertEqual(3, len(test_filtered_capabilities), 'Capabilities the test thinks it has are: %s, ' 'Filtered capabilities: %s' % (self.datastore_version.capabilities, test_filtered_capabilities)) self.assertIn(self.cap2.name, self.datastore_version.capabilities) self.assertNotIn("non-existent", self.datastore_version.capabilities) self.assertIn(self.cap1.name, self.datastore_version.capabilities)
def test_datastore_version_capabilities(self): self.datastore_version.capabilities.add(self.cap1, enabled=False) test_filtered_capabilities = self.capability_name_filter( self.datastore_version.capabilities) self.assertEqual( 3, len(test_filtered_capabilities), 'Capabilities the test thinks it has are: %s, ' 'Filtered capabilities: %s' % (self.datastore_version.capabilities, test_filtered_capabilities)) # Test a fresh reloading of the datastore self.datastore_version = DatastoreVersion.load(self.datastore, self.ds_version) test_filtered_capabilities = self.capability_name_filter( self.datastore_version.capabilities) self.assertEqual( 3, len(test_filtered_capabilities), 'Capabilities the test thinks it has are: %s, ' 'Filtered capabilities: %s' % (self.datastore_version.capabilities, test_filtered_capabilities)) self.assertIn(self.cap2.name, self.datastore_version.capabilities) self.assertNotIn("non-existent", self.datastore_version.capabilities) self.assertIn(self.cap1.name, self.datastore_version.capabilities)
def upgrade_cluster(self, context, cluster_id, datastore_version_id): datastore_version = DatastoreVersion.load_by_uuid(datastore_version_id) cluster_tasks = models.load_cluster_tasks(context, cluster_id) cluster_tasks.upgrade_cluster(context, cluster_id, datastore_version)
def upgrade(self, context, instance_id, datastore_version_id): instance_tasks = models.BuiltInstanceTasks.load(context, instance_id) datastore_version = DatastoreVersion.load_by_uuid(datastore_version_id) with EndNotification(context): instance_tasks.upgrade(datastore_version)
def test_load_datastore_version(self): datastore_version = DatastoreVersion.load(self.datastore, self.ds_version) self.assertEqual(self.ds_version, datastore_version.name)
def load_configuration_datastore_version(context, id): config = Configuration.load(context, id) datastore_version = DatastoreVersion.load_by_uuid( config.datastore_version_id) return datastore_version