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]