class CookieMemoryStore(object): def __init__(self, timeout, name=None, secure=False, httpOnly=False): self._timeout = timeout self._store = TimedDictionary(self._timeout) self._name = '{0}{1}'.format('' if name is None else '%s-' % name, uuid4()) self._secure = secure self._httpOnly = httpOnly def createCookie(self, anObject): cookie = str(uuid4()) cookieValues = dict(value=anObject) cookieValues[SECURE] = self._secure cookieValues[HTTPONLY] = self._httpOnly self._store[cookie] = cookieValues return self._result(cookie) def removeCookie(self, cookie): try: del self._store[cookie] except KeyError: pass def removeCookies(self, filter): for k in self._store.keys(): try: if filter(self._store.peek(k)['value']): del self._store[k] except (AttributeError, KeyError): pass def validateCookie(self, cookie): cookieInfo = self._store.get(cookie) if cookieInfo is not None and cookieInfo['value'] is not None: self._store.touch(cookie) return self._result(cookie) return None def cookieName(self): return self._name def _result(self, cookie): cookieInfo = self._store.get(cookie) values = [ "{0}={1}".format(*i) for i in [(self._name, cookie), ( 'path', '/'), ('expires', formatdate(self._now() + self._timeout))] ] values.extend(k for k in [SECURE, HTTPONLY] if cookieInfo.get(k) == True) return dict(cookie=cookie, value=cookieInfo['value'], header='Set-Cookie: {0}'.format('; '.join(values))) def _now(self): return time()
def testExpiredOnInShouldReturnDefaultOnGetWithoutAnException(self): timedDict = TimedDictionary(TWO_HOURS) setTime = time() timedDict._now = lambda : setTime timedDict[1] = SomeObject('id1') timedDict._now = lambda : setTime + TWO_HOURS try: 1 in timedDict except KeyError: self.fail("Key shouldn't have expired yet.") except: self.fail("This should not happen.") timedDict._now = lambda : setTime + TWO_HOURS + 0.000001 self.assertEquals(None, timedDict.get(1)) self.assertEquals('a default', timedDict.get(1, 'a default')) self.assertEquals([], timedDict._expirationOrder)
def testExpiredOnInShouldReturnDefaultOnGetWithoutAnException(self): timedDict = TimedDictionary(TWO_HOURS) setTime = time() timedDict._now = lambda: setTime timedDict[1] = SomeObject('id1') timedDict._now = lambda: setTime + TWO_HOURS try: 1 in timedDict except KeyError: self.fail("Key shouldn't have expired yet.") except: self.fail("This should not happen.") timedDict._now = lambda: setTime + TWO_HOURS + 0.000001 self.assertEqual(None, timedDict.get(1)) self.assertEqual('a default', timedDict.get(1, 'a default')) self.assertEqual([], timedDict._expirationOrder)
def testBasicGetAndPut(self): timedDict = TimedDictionary(TWO_HOURS) timedDict['key'] = 'value' self.assertEquals('value', timedDict['key']) timedDict['key'] = 'otherValue' self.assertEquals('otherValue', timedDict['key']) timedDict['key'] = 5 self.assertEquals(5, timedDict['key']) timedDict['key'] = 5.0 self.assertEquals(5.0, timedDict['key']) timedDict['key'] = ['someMutable', 5] self.assertEquals(['someMutable', 5], timedDict['key']) self.assertEquals(['someMutable', 5], timedDict.get('key')) self.assertRaises(TypeError, timedDict.__setitem__, [], 'value') self.assertRaises(KeyError, timedDict.__getitem__, 'iamnothere') self.assertEquals(None, timedDict.get('iamnothere')) self.assertEquals('MARK', timedDict.get('iamnothere', 'MARK'))
def testBasicGetAndPut(self): timedDict = TimedDictionary(TWO_HOURS) timedDict['key'] = 'value' self.assertEqual('value', timedDict['key']) timedDict['key'] = 'otherValue' self.assertEqual('otherValue', timedDict['key']) timedDict['key'] = 5 self.assertEqual(5, timedDict['key']) timedDict['key'] = 5.0 self.assertEqual(5.0, timedDict['key']) timedDict['key'] = ['someMutable', 5] self.assertEqual(['someMutable', 5], timedDict['key']) self.assertEqual(['someMutable', 5], timedDict.get('key')) self.assertRaises(TypeError, timedDict.__setitem__, [], 'value') self.assertRaises(KeyError, timedDict.__getitem__, 'iamnothere') self.assertEqual(None, timedDict.get('iamnothere')) self.assertEqual('MARK', timedDict.get('iamnothere', 'MARK'))
class CookieMemoryStore(object): def __init__(self, timeout, name=None): self._timeout = timeout self._store = TimedDictionary(self._timeout) self._name = '{0}{1}'.format('' if name is None else '%s-' % name, uuid4()) def createCookie(self, anObject): cookie = str(uuid4()) self._store[cookie] = anObject return self._result(cookie, anObject) def removeCookie(self, cookie): try: del self._store[cookie] except KeyError: pass def removeCookies(self, filter): for k in self._store.keys(): try: if filter(self._store.peek(k)): del self._store[k] except (AttributeError, KeyError): pass def validateCookie(self, cookie): anObject = self._store.get(cookie) if anObject is not None: self._store.touch(cookie) return self._result(cookie, anObject) return None def cookieName(self): return self._name def _result(self, cookie, anObject): return dict( cookie=cookie, value=anObject, header='Set-Cookie: {0}={1}; path=/; expires={2}'.format( self._name, cookie, formatdate(self._now() + self._timeout))) def _now(self): return time()
class FlagCheck(Observable): def __init__(self, serviceIdentifier, flag, name=None): Observable.__init__(self, name=name) self._serviceIdentifier = serviceIdentifier self._flag = flag self._flagSet = flag.default self._seed = randomWord(20) self._cookiekey = 'flagcheck%s=' % randomWord(10) self._debugTimeout = 60 self._debugIds = TimedDictionary(self._debugTimeout) def updateConfig(self, this_service=None, **kwargs): state = {} if this_service is None else this_service.get('state', {}) self._flagSet = self._flag.isSet(state) return yield def handleRequest(self, arguments, Headers, **kwargs): debugId = self._getDebugId(Headers) debug = arguments.pop('debug', [None])[0] is not None or debugId if not debug: try: self._check(message='handleRequest') yield self.all.handleRequest(arguments=arguments, Headers=Headers, **kwargs) except EnvironmentError: yield 'HTTP/1.0 503 Service Temporarily Unavailable\r\n\r\n' else: debugId = self._registerDebugId(debugId=debugId, **kwargs) yield insertHeader( compose(self.all.handleRequest(arguments=arguments, Headers=Headers, **kwargs)), extraHeader='Set-Cookie: '+'; '.join([ self._cookiekey+debugId, 'Expires={0}'.format(self._zulutime().add(seconds=2*self._debugTimeout).rfc1123()), ]) ) def _zulutime(self): return ZuluTime() def _getDebugId(self, Headers): debugIds = [cookie.split(self._cookiekey)[-1].strip() for cookie in Headers.get('Cookie','').split(';') if cookie.strip().startswith(self._cookiekey)] if len(debugIds) == 1: return self._debugIds.get(debugIds[0]) return None def _registerDebugId(self, debugId, Client, **ignored): if debugId is None: clientaddress, ignoredPort = Client debugId = sha1('%s%s%s%s' % (time(), randomWord(10), clientaddress, self._seed)).hexdigest() self._debugIds[debugId] = debugId else: self._debugIds.touch(debugId) return debugId def all_unknown(self, message, **kwargs): self._check(message=message) yield self.all.unknown(message, **kwargs) def _check(self, message): if not self._flagSet: raise EnvironmentError("'%s' is not allowed at the moment (%s=False)." % (message, self._flag))