Download Install Tutorial Docs FAQ Tools Wiki ∇ License Team IRC Planet Involvement Shop Book

Changeset 1322

Show
Ignore:
Timestamp:
09/02/06 17:32:57
Author:
fumanchu
Message:

cptools.session_auth was growing an unwieldy number of parameters, so I moved it from a functional approach to an object. Also moved _cptools.setargs to Tool._setargs.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/cherrypy/_cptools.py

    r1319 r1322  
    2828 
    2929 
    30 def setargs(obj, func): 
    31     """Copy func parameter names to obj attributes.""" 
    32     try: 
    33         import inspect 
    34         for arg in inspect.getargspec(func)[0]: 
    35             setattr(obj, arg, None) 
    36     except (ImportError, AttributeError): 
    37         pass 
    38  
    39  
    4030class Tool(object): 
    4131    """A registered function for use with CherryPy request-processing hooks. 
    …… 
    4939        self._name = name 
    5040        self.__doc__ = self.callable.__doc__ 
    51         setargs(self, callable) 
     41        self._setargs() 
     42     
     43    def _setargs(self): 
     44        """Copy func parameter names to obj attributes.""" 
     45        try: 
     46            import inspect 
     47            for arg in inspect.getargspec(self.callable)[0]: 
     48                setattr(self, arg, None) 
     49        except (ImportError, AttributeError): 
     50            pass 
    5251     
    5352    def _merged_args(self, d=None): 
    …… 
    253252 
    254253 
     254class SessionAuthTool(MainTool): 
     255     
     256    def _setargs(self): 
     257        for name in dir(cptools.SessionAuth): 
     258            if not name.startswith("__"): 
     259                setattr(self, name, None) 
     260 
     261 
    255262class CachingTool(Tool): 
    256263    """Caching Tool for CherryPy.""" 
    257      
    258     def __init__(self): 
    259         self._point = 'before_main' 
    260         self.callable = _caching.get 
    261         self._name = 'caching' 
    262         self.__doc__ = self.callable.__doc__ 
    263         setargs(self, self.callable) 
    264264     
    265265    def _wrapper(self, **kwargs): 
    …… 
    290290 
    291291default_toolbox = Toolbox() 
    292 default_toolbox.session_auth = MainTool(cptools.session_auth) 
     292default_toolbox.session_auth = SessionAuthTool(cptools.session_auth) 
    293293default_toolbox.proxy = Tool('before_request_body', cptools.proxy) 
    294294default_toolbox.response_headers = Tool('on_start_resource', cptools.response_headers) 
    …… 
    309309default_toolbox.xmlrpc = XMLRPCTool() 
    310310default_toolbox.wsgiapp = WSGIAppTool(_wsgiapp.run) 
    311 default_toolbox.caching = CachingTool() 
     311default_toolbox.caching = CachingTool('before_main', _caching.get, 'caching') 
    312312default_toolbox.expires = Tool('before_finalize', _caching.expires) 
    313313default_toolbox.tidy = Tool('before_finalize', tidy.tidy) 

  • trunk/cherrypy/lib/cptools.py

    r1319 r1322  
    143143 
    144144 
    145 _login_screen = """<html><body> 
     145class SessionAuth(object): 
     146    """Assert that the user is logged in.""" 
     147     
     148    session_key = "username" 
     149     
     150    def check_login_and_password(self, login, password): 
     151        pass 
     152     
     153    def anonymous(self): 
     154        """Provide a temporary user name for anonymous users.""" 
     155        pass 
     156     
     157    def load_user_by_username(self, username): 
     158        pass 
     159     
     160    def on_login(self, login): 
     161        pass 
     162     
     163    def on_logout(self, login): 
     164        pass 
     165     
     166    def login_screen(self, from_page='..', login='', error_msg=''): 
     167        return """<html><body> 
    146168Message: %(error_msg)s 
    147169<form method="post" action="do_login"> 
    …… 
    151173    <input type="submit" /> 
    152174</form> 
    153 </body></html>""" 
    154  
    155 def session_auth(check_login_and_password=None, not_logged_in=None, 
    156                  load_user_by_username=None, session_key='username', 
    157                  on_login=None, on_logout=None, login_screen=None): 
    158     """Assert that the user is logged in.""" 
    159      
    160     if login_screen is None: 
    161         login_screen = _login_screen 
    162      
    163     request = cherrypy.request 
    164     tdata = cherrypy.thread_data 
    165     sess = cherrypy.session 
    166     request.user = None 
    167     tdata.user = None 
    168      
    169     if request.path.endswith('login_screen'): 
    170         return False 
    171     elif request.path.endswith('do_logout'): 
    172         login = sess.get(session_key) 
    173         sess[session_key] = None 
     175</body></html>""" % {'from_page': from_page, 'login': login, 
     176                     'error_msg': error_msg} 
     177     
     178    def do_login(self, login, password, from_page='..'): 
     179        """Login. May raise redirect, or return True if request handled.""" 
     180        error_msg = self.check_login_and_password(login, password) 
     181        if error_msg: 
     182            body = self.login_screen(from_page, login, error_msg) 
     183            cherrypy.response.body = body 
     184            return True 
     185        else: 
     186            cherrypy.session[self.session_key] = login 
     187            self.on_login(login) 
     188            raise cherrypy.HTTPRedirect(from_page or "/") 
     189     
     190    def do_logout(self, from_page='..'): 
     191        """Logout. May raise redirect, or return True if request handled.""" 
     192        sess = cherrypy.session 
     193        login = sess.get(self.session_key) 
     194        sess[self.session_key] = None 
     195        if login: 
     196            self.on_logout(login) 
     197        raise cherrypy.HTTPRedirect(from_page) 
     198     
     199    def check_user(self): 
     200        """Assert username. May raise redirect, or return True if request handled.""" 
     201        sess = cherrypy.session 
     202        request = cherrypy.request 
     203         
     204        username = sess.get(self.session_key) 
     205        if not username: 
     206            username = self.anonymous() 
     207        if not username: 
     208            cherrypy.response.body = self.login_screen(request.browser_url) 
     209            return True 
     210         
     211        # Everything is OK: user is logged in 
     212        tdata = cherrypy.thread_data 
     213        if not tdata.user: 
     214            tdata.user = request.user = self.load_user_by_username(username) 
     215     
     216    def run(self): 
     217        request = cherrypy.request 
    174218        request.user = None 
    175         tdata.user = None 
    176         if login and on_logout: 
    177             on_logout(login) 
    178         from_page = request.params.get('from_page', '..') 
    179         raise cherrypy.HTTPRedirect(from_page) 
    180     elif request.path.endswith('do_login'): 
    181         from_page = request.params.get('from_page', '..') 
    182         login = request.params['login'] 
    183         password = request.params['password'] 
    184         error_msg = check_login_and_password(login, password) 
    185         if error_msg: 
    186             kw = {"from_page": from_page, 
    187                   "login": login, "error_msg": error_msg} 
    188             cherrypy.response.body = login_screen % kw 
    189             return True 
    190          
    191         sess[session_key] = login 
    192         if on_login: 
    193             on_login(login) 
    194         raise cherrypy.HTTPRedirect(from_page or "/") 
    195      
    196     # Check if user is logged in 
    197     temp_user = None 
    198     if (not sess.get(session_key)) and not_logged_in: 
    199         # Call not_logged_in so that applications where anonymous user 
    200         #   is OK can handle it 
    201         temp_user = not_logged_in() 
    202     if (not sess.get(session_key)) and not temp_user: 
    203         kw = {"from_page": request.browser_url, "login": "", "error_msg": ""} 
    204         cherrypy.response.body = login_screen % kw 
    205         return True 
    206      
    207     # Everything is OK: user is logged in 
    208     if load_user_by_username and not tdata.user: 
    209         username = temp_user or sess[session_key] 
    210         request.user = load_user_by_username(username) 
    211         tdata.user = request.user 
    212      
    213     return False 
     219        cherrypy.thread_data.user = None 
     220         
     221        path = request.path 
     222        if path.endswith('login_screen'): 
     223            # pass and let the normal handler work 
     224            return self.login_screen() 
     225        elif path.endswith('do_login'): 
     226            return self.do_login(**request.params) 
     227        elif path.endswith('do_logout'): 
     228            return self.do_logout(**request.params) 
     229        else: 
     230            return self.check_user() 
     231 
     232 
     233def session_auth(**kwargs): 
     234    sa = SessionAuth() 
     235    for k, v in kwargs.iteritems(): 
     236        setattr(sa, k, v) 
     237    return sa.run() 
     238 
    214239 
    215240def virtual_host(use_x_forwarded_host=True, **domains): 

  • trunk/cherrypy/test/test_sessionauthenticate.py

    r1275 r1322  
    2828from cherrypy.test import helper 
    2929 
     30 
    3031class SessionAuthenticateTest(helper.CPWebCase): 
    3132     
    …… 
    3435        self.getPage('/') 
    3536        self.assertInBody('<form method="post" action="do_login">') 
    36  
     37         
    3738        # setup credentials 
    3839        login_body = 'login=login&password=password&from_page=/' 
    39  
     40         
    4041        # attempt a login 
    4142        self.getPage('/do_login', method='POST', body=login_body) 
    42         self.assert_(self.status in ('302 Found', '303 See Other')) 
    43  
     43        self.assertStatus((302, 303)) 
     44         
    4445        # get the page now that we are logged in 
    4546        self.getPage('/', self.cookies) 
    4647        self.assertBody('Hi, you are logged in') 
    47  
     48         
    4849        # do a logout 
    4950        self.getPage('/do_logout', self.cookies) 
    50         self.assert_(self.status in ('302 Found', '303 See Other')) 
    51  
     51        self.assertStatus((302, 303)) 
     52         
    5253        # verify we are logged out 
    5354        self.getPage('/', self.cookies) 

Hosted by WebFaction

Log in as guest/cpguest to create tickets