def test_stats_conversions(): client = Client(None) client.sock = MockSocket([ # Most stats are converted to int 'STAT cmd_get 2519\r\n', 'STAT cmd_set 3099\r\n', # Unless they can't be, they remain str 'STAT libevent 2.0.19-stable\r\n', # Some named stats are explicitly converted 'STAT hash_is_expanding 0\r\n', 'STAT rusage_user 0.609165\r\n', 'STAT rusage_system 0.852791\r\n', 'STAT slab_reassign_running 1\r\n', 'STAT version 1.4.14\r\n', 'END\r\n', ]) result = client.stats() tools.assert_equal(client.sock.send_bufs, ['stats \r\n']) expected = { 'cmd_get': 2519, 'cmd_set': 3099, 'libevent': '2.0.19-stable', 'hash_is_expanding': False, 'rusage_user': 0.609165, 'rusage_system': 0.852791, 'slab_reassign_running': True, 'version': '1.4.14', } tools.assert_equal(result, expected)
def test_stats_conversions(): client = Client(None) client.sock = MockSocket([ # Most stats are converted to int 'STAT cmd_get 2519\r\n', 'STAT cmd_set 3099\r\n', # Unless they can't be, they remain str 'STAT libevent 2.0.19-stable\r\n', # Some named stats are explicitly converted 'STAT hash_is_expanding 0\r\n', 'STAT rusage_user 0.609165\r\n', 'STAT rusage_system 0.852791\r\n', 'STAT slab_reassign_running 1\r\n', 'STAT version 1.4.14\r\n', 'END\r\n', ]) result = client.stats() tools.assert_equal(client.sock.send_bufs, [ 'stats \r\n' ]) expected = { 'cmd_get': 2519, 'cmd_set': 3099, 'libevent': '2.0.19-stable', 'hash_is_expanding': False, 'rusage_user': 0.609165, 'rusage_system': 0.852791, 'slab_reassign_running': True, 'version': '1.4.14', } tools.assert_equal(result, expected)
def test_stats_with_args(): client = Client(None) client.sock = MockSocket(['STAT fake_stats 1\r\n', 'END\r\n']) result = client.stats('some_arg') tools.assert_equal(client.sock.send_bufs, [ 'stats some_arg\r\n' ]) tools.assert_equal(result, {'fake_stats': 1})
class my_memcached(object): """docstring for my_memcached 基础的 memcache 使用抽象类 """ def __init__(self, ip, port): super(my_memcached, self).__init__() # link = [str(ip) + ":" + str(port)] self.mc = Client((ip, int(port)), connect_timeout=2) self.ip = ip self.port = port def stats(self): return self.mc.stats() def show_stats(self, key): return self.stats().get(key.encode()) def get_connections_sum(self): return int(self.stats().get("curr_connections".encode())) def get_mem_rate(self): data = self.stats() memsum = int(data.get("limit_maxbytes".encode())) memused = int(data.get("bytes".encode())) return round(memused / memsum * 100, 2) def get_run_date(self, strid): mem_data = self.stats() cmd_get = mem_data.get("cmd_get".encode()) get_hits = mem_data.get("get_hits".encode()) memsum = mem_data.get("limit_maxbytes".encode()) memused = mem_data.get("bytes".encode()) if cmd_get > 0: get_hits_rate = round(get_hits / cmd_get * 100, 2) else: get_hits_rate = 100 run_data = { "mess_code": 1101, "mess_type": 102, "type": "memcache", "strid": strid, "ip": self.ip, "intip": int(ip_address(self.ip)), "port": self.port, "memsum": memsum, "memused": memused, "cmd_get": cmd_get, "cmd_set": mem_data.get("cmd_set".encode()), "get_hits": get_hits, "curr_connections": mem_data.get("curr_connections".encode()), "total_connections": mem_data.get("total_connections".encode()), "ram_used_rate": round(memused / memsum * 100, 2), "get_hits_rate": get_hits_rate, "ctime": time.strftime("%Y-%m-%d %H:%M:%S"), } return run_data
class MemcachedStore(object): """Caching implementation that uses Memcached as data storage. :param host: String representation of hostname or IP of the memcached server :param port: Port number (int) on which the memcached server is listening :param connect_timeout: optional float, seconds to wait for a connection to the memcached server. Defaults to "forever" (uses the underlying default socket timeout, which can be very long) :param timeout: optional float, seconds to wait for send or recv calls on the socket connected to memcached. Defaults to "forever" (uses the underlying default socket timeout, which can be very long). :param no_delay: optional bool, set the TCP_NODELAY flag, which may help with performance in some cases. Defaults to False. :param ignore_exc: optional bool, True to cause the "get", "gets", "get_many" and "gets_many" calls to treat any errors as cache misses. Defaults to True. Ie. if the cache is failing use the Stormpath API. :param socket_module: socket module to use, e.g. gevent.socket. Defaults to the standard library's socket module. :param key_prefix: Prefix of key. You can use this as namespace. Defaults to b''. """ DEFAULT_TTL = 5 * 60 # seconds def __init__(self, host='localhost', port=11211, connect_timeout=None, timeout=None, no_delay=False, ignore_exc=True, key_prefix=b'', socket_module=socket, ttl=DEFAULT_TTL): self.ttl = ttl try: from pymemcache.client import Client as Memcache except ImportError: raise RuntimeError('Memcached support is not available. Run "pip install pymemcache".') self.memcache = Memcache( (host, port), serializer=json_serializer, deserializer=json_deserializer, connect_timeout=connect_timeout, timeout=timeout, socket_module=socket_module, no_delay=no_delay, ignore_exc=ignore_exc, key_prefix=key_prefix) @memcache_error_handling def __getitem__(self, key): entry = self.memcache.get(key) if entry is None: return None return CacheEntry.parse(entry) @memcache_error_handling def __setitem__(self, key, entry): self.memcache.set(key, entry, expire=self.ttl) @memcache_error_handling def __delitem__(self, key): self.memcache.delete(key) @memcache_error_handling def clear(self): self.memcache.flush_all() @memcache_error_handling def __len__(self): return self.memcache.stats()['curr_items']
class MemcachedStore(object): """Caching implementation that uses Memcached as data storage. :param host: String representation of hostname or IP of the memcached server :param port: Port number (int) on which the memcached server is listening :param connect_timeout: optional float, seconds to wait for a connection to the memcached server. Defaults to "forever" (uses the underlying default socket timeout, which can be very long) :param timeout: optional float, seconds to wait for send or recv calls on the socket connected to memcached. Defaults to "forever" (uses the underlying default socket timeout, which can be very long). :param no_delay: optional bool, set the TCP_NODELAY flag, which may help with performance in some cases. Defaults to False. :param ignore_exc: optional bool, True to cause the "get", "gets", "get_many" and "gets_many" calls to treat any errors as cache misses. Defaults to True. Ie. if the cache is failing use the Stormpath API. :param socket_module: socket module to use, e.g. gevent.socket. Defaults to the standard library's socket module. :param key_prefix: Prefix of key. You can use this as namespace. Defaults to b''. """ DEFAULT_TTL = 5 * 60 # seconds def __init__(self, host='localhost', port=11211, connect_timeout=None, timeout=None, no_delay=False, ignore_exc=True, key_prefix=b'', socket_module=socket, ttl=DEFAULT_TTL): self.ttl = ttl try: from pymemcache.client import Client as Memcache except ImportError: raise RuntimeError( 'Memcached support is not available. Run "pip install pymemcache".' ) self.memcache = Memcache((host, port), serializer=json_serializer, deserializer=json_deserializer, connect_timeout=connect_timeout, timeout=timeout, socket_module=socket_module, no_delay=no_delay, ignore_exc=ignore_exc, key_prefix=key_prefix) @memcache_error_handling def __getitem__(self, key): entry = self.memcache.get(key) if entry is None: return None return CacheEntry.parse(entry) @memcache_error_handling def __setitem__(self, key, entry): self.memcache.set(key, entry, expire=self.ttl) @memcache_error_handling def __delitem__(self, key): self.memcache.delete(key) @memcache_error_handling def clear(self): self.memcache.flush_all() @memcache_error_handling def __len__(self): return self.memcache.stats()['curr_items']
def test_stats_with_args(): client = Client(None) client.sock = MockSocket(['STAT fake_stats 1\r\n', 'END\r\n']) result = client.stats('some_arg') tools.assert_equal(client.sock.send_bufs, ['stats some_arg\r\n']) tools.assert_equal(result, {'fake_stats': 1})
class Memcached(object): """docstring for Memcached 基础的 memcache 使用抽象类 """ def __init__(self, ip, port): super(Memcached, self).__init__() # link = [str(ip) + ":" + str(port)] self.mc = Client( (ip, int(port)), serializer=serialize_json, deserializer=deserialize_json, connect_timeout=2, ) def bytesDictToStrDict(self, data): new_data = {} for k, v in data.items(): key = k value = v if isinstance(k, bytes): key = k.decode() if isinstance(v, bytes): value = v.decode() new_data[key] = value return new_data def stats(self): return self.mc.stats() def stats_str(self): return (self.bytesDictToStrDict(self.mc.stats())) def get(self, key): data = self.mc.get(key.encode()) if data: return data.decode() return data # else: # return 'None Value' def delete(self, key): return self.mc.delete(key.encode()) def set(self, key, value, expire=600): return self.mc.set(key, value, expire) # data = bytes(value,encoding="utf-8") # return self.mc.set(key,data,expire) def show_stats(self, key): return self.stats().get(key.encode()) def get_connections_sum(self): return int(self.stats().get("curr_connections".encode())) def get_mem_rate(self): data = self.stats() memsum = int(data.get("limit_maxbytes".encode())) memused = int(data.get("bytes".encode())) return round(memused / memsum * 100, 2) def flush_all(self): return self.mc.flush_all()