def setUp(self):
self.mc = Client(["127.0.0.1:21211", "127.0.0.1:21212"])
self.mc_alt = Client(["127.0.0.1:21211", "127.0.0.1:21212"])
self.compressed_mc = Client(["127.0.0.1:21211", "127.0.0.1:21212"],
comp_threshold=1024)
self.noreply_mc = Client(["127.0.0.1:21211", "127.0.0.1:21212"],
noreply=True)
def setUp(self):
self.mc = Client(["127.0.0.1:%d" % (21211 + i) for i in range(10)])
self.compressed_mc = Client(
["127.0.0.1:%d" % (21211 + i) for i in range(10)],
comp_threshold=1024)
self.noreply_mc = Client(
["127.0.0.1:%d" % (21211 + i) for i in range(10)], noreply=True)
def setUp(self):
host = "127.0.0.1"
port = 21211
self.prefix = '/prefix'
self.server_addr = '%s:%d' % (host, port)
self.prefixed_mc = Client([self.server_addr],
comp_threshold=1024,
prefix=self.prefix)
self.mc = Client([self.server_addr], comp_threshold=1024)
def __init__(self, servers):
"""Initialize memcached.
@param servers: an array of servers. Servers can be passed in two forms:
1. Strings of the form host:port (implies a default weight of 1).
2. Tuples of the form (host:port, weight) (weight as integer)
"""
if LIBMC:
self._client = Client(servers, comp_threshold=10240, noreply=True)
else:
self._client = Client(servers)
self.timeout = 0
def setUp(self):
host = "127.0.0.1"
port = 21211
self.server_addr = '%s:%d' % (host, port)
self.mc = Client([self.server_addr], comp_threshold=1024)
if cmemcached is not None:
self.old_mc = cmemcached.Client([self.server_addr],
comp_threshold=1024)
def main():
mc = Client(['127.0.0.1:%d' % (21211 + i) for i in range(10)])
dct = {'test_key_%d' % i: 'i' * 1000 for i in range(10)}
while True:
print '%.2f: set_multi: %r' % (time.time(), mc.set_multi(dct))
print '%.2f: get_multi: %r' % (time.time(), mc.get_multi(dct.keys())
== dct)
time.sleep(0.5)
print
def mc_sleeper():
s = 2
print 'sleep in C++ for %ds, you can sing infinitely now, singer.' % s
mc = Client(["127.0.0.1:21211"])
release_gil = True # toggle here
stack.append('mc_sleep_begin')
mc._sleep(s, release_gil)
stack.append('mc_sleep_end')
print 'exit sleep'
def test_realtime_host_w_failover(self):
servers = ["127.0.0.1:21211", "127.0.0.1:21212"]
mc = Client(servers)
failover_mc = Client(servers, failover=True)
hosts_visited = set()
for i in range(1000):
key = "test:realtime:route:%d" % i
h1 = mc.get_host_by_key(key)
h2 = mc.get_realtime_host_by_key(key)
assert h1 is not None
assert h1 == h2
h3 = failover_mc.get_host_by_key(key)
h4 = failover_mc.get_realtime_host_by_key(key)
assert h3 == h1
assert h4 == h1
hosts_visited.add(h1)
assert len(hosts_visited) == len(servers)
def test_md5_router_mass(self):
with open(os.path.join(RES_DIR, 'server_port.csv')) as fhandler:
server_list = [':'.join(addr.strip().split(','))
for addr in fhandler.readlines()]
mc = Client(server_list, hash_fn=libmc.MC_HASH_MD5)
with open(os.path.join(RES_DIR, 'key_pool_idx.csv')) as fhandler:
for line in fhandler:
key, idx_ = line.strip().split(',')
idx = int(idx_)
assert mc.get_host_by_key(key) == server_list[idx]
def test_md5_router(self):
server_list = [
'localhost', 'myhost:11211', '127.0.0.1:11212', 'myhost:11213'
]
mc = Client(server_list)
md5_mc = Client(server_list, hash_fn=libmc.MC_HASH_MD5)
rs = {
'test:10000': 'localhost:11211',
'test:20000': '127.0.0.1:11212',
'test:30000': '127.0.0.1:11212',
'test:40000': '127.0.0.1:11212',
'test:50000': '127.0.0.1:11212',
'test:60000': 'myhost:11213',
'test:70000': '127.0.0.1:11212',
'test:80000': '127.0.0.1:11212',
'test:90000': '127.0.0.1:11212',
}
for k in rs:
self.assertEqual(mc.get_host_by_key(k), rs[k])
self.assertEqual(md5_mc.get_host_by_key(k), rs[k])
for addr in server_list:
ps = addr.split(':')
if len(ps) == 1:
hostname = ps[0]
port = 11211
else:
hostname = ps[0]
port = int(ps[1])
if port == 11211:
key = '%s-10' % hostname
else:
key = '%s:%s-10' % (hostname, port)
self.assertEqual(mc.get_host_by_key(key),
'%s:%s' % (hostname, port))
self.assertEqual(md5_mc.get_host_by_key(key),
'%s:%s' % (hostname, port))
def test_none_host(self):
existed_server = "127.0.0.1:21211"
not_existed_server = "127.0.0.1:1"
servers = [existed_server, not_existed_server]
mc = Client(servers)
failover_mc = Client(servers, failover=True)
hosts_visited = set()
for i in range(1000):
key = "test:realtime:route:%d" % i
h1 = mc.get_host_by_key(key)
h2 = mc.get_realtime_host_by_key(key)
if h1 == existed_server:
assert h1 == h2
elif h1 == not_existed_server:
assert h2 is None
h3 = failover_mc.get_host_by_key(key)
h4 = failover_mc.get_realtime_host_by_key(key)
assert h3 == h1
assert h4 == existed_server
hosts_visited.add(h1)
assert len(hosts_visited) == len(servers)
def test_ketama(self):
mc = Client(
['localhost', 'myhost:11211', '127.0.0.1:11212', 'myhost:11213'])
rs = {
'test:10000': 'localhost:11211',
'test:20000': '127.0.0.1:11212',
'test:30000': '127.0.0.1:11212',
'test:40000': '127.0.0.1:11212',
'test:50000': '127.0.0.1:11212',
'test:60000': 'myhost:11213',
'test:70000': '127.0.0.1:11212',
'test:80000': '127.0.0.1:11212',
'test:90000': '127.0.0.1:11212',
}
for k in rs:
self.assertEqual(mc.get_host_by_key(k), rs[k])
def test_crc_32_router(self):
crc_32_mc = Client(
['localhost', 'myhost:11211', '127.0.0.1:11212', 'myhost:11213'],
hash_fn=libmc.MC_HASH_CRC_32)
rs = {
'test:10000': '127.0.0.1:11212',
'test:20000': '127.0.0.1:11212',
'test:30000': '127.0.0.1:11212',
'test:40000': 'myhost:11213',
'test:50000': 'myhost:11211',
'test:60000': 'localhost:11211',
'test:70000': 'myhost:11213',
'test:80000': 'myhost:11211',
'test:90000': 'localhost:11211'
}
for k in rs:
self.assertEqual(crc_32_mc.get_host_by_key(k), rs[k])
def test_ketama_with_alias(self):
mc = Client([
'192.168.1.211:11211 tango.mc.douban.com',
'192.168.1.212:11212 uniform.mc.douban.com',
'192.168.1.211:11212 victor.mc.douban.com',
'192.168.1.212:11211 whiskey.mc.douban.com',
])
rs = {
'test:10000': 'whiskey.mc.douban.com',
'test:20000': 'victor.mc.douban.com',
'test:30000': 'victor.mc.douban.com',
'test:40000': 'victor.mc.douban.com',
'test:50000': 'victor.mc.douban.com',
'test:60000': 'uniform.mc.douban.com',
'test:70000': 'tango.mc.douban.com',
'test:80000': 'victor.mc.douban.com',
'test:90000': 'victor.mc.douban.com',
}
for k in rs:
self.assertEqual(mc.get_host_by_key(k), rs[k])
# coding=utf-8
from libmc import (Client, MC_HASH_MD5, MC_POLL_TIMEOUT, MC_CONNECT_TIMEOUT,
MC_RETRY_TIMEOUT)
mc = Client(
['localhost', 'localhost:11212', 'localhost:11213 mc_213'],
# 分割小于10M的的值
do_split=True,
# 所有类型的值编码为字符串
comp_threshold=0,
# 更新缓存操作不需要服务端响应，提高操作速度
noreply=False,
# 缓存键前缀
prefix=None,
# 哈希函数标示
hash_fn=MC_HASH_MD5,
# 服务器不可用时，是否做故障转移
failover=False)
mc.config(MC_POLL_TIMEOUT, 100)
mc.config(MC_CONNECT_TIMEOUT, 300)
mc.config(MC_RETRY_TIMEOUT, 5)
def connectMemCache():
ip = MONGO_IP + ":11211"
mc = Client([ip])
message("MemCache Connected", mssgType='ADMIN')
return mc
def test_mc_server_err(self):
mc = Client(["not_exist_host:11211"])
mc.get('valid_key')
assert mc.get_last_error() == MC_RETURN_MC_SERVER_ERR
def setUp(self):
self.mc = Client(["127.0.0.1:21211"])
assert self.mc.version()
assert self.mc.get_last_error() == MC_RETURN_OK
from libmc import (Client, MC_HASH_MD5, MC_POLL_TIMEOUT, MC_CONNECT_TIMEOUT,
MC_RETRY_TIMEOUT)
from app.mc.decorators import create_cache
mc = Client(['localhost'],
do_split=True,
comp_threshold=0,
noreply=False,
prefix=None,
hash_fn=MC_HASH_MD5,
failover=False)
mc.config(MC_CONNECT_TIMEOUT, 300) # ms
mc.config(MC_POLL_TIMEOUT, 100)
mc.config(MC_RETRY_TIMEOUT, 5)
globals().update(create_cache(mc))
def __init__(self, server):
self.server = server
self.mc = Client([server], do_split=0)
