class ComplianceTest(unittest.TestCase):
def setUp(self):
self.mc=MemcachedClient()
self.mc.flush()
def tearDown(self):
self.mc.flush()
self.mc.close()
def testVersion(self):
"""Test the version command returns something."""
v=self.mc.version()
self.assertTrue(len(v) > 0, "Bad version: ``" + str(v) + "''")
def testSimpleSetGet(self):
"""Test a simple set and get."""
self.mc.set("x", 5, 19, "somevalue")
self.assertGet((19, "somevalue"), self.mc.get("x"))
def testZeroExpiration(self):
"""Ensure zero-expiration sets work properly."""
self.mc.set("x", 0, 19, "somevalue")
time.sleep(1.1)
self.assertGet((19, "somevalue"), self.mc.get("x"))
def assertNotExists(self, key):
try:
x=self.mc.get(key)
self.fail("Expected an exception, got " + `x`)
except MemcachedError, e:
self.assertEquals(memcacheConstants.ERR_NOT_FOUND, e.status)
def get_mb_stats(servers, key):
for server in servers:
c = MemcachedClient(server.ip, 11210)
log.info("Get flush param on server {0}, {1}".format(server, key))
value = c.stats().get(key, None)
log.info("Get flush param on server {0}, {1}".format(server, value))
c.close()
def wait_for_mc_stats_no_timeout(master, bucket, stat_key, stat_value, timeout_in_seconds=-1, verbose=True):
log.info(
"waiting for bucket {0} stat : {1} to match {2} on {3}".format(bucket, stat_key, stat_value, master.ip)
)
# keep retrying until reaches the server
stats = {}
while not stats:
try:
c = MemcachedClient(master.ip, 11210)
c.sasl_auth_plain(bucket, "")
stats = c.stats()
except Exception as e:
log.info("Exception: {0}, retry in 2 seconds ...".format(str(e)))
stats = {}
time.sleep(2)
finally:
c.close()
while str(stats[stat_key]) != str(stat_value):
c = MemcachedClient(master.ip, 11210)
c.sasl_auth_plain(bucket, "")
stats = c.stats()
c.close()
if verbose:
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
time.sleep(5)
return True
def wait_for_mc_stats(master,
bucket,
stat_key,
stat_value,
timeout_in_seconds=120,
verbose=True):
log.info("waiting for bucket {0} stat : {1} to match {2} on {3}".format(bucket, stat_key, \
stat_value, master.ip))
start = time.time()
verified = False
while (time.time() - start) <= timeout_in_seconds:
c = MemcachedClient(master.ip, 11210)
stats = c.stats()
c.close()
if stats and stat_key in stats and str(
stats[stat_key]) == str(stat_value):
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
verified = True
break
else:
if stats and stat_key in stats:
if verbose:
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
if not verbose:
time.sleep(0.1)
else:
time.sleep(2)
return verified
def get_vBuckets_info(master):
"""
return state and count items for all vbuckets for each node
format: dict: {u'1node_ip1': {'vb_79': ['replica', '0'], 'vb_78': ['active', '0']..}, u'1node_ip1':....}
"""
rest = RestConnection(master)
port = rest.get_nodes_self().memcached
nodes = rest.node_statuses()
_nodes_stats= {}
for node in nodes:
stat={}
buckets = []
_server = {"ip": node.ip, "port": node.port, "username": master.rest_username,
"password": master.rest_password}
try:
buckets = rest.get_buckets()
mc = MemcachedClient(node.ip, port)
stat_hash = mc.stats("hash")
except Exception:
if not buckets:
log.error("There are not any buckets in {0}:{1} node".format(node.ip, node.port))
else:
log.error("Impossible to get vBucket's information for {0}:{1} node".format(node.ip, node.port))
_nodes_stats[node.ip+":"+str(node.port)]
continue
mc.close()
vb_names=[key[:key.index(":")] for key in stat_hash.keys()]
for name in vb_names:
stat[name]=[stat_hash[name + ":state"], stat_hash[name+":counted"]]
_nodes_stats[node.ip+":"+str(port)] = stat
log.info(_nodes_stats)
return _nodes_stats
def wait_for_mc_stats_no_timeout(master,
bucket,
stat_key,
stat_value,
timeout_in_seconds=-1,
verbose=True):
log = logger.get("infra")
log.info(
"Waiting for bucket {0} stat : {1} to match {2} on {3}".format(
bucket, stat_key, stat_value, master.ip))
# keep retrying until reaches the server
stats = dict()
while not stats:
try:
c = MemcachedClient(master.ip, constants.memcached_port)
c.sasl_auth_plain(bucket, '')
stats = c.stats()
except Exception as e:
stats = dict()
sleep(2,
"Exception: %s. Will retry.." % str(e),
log_type="infra")
finally:
c.close()
while str(stats[stat_key]) != str(stat_value):
c = MemcachedClient(master.ip, constants.memcached_port)
c.sasl_auth_plain(bucket, '')
stats = c.stats()
c.close()
if verbose:
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
sleep(5, log_type="infra")
return True
def get_vBuckets_info(master):
"""
return state and count items for all vbuckets for each node
format: dict: {u'1node_ip1': {'vb_79': ['replica', '0'], 'vb_78': ['active', '0']..}, u'1node_ip1':....}
"""
rest = RestConnection(master)
port = rest.get_nodes_self().memcached
nodes = rest.node_statuses()
_nodes_stats = {}
for node in nodes:
stat = {}
buckets = []
_server = {"ip": node.ip, "port": node.port, "username": master.rest_username,
"password": master.rest_password}
try:
buckets = rest.get_buckets()
mc = MemcachedClient(node.ip, port)
stat_hash = mc.stats("hash")
except Exception:
if not buckets:
log.error("There are not any buckets in {0}:{1} node".format(node.ip, node.port))
else:
log.error("Impossible to get vBucket's information for {0}:{1} node".format(node.ip, node.port))
_nodes_stats[node.ip + ":" + str(node.port)]
continue
mc.close()
vb_names = [key[:key.index(":")] for key in list(stat_hash.keys())]
for name in vb_names:
stat[name] = [stat_hash[name + ":state"], stat_hash[name + ":counted"]]
_nodes_stats[node.ip + ":" + str(port)] = stat
log.info(_nodes_stats)
return _nodes_stats
def wait_for_mc_stats(master,
bucket,
stat_key,
stat_value,
timeout_in_seconds=120,
verbose=True):
log = logger.get("infra")
log.info("Waiting for bucket {0} stat: {1} to match {2} on {3}".format(
bucket, stat_key, stat_value, master.ip))
start = time.time()
verified = False
while (time.time() - start) <= timeout_in_seconds:
c = MemcachedClient(master.ip, constants.memcached_port)
stats = c.stats()
c.close()
if stats and stat_key in stats \
and str(stats[stat_key]) == str(stat_value):
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
verified = True
break
else:
if stats and stat_key in stats:
if verbose:
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
sleep_time = 2
if not verbose:
sleep_time = 0.1
sleep(sleep_time, log_type="infra")
return verified
def wait_for_mc_stats_no_timeout(master,
bucket,
stat_key,
stat_value,
timeout_in_seconds=-1,
verbose=True):
log.info("waiting for bucket {0} stat : {1} to match {2} on {3}".format(bucket, stat_key, \
stat_value, master.ip))
# keep retrying until reaches the server
stats = {}
while not stats:
try:
c = MemcachedClient(master.ip, 11210)
c.sasl_auth_plain(bucket, '')
stats = c.stats()
except Exception as e:
log.info("Exception: {0}, retry in 2 seconds ...".format(
str(e)))
stats = {}
time.sleep(2)
finally:
c.close()
while str(stats[stat_key]) != str(stat_value):
c = MemcachedClient(master.ip, 11210)
c.sasl_auth_plain(bucket, '')
stats = c.stats()
c.close()
if verbose:
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
time.sleep(5)
return True
def get_mb_stats(servers, key):
log = logger.Logger.get_logger()
for server in servers:
c = MemcachedClient(server.ip, 11210)
log.info("Get flush param on server {0}, {1}".format(server, key))
value = c.stats().get(key, None)
log.info("Get flush param on server {0}, {1}".format(server, value))
c.close()
def get_mb_stats(servers, key):
log = logger.get("infra")
for server in servers:
c = MemcachedClient(server.ip, constants.memcached_port)
log.info("Get flush param on server {0}, {1}".format(server, key))
val = c.stats().get(key, None)
log.info("Get flush param on server {0}, {1}".format(server, val))
c.close()
def flushctl_set(servers, key, val):
log = logger.Logger.get_logger()
for server in servers:
c = MemcachedClient(server.ip, 11210)
log.info("Setting flush param on server {0}, {1} to {2}".format(server, key, val))
rv = c.set_flush_param(key, val)
log.info("Setting flush param on server {0}, {1} to {2}, result: {3}".format(server, key, val, rv))
c.close()
def wait_for_vbuckets_ready_state(node, bucket, timeout_in_seconds=300, log_msg=''):
log = logger.Logger.get_logger()
start_time = time.time()
end_time = start_time + timeout_in_seconds
ready_vbuckets = {}
rest = RestConnection(node)
servers = rest.get_nodes()
RestHelper(rest).vbucket_map_ready(bucket, 60)
vbucket_count = len(rest.get_vbuckets(bucket))
vbuckets = rest.get_vbuckets(bucket)
obj = VBucketAwareMemcached(rest, bucket)
memcacheds, vbucket_map, vbucket_map_replica = obj.request_map(rest, bucket)
#Create dictionary with key:"ip:port" and value: a list of vbuckets
server_dict = defaultdict(list)
for everyID in range(0, vbucket_count):
memcached_ip_port = str(vbucket_map[everyID])
server_dict[memcached_ip_port].append(everyID)
while time.time() < end_time and len(ready_vbuckets) < vbucket_count:
for every_ip_port in server_dict:
#Retrieve memcached ip and port
ip, port = every_ip_port.split(":")
client = MemcachedClient(ip, int(port), timeout=30)
client.vbucket_count = len(vbuckets)
bucket_info = rest.get_bucket(bucket)
client.sasl_auth_plain(bucket_info.name.encode('ascii'),
bucket_info.saslPassword.encode('ascii'))
for i in server_dict[every_ip_port]:
try:
(a, b, c) = client.get_vbucket_state(i)
except mc_bin_client.MemcachedError as e:
ex_msg = str(e)
if "Not my vbucket" in log_msg:
log_msg = log_msg[:log_msg.find("vBucketMap") + 12] + "..."
if e.status == memcacheConstants.ERR_NOT_MY_VBUCKET:
# May receive this while waiting for vbuckets, continue and retry...S
continue
log.error("%s: %s" % (log_msg, ex_msg))
continue
except exceptions.EOFError:
# The client was disconnected for some reason. This can
# happen just after the bucket REST API is returned (before
# the buckets are created in each of the memcached processes.)
# See here for some details: http://review.couchbase.org/#/c/49781/
# Longer term when we don't disconnect clients in this state we
# should probably remove this code.
log.error("got disconnected from the server, reconnecting")
client.reconnect()
client.sasl_auth_plain(bucket_info.name.encode('ascii'),
bucket_info.saslPassword.encode('ascii'))
continue
if c.find("\x01") > 0 or c.find("\x02") > 0:
ready_vbuckets[i] = True
elif i in ready_vbuckets:
log.warning("vbucket state changed from active to {0}".format(c))
del ready_vbuckets[i]
client.close()
return len(ready_vbuckets) == vbucket_count
def wait_for_mc_stats_no_timeout(master, bucket, stat_key, stat_value, timeout_in_seconds=-1, verbose=True):
log.info("waiting for bucket {0} stat : {1} to match {2} on {3}".format(bucket, stat_key, \
stat_value, master.ip))
c = MemcachedClient(master.ip, 11210)
stats = c.stats()
c.close()
while str(stats[stat_key]) != str(stat_value):
c = MemcachedClient(master.ip, 11210)
stats = c.stats()
c.close()
if verbose:
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
time.sleep(5)
return True
def wait_for_vbuckets_ready_state(node,
bucket,
timeout_in_seconds=300,
log_msg=''):
log = logger.Logger.get_logger()
start_time = time.time()
end_time = start_time + timeout_in_seconds
ready_vbuckets = {}
rest = RestConnection(node)
servers = rest.get_nodes()
RestHelper(rest).vbucket_map_ready(bucket, 60)
vbucket_count = len(rest.get_vbuckets(bucket))
vbuckets = rest.get_vbuckets(bucket)
obj = VBucketAwareMemcached(rest, bucket)
memcacheds, vbucket_map, vbucket_map_replica = obj.request_map(
rest, bucket)
#Create dictionary with key:"ip:port" and value: a list of vbuckets
server_dict = defaultdict(list)
for everyID in range(0, vbucket_count):
memcached_ip_port = str(vbucket_map[everyID])
server_dict[memcached_ip_port].append(everyID)
while time.time() < end_time and len(ready_vbuckets) < vbucket_count:
for every_ip_port in server_dict:
#Retrieve memcached ip and port
ip, port = every_ip_port.split(":")
client = MemcachedClient(ip, int(port), timeout=30)
client.vbucket_count = len(vbuckets)
bucket_info = rest.get_bucket(bucket)
client.sasl_auth_plain(
bucket_info.name.encode('ascii'),
bucket_info.saslPassword.encode('ascii'))
for i in server_dict[every_ip_port]:
try:
(a, b, c) = client.get_vbucket_state(i)
except mc_bin_client.MemcachedError as e:
log.error("%s: %s" % (log_msg, e))
continue
if c.find("\x01") > 0 or c.find("\x02") > 0:
ready_vbuckets[i] = True
elif i in ready_vbuckets:
log.warning(
"vbucket state changed from active to {0}".format(
c))
del ready_vbuckets[i]
client.close()
return len(ready_vbuckets) == vbucket_count
def wait_for_vbuckets_ready_state(node, bucket, timeout_in_seconds=300, log_msg=''):
log = logger.Logger.get_logger()
start_time = time.time()
end_time = start_time + timeout_in_seconds
ready_vbuckets = {}
rest = RestConnection(node)
servers = rest.get_nodes()
RestHelper(rest).vbucket_map_ready(bucket, 60)
vbucket_count = len(rest.get_vbuckets(bucket))
vbuckets = rest.get_vbuckets(bucket)
obj = VBucketAwareMemcached(rest, bucket)
memcacheds, vbucket_map, vbucket_map_replica = obj.request_map(rest, bucket)
#Create dictionary with key:"ip:port" and value: a list of vbuckets
server_dict = defaultdict(list)
for everyID in range(0, vbucket_count):
memcached_ip_port = str(vbucket_map[everyID])
server_dict[memcached_ip_port].append(everyID)
while time.time() < end_time and len(ready_vbuckets) < vbucket_count:
for every_ip_port in server_dict:
#Retrieve memcached ip and port
ip, port = every_ip_port.split(":")
client = MemcachedClient(ip, int(port), timeout=30)
client.vbucket_count = len(vbuckets)
bucket_info = rest.get_bucket(bucket)
client.sasl_auth_plain(bucket_info.name.encode('ascii'),
bucket_info.saslPassword.encode('ascii'))
for i in server_dict[every_ip_port]:
try:
(a, b, c) = client.get_vbucket_state(i)
except mc_bin_client.MemcachedError as e:
ex_msg = str(e)
if "Not my vbucket" in log_msg:
log_msg = log_msg[:log_msg.find("vBucketMap") + 12] + "..."
if "Not my vbucket" in ex_msg:
#reduce output
ex_msg = str(e)[:str(e).find('Not my vbucket') + 14] + "..."
log.error("%s: %s" % (log_msg, ex_msg))
continue
if c.find("\x01") > 0 or c.find("\x02") > 0:
ready_vbuckets[i] = True
elif i in ready_vbuckets:
log.warning("vbucket state changed from active to {0}".format(c))
del ready_vbuckets[i]
client.close()
return len(ready_vbuckets) == vbucket_count
def do_auth(self, bucket, password):
""" default self.auth_mech is 'PLAIN' """
self.log.info("Authenticate with {0} to {1}:{2}".format(
self.auth_mech, bucket, password))
ret = None
nodes = RestConnection(self.master).get_nodes()
for n in nodes:
if n.ip == self.master.ip and n.port == self.master.port:
node = n
client = MemcachedClient(self.master.ip, node.memcached)
try:
if self.auth_mech == "PLAIN":
ret = client.sasl_auth_plain(bucket, password)[2]
else:
self.fail("Invalid auth mechanism {0}".format(self.auth_mech))
except MemcachedError as e:
ret = e[0].split(' for vbucket')[0]
client.close()
return ret
def wait_for_mc_stats(master, bucket, stat_key, stat_value, timeout_in_seconds=120, verbose=True):
log.info("waiting for bucket {0} stat : {1} to match {2} on {3}".format(bucket, stat_key, \
stat_value, master.ip))
start = time.time()
verified = False
while (time.time() - start) <= timeout_in_seconds:
c = MemcachedClient(master.ip, 11210)
stats = c.stats()
c.close()
if stats and stat_key in stats and str(stats[stat_key]) == str(stat_value):
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
verified = True
break
else:
if stats and stat_key in stats:
if verbose:
log.info("{0} : {1}".format(stat_key, stats[stat_key]))
if not verbose:
time.sleep(0.1)
else:
time.sleep(2)
return verified
def wait_for_vbuckets_ready_state(node,
bucket,
timeout_in_seconds=300,
log_msg='',
admin_user='******',
admin_pass='******'):
start_time = time.time()
end_time = start_time + timeout_in_seconds
ready_vbuckets = {}
log = logger.get("infra")
rest = RestConnection(node)
# servers = rest.get_nodes()
bucket_conn = BucketHelper(node)
bucket_conn.vbucket_map_ready(bucket, 60)
vbucket_count = len(bucket_conn.get_vbuckets(bucket))
vbuckets = bucket_conn.get_vbuckets(bucket)
obj = VBucketAwareMemcached(rest, bucket, info=node)
memcacheds, vbucket_map, vbucket_map_replica = obj.request_map(
rest, bucket)
#Create dictionary with key:"ip:port" and value: a list of vbuckets
server_dict = defaultdict(list)
for everyID in range(0, vbucket_count):
memcached_ip_port = str(vbucket_map[everyID])
server_dict[memcached_ip_port].append(everyID)
while time.time() < end_time and len(ready_vbuckets) < vbucket_count:
for every_ip_port in server_dict:
#Retrieve memcached ip and port
ip, port = every_ip_port.split(":")
client = MemcachedClient(ip, int(port), timeout=30)
client.vbucket_count = len(vbuckets)
bucket_info = bucket_conn.get_bucket(bucket)
versions = rest.get_nodes_versions(logging=False)
pre_spock = False
for version in versions:
if "5" > version:
pre_spock = True
if pre_spock:
log.info("Atleast 1 of the server is on pre-spock "
"version. Using the old ssl auth to connect to "
"bucket.")
client.sasl_auth_plain(
bucket_info.name.encode('ascii'),
bucket_info.saslPassword.encode('ascii'))
else:
client.sasl_auth_plain(admin_user, admin_pass)
bucket = bucket.encode('ascii')
client.bucket_select(bucket)
for i in server_dict[every_ip_port]:
try:
(a, b, c) = client.get_vbucket_state(i)
except mc_bin_client.MemcachedError as e:
ex_msg = str(e)
if "Not my vbucket" in log_msg:
log_msg = log_msg[:log_msg.find("vBucketMap") +
12] + "..."
if e.status == memcacheConstants.ERR_NOT_MY_VBUCKET:
# May receive this while waiting for vbuckets, continue and retry...S
continue
log.error("%s: %s" % (log_msg, ex_msg))
continue
except exceptions.EOFError:
# The client was disconnected for some reason. This can
# happen just after the bucket REST API is returned (before
# the buckets are created in each of the memcached processes.)
# See here for some details: http://review.couchbase.org/#/c/49781/
# Longer term when we don't disconnect clients in this state we
# should probably remove this code.
log.error(
"got disconnected from the server, reconnecting")
continue
if c.find("\x01") > 0 or c.find("\x02") > 0:
ready_vbuckets[i] = True
elif i in ready_vbuckets:
log.warning(
"vbucket state changed from active to {0}".format(
c))
del ready_vbuckets[i]
client.close()
return len(ready_vbuckets) == vbucket_count
