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()
