def test_admin_router_create_edit_delete(self):
self.login_as_user()
url = reverse('admin_router_create')
resp = self.client.post(url, {'is_enabled': False, 'name': 'router1',
'subscription_ip': '127.0.0.1',
'subscription_port': 3333})
self.assertEqual(resp.status_code, 302)
router = RouterServer.objects(name='router1').first()
self.assertNotEqual(router, None)
self.assertEqual(router.name, 'router1')
self.assertEqual(router.is_enabled, False)
self.assertEqual(router.subscription_ip.strNormal(), '127.0.0.1')
self.assertEqual(router.subscription_port, 3333)
url = reverse('admin_router_edit', args=[router.name])
resp = self.client.post(url, {'is_enabled': True, 'name': 'router2',
'subscription_ip': '127.0.0.2',
'subscription_port': 4444})
self.assertEqual(resp.status_code, 302)
router.reload()
self.assertEqual(router.name, 'router2')
self.assertEqual(router.is_enabled, True)
self.assertEqual(router.subscription_ip.strNormal(), '127.0.0.2')
self.assertEqual(router.subscription_port, 4444)
router.delete()
self.assertEqual(RouterServer.objects().first(), None)
def migrate_routers(self):
collection = RouterServer._get_collection()
for name in ["private_ip_1", "public_ip_1"]:
if name in collection.index_information():
log.info("Dropping old router index: %s" % name)
collection.drop_index(name)
for router in OldRouterServer.objects():
if router.private_ip:
log.info("Migrating router: %s" % router.name)
RouterServer.objects(name=router.name).update_one(set__subscription_ip=router.private_ip)
router.update(unset__public_ip=True, unset__private_ip=True)
def create_router(request):
router = RouterServer.objects(name='router').first()
if router:
router.delete()
router = RouterServer(name='router', subscription_ip='127.0.0.1')
router.save()
def cleanup():
router.delete()
request.addfinalizer(cleanup)
request.instance.router = router
def generate_uwsgi_config(self, backend_conf):
"""
:param backend_conf: BackendRunPlanSettings instance for which we
generate config
"""
def _load_template(path):
log.debug("Loading uWSGI template from: %s" % path)
for search_path in UPAAS_CONFIG_DIRS:
template_path = os.path.join(search_path, path)
if os.path.exists(template_path):
f = open(template_path)
ret = f.read().splitlines()
f.close()
return ret
return []
# so it won't change while generating configuration
config = deepcopy(self.upaas_config)
base_template = config.interpreters['uwsgi']['template']
template = None
try:
template_any = config.interpreters[self.interpreter_name]['any'][
'uwsgi']['template']
except (AttributeError, KeyError):
pass
else:
if template_any:
template = template_any
try:
template_version = config.interpreters[self.interpreter_name][
self.interpreter_version]['uwsgi']['template']
except (AttributeError, KeyError):
pass
else:
if template_version:
template = template_version
max_memory = backend_conf.workers_max
max_memory *= self.application.run_plan.memory_per_worker
max_memory *= 1024 * 1024
variables = {
'namespace': self.package_path,
'chdir': config.apps.home,
'socket': '%s:%d' % (backend_conf.backend.ip, backend_conf.socket),
'stats': '%s:%d' % (backend_conf.backend.ip, backend_conf.stats),
'uid': config.apps.uid,
'gid': config.apps.gid,
'app_name': self.application.name,
'app_id': self.application.safe_id,
'pkg_id': self.safe_id,
'max_workers': backend_conf.workers_max,
'max_memory': max_memory,
'memory_per_worker': self.application.run_plan.memory_per_worker,
'max_log_size':
self.application.run_plan.max_log_size * 1024 * 1024,
}
if config.apps.graphite.carbon:
variables['carbon_servers'] = ' '.join(
config.apps.graphite.carbon)
variables['carbon_timeout'] = config.apps.graphite.timeout
variables['carbon_frequency'] = config.apps.graphite.frequency
variables['carbon_max_retry'] = config.apps.graphite.max_retry
variables['carbon_retry_delay'] = config.apps.graphite.retry_delay
variables['carbon_root'] = config.apps.graphite.root
try:
variables.update(config.interpreters[self.interpreter_name]['any'][
'uwsgi']['vars'])
except (AttributeError, KeyError):
pass
try:
variables.update(config.interpreters[self.interpreter_name][
self.interpreter_version]['uwsgi']['vars'])
except (AttributeError, KeyError):
pass
# interpretere default settings for any version
try:
for key, value in list(config.interpreters[self.interpreter_name][
'any']['settings'].items()):
var_name = "meta_%s_%s" % (self.interpreter_name, key)
variables[var_name] = value
except (AttributeError, KeyError):
pass
# interpretere default settings for current version
try:
for key, value in list(config.interpreters[self.interpreter_name][
self.interpreter_version]['settings'].items()):
var_name = "meta_%s_%s" % (self.interpreter_name, key)
variables[var_name] = value
except (AttributeError, KeyError):
pass
# interpreter settings from metadata
try:
for key, val in list(
self.metadata_config.interpreter.settings.items()):
var_name = "meta_%s_%s" % (self.interpreter_name, key)
variables[var_name] = val
except KeyError:
pass
envs = {}
try:
envs.update(config.interpreters[self.interpreter_name]['any'][
'env'])
except (AttributeError, KeyError):
pass
try:
envs.update(config.interpreters[self.interpreter_name][
self.interpreter_version]['env'])
except (AttributeError, KeyError):
pass
envs.update(self.metadata_config.env)
plugin = None
try:
plugin = config.interpreters[self.interpreter_name]['any'][
'uwsgi']['plugin']
except (AttributeError, KeyError):
pass
try:
plugin = config.interpreters[self.interpreter_name][
self.interpreter_version]['uwsgi']['plugin']
except (AttributeError, KeyError):
pass
options = ['[uwsgi]']
options.append('\n# starting uWSGI config variables list')
for key, value in list(variables.items()):
options.append('var_%s = %s' % (key, value))
for feature in self.application.feature_helper.load_enabled_features():
envs = feature.update_env(self.application, envs)
options.append('\n# starting ENV variables list')
for key, value in list(envs.items()):
options.append('env = %s=%s' % (key, value))
options.append(
'env = UPAAS_SYSTEM_DOMAIN=%s' % self.application.system_domain)
if self.application.custom_domains:
options.append('env = UPAAS_CUSTOM_DOMAINS=%s' % ','.join(
[d.name for d in self.application.custom_domains]))
options.append('\n# starting options from app metadata')
for opt in self.uwsgi_options_from_metadata():
options.append(opt)
# enable cheaper mode if we have multiple workers
if backend_conf.workers_max > backend_conf.workers_min:
options.append('\n# enabling cheaper mode')
options.append('cheaper = %d' % backend_conf.workers_min)
options.append('\n# starting base template')
options.extend(_load_template(base_template))
if config.apps.graphite.carbon:
options.append('\n# starting carbon servers block')
for carbon in config.apps.graphite.carbon:
options.append('carbon = %s' % carbon)
options.append('\n# starting interpreter plugin')
if plugin:
options.append('plugin = %s' % plugin)
options.append('\n# starting interpreter template')
options.extend(_load_template(template))
options.append('\n# starting subscriptions block')
for router in RouterServer.objects(is_enabled=True):
options.append('subscribe2 = server=%s:%d,key=%s' % (
router.subscription_ip, router.subscription_port,
self.application.system_domain))
for domain in self.application.custom_domains:
options.append('subscribe2 = server=%s:%d,key=%s' % (
router.subscription_ip, router.subscription_port,
domain.name))
options.append('\n')
for feature in self.application.feature_helper.load_enabled_features():
options = feature.update_vassal(self.application, options)
options.append('\n')
return options
