Changeset 80

Show
Ignore:
Timestamp:
06/05/07 22:49:10
Author:
bbangert
Message:

PEP 8 indentation and wrapping clean-up.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • AuthKit/branches/0.4/authkit/authenticate/cookie.py

    r68 r80  
    106106    """ 
    107107 
    108     def __init__( 
    109         self,  
    110         secret,  
    111         userid,  
    112         ip,  
    113         tokens=(),  
    114         user_data='', 
    115         time=None,  
    116         cookie_name='authkit', 
    117         cookie_params=None 
    118     ): 
     108    def __init__(self, secret, userid, ip, tokens=(), user_data='', time=None,  
     109                 cookie_name='authkit', cookie_params=None): 
    119110        secure = False 
    120111        if cookie_params is None: 
    …… 
    131122            else: 
    132123                self.cookie_params = cookie_params.copy() 
    133         AuthTicket.__init__( 
    134             self,  
    135             secret,  
    136             userid,  
    137             ip,  
    138             tokens=tokens, 
    139             user_data=user_data, 
    140             time=time, 
    141             cookie_name=cookie_name, 
    142             secure=secure 
    143         ) 
     124        AuthTicket.__init__(self, secret, userid, ip, tokens=tokens,  
     125                            user_data=user_data, time=time,  
     126                            cookie_name=cookie_name, secure=secure) 
    144127 
    145128    def digest(self): 
    146         digest_ = calculate_digest( 
    147             self.ip, self.time, self.secret, self.userid, self.tokens, 
    148             self.user_data) 
     129        digest_ = calculate_digest(self.ip, self.time, self.secret,  
     130                                   self.userid, self.tokens, self.user_data) 
    149131        log.debug( 
    150132            "Calculating the digest ip %r, time %r, secret %r, userid %r, " 
    151             "tokens %r, user_data %r, digest %r",  
    152             self.ip,  
    153             self.time,  
    154             self.secret,  
    155             self.userid,  
    156             self.tokens,  
    157             self.user_data, 
    158             digest_ 
    159         ) 
     133            "tokens %r, user_data %r, digest %r", self.ip, self.time,  
     134            self.secret, self.userid, self.tokens, self.user_data, digest_) 
    160135        return digest_ 
    161136 
    …… 
    216191        user_data = data 
    217192     
    218     expected = calculate_digest(ip, timestamp, secret, 
    219                                 userid, tokens, user_data) 
    220  
     193    expected = calculate_digest(ip, timestamp, secret, userid, tokens,  
     194                                user_data) 
     195     
    221196    if expected != digest: 
    222197        raise BadTicket('Digest signature is not correct', 
    223198                        expected=(expected, digest)) 
    224  
     199     
    225200    tokens = tokens.split(',') 
    226  
     201     
    227202    return (timestamp, userid, tokens, user_data) 
    228203     
    …… 
    230205    log.debug( 
    231206        "calculate_digest(ip=%r, timestamp=%r, secret=%r, userid=%r, " 
    232         "tokens=%r, user_data=%r)", 
    233         ip,  
    234         timestamp,  
    235         secret,  
    236         userid,  
    237         tokens,  
    238         user_data 
    239     ) 
    240     digest0 = md5.new( 
    241         encode_ip_timestamp(ip, timestamp) + secret + userid + '\0' 
    242         + tokens + '\0' + user_data).hexdigest() 
     207        "tokens=%r, user_data=%r)", ip, timestamp, secret, userid, tokens,  
     208        user_data) 
     209    digest0 = md5.new(encode_ip_timestamp(ip, timestamp) + secret + userid 
     210                      + '\0' + tokens + '\0' + user_data).hexdigest() 
    243211    digest = md5.new(digest0 + secret).hexdigest() 
    244212    return digest 
    …… 
    248216    ip_chars = ''.join(map(chr, map(int, ip.split('.')))) 
    249217    t = int(timestamp) 
    250     ts = ((t & 0xff000000) >> 24, 
    251           (t & 0xff0000) >> 16, 
    252           (t & 0xff00) >> 8, 
     218    ts = ((t & 0xff000000) >> 24, (t & 0xff0000) >> 16, (t & 0xff00) >> 8, 
    253219          t & 0xff) 
    254220    ts_chars = ''.join(map(chr, ts)) 
    …… 
    272238    """ 
    273239 
    274     def __init__( 
    275         self, 
    276         app, 
    277         secret,  
    278         name='authkit',  
    279         params=None, 
    280         includeip=True,  
    281         signoutpath=None, 
    282         enforce=False, 
    283         ticket_class=AuthKitTicket 
    284     ): 
     240    def __init__(self, app, secret, name='authkit', params=None,  
     241                 includeip=True, signoutpath=None, enforce=False,  
     242                 ticket_class=AuthKitTicket): 
    285243        log.debug("Setting up the cookie middleware") 
    286244        secure = False 
    287245        if params.has_key('secure') and asbool(params['secure']) == True: 
    288246            secure = True 
    289         AuthTKTMiddleware.__init__( 
    290             self, 
    291             app, 
    292             secret,  
    293             cookie_name=name,  
    294             # secure not needed! 
    295             secure=secure, 
    296             include_ip=asbool(includeip),  
    297             logout_path=signoutpath, 
    298         ) 
    299         #raise Exception(include_ip) 
     247         
     248        # secure not needed! 
     249        AuthTKTMiddleware.__init__(self, app, secret, cookie_name=name,  
     250                                   secure=secure, include_ip=asbool(includeip), 
     251                                   logout_path=signoutpath) 
     252         
    300253        self.ticket_class = ticket_class 
    301254        self.cookie_params = params and params.copy() or {} 
    302255        self.cookie_enforce = enforce 
    303256        if self.cookie_enforce and not self.cookie_params.has_key('expires'): 
    304             raise Exception( 
    305                 "Cannot enforce cookie expiration since no cookie_params " 
    306                 "'expires' has been set" 
    307             ) 
     257            raise Exception("Cannot enforce cookie expiration since no " 
     258                            "cookie_params expires' has been set") 
    308259 
    309260    def __call__(self, environ, start_response): 
    …… 
    314265        else: 
    315266            cookie_value = '' 
    316         log.debug( 
    317             "Our cookie %r value is therefore %r",  
    318             self.cookie_name,  
    319             cookie_value 
    320         ) 
    321         remote_addr = environ.get( 
    322             'HTTP_X_FORWARDED_FOR',  
    323             environ.get('REMOTE_ADDR','0.0.0.0') 
    324         ) 
    325         log.debug( 
    326             "Remote addr %r, value %r, include_ip %r",  
    327             remote_addr,  
    328             cookie_value,  
    329             self.include_ip, 
    330         ) 
     267        log.debug("Our cookie %r value is therefore %r", self.cookie_name,  
     268                  cookie_value) 
     269        remote_addr = environ.get('HTTP_X_FORWARDED_FOR',  
     270                                  environ.get('REMOTE_ADDR','0.0.0.0')) 
     271        log.debug("Remote addr %r, value %r, include_ip %r", remote_addr,  
     272                  cookie_value, self.include_ip) 
    331273        if cookie_value: 
    332274            if self.include_ip: 
    …… 
    345287                headers = self.logout_user_cookie(environ) 
    346288                headers.append(('Content-type','text/plain')) 
    347                 start_response( 
    348                     '401 Not authenticated', 
    349                     headers, 
    350                 ) 
     289                start_response('401 Not authenticated', headers) 
    351290                if not msg: 
    352291                    msg = 'Bad cookie, you have been signed out.\n If this' 
    …… 
    355294                return [msg] 
    356295            try: 
    357                 log.debug( 
    358                     "Parsing ticket secret %r, cookie value %r, " 
    359                     "remote address %s",  
    360                     self.secret,  
    361                     cookie_value,  
    362                     remote_addr, 
    363                 ) 
    364                 timestamp, userid, tokens, user_data = parse_ticket( 
    365                     self.secret,  
    366                     cookie_value,  
    367                     remote_addr 
    368                 ) 
     296                log.debug("Parsing ticket secret %r, cookie value %r, " 
     297                          "remote address %s", self.secret, cookie_value,  
     298                          remote_addr) 
     299                timestamp, userid, tokens, user_data = \ 
     300                    parse_ticket(self.secret, cookie_value, remote_addr) 
    369301            except BadTicket, e: 
    370302                if e.expected: 
    …… 
    377309                log.debug("Cookie enforce: %s", self.cookie_enforce) 
    378310                log.debug("Time difference: %s", str(now-timestamp)) 
    379                 log.debug( 
    380                     "Cookie params expire: %s",  
    381                     self.cookie_params.get('expires') 
    382                 ) 
     311                log.debug("Cookie params expire: %s",  
     312                          self.cookie_params.get('expires')) 
    383313                if self.cookie_enforce and now - timestamp > \ 
    384314                   float(self.cookie_params['expires']) + 1: 
    385                     return bad_ticket_app( 
    386                         environ,  
    387                         start_response,  
    388                         msg="Cookie expired." 
    389                     ) 
     315                    return bad_ticket_app(environ, start_response,  
     316                                          msg="Cookie expired.") 
    390317                else: 
    391318                    environ['paste.auth_tkt.timestamp'] = timestamp 
     319            # End changes from the default 
    392320             
    393             # 
    394             # End changes from the default 
    395             # 
    396          
    397321            tokens = ','.join(tokens) 
    398322            environ['REMOTE_USER'] = userid 
    …… 
    404328            environ['AUTH_TYPE'] = 'cookie' 
    405329        set_cookies = [] 
     330         
    406331        def set_user(userid, tokens='', user_data=''): 
    407             set_cookies.extend(self.set_user_cookie( 
    408                 environ, userid, tokens, user_data)) 
     332            set_cookies.extend(self.set_user_cookie(environ, userid, tokens,  
     333                                                    user_data)) 
    409334        def logout_user(): 
    410335            set_cookies.extend(self.logout_user_cookie(environ)) 
     336         
    411337        environ['paste.auth_tkt.set_user'] = set_user 
    412338        environ['paste.auth_tkt.logout_user'] = logout_user 
    413339        if self.logout_path and environ.get('PATH_INFO') == self.logout_path: 
    414340            logout_user() 
     341         
    415342        def cookie_setting_start_response(status, headers, exc_info=None): 
    416343            headers.extend(set_cookies) 
    …… 
    434361                #~ 'we got here. This means the base class has changed ' 
    435362                #~ 'since this class was written. %r %r'%self.secure, ) 
    436         ticket = self.ticket_class( 
    437             self.secret, 
    438             userid, 
    439             remote_addr, 
    440             tokens=tokens, 
    441             user_data=user_data, 
    442             cookie_name=self.cookie_name, 
    443             cookie_params = self.cookie_params 
    444         ) 
     363        ticket = self.ticket_class(self.secret, userid, remote_addr,  
     364                                   tokens=tokens, user_data=user_data,  
     365                                   cookie_name=self.cookie_name,  
     366                                   cookie_params=self.cookie_params) 
     367         
    445368        # @@: Should we set REMOTE_USER etc in the current 
    446369        # environment right now as well? 
    …… 
    454377        path = '/' 
    455378        if not domain: 
    456             cookies = [ 
    457                 ( 
    458                     'Set-Cookie', '%s=""; Path=%s' % ( 
    459                         self.cookie_name,  
    460                         path 
    461                     ) 
    462                 ), 
    463             ] 
    464         else: 
    465             cookies = [ 
    466                 ( 
    467                     'Set-Cookie',  
    468                     '%s=""; Path=%s; Domain=%s' % ( 
    469                         self.cookie_name,  
    470                         path,  
    471                         domain 
    472                     ) 
    473                 ), 
    474             ] 
     379            cookies = [('Set-Cookie', '%s=""; Path=%s' % (self.cookie_name,  
     380                                                          path))] 
     381        else: 
     382            cookies = [('Set-Cookie', '%s=""; Path=%s; Domain=%s' %  
     383                       (self.cookie_name, path, domain))] 
    475384        return cookies 
    476385 
    477 def make_cookie_handler( 
    478     app,  
    479     auth_conf,  
    480     app_conf=None, 
    481     global_conf=None, 
    482     prefix='authkit.cookie.',  
    483 ): 
     386def make_cookie_handler(app, auth_conf, app_conf=None, global_conf=None,  
     387                        prefix='authkit.cookie.'): 
    484388    param_conf = strip_base(auth_conf, 'params.') 
    485389    cookie_args = {} 
    …… 
    491395            'No cookie secret specified under %r'%(prefix+'secret') 
    492396        ) 
    493     app = AuthKitCookieMiddleware( 
    494         app, 
    495         params=param_conf, 
    496         ticket_class=AuthKitTicket, 
    497         **cookie_args 
    498     ) 
     397    app = AuthKitCookieMiddleware(app, params=param_conf,  
     398                                  ticket_class=AuthKitTicket, cookie_args) 
    499399    return app 
    500