def test_renewing_fs_session(tmpdir): store = FilesystemSessionStore(str(tmpdir), renew_missing=True) x = store.new() store.save(x) store.delete(x) x2 = store.get(x.sid) assert x2.new
def test_basic_fs_sessions(): """Test basic file system sessions""" store = FilesystemSessionStore(session_folder) x = store.new() assert x.new assert not x.modified x['foo'] = [1, 2, 3] assert x.modified store.save(x) x2 = store.get(x.sid) assert not x2.new assert not x2.modified assert x2 is not x assert x2 == x x2['test'] = 3 assert x2.modified assert not x2.new store.save(x2) x = store.get(x.sid) store.delete(x) x2 = store.get(x.sid) # the session is not new when it was used previously. assert not x2.new
def test_renewing_fs_session(self): store = FilesystemSessionStore(self.session_folder, renew_missing=True) x = store.new() store.save(x) store.delete(x) x2 = store.get(x.sid) assert x2.new
def after_request(response): session_store = FilesystemSessionStore(SESSIONS_DIR) if g.session.should_save: session_store.save(g.session) session['sid'] = g.session.sid session.permanent = True app.save_session(session, response) return response
def test_fs_session_lising(tmpdir): store = FilesystemSessionStore(str(tmpdir), renew_missing=True) sessions = set() for x in range(10): sess = store.new() store.save(sess) sessions.add(sess.sid) listed_sessions = set(store.list()) assert sessions == listed_sessions
def test_fs_session_lising(): """Test listing of filesystem sessions""" store = FilesystemSessionStore(session_folder, renew_missing=True) sessions = set() for x in xrange(10): sess = store.new() store.save(sess) sessions.add(sess.sid) listed_sessions = set(store.list()) assert sessions == listed_sessions
def db_login(self, **post): request.session.db = post['db'] uid = request.session.authenticate(request.session.db, post['account'], post['passwd']) # 写入文件 考虑后期换成redis缓存 session_store = FilesystemSessionStore() session_store.save(request.session) if uid is not False: return request.env['ir.http'].session_info() return {'code': '1', 'data': u'用户名或者密码错误。'}
def after_request(response): """ Closes the database again at the end of the request and store the session if neccessary. """ session_store = FilesystemSessionStore(config.SESSIONS_DIR) if g.session.should_save: session_store.save(g.session) session['sid'] = g.session.sid session.permanent = True # we have to do this because Flask # stores the SecureCookie containing the "Session" # before calling the "after_request" functions app.save_session(session, response) g.db.close() return response
def test_basic_fs_sessions(self): store = FilesystemSessionStore(self.session_folder) x = store.new() assert x.new assert not x.modified x["foo"] = [1, 2, 3] assert x.modified store.save(x) x2 = store.get(x.sid) assert not x2.new assert not x2.modified assert x2 is not x assert x2 == x x2["test"] = 3 assert x2.modified assert not x2.new store.save(x2) x = store.get(x.sid) store.delete(x) x2 = store.get(x.sid) # the session is not new when it was used previously. assert not x2.new
def test_basic_fs_sessions(tmpdir): store = FilesystemSessionStore(str(tmpdir)) x = store.new() assert x.new assert not x.modified x["foo"] = [1, 2, 3] assert x.modified store.save(x) x2 = store.get(x.sid) assert not x2.new assert not x2.modified assert x2 is not x assert x2 == x x2["test"] = 3 assert x2.modified assert not x2.new store.save(x2) x = store.get(x.sid) store.delete(x) x2 = store.get(x.sid) # the session is not new when it was used previously. assert not x2.new
class PredmetyApp(object): def __init__(self, settings): self.settings = settings loader = jinja2.PackageLoader(__package__) def guess_autoescape(template_name): return template_name and any(template_name.endswith(ext) for ext in ('.html', '.htm', '.xml')) self.jinja = jinja2.Environment(loader=loader, autoescape=guess_autoescape) self.session_store = FilesystemSessionStore( renew_missing=True, path=settings.session_path) self.views = {} for module in site_modules: self.views.update(module.views) self.url_map = Map() self.url_map.converters['regex'] = RegexConverter for module in site_modules: for rulefactory in module.get_routes(): self.url_map.add(rulefactory) self.db_engine = settings.db_connect() self.DbSession = sessionmaker(bind=self.db_engine) def create_tables(self): models.create_tables(self.db_engine) def render(self, template_name, **context): template = self.jinja.get_template(template_name) return jinja2.Markup(template.render(context)) def dispatch_request(self, request): try: endpoint, values = request.url_adapter.match() return endpoint(request, **values) except NotFound as e: return self.views['not_found'](request) except HttpException as e: return e @Request.application def wsgi_app(self, request): request.app = self request.max_content_length = 16 * 1024 * 1024 request.max_form_memory_size = 2 * 1024 * 1024 cookie_name = self.settings.cookie_name sid = request.cookies.get(cookie_name, '') request.session = self.session_store.get(sid) request.db_session = self.DbSession() request.url_adapter = self.url_map.bind_to_environ(request.environ) def build_url(view_name, *args, **kwargs): endpoint = self.views[view_name] return request.url_adapter.build(endpoint, *args, **kwargs) request.build_url = build_url response = self.dispatch_request(request) if request.session.should_save: self.session_store.save(request.session) response.set_cookie(cookie_name, request.session.sid) elif sid and request.session.new and hasattr(response, 'delete_cookie'): response.delete_cookie(cookie_name) request.db_session.close() return response def __call__(self, *args): return self.wsgi_app(*args)
class Glim: """ The class that holds the wsgi app of glim framework. Attributes ---------- config (dict): The 'glim' key of app.config.<env>. session_store (werkzeug.contrib.sessions.FilesystemSessionStore): The session store in case of session usage. url_map (werkzeug.routing.Map): The url map of wsgi app. Usage ----- app = Glim(urls, config) # start the web server run_simple(host, int(port), app, use_debugger=True, use_reloader=True) """ def __init__(self, urls={}, config={}): self.config = config try: self.session_store = FilesystemSessionStore( self.config['sessions']['path'] ) except: self.session_store = None ruleset = self.flatten_urls(urls) rule_map = [] for url, rule in ruleset.items(): rule_map.append(Rule(url, endpoint=rule)) self.url_map = Map(rule_map) def flatten_urls(self, urls, current_key="", ruleset={}): """ Function flatten urls for route grouping feature of glim. Thanks for the stackoverflow guy! Args ---- urls (dict): a dict of url definitions. current_key (unknown type): a dict or a string marking the current key that is used for recursive calls. ruleset (dict): the ruleset that is eventually returned to dispatcher. Returns ------- ruleset (dict): the ruleset to be bound. """ for key in urls: # If the value is of type `dict`, then recurse with the # value if isinstance(urls[key], dict): self.flatten_urls(urls[key], current_key + key) # Else if the value is type of list, meaning it is a filter elif isinstance(urls[key], (list, tuple)): k = ','.join(urls[key]) ruleset[current_key + key] = k else: ruleset[current_key + key] = urls[key] return ruleset def dispatch_request(self, request): """ Function dispatches the request. It also handles route filtering. Args ---- request (werkzeug.wrappers.Request): the request object. Returns ------- response (werkzeug.wrappers.Response): the response object. """ adapter = self.url_map.bind_to_environ(request.environ) try: endpoint, values = adapter.match() mcontroller = import_module('app.controllers') # detect filters filters = endpoint.split(',') endpoint_pieces = filters[-1].split('.') # if there exists any filter defined if len(filters) > 1: filters = filters[:-1] # here run filters for f in filters: fpieces = f.split('.') cls = fpieces[0] fnc = fpieces[1] mfilter = mcontroller obj = getattr(mfilter, cls) ifilter = obj(request) raw = getattr(ifilter, fnc)(** values) if isinstance(raw, basestring): return Response(raw) if isinstance(raw, Response): return raw cls = endpoint_pieces[0] restful = False try: fnc = endpoint_pieces[1] except: restful = True fnc = None obj = getattr(mcontroller, cls) instance = obj(request) raw = None if restful: raw = getattr(instance, request.method.lower())(**values) else: raw = getattr(instance, fnc)(** values) if isinstance(raw, Response): return raw else: return Response(raw) except HTTPException as e: return e def wsgi_app(self, environ, start_response): """ Function returns the wsgi app of glim framework. Args ---- environ (unknown type): The werkzeug environment. start_response (function): The werkzeug's start_response function. Returns ------- response (werkzeug.wrappers.Response): the dispatched response object. """ request = Request(environ) if self.session_store is not None: sid = request.cookies.get(self.config['sessions']['id_header']) if sid is None: request.session = self.session_store.new() else: request.session = self.session_store.get(sid) response = self.dispatch_request(request) if self.session_store is not None: if request.session.should_save: self.session_store.save(request.session) response.set_cookie( self.config['sessions']['id_header'], request.session.sid ) return response(environ, start_response) def __call__(self, environ, start_response): return self.wsgi_app(environ, start_response)