def enable_disable_languages(store, request):
cur_enabled_langs = EnabledLanguage.list(store)
new_enabled_langs = [unicode(y) for y in request['languages_enabled']]
if len(new_enabled_langs) < 1:
raise errors.InvalidInputFormat("No languages enabled!")
if request['default_language'] not in new_enabled_langs:
raise errors.InvalidInputFormat(
"Invalid lang code for chosen default_language")
appdata = None
for lang_code in new_enabled_langs:
if lang_code not in LANGUAGES_SUPPORTED_CODES:
raise errors.InvalidInputFormat("Invalid lang code: %s" %
lang_code)
if lang_code not in cur_enabled_langs:
if appdata is None:
appdata = load_appdata()
log.debug("Adding a new lang %s" % lang_code)
EnabledLanguage.add_new_lang(store, lang_code, appdata)
to_remove = list(set(cur_enabled_langs) - set(new_enabled_langs))
if to_remove:
store.find(models.User,
In(models.User.language,
to_remove)).set(language=request['default_language'])
models.db_delete(store, models.l10n.EnabledLanguage,
In(models.l10n.EnabledLanguage.name, to_remove))
def epilogue(self):
nf = NodeFactory(self.store_new)
url = nf.get_val(u'public_site')
o = urlparse(url)
domain = o.hostname if not o.hostname is None else ''
models.db_delete(self.store_new,
Config,
var_group=u'node',
var_name=u'public_site')
add_raw_config(self.store_new, u'node', u'hostname', domain != '',
unicode(domain))
url = nf.get_val(u'hidden_service')
o = urlparse(url)
domain = o.hostname if not o.hostname is None else ''
models.db_delete(self.store_new,
Config,
var_group=u'node',
var_name=u'hidden_service')
add_raw_config(self.store_new, u'node', u'onionservice', domain != '',
unicode(domain))
add_raw_config(self.store_new, u'node', u'reachable_via_web', False,
False)
self.entries_count['Config'] += 1
self.store_new.commit()
def epilogue(self):
"""
Imports the contents of the tor_hs directory into the config table
NOTE the function does not delete the torhs dir, but instead leaves it
on disk to ensure that the operator does not lose their HS key.
"""
hostname, key = '', ''
pk_path = os.path.join(TOR_DIR, 'private_key')
hn_path = os.path.join(TOR_DIR, 'hostname')
if os.path.exists(TOR_DIR) and os.path.exists(pk_path) and os.path.exists(hn_path):
with open(hn_path, 'r') as f:
hostname = f.read().strip()
# TODO assert that the hostname corresponds with the key
if not re.match(r'[A-Za-z0-9]{16}\.onion', hostname):
raise Exception('The hostname format does not match')
with open(pk_path, 'r') as f:
r = f.read()
if not r.startswith('-----BEGIN RSA PRIVATE KEY-----\n'):
raise Exception('%s does not have the right format!')
# Clean and convert the pem encoded key read into the format
# expected by the ADD_ONION tor control protocol.
# TODO assert the key passes deeper validation
key = 'RSA1024:' + ''.join(r.strip().split('\n')[1:-1])
else:
log.err('The structure of %s is incorrect. Cannot load onion service keys' % TOR_DIR)
models.db_delete(self.store_new, Config, var_group=u'node', var_name=u'onionservice')
add_raw_config(self.store_new, u'node', u'onionservice', True, hostname)
add_raw_config(self.store_new, u'private', u'tor_onion_key', True, key)
self.entries_count['Config'] += 1
def wizard(store, request, language):
models.db_delete(store, l10n.EnabledLanguage,
l10n.EnabledLanguage.name != language)
node = config.NodeFactory(store)
if node.get_val(u'wizard_done'):
log.err("DANGER: Wizard already initialized!")
raise errors.ForbiddenOperation
node._query_group()
node.set_val(u'name', request['node']['name'])
node.set_val(u'default_language', language)
node.set_val(u'wizard_done', True)
node_l10n = l10n.NodeL10NFactory(store)
node_l10n.set_val(u'description', language, request['node']['description'])
node_l10n.set_val(u'header_title_homepage', language,
request['node']['name'])
profiles.load_profile(store, request['profile'])
context = db_create_context(store, request['context'], language)
request['receiver']['username'] = u'recipient'
request['receiver']['contexts'] = [context.id]
request['receiver']['language'] = language
db_create_receiver_user(store, request['receiver'], language)
admin_dict = {
'username': u'admin',
'password': request['admin']['password'],
'role': u'admin',
'state': u'enabled',
'deletable': False,
'name': u'Admin',
'public_name': u'Admin',
'description': u'',
'mail_address': request['admin']['mail_address'],
'language': language,
'password_change_needed': False,
'pgp_key_remove': False,
'pgp_key_fingerprint': '',
'pgp_key_public': '',
'pgp_key_expiration': datetime_null()
}
db_create_admin_user(store, admin_dict, language)
db_refresh_memory_variables(store)
def wizard(store, request, language):
models.db_delete(store, l10n.EnabledLanguage, l10n.EnabledLanguage.name != language)
node = config.NodeFactory(store)
if node.get_val(u'wizard_done'):
log.err("DANGER: Wizard already initialized!")
raise errors.ForbiddenOperation
node._query_group()
node.set_val(u'name', request['node_name'])
node.set_val(u'default_language', language)
node.set_val(u'wizard_done', True)
node_l10n = l10n.NodeL10NFactory(store)
node_l10n.set_val(u'header_title_homepage', language, request['node_name'])
profiles.load_profile(store, request['profile'])
receiver_desc = models.User().dict(language)
receiver_desc['username'] = u'recipient'
receiver_desc['name'] = receiver_desc['public_name'] = request['receiver_name']
receiver_desc['mail_address'] = request['receiver_mail_address']
receiver_desc['language'] = language
receiver_desc['role'] =u'receiver'
receiver_desc['deletable'] = True
receiver_desc['pgp_key_remove'] = False
_, receiver = db_create_receiver_user(store, receiver_desc, language)
context_desc = models.Context().dict(language)
context_desc['name'] = u'Default'
context_desc['receivers'] = [receiver.id]
context = db_create_context(store, context_desc, language)
admin_desc = models.User().dict(language)
admin_desc['username'] = u'admin'
admin_desc['password'] = request['admin_password']
admin_desc['name'] = admin_desc['public_name'] = request['admin_name']
admin_desc['mail_address'] = request['admin_mail_address']
admin_desc['language'] = language
admin_desc['role'] =u'admin'
admin_desc['deletable'] = False
admin_desc['pgp_key_remove'] = False
admin_desc['password_change_needed'] = False
db_create_admin_user(store, admin_desc, language)
db_refresh_memory_variables(store)
def delete(session, id):
models.db_delete(session, models.Tenant, models.Tenant.id == id)
db_refresh_memory_variables(session, [id])
def delete(session, id):
models.db_delete(session, models.Tenant, models.Tenant.id == id)
db_refresh_memory_variables(session, [id])
def delete(session, id):
models.db_delete(session, models.Tenant, models.Tenant.id == id)
