← Back to branch summary

~ubuntu-cloud-archive/ubuntu/precise/keystone/folsom

« back to all changes in this revision

Viewing changes to keystone/middleware/auth_token.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-03-26 13:41:45 UTC
  • mto: (35.1.2 keystone)
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: package-import@ubuntu.com-20120326134145-rq0l7xymweuap1ir
Tags: upstream-2012.1~rc1
Import upstream version 2012.1~rc1

Show diffs side-by-side

added added

removed removed

Lines of Context:
keystone/middleware/auth_token.py
99
99
import webob.exc
100
100
 
101
101
 
102
 
logger = logging.getLogger('keystone.middleware.auth_token')
 
102
LOG = logging.getLogger(__name__)
103
103
 
104
104
 
105
105
class InvalidUserToken(Exception):
114
114
    """Auth Middleware that handles authenticating client calls."""
115
115
 
116
116
    def __init__(self, app, conf):
117
 
        logger.info('Starting keystone auth_token middleware')
 
117
        LOG.info('Starting keystone auth_token middleware')
118
118
        self.conf = conf
119
119
        self.app = app
120
120
 
153
153
            try:
154
154
                import memcache
155
155
                import iso8601
156
 
                logger.info('Using memcache for caching token')
 
156
                LOG.info('Using memcache for caching token')
157
157
                self._cache = memcache.Client(memcache_servers.split(','))
158
158
                self._iso8601 = iso8601
159
159
            except NameError as e:
160
 
                logger.warn('disabled caching due to missing libraries %s', e)
 
160
                LOG.warn('disabled caching due to missing libraries %s', e)
161
161
 
162
162
    def __call__(self, env, start_response):
163
163
        """Handle incoming request.
166
166
        we can't authenticate.
167
167
 
168
168
        """
169
 
        logger.debug('Authenticating user token')
 
169
        LOG.debug('Authenticating user token')
170
170
        try:
171
171
            self._remove_auth_headers(env)
172
172
            user_token = self._get_user_token_from_header(env)
177
177
 
178
178
        except InvalidUserToken:
179
179
            if self.delay_auth_decision:
180
 
                logger.info('Invalid user token - deferring reject downstream')
 
180
                LOG.info('Invalid user token - deferring reject downstream')
181
181
                self._add_headers(env, {'X-Identity-Status': 'Invalid'})
182
182
                return self.app(env, start_response)
183
183
            else:
184
 
                logger.info('Invalid user token - rejecting request')
 
184
                LOG.info('Invalid user token - rejecting request')
185
185
                return self._reject_request(env, start_response)
186
186
 
187
187
        except ServiceError, e:
188
 
            logger.critical('Unable to obtain admin token: %s' % e)
 
188
            LOG.critical('Unable to obtain admin token: %s' % e)
189
189
            resp = webob.exc.HTTPServiceUnavailable()
190
190
            return resp(env, start_response)
191
191
 
207
207
            'X-Tenant',
208
208
            'X-Role',
209
209
        )
210
 
        logger.debug('Removing headers from request environment: %s' %
 
210
        LOG.debug('Removing headers from request environment: %s' %
211
211
                     ','.join(auth_headers))
212
212
        self._remove_headers(env, auth_headers)
213
213
 
285
285
            response = conn.getresponse()
286
286
            body = response.read()
287
287
        except Exception, e:
288
 
            logger.error('HTTP connection exception: %s' % e)
 
288
            LOG.error('HTTP connection exception: %s' % e)
289
289
            raise ServiceError('Unable to communicate with keystone')
290
290
        finally:
291
291
            conn.close()
293
293
        try:
294
294
            data = json.loads(body)
295
295
        except ValueError:
296
 
            logger.debug('Keystone did not return json-encoded body')
 
296
            LOG.debug('Keystone did not return json-encoded body')
297
297
            data = {}
298
298
 
299
299
        return response, data
356
356
            self._cache_store_invalid(user_token)
357
357
            raise InvalidUserToken('Token authorization failed')
358
358
        if response.status == 401:
359
 
            logger.info('Keystone rejected admin token, resetting')
 
359
            LOG.info('Keystone rejected admin token, resetting')
360
360
            self.admin_token = None
361
361
        else:
362
 
            logger.error('Bad response code while validating token: %s' %
 
362
            LOG.error('Bad response code while validating token: %s' %
363
363
                         response.status)
364
364
        if retry:
365
 
            logger.info('Retrying validation')
 
365
            LOG.info('Retrying validation')
366
366
            return self._validate_user_token(user_token, False)
367
367
        else:
368
368
            raise InvalidUserToken()
470
470
            key = 'tokens/%s' % token
471
471
            cached = self._cache.get(key)
472
472
            if cached == 'invalid':
473
 
                logger.debug('Cached Token %s is marked unauthorized', token)
 
473
                LOG.debug('Cached Token %s is marked unauthorized', token)
474
474
                raise InvalidUserToken('Token authorization failed')
475
475
            if cached:
476
476
                data, expires = cached
477
477
                if time.time() < float(expires):
478
 
                    logger.debug('Returning cached token %s', token)
 
478
                    LOG.debug('Returning cached token %s', token)
479
479
                    return data
480
480
                else:
481
 
                    logger.debug('Cached Token %s seems expired', token)
 
481
                    LOG.debug('Cached Token %s seems expired', token)
482
482
 
483
483
    def _cache_put(self, token, data):
484
484
        """Put token data into the cache.
492
492
                timestamp = data['access']['token']['expires']
493
493
                expires = self._iso8601.parse_date(timestamp).strftime('%s')
494
494
            else:
495
 
                logger.error('invalid token format')
 
495
                LOG.error('invalid token format')
496
496
                return
497
 
            logger.debug('Storing %s token in memcache', token)
 
497
            LOG.debug('Storing %s token in memcache', token)
498
498
            self._cache.set(key,
499
499
                            (data, expires),
500
500
                            time=self.token_cache_time)
503
503
        """Store invalid token in cache."""
504
504
        if self._cache:
505
505
            key = 'tokens/%s' % token
506
 
            logger.debug('Marking token %s as unauthorized in memcache', token)
 
506
            LOG.debug('Marking token %s as unauthorized in memcache', token)
507
507
            self._cache.set(key,
508
508
                            'invalid',
509
509
                            time=self.token_cache_time)