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 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 load_configuration_datastore_version(context, id):
config = Configuration.load(context, id)
datastore_version = DatastoreVersion.load_by_uuid(
config.datastore_version_id)
return datastore_version
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 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
