def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.controller = FakeAsyncJobController()
self.context = context.get_admin_context()
self.job_resource_map = constants.job_resource_map
policy.populate_default_rules()
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.get_admin_context()
self._ensure_token_for_admin(admin_context)
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': 'region_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_cached_endpoints(cxt, config_filters)
if len(config_list) > 1:
continue
if len(config_list) == 1:
config_id = config_list[0]['service_id']
update_dict = {
'service_url': endpoint_map[region][service]
}
api.update_cached_endpoints(cxt, config_id, update_dict)
else:
config_dict = {
'service_id': uuidutils.generate_uuid(),
'pod_id': pod_id,
'service_type': service,
'service_url': endpoint_map[region][service]
}
api.create_cached_endpoints(cxt, config_dict)
def __init__(self):
self._sites = {}
self.compute_host_manager = ComputeHostManager(self)
sites = models.list_sites(t_context.get_db_context(), [])
for site in sites:
# skip top site
if not site['az_id']:
continue
self.create_site(t_context.get_admin_context(), site['site_name'])
def setUp(self):
super(RoutingControllerTest, self).setUp()
cfg.CONF.clear()
cfg.CONF.register_opts(app.common_opts)
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.controller = routing.RoutingController()
self.context = context.get_admin_context()
policy.populate_default_rules()
def setUp(self):
super(RoutingControllerTest, self).setUp()
cfg.CONF.clear()
cfg.CONF.register_opts(app.common_opts)
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.controller = routing.RoutingController()
self.context = context.get_admin_context()
policy.populate_default_rules()
def setUp(self):
super(AsyncJobControllerTest, self).setUp()
cfg.CONF.clear()
cfg.CONF.register_opts(app.common_opts)
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.controller = FakeAsyncJobController()
self.context = context.get_admin_context()
self.job_resource_map = constants.job_resource_map
policy.populate_default_rules()
def setUp(self):
super(AsyncJobControllerTest, self).setUp()
cfg.CONF.clear()
cfg.CONF.register_opts(app.common_opts)
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.controller = FakeAsyncJobController()
self.context = context.get_admin_context()
self.job_resource_map = constants.job_resource_map
policy.populate_default_rules()
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.get_admin_context()
self._ensure_token_for_admin(admin_context)
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': 'region_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_cached_endpoints(
cxt, config_filters)
if len(config_list) > 1:
continue
if len(config_list) == 1:
config_id = config_list[0]['service_id']
update_dict = {
'service_url': endpoint_map[region][service]}
api.update_cached_endpoints(
cxt, config_id, update_dict)
else:
config_dict = {
'service_id': uuidutils.generate_uuid(),
'pod_id': pod_id,
'service_type': service,
'service_url': endpoint_map[region][service]
}
api.create_cached_endpoints(
cxt, config_dict)
def setUp(self):
super(API_FunctionalTest, self).setUp()
self.addCleanup(set_config, {}, overwrite=True)
cfg.CONF.register_opts(app.common_opts)
self.CONF = self.useFixture(fixture_config.Config()).conf
self.CONF.set_override('auth_strategy', 'noauth')
self.CONF.set_override('tricircle_db_connection', 'sqlite:///:memory:')
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.get_admin_context()
self.app = self._make_app()
def setUp(self):
super(API_FunctionalTest, self).setUp()
self.addCleanup(set_config, {}, overwrite=True)
cfg.CONF.register_opts(app.common_opts)
self.CONF = self.useFixture(fixture_config.Config()).conf
self.CONF.set_override('auth_strategy', 'noauth')
self.CONF.set_override('tricircle_db_connection', 'sqlite:///:memory:')
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.get_admin_context()
self.app = self._make_app()
def periodic_tasks(self, raise_on_error=False):
"""Tasks to be run at a periodic interval."""
ctxt = context.get_admin_context()
return self.manager.periodic_tasks(ctxt, raise_on_error=raise_on_error)
def prepare_bottom_network_subnets(self, t_ctx, q_ctx, project_id, pod,
t_net, t_subnets):
"""Get or create bottom network, subnet and dhcp port
:param t_ctx: tricircle context
:param q_ctx: neutron context
:param project_id: project id
:param pod: dict of bottom pod
:param t_net: dict of top network
:param t_subnets: list of top subnet dict
:return: bottom network id and a dict with top subnet id as key,
bottom subnet id as value
"""
# network
net_body = self.get_create_network_body(project_id, t_net)
if net_body['network'].get(provider_net.NETWORK_TYPE):
# if network type specified, we need to switch to admin account
admin_context = t_context.get_admin_context()
_, b_net_id = self.prepare_bottom_element(admin_context,
project_id, pod, t_net,
t_constants.RT_NETWORK,
net_body)
else:
_, b_net_id = self.prepare_bottom_element(t_ctx, project_id, pod,
t_net,
t_constants.RT_NETWORK,
net_body)
# subnet
subnet_map = {}
subnet_dhcp_map = {}
for subnet in t_subnets:
# gateway
t_interface_name = t_constants.interface_port_name % (
pod['region_name'], subnet['id'])
t_interface_body = self.get_create_interface_body(
project_id, t_net['id'], pod['region_name'], subnet['id'])
_, t_interface_id = self.prepare_top_element(
t_ctx, q_ctx, project_id, pod, {'id': t_interface_name},
t_constants.RT_PORT, t_interface_body)
t_interface = self._get_top_element(t_ctx, q_ctx,
t_constants.RT_PORT,
t_interface_id)
gateway_ip = t_interface['fixed_ips'][0]['ip_address']
subnet_body = self.get_create_subnet_body(project_id, subnet,
b_net_id, gateway_ip)
_, b_subnet_id = self.prepare_bottom_element(
t_ctx, project_id, pod, subnet, t_constants.RT_SUBNET,
subnet_body)
subnet_map[subnet['id']] = b_subnet_id
subnet_dhcp_map[subnet['id']] = subnet['enable_dhcp']
# dhcp port
for t_subnet_id, b_subnet_id in six.iteritems(subnet_map):
if not subnet_dhcp_map[t_subnet_id]:
continue
self.prepare_dhcp_port(t_ctx, project_id, pod, t_net['id'],
t_subnet_id, b_net_id, b_subnet_id)
b_client = self._get_client(pod['region_name'])
b_client.update_subnets(t_ctx, b_subnet_id,
{'subnet': {
'enable_dhcp': True
}})
return b_net_id, subnet_map
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.controller = routing.RoutingController()
self.context = context.get_admin_context()
policy.populate_default_rules()
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.get_admin_context()
self.project_id = 'test_project'
self.controller = action.ActionController(self.project_id, '')
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.get_admin_context()
self.project_id = 'test_project'
self.controller = volume.VolumeController(self.project_id, '')
def prepare_bottom_network_subnets(self, t_ctx, q_ctx, project_id, pod,
t_net, t_subnets):
"""Get or create bottom network, subnet and dhcp port
:param t_ctx: tricircle context
:param q_ctx: neutron context
:param project_id: project id
:param pod: dict of bottom pod
:param t_net: dict of top network
:param t_subnets: list of top subnet dict
:return: bottom network id and a dict with top subnet id as key,
bottom subnet id as value
"""
# network
net_body = self.get_create_network_body(project_id, t_net)
if net_body['network'].get(provider_net.NETWORK_TYPE):
# if network type specified, we need to switch to admin account
admin_context = t_context.get_admin_context()
_, b_net_id = self.prepare_bottom_element(
admin_context, project_id, pod, t_net, t_constants.RT_NETWORK,
net_body)
else:
_, b_net_id = self.prepare_bottom_element(
t_ctx, project_id, pod, t_net, t_constants.RT_NETWORK,
net_body)
# subnet
subnet_map = {}
subnet_dhcp_map = {}
for subnet in t_subnets:
# gateway
t_interface_name = t_constants.interface_port_name % (
pod['region_name'], subnet['id'])
t_interface_body = self.get_create_interface_body(
project_id, t_net['id'], pod['region_name'], subnet['id'])
_, t_interface_id = self.prepare_top_element(
t_ctx, q_ctx, project_id, pod, {'id': t_interface_name},
t_constants.RT_PORT, t_interface_body)
t_interface = self._get_top_element(
t_ctx, q_ctx, t_constants.RT_PORT, t_interface_id)
gateway_ip = t_interface['fixed_ips'][0]['ip_address']
subnet_body = self.get_create_subnet_body(
project_id, subnet, b_net_id, gateway_ip)
_, b_subnet_id = self.prepare_bottom_element(
t_ctx, project_id, pod, subnet, t_constants.RT_SUBNET,
subnet_body)
subnet_map[subnet['id']] = b_subnet_id
subnet_dhcp_map[subnet['id']] = subnet['enable_dhcp']
# dhcp port
for t_subnet_id, b_subnet_id in six.iteritems(subnet_map):
if not subnet_dhcp_map[t_subnet_id]:
continue
self.prepare_dhcp_port(t_ctx, project_id, pod, t_net['id'],
t_subnet_id, b_net_id, b_subnet_id)
b_client = self._get_client(pod['region_name'])
b_client.update_subnets(t_ctx, b_subnet_id,
{'subnet': {'enable_dhcp': True}})
return b_net_id, subnet_map
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.controller = pod.PodsController()
self.context = context.get_admin_context()
def periodic_tasks(self, raise_on_error=False):
"""Tasks to be run at a periodic interval."""
ctxt = context.get_admin_context()
return self.manager.periodic_tasks(ctxt, raise_on_error=raise_on_error)
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.context = context.get_admin_context()
def setUp(self):
core.initialize()
core.ModelBase.metadata.create_all(core.get_engine())
self.controller = routing.RoutingController()
self.context = context.get_admin_context()
policy.populate_default_rules()
