cleanup

.gitignore

@@ -6,6 +6,8 @@ __pycache__/
 # C extensions
 *.so
 
+.idea/
+
 # Distribution / packaging
 .Python
 build/

bloomfilter.py → bloom_filter.py

@@ -1,18 +1,23 @@
+import math
+
 from bitarray import bitarray
 
 #
 # Bloom Filter ########
-#  Calculation with n=500 & p=0.01
-#  Then k=7 & m=4797
 #
 
+
+NUM_KEYS = 20
+FALSE_POSITIVE_PROBABILITY = 0.05
+
+
 class BloomFilter(object):
 
-    def __init__(self, size=4797):
-        self.size = size
+    def __init__(self, NUM_KEYS, FALSE_POSITIVE_PROBABILITY):
+        self.size = int(-(NUM_KEYS * math.log(FALSE_POSITIVE_PROBABILITY)) / (math.log(2) ** 2))
         self.bloom_filter = bitarray(self.size)
         self.bloom_filter.setall(0)
-        self.number_hash_functions = 7
+        self.number_hash_functions = int((self.size/NUM_KEYS) * math.log(2))
 
     def _hash_djb2(self, s):
         hash_temp = 5381
@@ -33,13 +38,8 @@ def is_member(self, item):
                 return True
         return False
 
-bloom_filter = BloomFilter()
-# base_ip = "192.168.1."
-# bloom_filter.add(base_ip + str(1))
-#
-# for i in range(1, 100):
-#     if not bloom_filter.is_member(base_ip + str(i)):
-#         print(base_ip + str(i))
+if __name__ == '__main__':
+    bloomfilter = BloomFilter(NUM_KEYS, FALSE_POSITIVE_PROBABILITY)
 
-bloom_filter.add('e621944d55b827774fa6f9813ddeacd9')
-print(bloom_filter.is_member('e621944d55b827774fa6f9813ddeacd9'))
+    bloomfilter.add('e621944d55b827774fa6f9813ddeacd9')
+    print(bloomfilter.is_member('e621944d55b827774fa6f9813ddeacd9'))

cache_client.py

@@ -6,12 +6,16 @@
 from server_config import NODES
 from pickle_hash import serialize_GET, serialize_PUT, serialize_DELETE
 
-from bloomfilter import BloomFilter
-import lru
+from bloom_filter import BloomFilter
+from lru_cache import lru_cache
 
-# set_LRU_cache_size(3)
-lru.set_LRU_cache_size(3)
-bloomFilter = BloomFilter()
+
+#
+# Bloom Filter ########
+#  Calculation with n=500 & p=0.01
+#  Then k=7 & m=4797
+#
+bloomFilter = BloomFilter(500,0.01)
 
 BUFFER_SIZE = 1024
 
@@ -31,17 +35,17 @@ def send(self, request):
             print("Error! {}".format(socket.error))
             exit()
 
-    @lru.lru_cache
+    lru_cache(5)
     def put(self, key, payload):
         bloomFilter.add(key)
         return self.send(payload)
 
-    @lru.lru_cache
-    def get(self,key,payload):
+    lru_cache(5)
+    def get_request(self, key, payload):
         if bloomFilter.is_member(key):
             return self.send(payload)
 
-    @lru.lru_cache
+    lru_cache(5)
     def delete(self, key, payload):
         if bloomFilter.is_member(key):
             return self.send(payload)
@@ -59,18 +63,17 @@ def process(udp_clients):
         print(response)
 
     print(f"Number of Users={len(USERS)}\nNumber of Users Cached={len(hash_codes)}")
-    # print(lru.cache.cache)
-
-    # TODO: PART I
+
     # GET all users.
     for hc in hash_codes:
         print(hc)
         data_bytes, key = serialize_GET(hc)
         ring = NodeRing(NODES)
         server_index = NODES.index(ring.get_node(key))
-        response = udp_clients[server_index].get(hc,data_bytes)
+        response = udp_clients[server_index].get_request(hc, data_bytes)
         print(response)
 
+    # Delete all Users
     for hc in hash_codes:
         print(hc)
         data_bytes, key = serialize_DELETE(hc)

cache_server.py

@@ -15,12 +15,14 @@ def put(self, key, value):
         return key
 
     def get(self, key):
-        value = self[key]
-        return value
+        if key in self:
+            value = self[key]
+            return value
 
     def delete(self, key):
-        if self.pop(key):
-            return 'success'
+        if key in self:
+            if self.pop(key):
+                return 'success'
 
 class UDPServer():
     def __init__(self, host, port):

lru_cache.py

@@ -0,0 +1,116 @@
+from collections import OrderedDict
+
+
+class LRUCache(object):
+    length = 5
+    def __init__(self, max_length=5):
+        self.cache = OrderedDict()
+        self.length = max_length
+
+    def __setitem__(self, key, value):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+        else:
+            self.cache[key] = value
+            if len(self.cache) > self.length:
+                self.cache.popitem(last=False)
+
+    def __getitem__(self, key):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+            return self.cache[key]
+        else:
+            return 0
+
+    def __delitem__(self, key):
+        del self.cache[key]
+
+    def update_length(self,i):
+        self.length = i
+
+#
+cache = LRUCache(5)
+#
+def set_LRU_cache_size(i):
+    global cache
+    cache = LRUCache(i)
+
+def lru_cache(cache_size):
+    def decorator(func):
+        cache.update_length(cache_size)
+        def LRUwrapper(*args, **kw):
+            if func.__name__ == 'get_request':
+                obj = args[0]
+                key=args[1]
+                payload = args[2]
+                temp = cache[key]
+
+                if temp:
+                    return temp
+                else:
+                    return func(obj, key, payload)
+
+            elif func.__name__ == 'put':
+                obj = args[0]
+                key = args[1]
+                payload = args[2]
+
+                cache[key]=payload
+                return func(obj, key, payload)
+
+            elif func.__name__ == 'delete':
+                obj = args[0]
+                key = args[1]
+                payload = args[2]
+
+                if cache[key]:
+                    del cache[key]
+                return func(obj, key, payload)
+
+            else:
+                key = args[0]
+                temp = cache[key]
+
+                if temp:
+                    print(f"[cache-hit] {func.__name__}({key}) -> {temp}")
+                    return temp
+                else:
+                    y = func(key)
+                    cache[key] = y
+                    print(f"[cache-missed] {func.__name__}({key}) -> {y}")
+                    return y
+
+
+            return func(*args, **kw)
+        return LRUwrapper
+    return decorator
+
+if __name__ == '__main__':
+    def test():
+        cache[1] = 2
+        cache[2] = 3
+        cache[3] = 4
+        cache[4] = 5
+        cache[1] = 2
+
+        @lru_cache(5)
+        def get(key, value):
+            return 'GET server'
+
+        @lru_cache(5)
+        def put(key,value):
+            return 'PUT to server'
+
+        @lru_cache(5)
+        def delete(key, value):
+            return 'del server'
+
+        print(put(4, 5))
+
+        print(get(4, 4))
+
+        print(delete(4, 4))
+
+        print(cache.cache)
+
+    test()