def __call__(self, environ, start_response):
        cookie = parse_cookie(environ.get('HTTP_COOKIE', ''))
        sid = cookie.get(self.cookie_name, None)
        if sid is None:
            session = self.store.new()
        else:
            session = self.store.get(sid)
        environ[self.environ_key] = session

        def injecting_start_response(status, headers, exc_info=None):
            if session.should_save:
                age = session.get('_sheep_permstore', self.cookie_age)
                try:
                    age = int(age)
                except:
                    age = self.cookie_age
                self.store.save(session)
                headers.append(('Set-Cookie', dump_cookie(self.cookie_name,
                                session.sid, age,
                                self.cookie_expires, self.cookie_path,
                                self.cookie_domain, self.cookie_secure,
                                self.cookie_httponly)))
            return start_response(status, headers, exc_info)
        return ClosingIterator(self.app(environ, injecting_start_response),
                               lambda: self.store.save_if_modified(session))

    def __call__(self, environ, start_response):
        
        cookie = parse_cookie(environ)
        user_cookie = cookie.get(self.cookie_name, None)
        
        usersession = UserSession(self.userbase)
        usersession.set_cookie_value(user_cookie)
        
        environ[self.environ_key + ".session"] = usersession
        environ[self.environ_key + ".userbase"] = self.userbase

        def injecting_start_response(status, headers, exc_info=None):
            
            cookie_value = usersession.get_cookie_value()            
            
            cookie_str = dump_cookie(
                self.cookie_name,
                cookie_value if cookie_value is not None else "", 
                self.cookie_age,
                None if cookie_value is not None else datetime.datetime.now() - datetime.timedelta(days=1),
                self.cookie_path,
                self.cookie_domain, 
                self.cookie_secure,
                self.cookie_httponly)
                            
            headers.append(('Set-Cookie', cookie_str))
            
            self.userbase.store_changes()
            
            return start_response(status, headers, exc_info)
            
        return self.app(environ, injecting_start_response)

    def __call__(self, environ, start_response):
        cookie = parse_cookie(environ.get("HTTP_COOKIE", ""))
        sid = cookie.get(self.cookie_name, None)
        if sid is None:
            session = self.store.new()
        else:
            session = self.store.get(sid)
        environ[self.environ_key] = session

        def injecting_start_response(status, headers, exc_info=None):
            if session.should_save:
                self.store.save(session)
                headers.append(
                    (
                        "Set-Cookie",
                        dump_cookie(
                            self.cookie_name,
                            session.sid,
                            self.cookie_age,
                            self.cookie_expires,
                            self.cookie_path,
                            self.cookie_domain,
                            self.cookie_secure,
                            self.cookie_httponly,
                        ),
                    )
                )
            return start_response(status, headers, exc_info)

        return ClosingIterator(
            self.app(environ, injecting_start_response), lambda: self.store.save_if_modified(session)
        )

    def __call__(self, environ, start_response):
        session_store = locate(settings.SESSION_STORE)

        if not session_store or not issubclass(session_store, SessionStore):
            raise ValueError(
                'SESSION_STORE must be a sub class of \'SessionStore\''
            )

        session_store = session_store()

        auth_collection = locate(settings.AUTH_COLLECTION)
        if not auth_collection or not issubclass(auth_collection, Collection):
            raise ValueError(
                'AUTH_COLLECTION must be a sub class of \'Collection\''
            )

        environ['session'] = session_store.new()

        session_id = environ.get('HTTP_AUTHORIZATION', '')
        if len(session_id.split('Token ')) == 2:
            session_id = session_id.split('Token ')[1]
            environ['session'] = session_store.get(session_id)
        else:
            cookies = environ.get('HTTP_COOKIE')

            if cookies:
                session_id = parse_cookie(cookies).get('session_id')

                if session_id:
                    environ['session'] = session_store.get(session_id)

        environ[auth_collection.__name__.lower()] = auth_collection.get({
            '_id': deserialize(
                environ['session'].get(auth_collection.__name__.lower(), '""')
            )
        })

        def authentication(status, headers, exc_info=None):
            headers.extend([
                (
                    'Set-Cookie', dump_cookie(
                        'session_id', environ['session'].sid, 7 * 24 * 60 * 60,
                    )
                ),
                (
                    'HTTP_AUTHORIZATION', 'Token {0}'.format(
                        environ['session'].sid
                    )
                ),
            ])

            return start_response(status, headers, exc_info)

        response = self.app(environ, authentication)

        if environ['session'].should_save:
            session_store.save(environ['session'])

        return response

