def test_non_urandom(self): urandom = os.urandom del os.urandom try: store = FilesystemSessionStore(self.session_folder) store.new() finally: os.urandom = urandom
def test_non_urandom(tmpdir): urandom = os.urandom del os.urandom try: store = FilesystemSessionStore(str(tmpdir)) store.new() finally: os.urandom = urandom
def test_non_urandom(self): urandom = os.urandom del os.urandom try: store = FilesystemSessionStore(self.session_folder) store.new() finally: os.urandom = urandom
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_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(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_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 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 before_request(): session_store = FilesystemSessionStore(SESSIONS_DIR) if 'sid' in session: sid = session.get('sid') g.session = session_store.get(sid) else: session['sid'] = os.urandom(24) g.session = session_store.new()
class WSGIApplication(object): def __init__(self, url_mapping, middlewares=None): self.url_mapping = url_mapping self.session_store = FilesystemSessionStore() #self.session_store = BDBSessionStore() #self.session_store = MemorySessionStore() self.middlewares = middlewares or [] def addMiddleware(self, middleware): self.middlewares.append(middleware) def __call__(self, environ, start_response): # start_response('200 OK', [('Content-type','text/plain')]) # return ['Hello World!'] adapter = self.url_mapping.bind_to_environ(environ) # build request with session request = Request(environ) request.session = dummy_session request.user_id = None # url mapping try: endpoint, kwargs = adapter.match() # turn hander class path like 'www.views.main.index' to a real # handler class like index if isinstance(endpoint, basestring): dot = endpoint.rindex('.') module, cls = endpoint[:dot], endpoint[dot+1:] endpoint = __import__(module, {}, {}, [cls]) # build handler handler = endpoint() if handler.with_session: sid = request.cookies.get('session_id') if sid is None: request.session = self.session_store.new() else: request.session = self.session_store.get(sid) # build user if possible request.user_id = request.session.get(SESSION_USER_KEY) handler.app = self handler.errors = {} if settings.store_manager: handler.store = settings.store_manager.new() handler.request = request # middleware for middleware in self.middlewares: middleware.processRequest(handler.request) response = handler(kwargs) for middleware in reversed(self.middlewares): middleware.processResponse(handler.request, response) assert isinstance(response, BaseResponse) except HTTPException, e: response = e except Exception, e: logging.error(e) if settings.debug: raise response = InternalServerError()
def _make_filesystem_session(env: Environment) -> Session: session_store = FilesystemSessionStore(config.session_dir, session_class=OpenERPSession, renew_missing=True) session = session_store.new() session.db = env.cr.dbname session.uid = env.uid session.context = env.context return session
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 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 before_request(): """ Make sure we are connected to the database each request and also do the session handling. """ g.db = connect_db() session_store = FilesystemSessionStore(config.SESSIONS_DIR) if 'sid' in session: sid = session.get('sid') g.session = session_store.get(sid) if 'user' in g.session: g.user = g.session['user'] else: g.user = None else: g.session = session_store.new() g.user = None
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 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)