def db_update_node(store, request, language):
"""
Update and serialize the node infos
:param store: the store on which perform queries.
:param language: the language in which to localize data
:return: a dictionary representing the serialization of the node
"""
enable_disable_languages(store, request)
if language in request['languages_enabled']:
node_l10n = NodeL10NFactory(store)
node_l10n.update(request, language)
node = NodeFactory(store)
node.update(request)
if request[
'basic_auth'] and request['basic_auth_username'] != '' and request[
'basic_auth_password'] != '':
node.set_val('basic_auth', True)
node.set_val('basic_auth_username', request['basic_auth_username'])
node.set_val('basic_auth_password', request['basic_auth_password'])
else:
node.set_val('basic_auth', False)
db_refresh_memory_variables(store)
# TODO pass instance of db_update_node into admin_serialize
return db_admin_serialize_node(store, language)
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 get_onion_service_info(store):
node_fact = NodeFactory(store)
hostname = node_fact.get_val(u'onionservice')
priv_fact = PrivateFactory(store)
key = priv_fact.get_val(u'tor_onion_key')
return hostname, key
def set_onion_service_info(store, hostname, key):
node_fact = NodeFactory(store)
node_fact.set_val(u'onionservice', hostname)
priv_fact = PrivateFactory(store)
priv_fact.set_val(u'tor_onion_key', key)
GLApiCache.invalidate()
def wizard(store, request, language):
node = NodeFactory(store)
if node.get_val('wizard_done'):
# TODO report as anomaly
log.err("DANGER: Wizard already initialized!")
raise errors.ForbiddenOperation
try:
node._query_group()
nn = unicode(request['node']['name'])
node.set_val('name', nn)
node.set_val('default_language', language)
node.set_val('wizard_done', True)
node_l10n = NodeL10NFactory(store)
node_l10n.set_val('description', language, nn)
node_l10n.set_val('header_title_homepage', language, nn)
node_l10n.set_val('presentation', language, nn)
context = db_create_context(store, request['context'], language)
langs_to_drop = EnabledLanguage.list(store)
langs_to_drop.remove(language)
if len(langs_to_drop):
EnabledLanguage.remove_old_langs(store, langs_to_drop)
request['receiver']['contexts'] = [context.id]
request['receiver']['language'] = language
db_create_receiver(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)
except Exception as excep:
log.err("Failed wizard initialization %s" % excep)
raise excep
def db_update_node(store, request, language):
"""
Update and serialize the node infos
:param store: the store on which perform queries.
:param language: the language in which to localize data
:return: a dictionary representing the serialization of the node
"""
enable_disable_languages(store, request)
if language in request["languages_enabled"]:
node_l10n = NodeL10NFactory(store)
node_l10n.update(request, language)
node = NodeFactory(store)
node.update(request)
if request["basic_auth"] and request["basic_auth_username"] != "" and request["basic_auth_password"] != "":
node.set_val("basic_auth", True)
node.set_val("basic_auth_username", request["basic_auth_username"])
node.set_val("basic_auth_password", request["basic_auth_password"])
else:
node.set_val("basic_auth", False)
db_refresh_memory_variables(store)
# TODO pass instance of db_update_node into admin_serialize
return db_admin_serialize_node(store, language)
def db_serialize_node(store, language):
"""
Serialize node info.
"""
# Contexts and Receivers relationship
configured = store.find(models.ReceiverContext).count() > 0
ro_node = NodeFactory(store).public_export()
misc_dict = {
'languages_enabled': l10n.EnabledLanguage.list(store),
'languages_supported': LANGUAGES_SUPPORTED,
'configured': configured,
'accept_submissions': GLSettings.accept_submissions,
'logo': db_get_file(store, u'logo'),
'favicon': db_get_file(store, u'favicon'),
'css': db_get_file(store, u'css'),
'homepage': db_get_file(store, u'homepage'),
'script': db_get_file(store, u'script')
}
l10n_dict = NodeL10NFactory(store).localized_dict(language)
ret = disjoint_union(ro_node, l10n_dict, misc_dict)
return ret
def migrate_User(self):
default_language = NodeFactory(
self.store_old).get_val(u'default_language')
enabled_languages = EnabledLanguage.list(self.store_old)
old_objs = self.store_old.find(self.model_from['User'])
for old_obj in old_objs:
new_obj = self.model_to['User']()
for _, v in new_obj._storm_columns.items():
if v.name in ['pgp_key_public', 'pgp_key_fingerprint']:
if getattr(old_obj, v.name) is None:
setattr(new_obj, v.name, '')
continue
elif v.name in ['pgp_key_expiration']:
if getattr(old_obj, v.name) is None:
setattr(new_obj, v.name, datetime_null())
continue
elif v.name == 'language' and getattr(
old_obj, v.name) not in enabled_languages:
# fix users that have configured a language that has never been there
setattr(new_obj, v.name, default_language)
continue
setattr(new_obj, v.name, getattr(old_obj, v.name))
self.store_new.add(new_obj)
def init_db(store, use_single_lang=False):
db_create_tables(store)
appdata_dict = db_update_appdata(store)
log.debug("Performing database initialization...")
config.system_cfg_init(store)
if GLSettings.skip_wizard:
NodeFactory(store).set_val('wizard_done', True)
log.debug("Inserting internationalized strings...")
if not use_single_lang:
EnabledLanguage.add_all_supported_langs(store, appdata_dict)
else:
EnabledLanguage.add_new_lang(store, u'en', appdata_dict)
with open(os.path.join(GLSettings.client_path, 'logo.png'),
'r') as logo_file:
data = logo_file.read()
files.db_add_file(store, data, u'logo')
with open(os.path.join(GLSettings.client_path, 'favicon.ico'),
'r') as favicon_file:
data = favicon_file.read()
files.db_add_file(store, data, u'favicon')
def db_refresh_memory_variables(store):
"""
This routine loads in memory few variables of node and notification tables
that are subject to high usage.
"""
node_ro = ObjectDict(NodeFactory(store).admin_export())
GLSettings.memory_copy = node_ro
GLSettings.memory_copy.accept_tor2web_access = {
'admin': node_ro.tor2web_admin,
'custodian': node_ro.tor2web_custodian,
'whistleblower': node_ro.tor2web_whistleblower,
'receiver': node_ro.tor2web_receiver,
'unauth': node_ro.tor2web_unauth
}
enabled_langs = models.l10n.EnabledLanguage.list(store)
GLSettings.memory_copy.languages_enabled = enabled_langs
notif_ro = ObjectDict(NotificationFactory(store).admin_export())
GLSettings.memory_copy.notif = notif_ro
if GLSettings.developer_name:
GLSettings.memory_copy.notif.source_name = GLSettings.developer_name
if GLSettings.disable_mail_notification:
GLSettings.memory_copy.notif.disable_admin_notification_emails = True
GLSettings.memory_copy.notif.disable_custodian_notification_emails = True
GLSettings.memory_copy.notif.disable_receiver_notification_emails = True
GLSettings.memory_copy.private = ObjectDict(
PrivateFactory(store).mem_copy_export())
def load_profile(store, name):
path = os.path.join(Settings.client_path, 'data/profiles',
'{}.json'.format(name))
prof = read_json_file(path)
if not set(prof['node'].keys()) <= NodeFactory.admin_node:
raise ValueError('profile configuration key not in admin_node')
NodeFactory(store).update(prof['node'])
def commit_valid_config(store):
cfg = get_valid_setup()
priv_fact = PrivateFactory(store)
priv_fact.set_val(u'https_dh_params', cfg['dh_params'])
priv_fact.set_val(u'https_priv_key', cfg['key'])
priv_fact.set_val(u'https_cert', cfg['cert'])
priv_fact.set_val(u'https_chain', cfg['chain'])
priv_fact.set_val(u'https_enabled', True)
NodeFactory(store).set_val(u'hostname', 'localhost:9999')
def serialize_ahmia(store, language):
"""
Serialize Ahmia.fi descriptor.
"""
ret_dict = NodeFactory(store).public_export()
return {
'title': ret_dict['name'],
'description': NodeL10NFactory(store).get_val(language, 'description'),
'keywords': '%s (GlobaLeaks instance)' % ret_dict['name'],
'relation': ret_dict['public_site'],
'language': ret_dict['default_language'],
'contactInformation': u'',
'type': 'GlobaLeaks'
}
def db_admin_serialize_node(store, language):
node_dict = NodeFactory(store).admin_export()
# Contexts and Receivers relationship
configured = store.find(models.ReceiverContext).count() > 0
custom_homepage = os.path.isfile(os.path.join(GLSettings.static_path, "custom_homepage.html"))
misc_dict = {
'version': PrivateFactory(store).get_val('version'),
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': EnabledLanguage.list(store),
'configured': configured,
'custom_homepage': custom_homepage,
}
l10n_dict = NodeL10NFactory(store).localized_dict(language)
return utils.sets.disjoint_union(node_dict, misc_dict, l10n_dict)
def db_admin_serialize_node(store, language):
node_dict = NodeFactory(store).admin_export()
priv_dict = PrivateFactory(store)
# Contexts and Receivers relationship
configured = store.find(models.ReceiverContext).count() > 0
misc_dict = {
'version': priv_dict.get_val(u'version'),
'latest_version': priv_dict.get_val(u'latest_version'),
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': EnabledLanguage.list(store),
'configured': configured
}
l10n_dict = NodeL10NFactory(store).localized_dict(language)
return utils.sets.merge_dicts(node_dict, misc_dict, l10n_dict)
def db_refresh_memory_variables(store):
"""
This routine loads in memory few variables of node and notification tables
that are subject to high usage.
"""
node_ro = ObjectDict(NodeFactory(store).admin_export())
GLSettings.memory_copy = node_ro
GLSettings.memory_copy.accept_tor2web_access = {
'admin': node_ro.tor2web_admin,
'custodian': node_ro.tor2web_custodian,
'whistleblower': node_ro.tor2web_whistleblower,
'receiver': node_ro.tor2web_receiver
}
enabled_langs = models.l10n.EnabledLanguage.list(store)
GLSettings.memory_copy.languages_enabled = enabled_langs
notif_fact = NotificationFactory(store)
notif_ro = ObjectDict(notif_fact.admin_export())
GLSettings.memory_copy.notif = notif_ro
if GLSettings.developer_name:
GLSettings.memory_copy.notif.source_name = GLSettings.developer_name
db_refresh_exception_delivery_list(store)
GLSettings.memory_copy.private = ObjectDict(
PrivateFactory(store).mem_copy_export())
if GLSettings.memory_copy.private.admin_api_token_digest != '':
api_id = store.find(User.id, User.role == u'admin').order_by(
User.creation_date).first()
if api_id is not None:
GLSettings.appstate.api_token_session = GLSession(
api_id, 'admin', 'enabled')
def wizard(store, request, language):
node = NodeFactory(store)
if node.get_val('wizard_done'):
# TODO report as anomaly
log.err("DANGER: Wizard already initialized!")
raise errors.ForbiddenOperation
try:
node._query_group()
node.set_val('name', request['node']['name'])
node.set_val('default_language', language)
node.set_val('wizard_done', True)
if GLSettings.memory_copy.onionservice is not None:
node.set_val('onionservice', GLSettings.memory_copy.onionservice)
node_l10n = NodeL10NFactory(store)
node_l10n.set_val('description', language, request['node']['description'])
node_l10n.set_val('header_title_homepage', language, request['node']['name'])
context = db_create_context(store, request['context'], language)
langs_to_drop = EnabledLanguage.list(store)
langs_to_drop.remove(language)
if len(langs_to_drop):
EnabledLanguage.remove_old_langs(store, langs_to_drop)
request['receiver']['contexts'] = [context.id]
request['receiver']['language'] = language
db_create_receiver(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)
except Exception as excep:
log.err("Failed wizard initialization %s" % excep)
raise excep
def set_onion_service_info(store, hostname, key):
node_fact = NodeFactory(store)
node_fact.set_val('onionservice', hostname)
priv_fact = PrivateFactory(store)
priv_fact.set_val('tor_onion_key', key)
def set_init_params(store, dh_params, hostname='localhost:9999'):
PrivateFactory(store).set_val(u'https_dh_params', dh_params)
NodeFactory(store).set_val(u'hostname', hostname)
State.tenant_cache[1].hostname = 'localhost:9999'
def epilogue(self):
nf = NodeFactory(self.store_new)
self.trim_value_to_range(nf, u'wbtip_timetolive')
self.store_new.commit()
def set_init_params(store, dh_params, hostname='localhost:9999'):
PrivateFactory(store).set_val(u'https_dh_params', dh_params)
NodeFactory(store).set_val(u'hostname', hostname)
GLSettings.memory_copy.hostname = 'localhost:9999'
def epilogue(self):
nf = NodeFactory(self.store_new)
self.trim_value_to_range(nf, 'wbtip_timetolive')
self.trim_value_to_range(nf, 'submission_maximum_ttl')
self.store_new.commit()
