Ignore:
Timestamp:
19/10/12 10:52:53 (8 years ago)
Author:
pjkersha
Message:

Reformatting of code

Location:
trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/examples/bearer_tok/bearer_tok_server_app_serve.py

    r8153 r8195  
    180180    if opt.withSSL.lower() == 'true': 
    181181        ssl_context = SSL.Context(SSL.SSLv23_METHOD) 
    182 #        ssl_context.set_options(SSL.OP_NO_SSLv2) 
    183      
     182     
     183        ssl_context.set_session_id('oauthserver') 
    184184        ssl_context.use_privatekey_file(opt.priKeyFilePath) 
    185185        ssl_context.use_certificate_file(opt.certFilePath) 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/lib/authorization_server.py

    r8119 r8195  
    1616import urllib 
    1717 
    18 from ndg.oauth.server.lib.access_token.make_access_token import make_access_token 
     18from ndg.oauth.server.lib.access_token.make_access_token import \ 
     19                                                    make_access_token 
    1920from ndg.oauth.server.lib.oauth.access_token import AccessTokenRequest 
    20 from ndg.oauth.server.lib.oauth.authorize import AuthorizeRequest, AuthorizeResponse 
     21from ndg.oauth.server.lib.oauth.authorize import (AuthorizeRequest,  
     22                                                  AuthorizeResponse) 
    2123from ndg.oauth.server.lib.oauth.oauth_exception import OauthException 
    2224from ndg.oauth.server.lib.register.access_token import AccessTokenRegister 
    2325from ndg.oauth.server.lib.register.client import ClientRegister 
    24 from ndg.oauth.server.lib.register.authorization_grant import AuthorizationGrantRegister 
     26from ndg.oauth.server.lib.register.authorization_grant import \ 
     27                                                    AuthorizationGrantRegister 
    2528 
    2629log = logging.getLogger(__name__) 
     
    4649        authenticated and that the user has authorised the client and scope. 
    4750 
    48         Request query parameters (from http://tools.ietf.org/html/draft-ietf-oauth-v2-22): 
     51        Request query parameters (from  
     52        http://tools.ietf.org/html/draft-ietf-oauth-v2-22): 
    4953 
    5054        response_type 
     
    128132 
    129133            client_error = self.client_register.is_valid_client( 
    130                                                         auth_request.client_id,  
    131                                                         auth_request.redirect_uri) 
     134                                                    auth_request.client_id,  
     135                                                    auth_request.redirect_uri) 
    132136            if client_error: 
    133137                log.error("Invalid client: %s", client_error) 
    134138                return (None, httplib.BAD_REQUEST, client_error) 
    135139 
    136             # redirect_uri must be included in the request if the client has more 
    137             # than one registered. 
     140            # redirect_uri must be included in the request if the client has 
     141            # more than one registered. 
    138142            client = self.client_register.register[auth_request.client_id] 
    139143            if len(client.redirect_uris) != 1 and not auth_request.redirect_uri: 
     
    197201        ) 
    198202        if not redirect_uri: 
    199             return(None, httplib.BAD_REQUEST, 
    200                    'An authorization request has been made without a return URI.') 
     203            return ( 
     204                None,  
     205                httplib.BAD_REQUEST, 
     206                'An authorization request has been made without a return URI.') 
    201207 
    202208        # Redirect back to client with authorization code or error. 
     
    251257        Handles a request for an access token. 
    252258 
    253         Request parameters in post data (from http://tools.ietf.org/html/draft-ietf-oauth-v2-22): 
     259        Request parameters in post data (from  
     260        http://tools.ietf.org/html/draft-ietf-oauth-v2-22): 
    254261 
    255262        The client makes a request to the token endpoint by adding the 
     
    302309                log.debug("Client id: %s", client_id) 
    303310 
    304             # redirect_uri is only required if it was included in the authorization request. 
     311            # redirect_uri is only required if it was included in the  
     312            # authorization request. 
    305313            required_parameters = ['grant_type', 'code'] 
    306314            for param in required_parameters: 
     
    308316                    log.error("Missing request parameter %s from inputs: %s", 
    309317                              param, params) 
    310                     raise OauthException('invalid_request',  
    311                                     ("Missing request parameter: %s" % param)) 
     318                    raise OauthException( 
     319                                    'invalid_request',  
     320                                    "Missing request parameter: %s" % param) 
    312321 
    313322        except OauthException, exc: 
     
    331340 
    332341        if response: 
    333             return(self._access_token_response(response), None, None) 
     342            return self._access_token_response(response), None, None 
    334343        else: 
    335             return(None, httplib.INTERNAL_SERVER_ERROR,  
    336                    'Access token generation failed.') 
     344            return (None, httplib.INTERNAL_SERVER_ERROR,  
     345                    'Access token generation failed.') 
    337346 
    338347    def _access_token_response(self, resp): 
     
    453462            else: 
    454463                required_scope = params.get('scope', None) 
    455             (token, error) = self.access_token_register.get_token(access_token, 
    456                                                                 required_scope) 
     464            error = self.access_token_register.get_token(access_token, 
     465                                                         required_scope)[-1] 
    457466 
    458467        status = {'invalid_request': httplib.BAD_REQUEST, 
     
    510519            else: 
    511520                required_scope = params.get('scope', None) 
    512             (token, error) = self.access_token_register.get_token(access_token, 
     521                 
     522            token, error = self.access_token_register.get_token(access_token, 
    513523                                                                required_scope) 
    514524 
     
    518528                  None: httplib.OK}.get(error, httplib.BAD_REQUEST) 
    519529 
    520         return (token, status, error) 
     530        return token, status, error 
    521531 
    522532    def is_registered_client(self, request): 
     
    530540        client_id = request.params.get('client_id', None) 
    531541        if not client_id: 
    532             return ('invalid_request', 'Missing request parameter: client_id') 
     542            return 'invalid_request', 'Missing request parameter: client_id' 
    533543        else: 
    534544            error_description = self.client_register.is_registered_client( 
    535545                                                                    client_id) 
    536546            if error_description: 
    537                 return ('unauthorized_client', error_description) 
     547                return 'unauthorized_client', error_description 
    538548             
    539         return (None, None) 
     549        return None, None 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/lib/register/access_token.py

    r8057 r8195  
    6767            log.debug("Request for token of ID that is not registered: %s", 
    6868                      token_id) 
    69             return (None, 'invalid_token') 
     69            return None, 'invalid_token' 
    7070 
    7171        if not token.valid: 
    7272            log.debug("Request for invalid token of ID: %s", token_id) 
    73             return (None, 'invalid_token') 
     73            return None, 'invalid_token' 
     74         
    7475        if token.expires <= datetime.utcnow(): 
    7576            log.debug("Request for expired token of ID: %s", token_id) 
    76             return (None, 'invalid_token') 
     77            return None, 'invalid_token' 
     78                     
    7779        # Check scope 
    7880        if not scopeutil.isScopeGranted(token.scope, 
    7981                                        scopeutil.scopeStringToList(scope)): 
    80             log.debug("Request for token of ID: %s - token was not granted scope %s", 
    81                       token_id, scope) 
    82             return (None, 'insufficient_scope') 
    83         return (token, None) 
     82            log.debug("Request for token of ID: %s - token was not granted " 
     83                      "scope %s", token_id, scope) 
     84            return None, 'insufficient_scope' 
     85         
     86        return token, None 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/lib/register/client.py

    r8033 r8195  
    77__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    88__revision__ = "$Id$" 
    9  
    109import logging 
    1110from ConfigParser import SafeConfigParser 
    1211log = logging.getLogger(__name__) 
     12 
    1313 
    1414class ClientRegistration(object): 
     
    1616    An entry in the client register. 
    1717    """ 
    18     def __init__(self, name, client_id, client_type, redirect_uris, authentication_data): 
     18    def __init__(self, name, client_id, client_type, redirect_uris,  
     19                 authentication_data): 
    1920        self.name = name 
    2021        self.client_id = client_id 
     
    2526            self.redirect_uris = [] 
    2627        self.authentication_data = authentication_data 
     28 
    2729 
    2830class ClientRegister(object): 
     
    6870        if redirect_uri is None: 
    6971            if len(client.redirect_uris) != 1: 
    70                 return 'No redirect URI is registered for the client or specified in the request.' 
     72                return ('No redirect URI is registered for the client or ' 
     73                        'specified in the request.') 
    7174        if redirect_uri is not None and redirect_uri not in client.redirect_uris: 
    7275            return 'Redirect URI is not registered.' 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/lib/register/client_authorization.py

    r8057 r8195  
    77__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    88__revision__ = "$Id$" 
     9import ndg.oauth.server.lib.register.scopeutil as scopeutil 
    910 
    10 import ndg.oauth.server.lib.register.scopeutil as scopeutil 
    1111 
    1212class ClientAuthorization(object): 
     
    2929        requested scopes that are not granted, otherwise False 
    3030        """ 
    31         return ((self.user == other.user) 
    32                 and (self.client_id == other.client_id) 
     31        return (self.user == other.user 
     32                and self.client_id == other.client_id 
    3333                and scopeutil.isScopeGranted(self.scope, other.scope)) 
    3434 
    3535    def __repr__(self): 
    36         return ("user: %s  client_id: %s  scope: %s  granted: %s" % (self.user, self.client_id, self.scope, self.is_authorized)) 
     36        return "user: %s  client_id: %s  scope: %s  granted: %s" % ( 
     37                                                            self.user,  
     38                                                            self.client_id,  
     39                                                            self.scope,  
     40                                                            self.is_authorized) 
    3741 
    3842class ClientAuthorizationRegister(object): 
     
    4448 
    4549    def add_client_authorization(self, client_authorization): 
    46         user_authorizations = self.register.setdefault(client_authorization.user, {}) 
    47         client_authorizations = user_authorizations.setdefault(client_authorization.client_id, []) 
     50        user_authorizations = self.register.setdefault( 
     51                                            client_authorization.user, {}) 
     52        client_authorizations = user_authorizations.setdefault( 
     53                                            client_authorization.client_id, []) 
    4854        for auth in client_authorizations: 
    4955            if auth.eq_authz_basis(client_authorization): 
    5056                auth.is_authorized = client_authorization.is_authorized 
    5157 
    52         user_authorizations[client_authorization.client_id].append(client_authorization) 
     58        user_authorizations[client_authorization.client_id].append( 
     59                                            client_authorization) 
    5360 
    5461 
     
    5865        if user_authorizations: 
    5966            client_authorizations = user_authorizations.get(client_id, []) 
    60             # Assume small number of authorization types per user/client (probably typically one). 
     67            # Assume small number of authorization types per user/client  
     68            # (probably typically one). 
    6169            for auth in client_authorizations: 
    6270                if auth.eq_authz_basis(client_authorization): 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/lib/register/register_base.py

    r7952 r8195  
    3333            'cache.expire': config.get(base + 'expire', None), 
    3434            'cache.type': config.get(base + 'type', 'file'), 
    35             'cache.data_dir': config.get(base + 'data_dir', '/tmp/ndgoauth/cache/' + name), 
     35            'cache.data_dir': config.get(base + 'data_dir',  
     36                                         '/tmp/ndgoauth/cache/' + name), 
    3637            'cache.lock_dir': config.get(base + 'lock_dir', None) 
    3738            } 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/wsgi/oauth2_server.py

    r8119 r8195  
    223223            log.debug("%s not in environ - authentication required", 
    224224                      self.user_identifier_env_key) 
    225             start_response(self._get_http_status_string(httplib.UNAUTHORIZED), []) 
     225            start_response(self._get_http_status_string(httplib.UNAUTHORIZED),  
     226                           []) 
    226227            return [] 
    227228 
    228229        # User authorization for the client is also required. 
    229         (client_authorized, authz_uri) = self._check_client_authorization(user, req) 
     230        (client_authorized, authz_uri) = self._check_client_authorization(user,  
     231                                                                          req) 
    230232        if authz_uri: 
    231233            log.debug("Redirecting to %s", authz_uri) 
     
    238240        (redirect_uri,  
    239241         error,  
    240          error_description) = self._authorizationServer.authorize(req,  
     242         error_description) = self._authorizationServer.authorize( 
     243                                                            req,  
    241244                                                            client_authorized) 
    242245        if error: 
     
    392395 
    393396        if status == httplib.OK: 
    394             (token, status, 
    395                 error) = self._authorizationServer.get_registered_token(req, dn) 
     397            (token,  
     398             status, 
     399             error) = self._authorizationServer.get_registered_token(req, dn) 
    396400 
    397401        if status == httplib.OK: 
Note: See TracChangeset for help on using the changeset viewer.