def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.Context()
self.project_id = 'test_project'
self.context.tenant = self.project_id
self.controller = action.VolumeActionController(self.project_id, '')
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
core.get_engine().execute('pragma foreign_keys=on')
self.context = context.Context()
xmanager.IN_TEST = True
directory.get_plugin = fake_get_plugin
def setUp(self):
super(PolicyTestCase, self).setUp()
rules = oslo_policy.Rules.from_dict({
"true":
'@',
"example:allowed":
'@',
"example:denied":
"!",
"example:my_file":
"role:admin or "
"project_id:%(project_id)s",
"example:early_and_fail":
"! and @",
"example:early_or_success":
"@ or !",
"example:lowercase_admin":
"role:admin or role:sysadmin",
"example:uppercase_admin":
"role:ADMIN or role:sysadmin",
})
policy.reset()
policy.init()
policy.set_rules(rules)
self.context = context.Context(user_id='fake',
tenant_id='fake',
roles=['member'])
self.target = None
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
# enforce foreign key constraint for sqlite
core.get_engine().execute('pragma foreign_keys=on')
self.context = context.Context()
pod_dict = {
'pod_id': FAKE_SITE_ID,
'region_name': FAKE_SITE_NAME,
'az_name': FAKE_AZ
}
config_dict = {
'service_id': FAKE_SERVICE_ID,
'pod_id': FAKE_SITE_ID,
'service_type': FAKE_TYPE,
'service_url': FAKE_URL
}
api.create_pod(self.context, pod_dict)
api.create_cached_endpoints(self.context, config_dict)
global FAKE_RESOURCES
FAKE_RESOURCES = [{'name': 'res1'}, {'name': 'res2'}]
cfg.CONF.set_override(name='top_region_name',
override=FAKE_SITE_NAME,
group='client')
self.client = client.Client()
self.client.resource_service_map[FAKE_RESOURCE] = FAKE_TYPE
self.client.operation_resources_map['list'].add(FAKE_RESOURCE)
self.client.operation_resources_map['create'].add(FAKE_RESOURCE)
self.client.operation_resources_map['delete'].add(FAKE_RESOURCE)
self.client.operation_resources_map['action'].add(FAKE_RESOURCE)
self.client.service_handle_map[FAKE_TYPE] = FakeResHandle(None)
def _update_endpoint_from_keystone(self, cxt, is_internal):
"""Update the database by querying service endpoint url from Keystone
:param cxt: context object
:param is_internal: if True, this method utilizes pre-configured admin
username and password to apply an new admin token, this happens only
when auto_refresh_endpoint is set to True. if False, token in cxt is
directly used, users should prepare admin token themselves
:return: None
"""
if is_internal:
admin_context = tricircle_context.Context()
admin_context.auth_token = self._get_admin_token()
endpoint_map = self._get_endpoint_from_keystone(admin_context)
else:
endpoint_map = self._get_endpoint_from_keystone(cxt)
for region in endpoint_map:
# use region name to query pod
pod_filters = [{
'key': 'pod_name',
'comparator': 'eq',
'value': region
}]
pod_list = api.list_pods(cxt, pod_filters)
# skip region/pod not registered in cascade service
if len(pod_list) != 1:
continue
for service in endpoint_map[region]:
pod_id = pod_list[0]['pod_id']
config_filters = [{
'key': 'pod_id',
'comparator': 'eq',
'value': pod_id
}, {
'key': 'service_type',
'comparator': 'eq',
'value': service
}]
config_list = api.list_pod_service_configurations(
cxt, config_filters)
if len(config_list) > 1:
raise exceptions.EndpointNotUnique(pod_id, service)
if len(config_list) == 1:
config_id = config_list[0]['service_id']
update_dict = {
'service_url': endpoint_map[region][service]
}
api.update_pod_service_configuration(
cxt, config_id, update_dict)
else:
config_dict = {
'service_id': str(uuid.uuid4()),
'pod_id': pod_id,
'service_type': service,
'service_url': endpoint_map[region][service]
}
api.create_pod_service_configuration(cxt, config_dict)
def test_ignore_case_role_check(self):
lowercase_action = "example:lowercase_admin"
uppercase_action = "example:uppercase_admin"
admin_context = context.Context(user_id='fake',
tenant_id='fake',
roles=['AdMiN'])
result = policy.enforce(admin_context, lowercase_action, self.target)
self.assertTrue(result)
result = policy.enforce(admin_context, uppercase_action, self.target)
self.assertTrue(result)
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
# enforce foreign key constraint for sqlite
core.get_engine().execute('pragma foreign_keys=on')
for opt in xservice.common_opts:
if opt.name in ('worker_handle_timeout', 'job_run_expire',
'worker_sleep_time', 'redo_time_span'):
cfg.CONF.register_opt(opt)
self.context = context.Context()
self.xmanager = FakeXManager()
def setUp(self):
super(DefaultPolicyTestCase, self).setUp()
self.rules = oslo_policy.Rules.from_dict({
"default": '',
"example:exist": "!",
})
self._set_rules('default')
self.context = context.Context(user_id='fake', tenant_id='fake')
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.Context()
xmanager.IN_TEST = True
def fake_get_plugin(alias='core'):
if alias == 'trunk':
return FakePlugin()
return FakeCorePlugin()
directory.get_plugin = fake_get_plugin
def _init_db(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
# enforce foreign key constraint for sqlite
core.get_engine().execute('pragma foreign_keys=on')
self.context = context.Context()
pod_dict = {
'pod_id': 'fake_pod_id',
'pod_name': 'fake_pod_name',
'az_name': FAKE_AZ
}
config_dict = {
'service_id': 'fake_service_id',
'pod_id': 'fake_pod_id',
'service_type': cons.ST_NOVA,
'service_url': 'http://127.0.0.1:8774/v2/$(tenant_id)s'
}
pod_dict2 = {
'pod_id': 'fake_pod_id' + '2',
'pod_name': 'fake_pod_name' + '2',
'az_name': FAKE_AZ + '2'
}
config_dict2 = {
'service_id': 'fake_service_id' + '2',
'pod_id': 'fake_pod_id' + '2',
'service_type': cons.ST_CINDER,
'service_url': 'http://10.0.0.2:8774/v2/$(tenant_id)s'
}
top_pod = {
'pod_id': 'fake_top_pod_id',
'pod_name': 'RegionOne',
'az_name': ''
}
top_config = {
'service_id': 'fake_top_service_id',
'pod_id': 'fake_top_pod_id',
'service_type': cons.ST_CINDER,
'service_url': 'http://127.0.0.1:19998/v2/$(tenant_id)s'
}
db_api.create_pod(self.context, pod_dict)
db_api.create_pod(self.context, pod_dict2)
db_api.create_pod(self.context, top_pod)
db_api.create_pod_service_configuration(self.context, config_dict)
db_api.create_pod_service_configuration(self.context, config_dict2)
db_api.create_pod_service_configuration(self.context, top_config)
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
# enforce foreign key constraint for sqlite
core.get_engine().execute('pragma foreign_keys=on')
self.context = context.Context()
top_pod = {
'pod_id': FAKE_TOP_ID,
'pod_name': FAKE_TOP_NAME,
'az_name': ''
}
config_dict_top = {
'service_id': FAKE_TOP_SERVICE_ID,
'pod_id': FAKE_TOP_ID,
'service_type': FAKE_SERVICE_TYPE,
'service_url': FAKE_TOP_ENDPOINT
}
pod_dict = {
'pod_id': FAKE_SITE_ID,
'pod_name': FAKE_SITE_NAME,
'az_name': FAKE_AZ
}
pod_dict2 = {
'pod_id': FAKE_SITE_ID_2,
'pod_name': FAKE_SITE_NAME_2,
'az_name': FAKE_AZ
}
config_dict = {
'service_id': FAKE_SERVICE_ID,
'pod_id': FAKE_SITE_ID,
'service_type': FAKE_SERVICE_TYPE,
'service_url': FAKE_SERVICE_ENDPOINT
}
config_dict2 = {
'service_id': FAKE_SERVICE_ID_2,
'pod_id': FAKE_SITE_ID_2,
'service_type': FAKE_SERVICE_TYPE,
'service_url': FAKE_SERVICE_ENDPOINT_2
}
api.create_pod(self.context, pod_dict)
api.create_pod(self.context, pod_dict2)
api.create_pod(self.context, top_pod)
api.create_pod_service_configuration(self.context, config_dict)
api.create_pod_service_configuration(self.context, config_dict2)
api.create_pod_service_configuration(self.context, config_dict_top)
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.Context()
cfg.CONF.set_override('tenant_network_types', ['local', 'vlan'],
group='tricircle')
cfg.CONF.set_override('bridge_network_type', 'vlan', group='tricircle')
xmanager.IN_TEST = True
def fake_get_plugin(alias='core'):
if alias == 'trunk':
return FakePlugin()
return FakeCorePlugin()
directory.get_plugin = fake_get_plugin
def _extract_context_from_environ(environ):
context_paras = {'auth_token': 'HTTP_X_AUTH_TOKEN',
'user': '******',
'tenant': 'HTTP_X_TENANT_ID',
'user_name': 'HTTP_X_USER_NAME',
'tenant_name': 'HTTP_X_PROJECT_NAME',
'domain': 'HTTP_X_DOMAIN_ID',
'user_domain': 'HTTP_X_USER_DOMAIN_ID',
'project_domain': 'HTTP_X_PROJECT_DOMAIN_ID',
'request_id': 'openstack.request_id'}
for key in context_paras:
context_paras[key] = environ.get(context_paras[key])
role = environ.get('HTTP_X_ROLE')
# TODO(zhiyuan): replace with policy check
context_paras['is_admin'] = role == 'admin'
return t_context.Context(**context_paras)
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
cfg.CONF.register_opts(q_config.core_opts)
cfg.CONF.register_opts(plugin.tricircle_opts)
cfg.CONF.set_override('enable_l3_route_network', True,
group='tricircle')
plugin_path = \
'tricircle.tests.unit.network.test_central_plugin.FakePlugin'
cfg.CONF.set_override('core_plugin', plugin_path)
cfg.CONF.set_override('enable_api_gateway', True)
self.context = context.Context()
phynet = 'bridge'
phynet2 = 'bridge2'
vlan_min, vlan_max = 2000, 3000
cfg.CONF.set_override('type_drivers', ['local', 'vlan'],
group='tricircle')
cfg.CONF.set_override('tenant_network_types', ['local', 'vlan'],
group='tricircle')
cfg.CONF.set_override('network_vlan_ranges',
['%s:%d:%d' % (phynet, vlan_min, vlan_max),
'%s:%d:%d' % (phynet2, vlan_min, vlan_max)],
group='tricircle')
cfg.CONF.set_override('bridge_network_type', 'vlan',
group='tricircle')
def fake_get_plugin(alias=plugin_constants.CORE):
if alias == 'trunk':
return FakeTrunkPlugin()
return CentralFakePlugin()
from neutron_lib.plugins import directory
directory.get_plugin = fake_get_plugin
global segments_plugin
segments_plugin = FakePlugin()
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.Context()
self.project_id = 'test_project'
self.controller = FakeServerController(self.project_id)
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
cfg.CONF.register_opts(q_config.core_opts)
self.helper = helper.NetworkHelper()
self.context = context.Context()
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
# enforce foreign key constraint for sqlite
core.get_engine().execute('pragma foreign_keys=on')
self.context = context.Context()
def fake_non_admin_context():
context_paras = {}
return context.Context(**context_paras)
def fake_admin_context():
context_paras = {'is_admin': True}
return context.Context(**context_paras)
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.Context()
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.project_id = 'project_id'
self.t_ctx = context.Context()
self.q_ctx = object()
def setUp(self):
self.context = context.Context()
self.handle = FakeResourceHandle('fake_auth_url')
