Пример #1
0
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
Пример #2
0
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
Пример #3
0
 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
Пример #4
0
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
Пример #5
0
 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
Пример #6
0
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
Пример #7
0
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
Пример #8
0
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
Пример #9
0
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
Пример #10
0
    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'用户名或者密码错误。'}
Пример #11
0
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
Пример #12
0
    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
Пример #13
0
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
Пример #14
0
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)
Пример #15
0
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)