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 my_parse_config(filename):
cp = ConfigParser.RawConfigParser()
cp.read([filename])
conf = dict(raw=cp, config_file=filename)
# server settings
conf["debug"] = tryget(cp.getboolean, "server", "debug", False)
conf["xheaders"] = tryget(cp.getboolean, "server", "xheaders", False)
conf["cookie_secret"] = cp.get("server", "cookie_secret")
conf["xsrf_cookies"] = tryget(cp.getboolean,
"server", "xsrf_cookies", False)
# make relative path absolute to this file's parent directory
root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
getpath = lambda k, v: os.path.join(root, tryget(cp.get, k, v))
# locale, template and static directories
conf["locale_path"] = getpath("frontend", "locale_path")
conf["static_path"] = getpath("frontend", "static_path")
conf["template_path"] = getpath("frontend", "template_path")
# sqlite support
if tryget(cp.getboolean, "sqlite", "enabled", False) is True:
conf["sqlite_settings"] = \
ObjectDict(database=cp.get("sqlite", "database"))
# redis support
if tryget(cp.getboolean, "redis", "enabled", False) is True:
conf["redis_settings"] = ObjectDict(
unixsocket=tryget(cp.get, "redis", "unixsocket", None),
host=tryget(cp.get, "redis", "host", "127.0.0.1"),
port=tryget(cp.getint, "redis", "port", 6379),
dbid=tryget(cp.getint, "redis", "dbid", 0),
poolsize=tryget(cp.getint, "redis", "poolsize", 10))
# mysql support
if tryget(cp.getboolean, "mysql", "enabled", False) is True:
conf["mysql_settings"] = ObjectDict(
host=cp.get("mysql", "host"),
port=cp.getint("mysql", "port"),
username=tryget(cp.get, "mysql", "username"),
password=tryget(cp.get, "mysql", "password"),
database=tryget(cp.get, "mysql", "database"),
poolsize=tryget(cp.getint, "mysql", "poolsize", 10),
debug=tryget(cp.getboolean, "mysql", "debug", False),
ping=tryget(cp.getint, "mysql", "ping_interval"))
# email support
if tryget(cp.getboolean, "email", "enabled", False) is True:
conf["email_settings"] = ObjectDict(
host=cp.get("email", "host"),
port=tryget(cp.getint, "email", "port"),
tls=tryget(cp.getboolean, "email", "tls"),
username=tryget(cp.get, "email", "username"),
password=tryget(cp.get, "email", "password"))
return conf
def parse_config(filename):
cfg = ConfigParser.RawConfigParser()
with open(filename) as fp:
cfg.readfp(fp)
settings = {}
# web server settings
settings["debug"] = xget(cfg.getboolean, "server", "debug", False)
settings["xheaders"] = xget(cfg.getboolean, "server", "xheaders", False)
settings["cookie_secret"] = cfg.get("server", "cookie_secret")
settings["xsrf_cookies"] = xget(cfg.getboolean, "server", "xsrf_cookies",
False)
# get project's absolute path
root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
getpath = lambda k, v: os.path.join(root, xget(cfg.get, k, v))
# locale, template and static directories' path
settings["locale_path"] = getpath("frontend", "locale_path")
settings["static_path"] = getpath("frontend", "static_path")
settings["template_path"] = getpath("frontend", "template_path")
# sqlite support
if xget(cfg.getboolean, "sqlite", "enabled", False):
settings["sqlite_settings"] = ObjectDict(
database=cfg.get("sqlite", "database")
)
else:
settings["sqlite_settings"] = None
# redis support
if xget(cfg.getboolean, "redis", "enabled", False):
settings["redis_settings"] = ObjectDict(
host=cfg.get("redis", "host"),
port=cfg.getint("redis", "port"),
dbid=cfg.getint("redis", "dbid"),
poolsize=cfg.getint("redis", "poolsize"),
)
else:
settings["redis_settings"] = None
# mysql support
if xget(cfg.getboolean, "mysql", "enabled", False):
settings["mysql_settings"] = ObjectDict(
host=cfg.get("mysql", "host"),
port=cfg.getint("mysql", "port"),
username=xget(cfg.get, "mysql", "username"),
password=xget(cfg.get, "mysql", "password"),
database=xget(cfg.get, "mysql", "database"),
poolsize=xget(cfg.getint, "mysql", "poolsize", 10),
debug=xget(cfg.getboolean, "mysql", "debug", False),
)
else:
settings["mysql_settings"] = None
# it must always return a dict
return settings
def parse_config(filename=None):
global CONFIG_FILE_PATH
if CONFIG_FILE_PATH is None and os.path.isfile(filename):
CONFIG_FILE_PATH = os.path.abspath(filename)
cfg = ConfigParser.RawConfigParser()
with open(filename) as fp:
cfg.readfp(fp)
settings = {}
# web server settings
settings["debug"] = xget(cfg.getboolean, "server", "debug", False)
settings["base_url"] = cfg.get("server", "base_url")
# get project's absolute path
root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
print root
getpath = lambda k, v: os.path.join(root, xget(cfg.get, k, v))
# template and static directories' path
settings["static_path"] = getpath("frontend", "static_path")
settings["template_path"] = getpath("frontend", "template_path")
# postgresql support
if xget(cfg.getboolean, "postgresql", "enabled", False):
settings["postgresql_settings"] = ObjectDict(
host=cfg.get("postgresql", "host"),
port=cfg.getint("postgresql", "port"),
database=cfg.get("postgresql", "database"),
poolsize=cfg.getint("postgresql", "poolsize"),
username=cfg.get("postgresql", "username"),
password=cfg.get("postgresql", "password"))
else:
settings["postgresql_settings"] = None
# search engine
if xget(cfg.getboolean, "search_engine", "enabled", False):
settings['search_engine'] = ObjectDict(
host=cfg.get('search_engine', 'host'),
port=cfg.get('search_engine', 'port'),
index=cfg.get('search_engine', 'index'),
document_type=cfg.get('search_engine', 'document_type'))
else:
settings["search_engine"] = None
#Neo4j server
if xget(cfg.getboolean, "neo4j", "enabled", False):
settings["neo4j"] = ObjectDict(host=cfg.get("neo4j", "host"),
port=cfg.getint("neo4j", "port"))
else:
settings["neo4j"] = None
return settings
def get_current_user(self):
session_opr = ObjectDict()
session_opr.username = '******'
session_opr.ipaddr = self.request.remote_ip
session_opr.opr_type = 0
session_opr.login_time = utils.get_currtime()
return session_opr
def generate(self, **kwargs):
"""Generate this template with the given arguments."""
namespace = {
"escape": escape.xhtml_escape,
"xhtml_escape": escape.xhtml_escape,
"url_escape": escape.url_escape,
"json_encode": escape.json_encode,
"squeeze": escape.squeeze,
"linkify": escape.linkify,
"datetime": datetime,
"_utf8": escape.utf8, # for internal use
"_string_types": (unicode, bytes_type),
# __name__ and __loader__ allow the traceback mechanism to find
# the generated source code.
"__name__": self.name.replace('.', '_'),
"__loader__": ObjectDict(get_source=lambda name: self.code),
}
namespace.update(self.namespace)
namespace.update(kwargs)
exec self.compiled in namespace
execute = namespace["_execute"]
# Clear the traceback module's cache of source data now that
# we've generated a new template (mainly for this module's
# unittests, where different tests reuse the same name).
linecache.clearcache()
try:
return execute()
except Exception:
formatted_code = _format_code(self.code).rstrip()
log.msg("%s code:" % self.name)
for line in formatted_code.split("\n"):
log.msg(line)
raise
def set_session_user(self, customer, ipaddr, login_time):
session_user = ObjectDict()
session_user.username = customer.customer_name
session_user.cid = customer.customer_id
session_user.ipaddr = ipaddr
session_user.login_time = login_time
self.session['session_user'] = session_user
self.session.save()
def set_session_user(self, username, ipaddr, login_time, **kwargs):
session_user = ObjectDict()
session_user.username = username
session_user.ipaddr = ipaddr
session_user.login_time = login_time
session_user.update(**kwargs)
self.session['session_user'] = session_user
self.session.save()
def set_session_user(self, username, ipaddr, opr_type, login_time):
session_opr = ObjectDict()
session_opr.username = username
session_opr.ipaddr = ipaddr
session_opr.opr_type = opr_type
session_opr.login_time = login_time
self.session['session_opr'] = session_opr
self.session.save()
def set_session_user(self, uid, username, ipaddr, login_time):
session_user = ObjectDict()
session_user.uid = uid
session_user.username = username
session_user.ipaddr = ipaddr
session_user.login_time = login_time
self.session['session_user'] = session_user
self.session.save()
def test_object_dict(self):
od = ObjectDict()
self.assertRaises(AttributeError, getattr, od, "something")
od["foo"] = "bar"
self.assertEqual(od['foo'], "bar")
self.assertEqual(od.foo, "bar")
od.rah = "meow"
self.assertEqual(od['rah'], "meow")
def get_current_user(self):
username = self.get_secure_cookie("portal_user")
if not username: return None
ipaddr = self.get_secure_cookie("portal_user_ip")
user = ObjectDict()
user.username = username
user.ipaddr = ipaddr
return user
def get_current_user(self):
return self.session.get("session_user")
if not username: return None
user = ObjectDict()
user.username = username
user.ipaddr = self.session.get("tr_login_ip")
user.login_time = self.session.get("tr_login_time")
return user
def get_current_user(self):
username = self.get_secure_cookie("opr_name")
if not username: return None
ipaddr = self.get_secure_cookie("opr_login_ip")
opr_type = int(self.get_secure_cookie("opr_type"))
login_time = self.get_secure_cookie("opr_login_time")
user = ObjectDict()
user.username = username
user.ipaddr = ipaddr
user.opr_type = opr_type
user.login_time = login_time
return user
def set_session_user(self, username, ipaddr, opr_type, login_time):
session_opr = ObjectDict()
session_opr.username = username
session_opr.ipaddr = ipaddr
session_opr.opr_type = opr_type
session_opr.login_time = login_time
session_opr.resources = [
r.rule_path
for r in self.db.query(models.SysOperatorRule).filter_by(
operator_name=username)
]
self.session['session_opr'] = session_opr
self.session.save()
def set_session_user(self, username, ipaddr, opr_type, login_time):
session_opr = ObjectDict()
session_opr.operator_name = username
session_opr.username = username
session_opr.operate_ip = ipaddr
session_opr.ipaddr = ipaddr
session_opr.opr_type = opr_type
session_opr.login_time = login_time
session_opr.resources = [ r.rule_path for r in self.db.query(models.TrOperatorRule).filter_by(operator_name=username) ]
_agency = self.db.query(models.TrAgency).filter_by(operator_name=username).first()
session_opr.agency_id = _agency.id if _agency else None
session_opr.agency_name = _agency.agency_name if _agency else None
self.session['session_opr'] = session_opr
self.session.save()
return
def test_001_successful_session_update_on_unauth_request(self):
date1 = utility.datetime_now()
GLSetting.sessions = {}
GLSetting.sessions[u'antani'] = ObjectDict()
GLSetting.sessions[u'antani']['user_id'] = u'admin'
GLSetting.sessions[u'antani']['role'] = u'admin'
GLSetting.sessions[u'antani']['id'] = u'antani'
GLSetting.sessions[u'antani']['refreshdate'] = date1
handler = self.request({}, headers={'X-Session': 'antani'})
yield handler.get()
date2 = GLSetting.sessions.values()[0].refreshdate
self.assertNotEqual(date1, date2)
def set_session_user(self, uid, username, ipaddr, login_time, status,
expire_date, create_time, product_policy,
product_name):
session_user = ObjectDict()
session_user.uid = uid
session_user.username = username
session_user.ipaddr = ipaddr
session_user.login_time = login_time
session_user.status = status
session_user.expire_date = expire_date
session_user.create_time = create_time
session_user.product_policy = product_policy
session_user.product_name = product_name
self.session['session_user'] = session_user
self.session.save()
return
def test_001_successful_session_expiry_on_admin_auth_request(self):
date1 = utility.datetime_null() # oh a very old date!
GLSetting.sessions = {}
GLSetting.sessions[u'antani'] = ObjectDict()
GLSetting.sessions[u'antani']['user_id'] = u'admin'
GLSetting.sessions[u'antani']['role'] = u'admin'
GLSetting.sessions[u'antani']['id'] = u'antani'
GLSetting.sessions[u'antani']['refreshdate'] = date1
handler = self.request({}, headers={'X-Session': 'antani'})
self.assertRaises(errors.AdminSessionExpired, handler.get)
self.assertTrue(handler.current_user is None)
self.assertEqual(len(GLSetting.sessions.keys()), 0)
def generate(self, **kwargs):
"""Generate this template with the given arguments."""
namespace = {
"escape": escape.xhtml_escape,
"xhtml_escape": escape.xhtml_escape,
"url_escape": escape.url_escape,
"json_encode": escape.json_encode,
"squeeze": escape.squeeze,
"linkify": escape.linkify,
"datetime": datetime,
"_utf8": escape.utf8, # for internal use
"_string_types": (unicode_type, bytes_type),
# __name__ and __loader__ allow the traceback mechanism to find
# the generated source code.
"__name__": self.name.replace('.', '_'),
"__loader__": ObjectDict(get_source=lambda name: self.code),
}
namespace.update(self.namespace)
namespace.update(kwargs)
exec_in(self.compiled, namespace)
execute = namespace["_execute"]
# Clear the traceback module's cache of source data now that
# we've generated a new template (mainly for this module's
# unittests, where different tests reuse the same name).
linecache.clearcache()
try:
rv = execute()
assert isinstance(rv, Deferred), rv
if hasattr(rv, "result"):
# Deferred is already resolved.
# Return the result immidiatly to avoid compatibility problems.
rv = rv.result
if isinstance(rv, Failure):
rv.raiseException()
return rv
except:
raise TemplateError(
"Error executing template " + self.name + ":\n" +
_format_code(traceback.format_exception(*sys.exc_info())))
def fetch_docs(self, query, categories=()):
page = self.get_arg('page', self.page)
try:
self.page = int(page)
except ValueError:
self.page = 1
offset = self.limit * (self.page - 1)
try:
data = yield self.client.search(query, categories,
offset=offset, limit=self.limit)
except Exception as e:
self.logerr('error while retrieveing results for {!r}'.format(query))
self.render_error()
defer.returnValue(None)
if 'error' in data:
self.logerr('error from search search: {!r}'.format(data))
self.render_error()
defer.returnValue(None)
results = []
for ret in data['docs']:
info = self.corpus_db.get(ret['id'])
if not info:
self.log('document key without record {!r}'.format(ret))
continue
if any(f not in info for f in ('headline', 'body', 'url')):
self.log("Document with missing fields: {!r}".format(info))
break
doc = ObjectDict((k,v) for (k,v) in ret.items()
if not k.startswith('_'))
doc.update(info)
results.append(doc)
defer.returnValue((data['total'], results))
def parse_config(filename=None):
if filename is None:
filename = config_file_path()
global CONFIG_FILE_PATH
if CONFIG_FILE_PATH is None and os.path.isfile(filename):
CONFIG_FILE_PATH = os.path.abspath(filename)
cfg = ConfigParser.RawConfigParser()
with open(filename) as fp:
cfg.readfp(fp)
settings = {}
# web server settings
settings["debug"] = xget(cfg.getboolean, "server", "debug", False)
settings["xheaders"] = xget(cfg.getboolean, "server", "xheaders", False)
settings["enable_logging"] = xget(cfg.getboolean, "server",
"enable_logging", False)
settings["enable_caching"] = xget(cfg.getboolean, "server",
"enable_caching", False)
settings["base_url"] = cfg.get("server", "base_url")
# get project's absolute path
root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
print root
getpath = lambda k, v: os.path.join(root, xget(cfg.get, k, v))
# locale, template and static directories' path
settings["locale_path"] = getpath("frontend", "locale_path")
settings["static_path"] = getpath("frontend", "static_path")
settings["template_path"] = getpath("frontend", "template_path")
settings["project_selection"] = cfg.get("frontend", "project_selection")
# postgresql support
if xget(cfg.getboolean, "postgresql", "enabled", False):
settings["postgresql_settings"] = ObjectDict(
host=cfg.get("postgresql", "host"),
port=cfg.getint("postgresql", "port"),
database=cfg.get("postgresql", "database"),
poolsize=cfg.getint("postgresql", "poolsize"),
username=cfg.get("postgresql", "username"),
password=cfg.get("postgresql", "password"))
else:
settings["postgresql_settings"] = None
# redis support
if xget(cfg.getboolean, "redis", "enabled", False):
settings["redis_settings"] = ObjectDict(
host=cfg.get("redis", "host"),
port=cfg.getint("redis", "port"),
dbid=cfg.getint("redis", "dbid"),
poolsize=cfg.getint("redis", "poolsize"),
)
else:
settings["redis_settings"] = None
settings['search_engine'] = ObjectDict(
host=cfg.get('search_engine', 'host'),
port=cfg.get('search_engine', 'port'),
index=cfg.get('search_engine', 'index'))
return settings
