def __init__(self, config_path):
cfg = ObjectDict(read_config(config_path))
cfg.db_name = cfg['mongo.db']
cfg['num_processes'] = int(cfg.get('num_processes', 0))
cfg['stubo_version'] = version
cfg['debug'] = asbool(cfg.get('debug', False))
max_workers = int(cfg.get('max_workers', 100))
log.info('started with {0} worker threads'.format(max_workers))
cfg['executor'] = ThreadPoolExecutor(max_workers)
try:
cfg['statsd_client'] = StatsClient(host=cfg.get('statsd.host',
'localhost'), prefix=cfg.get('statsd.prefix', 'stubo'))
cfg['stats'] = StatsdStats()
log.info('statsd host addr={0}, prefix={1}'.format(
cfg['statsd_client']._addr, cfg['statsd_client']._prefix))
except socket.gaierror, e:
log.warn("unable to connect to statsd: {0}".format(e))
def __init__(self, config_path):
cfg = ObjectDict(read_config(config_path))
cfg.db_name = cfg["mongo.db"]
cfg["num_processes"] = int(cfg.get("num_processes", 0))
cfg["stubo_version"] = version
cfg["debug"] = asbool(cfg.get("debug", False))
max_workers = int(cfg.get("max_workers", 100))
log.info("started with {0} worker threads".format(max_workers))
cfg["executor"] = ThreadPoolExecutor(max_workers)
try:
cfg["statsd_client"] = StatsClient(
host=cfg.get("statsd.host", "localhost"), prefix=cfg.get("statsd.prefix", "stubo")
)
cfg["stats"] = StatsdStats()
log.info(
"statsd host addr={0}, prefix={1}".format(cfg["statsd_client"]._addr, cfg["statsd_client"]._prefix)
)
except socket.gaierror, e:
log.warn("unable to connect to statsd: {0}".format(e))
class A(object):
__slots__ = ['_data', '_dirty']
def __init__(self):
self._dirty = False
self._data = ObjectDict({'a':10})
def __getitem__(self, name):
return self._data.get(name, None)
def __setitem__(self, name, value):
self._data[name] = value
self._dirty = True
def __delitem__(self, name):
del self._data[name]
self._dirty = True
def __contains__(self, name):
return name in self._data
def __len__(self):
return len(self._data)
def __getattr__(self, name):
print('getattr %s' % name)
return getattr(self._data, name)
def __setattr__(self, name, value):
print('__setattr__ %s '%name)
if name in self.__slots__:
print('setattr slots %s'%name)
super(A, self).__setattr__(name, value)
else:
print('setattr data %'%name)
self._dirty = True
setattr(self._data, name, value)
def __delattr__(self, name):
print('__delattr__')
delattr(self._data, name)
self._dirty = True
def __iter__(self):
for key in self._data:
yield key
def __repr__(self):
return str(self._data)
def get_pm25(self):
res = yield http_get(
"http://www.pm25.in/api/querys/all_cities.json?token=dSL6xvEWvyYxTeAX4Wyy",
timeout=60)
Obj_dict = ObjectDict()
for item in res:
city = item['area']
if not isinstance(Obj_dict.get(city, None), list):
Obj_dict[city] = list()
Obj_dict[city].append(item)
else:
Obj_dict[city].append(item)
if Obj_dict:
self.hztrip.set_pm25_session(Obj_dict)
class InterfaceBaseHandler(RequestHandler, TraceAbleObject):
TemplatePath = None
def __init__(self, *args, **kwargs):
super(InterfaceBaseHandler, self).__init__(*args, **kwargs)
self.make_trace()
def genReturn(self, response={}):
raise Return(response)
def is_active_page(self, reverse_name, second_name=None):
return 'active' if reverse_name == self.ReverseName else ''
def is_active_showcase(self, second_name, showcase):
return 'active' if second_name == showcase else ''
def initialize(self, *args, **kwargs):
self.cookies_name = self.config.interface['cookie']['name']
cookie = self.get_secure_cookie(self.cookies_name)
self.cookie_data = ObjectDict(
json.loads(cookie)) if cookie else ObjectDict()
def check_browser(self):
useragent = user_agents.parse(self.request.header.user_agent)
if useragent.browser.family == 'Microsoft IE' and int(
useragent.browser.version) < 9:
message = self.translate('Microsoft IE is not supported')
raise error.CheckBrowerError(message)
def update_cookies(self, **kwargs):
self.cookie_data.update(**kwargs)
self.set_secure_cookie(self.cookies_name, json.dumps(self.cookie_data))
@property
def config(self):
return self.application.settings['config']
@property
def env(self):
return self.application._jinja_env
@property
def session_factory(self):
return self.application.session_factory
@property
def mailgun(self):
return self.application.settings['mailgun']
def _render(self, template, **kwargs):
self.env.globals.update(translate=self.translate,
reverse_url=self.reverse_url,
current_user=self.current_user,
is_active_page=self.is_active_page,
is_active_showcase=self.is_active_showcase,
config=self.config)
template = self.env.get_template(template)
self.env.globals['static_url'] = self.static_url
self.write(template.render(kwargs))
def render(self, **kwargs):
self._render(self.TemplatePath, **kwargs)
def get_current_user(self):
sessionid = self.cookie_data.get('sessionid')
if not sessionid:
session = self.create_session()
else:
session = self.session_factory.get_session(sessionid,
expire_sec=3600)
if not session:
self.clear_cookie(self.cookies_name)
session = self.create_session()
self.session = session
return session
def create_session(self):
sessionid = uuid4().get_hex()
session = self.session_factory.generate(sessionid)
self.set_secure_cookie(self.cookies_name,
json.dumps({'sessionid': sessionid}))
return session
def get_login_url(self):
return self.reverse_url('account.signin')
def get_user_locale(self):
return locale.get(self.cookie_data.get('locale', 'zh_CN'))
def translate(self, text):
return self.get_user_locale().translate(text)
def _get_argument(self, name, default, source, strip=True):
args = self._get_arguments(name, source, strip=strip)
if not args:
print 'default is self._ARG_DEFAULT:', (default is
self._ARG_DEFAULT)
if default is self._ARG_DEFAULT:
raise error.ArgumentError(name=name)
return default
return args[-1]
def redirect_to(self, reverse_name, **kwargs):
self.redirect(self.reverse_url(reverse_name, **kwargs))
def output(self, response):
response['data']['trace'] = self.trace
self._chunk = json.dumps(response)
self.set_header('Content-Type', 'application/json; charset=UTF-8')
self.write(self._chunk)
self.finish()
def make_response(self, data, **kwargs):
return {
'success': True,
'message': data.get('message') or 'ok',
'data': data
}
def make_error(self, error, **kwargs):
return {'success': False, 'message': error.msg, 'data': {}}
def make_exception(self, **kwargs):
return {'success': False, 'message': 'system_error', 'data': {}}
@coroutine
def handle(self, *args, **kwargs):
try:
data = yield self.post_operate(*args, **kwargs)
response = self.make_response(data)
except error.LogicError, e:
logger.error(e, extra={'trace': self.trace})
response = self.make_error(e)
except error.SysError, e:
logger.error(e, exc_info=True, extra={'trace': self.trace})
response = self.make_error(e)
class Session(object):
__slots__ = ['store', 'handler', 'app', '_data', '_dirty', '_config',
'_initializer', 'session_id', '_session_object', '_session_name']
def __init__(self, app, handler, store, initializer, session_config=None, session_object=None):
self.handler = handler
self.app = app
self.store = store or DiskStore(app_config.store_config.diskpath)
self._config = deepcopy(app_config.session_config)
if session_config:
self._config.update(session_config)
self._session_name = self._config.name
self._session_object = (session_object or CookieObject)(app, handler, self.store, self._config)
self._data = ObjectDict()
self._initializer = initializer
self.session_id = None
self._dirty = False
self._processor()
def __getitem__(self, name):
if name not in self._data:
session_log.error('%s key not exist in %s session' % (name, self.session_id))
return self._data.get(name, None)
def __setitem__(self, name, value):
self._data[name] = value
self._dirty = True
def __delitem__(self, name):
del self._data[name]
self._dirty = True
def __contains__(self, name):
return name in self._data
def __len__(self):
return len(self._data)
def __getattr__(self, name):
return getattr(self._data, name)
def __setattr__(self, name, value):
if name in self.__slots__:
super(Session, self).__setattr__(name, value)
else:
self._dirty = True
setattr(self._data, name, value)
def __delattr__(self, name):
delattr(self._data, name)
self._dirty = True
def __iter__(self):
for key in self._data:
yield key
def __repr__(self):
return str(self._data)
def _processor(self):
"""Application processor to setup session for every request"""
self.store.cleanup(self._config.timeout)
self._load()
def _load(self):
"""Load the session from the store, by the id from cookie"""
self.session_id = self._session_object.get_session_id()
# protection against session_id tampering
if self.session_id and not self._valid_session_id(self.session_id):
self.session_id = None
if self.session_id:
d = self.store[self.session_id]
if isinstance(d, dict) and d:
self.update(d)
if not self.session_id:
self.session_id = self._session_object.generate_session_id()
if not self._data:
if self._initializer and isinstance(self._initializer, dict):
self.update(deepcopy(self._initializer))
self._session_object.set_session_id(self.session_id)
def save(self):
if self._dirty:
self.store[self.session_id] = self._data
def _valid_session_id(self, session_id):
return True
def kill(self):
"""Kill the session, make it no longer available"""
del self.store[self.session_id]
def clear(self):
del self.store[self.session_id]
