class Cache: def __init__(self): self.cache = SimpleCache(expire=3600, host=settings.CACHE_REDIS_HOST, port=settings.CACHE_REDIS_PORT, db=settings.CACHE_REDIS_DB, password=settings.CACHE_REDIS_PASSWORD, namespace=settings.CACHE_NAMESPACE) if not self.cache.connection: logger.warning("Could not establish a connection with redis. Message deduplication won't work") def store(self, key, value, expire=None): if not self.cache.connection: return return self.cache.store(key, value, expire) def get(self, key): if not self.cache.connection: return return self.cache.get(key) def __contains__(self, key): return self.cache.connection and key in self.cache
class RedisCache: def __init__(self, **kwargs: Any) -> None: self.cache = SimpleCache( expire=kwargs.get("expire", 3600), host=kwargs.get("host", 3600), port=kwargs.get("port", 3600), db=kwargs.get("db", 3600), password=kwargs.get("password", 3600), namespace=kwargs.get("namespace", 3600), ) if not self.cache.connection: logger.warning( "Could not establish a connection with redis. Message deduplication won't work" ) def store(self, key: str, value: Any, expire: Optional[int] = None) -> None: if not self.cache.connection: return return self.cache.store(key, value, expire) def get(self, key: str) -> Any: if not self.cache.connection: return return self.cache.get(key) def __contains__(self, key: str) -> bool: return self.cache.connection and key in self.cache
def test_expire(self): import time quick_c = SimpleCache() quick_c.store("foo", "bar", expire=1) time.sleep(1.1) self.assertRaises(ExpiredKeyException, quick_c.get, "foo") quick_c.flush()
def test_flush_multiple(self): c1 = SimpleCache(10) c2 = SimpleCache(10) c1.store("foo", "bar") c2.store("foo", "bar") c1.flush() self.assertEqual(len(c1), 0) self.assertEqual(len(c2), 1) c2.flush()
def __init__(self): self.cache = SimpleCache(expire=3600, host=settings.CACHE_REDIS_HOST, port=settings.CACHE_REDIS_PORT, db=settings.CACHE_REDIS_DB, password=settings.CACHE_REDIS_PASSWORD, namespace=settings.CACHE_NAMESPACE) if not self.cache.connection: logger.warning("Could not establish a connection with redis. Message deduplication won't work")
def __init__(self, **kwargs: Any) -> None: self.cache = SimpleCache( expire=kwargs.get("expire", 3600), host=kwargs.get("host", 3600), port=kwargs.get("port", 3600), db=kwargs.get("db", 3600), password=kwargs.get("password", 3600), namespace=kwargs.get("namespace", 3600), ) if not self.cache.connection: logger.warning( "Could not establish a connection with redis. Message deduplication won't work" )
def _get_cache(namespace=None, expire=600): """ Get the simple cache object Args: namespace (str, optional): namespace for the cache expire (int, optional): expiration time of cache keys in seconds, defaults to 600 (10 minutes) """ if namespace is None: namespace = "AlienvaultAPI" cache = SimpleCache(limit=1000, expire=expire, hashkeys=True, namespace=namespace) return cache
def setUp(self): self.c = SimpleCache(10) # Cache that has a maximum limit of 10 keys self.assertIsNotNone(self.c.connection)
class SimpleCacheTest(TestCase): def setUp(self): self.c = SimpleCache(10) # Cache that has a maximum limit of 10 keys self.assertIsNotNone(self.c.connection) def test_expire(self): import time quick_c = SimpleCache() quick_c.store("foo", "bar", expire=1) time.sleep(1.1) self.assertRaises(ExpiredKeyException, quick_c.get, "foo") quick_c.flush() def test_miss(self): self.assertRaises(CacheMissException, self.c.get, "blablabla") def test_store_retrieve(self): self.c.store("foo", "bar") foo = self.c.get("foo") self.assertEqual(foo, "bar") def test_json(self): payload = {"example": "data"} self.c.store_json("json", payload) self.assertEqual(self.c.get_json("json"), payload) def test_pickle(self): payload = ComplexNumber(3, 4) self.c.store_pickle("pickle", payload) self.assertEqual(self.c.get_pickle("pickle"), payload) def test_decorator(self): mutable = [] @cache_it(cache=self.c) def append(n): mutable.append(n) return mutable append(1) len_before = len(mutable) mutable_cached = append(1) len_after = len(mutable) self.assertEqual(len_before, len_after) self.assertNotEqual(id(mutable), id(mutable_cached)) self.assertEqual(mutable, mutable_cached) def test_decorator_json(self): import random mutable = {} @cache_it_json(cache=self.c) def set_key(n): mutable[str(random.random())] = n return mutable set_key('a') len_before = len(mutable) mutable_cached = set_key('a') len_after = len(mutable) self.assertEqual(len_before, len_after) self.assertNotEqual(id(mutable), id(mutable_cached)) self.assertEqual(mutable, mutable_cached) def test_decorator_complex_type(self): import math @cache_it(cache=self.c) def add(x, y): return ComplexNumber(x.real + y.real, x.imag + y.imag) result = add(ComplexNumber(3, 4), ComplexNumber(4, 5)) result_cached = add(ComplexNumber(3, 4), ComplexNumber(4, 5)) self.assertNotEqual(id(result), id(result_cached)) self.assertEqual(result, result_cached) self.assertEqual(result, complex(3, 4) + complex(4, 5)) def test_cache_limit(self): for i in range(100): self.c.store("foo%d" % i, "foobar") self.failUnless(len(self.c) <= 10) self.failUnless(len(self.c.keys()) <= 10) def test_flush(self): connection = self.c.connection connection.set("will_not_be_deleted", '42') self.c.store("will_be_deleted", '10') len_before = len(self.c) len_keys_before = len(connection.keys(self.c.make_key("*"))) self.c.flush() len_after = len(self.c) len_keys_after = len(connection.keys(self.c.make_key("*"))) self.assertEqual(len_before, 1) self.assertEqual(len_after, 0) self.assertEqual(len_keys_before, 1) self.assertEqual(len_keys_after, 0) self.assertEqual(connection.get("will_not_be_deleted"), '42') connection.delete("will_not_be_deleted") def test_flush_multiple(self): c1 = SimpleCache(10) c2 = SimpleCache(10) c1.store("foo", "bar") c2.store("foo", "bar") c1.flush() self.assertEqual(len(c1), 0) self.assertEqual(len(c2), 1) c2.flush() def tearDown(self): self.c.flush()
from pi_switch import RCSwitchReceiver from hotqueue import HotQueue from redis_cache import SimpleCache, CacheMissException receiver = RCSwitchReceiver() receiver.enableReceive(2) queue = HotQueue("sensordata", host="localhost", port=6379, db=0) cache = SimpleCache(15) cache.flush() previousTempData = 0 previousHumData = 0 checksum = 0 while True: if receiver.available(): received_value = receiver.getReceivedValue() currentData = str(received_value) try: if len(currentData) > 0: checksum = (int(currentData[0:1]) + int(currentData[1:2]) + int(currentData[2:4])) * int(currentData[4:5]) except ValueError: continue if ((currentData[1:2] == "1" or currentData[1:2] == "2") and (currentData[4:5] != "0") and (len(currentData) == 8)
from pi_switch import RCSwitchReceiver from hotqueue import HotQueue from redis_cache import SimpleCache,CacheMissException receiver = RCSwitchReceiver() receiver.enableReceive(2) queue = HotQueue("sensordata", host="localhost", port=6379, db=0) cache = SimpleCache(15) cache.flush() previousTempData=0 previousHumData=0 checksum=0 while True: if receiver.available(): received_value = receiver.getReceivedValue() currentData = str(received_value) try: if len(currentData) > 0: checksum = (int(currentData[0:1]) + int(currentData[1:2]) + int(currentData[2:4])) * int(currentData[4:5]) except ValueError: continue if ((currentData[1:2] == "1" or currentData[1:2] == "2") and (currentData[4:5] != "0") and (len(currentData) == 8) and (checksum == int(currentData[5:8]))): if (currentData[1:2] == "1" and received_value!=previousTempData) :
WOT = Namespace('http://iot.linkeddata.es/def/wot#') CORE = Namespace('http://iot.linkeddata.es/def/core#') EXT = Namespace(EXTENSION_BASE) GEO = Namespace('http://www.w3.org/2003/01/geo/wgs84_pos#') FOUNTAIN_HOST = os.environ.get('FOUNTAIN_HOST', 'localhost') FOUNTAIN_PORT = os.environ.get('FOUNTAIN_PORT', 8001) log = logging.getLogger('agora.gateway.repository') _lock = Lock() query_cache = SimpleCache(limit=10000, expire=60 * 60, hashkeys=True, host=QUERY_CACHE_HOST, port=6379, db=QUERY_CACHE_NUMBER, namespace='gateway') REPOSITORY_BASE = unicode( os.environ.get('REPOSITORY_BASE', 'http://descriptions').rstrip('/')) BNODE_SKOLEM_BASE = os.environ.get('BNODE_SKOLEM_BASE', 'http://bnodes').rstrip('/') def get_agora(): fountain = fc(host=FOUNTAIN_HOST, port=FOUNTAIN_PORT) planner = Planner(fountain) agora = Agora()
class SimpleCacheTest(TestCase): def setUp(self): self.c = SimpleCache(10) # Cache that has a maximum limit of 10 keys self.assertIsNotNone(self.c.connection) def test_expire(self): import time quick_c = SimpleCache() quick_c.store("foo", "bar", expire=1) time.sleep(1.1) self.assertRaises(ExpiredKeyException, quick_c.get, "foo") quick_c.flush() def test_miss(self): self.assertRaises(CacheMissException, self.c.get, "blablabla") def test_store_retrieve(self): self.c.store("foo", "bar") foo = self.c.get("foo") self.assertEqual(foo, "bar") def test_json(self): payload = {"example": "data"} self.c.store_json("json", payload) self.assertEqual(self.c.get_json("json"), payload) def test_pickle(self): payload = ComplexNumber(3,4) self.c.store_pickle("pickle", payload) self.assertEqual(self.c.get_pickle("pickle"), payload) def test_decorator(self): mutable = [] @cache_it(cache=self.c) def append(n): mutable.append(n) return mutable append(1) len_before = len(mutable) mutable_cached = append(1) len_after = len(mutable) self.assertEqual(len_before, len_after) self.assertNotEqual(id(mutable), id(mutable_cached)) self.assertEqual(mutable, mutable_cached) def test_decorator_json(self): import random mutable = {} @cache_it_json(cache=self.c) def set_key(n): mutable[str(random.random())] = n return mutable set_key('a') len_before = len(mutable) mutable_cached = set_key('a') len_after = len(mutable) self.assertEqual(len_before, len_after) self.assertNotEqual(id(mutable), id(mutable_cached)) self.assertEqual(mutable, mutable_cached) def test_decorator_complex_type(self): import math @cache_it(cache=self.c) def add(x, y): return ComplexNumber(x.real + y.real, x.imag + y.imag) result = add(ComplexNumber(3,4), ComplexNumber(4,5)) result_cached = add(ComplexNumber(3,4), ComplexNumber(4,5)) self.assertNotEqual(id(result), id(result_cached)) self.assertEqual(result, result_cached) self.assertEqual(result, complex(3,4) + complex(4,5)) def test_cache_limit(self): for i in range(100): self.c.store("foo%d" % i, "foobar") self.failUnless(len(self.c) <= 10) self.failUnless(len(self.c.keys()) <= 10) def test_flush(self): connection = self.c.connection connection.set("will_not_be_deleted", '42') self.c.store("will_be_deleted", '10') len_before = len(self.c) len_keys_before = len(connection.keys(self.c.make_key("*"))) self.c.flush() len_after = len(self.c) len_keys_after = len(connection.keys(self.c.make_key("*"))) self.assertEqual(len_before, 1) self.assertEqual(len_after, 0) self.assertEqual(len_keys_before, 1) self.assertEqual(len_keys_after, 0) self.assertEqual(connection.get("will_not_be_deleted"), '42') connection.delete("will_not_be_deleted") def test_flush_multiple(self): c1 = SimpleCache(10) c2 = SimpleCache(10) c1.store("foo", "bar") c2.store("foo", "bar") c1.flush() self.assertEqual(len(c1), 0) self.assertEqual(len(c2), 1) c2.flush() def tearDown(self): self.c.flush()
def invalidate_cache(): cache = SimpleCache(hashkeys=True, namespace=invalidate_cache.__module__) cache.expire_all_in_set()
raise ValueError(e.message) else: response = self.__request(query) response_str = json.dumps(response) try: return self.parse_json( json.loads(response_str, parse_float=Decimal)) except AttributeError: return None cache_proc = SimpleCache(hashkeys=True, host=CACHE_REDIS_HOST, port=CACHE_REDIS_PORT, db=CACHE_REDIS_DB + 1, namespace='pr', limit=10000000, expire=MAX_AGE) cache_q = ZSimpleCache(hashkeys=True, host=CACHE_REDIS_HOST, port=CACHE_REDIS_PORT, db=CACHE_REDIS_DB + 2, namespace='q', limit=100000, expire=MAX_AGE) api = Overpass(url=os.environ.get('OVERPASS_API_URL', 'http://127.0.0.1:5000/api/interpreter'), cache=cache_q,