def get_session_from_env(environ):
    global gSessionStore
    cookie = parse_cookie(environ)
    session_id = None
    ret = None
    if 'session_id' in cookie:
        session_id = cookie['session_id']
        ret = gSessionStore.get(session_id)
    return ret

    def get_cookies(self, response):
        """Parse cookies from Flask Response.

        :param response:
        :return: dict with cookie values
        """
        cookies = {}
        for value in response.headers.get_all('Set-Cookie'):
            cookies.update(parse_cookie(value))
        return cookies

def _get_cookies(headers):
    """
    Convert a list of headers into all the cookies set
    """
    result = {}
    for cookie_str in headers.getlist('Set-Cookie'):
        cookie = parse_cookie(cookie_str)
        result.update(cookie)  # cookies are k => val dicts

        return result

def get_userinfo_from_env(environ):
    global gConfig, gLoginToken
    cookie = parse_cookie(environ)
    session_id = None
    ret = None
    if 'session_id' in cookie:
        session_id = cookie['session_id']
        if session_id in gLoginToken:
            ret = gLoginToken[session_id]
    return session_id, ret

def test_wrapper_support():
    req = Request.from_values()
    resp = Response()
    c = SecureCookie.load_cookie(req, secret_key=b'foo')
    assert c.new
    c['foo'] = 42
    assert c.secret_key == b'foo'
    c.save_cookie(resp)

    req = Request.from_values(headers={
        'Cookie':  'session="%s"' % parse_cookie(resp.headers['set-cookie'])['session']
    })
    c2 = SecureCookie.load_cookie(req, secret_key=b'foo')
    assert not c2.new
    assert c2 == c

    def test_wrapper_support(self):
        req = Request.from_values()
        resp = Response()
        c = SecureCookie.load_cookie(req, secret_key="foo")
        assert c.new
        c["foo"] = 42
        assert c.secret_key == "foo"
        c.save_cookie(resp)

        req = Request.from_values(
            headers={"Cookie": 'session="%s"' % parse_cookie(resp.headers["set-cookie"])["session"]}
        )
        c2 = SecureCookie.load_cookie(req, secret_key="foo")
        assert not c2.new
        assert c2 == c

    def test_wrapper_support(self):
        req = Request.from_values()
        resp = Response()
        c = EncryptedCookie.load_cookie(req, crypter_or_keys_location=KEYS_DIR)
        assert c.new
        c['foo'] = 42
        assert c.crypter is not None
        c.save_cookie(resp)

        req = Request.from_values(headers={
            'Cookie':  'session="%s"' % parse_cookie(resp.headers['set-cookie'])['session']
        })
        c2 = EncryptedCookie.load_cookie(req, crypter_or_keys_location=KEYS_DIR)
        assert not c2.new
        assert c2 == c

    def api(self, request, args):
        cookies = parse_cookie(request.environ)
        if not "key" in cookies or not cookies["key"] == password:
            return Response("fail")

        func = args["func"]
        if func == "rgb":
            if not "args" in args:
                return NotFound()
            parts = args["args"].split(":")
            print parts
            try:
                arduino.client.rgb(*parts)
            except Exception as e:
                print e
                return NotFound()

        return Response("")

def _get_auth_cookies():
    # Login with the user specified to get the reports
    with app.test_request_context():
        user = security_manager.find_user(config.get('EMAIL_REPORTS_USER'))
        login_user(user)

        # A mock response object to get the cookie information from
        response = Response()
        app.session_interface.save_session(app, session, response)

    cookies = []

    # Set the cookies in the driver
    for name, value in response.headers:
        if name.lower() == 'set-cookie':
            cookie = parse_cookie(value)
            cookies.append(cookie['session'])

    return cookies

def get_cookies(rv):
    cookies = {}
    for value in rv.headers.get_all("Set-Cookie"):
        cookies.update(parse_cookie(value))
    return cookies

 def getCookies(self, response):
     cookies = {}
     for value in response.headers.get_all("Set-Cookie"):
         cookies.update(parse_cookie(value))
     return cookies

 def cookies(self):
     """The retreived cookie values as regular dictionary."""
     return parse_cookie(self.environ, self.charset)

 def cookies(self):
     return parse_cookie(self.environ, self.charset, cls=self.dict_storage_class)