def test_set_conditions(self):
c = etcd.Client(host=HOSTS)
c.test_and_set('foo', 'val')
c.test_and_set('foo', 'val', prevExist=True)
self.assertRaises(etcd.EcodeNodeExist,
c.test_and_set,
'foo',
'val',
prevExist=False)
res = c.test_and_set('foo', 'val1', prevValue='val')
self.assertEqual('val1', res.value)
self.assertRaises(etcd.EcodeTestFailed,
c.test_and_set,
'foo',
'val1',
prevValue='val1000')
res = c.test_and_set('foo', 'val2', prevIndex=res.modifiedIndex)
self.assertEqual('val2', res.value)
res = c.test_and_set('foo', None, refresh=True, ttl=2)
self.assertEqual(2, res.ttl)
def test_st_self(self):
c = etcd.Client(host=HOSTS)
s = c.st_self
self.assertTrue(type(s) is dict)
self.assertTrue(len(s) > 0)
def test_decode(self):
cases = (
('key1', utfjson.dump(u'我', encoding=None), '"\\u6211"'),
# when save '"\xb6\xd4"' with etcd but the etcd cannot
# convert them, so the default '\ufffd\ufffd' was saved.
# when get it from etcd, '\ufffd\ufffd' was converted into
# '"\xef\xbf\xbd\xef\xbf\xbd"'.
('key2', utfjson.dump(u'对', encoding='gbk'),
'"\xef\xbf\xbd\xef\xbf\xbd"'),
('key3', utfjson.dump(u'我', encoding='utf-8'), '"\xe6\x88\x91"'),
('key4', utfjson.dump(u'我'), '"\xe6\x88\x91"'),
('key5', utfjson.dump('我'), '"\xe6\x88\x91"'),
('key6', utfjson.dump({"我":
"我"}), '{"\xe6\x88\x91": "\xe6\x88\x91"}'),
('key7', utfjson.dump({"我":
u"我"}), '{"\xe6\x88\x91": "\xe6\x88\x91"}'),
('key8', utfjson.dump({u"我":
"我"}), '{"\xe6\x88\x91": "\xe6\x88\x91"}'),
('key9', utfjson.dump({u"我":
u"我"}), '{"\xe6\x88\x91": "\xe6\x88\x91"}'),
('key10', utfjson.dump((u"我", )), '["\xe6\x88\x91"]'),
)
cli = etcd.Client(host=HOSTS)
for key, val, expected in cases:
cli.set(key, val)
res = cli.get(key)
self.assertEqual(expected, res.value)
def test_watch(self):
c = etcd.Client(host=HOSTS)
res = c.set('abc', 'val')
self.assertEqual(res.value,
c.watch('abc', waitindex=res.modifiedIndex).value)
self.assertRaises(etcd.EtcdReadTimeoutError,
c.watch,
'abc',
waitindex=res.modifiedIndex + 1,
timeout=1)
start_index = res.modifiedIndex
for i in range(4):
res = c.set('abc', 'val%d' % (i))
end_index = res.modifiedIndex
result = []
for res in c.eternal_watch('abc',
waitindex=start_index + 1,
until=end_index):
result.append(res.value)
self.assertListEqual(['val0', 'val1', 'val2', 'val3'], result)
def test_refresh(self):
c = etcd.Client(host=HOSTS)
c.set('key', 'val')
res = c.refresh('key', ttl=1)
self.assertEqual(1, res.ttl)
def test_deldir(self):
c = etcd.Client(host=HOSTS)
c.test_and_set('dir1', None, dir=True)
c.deldir('dir1')
self.assertNotIn('dir1', c)
def test_del_member(self):
hosts = (
('192.168.52.50', 3379),
('192.168.52.51', 3379),
('192.168.52.52', 3379),
)
names = ('etcd_d0', 'etcd_d1', 'etcd_d2')
nodes = (
'node_d0',
'node_d1',
'node_d2',
)
_start_etcd_server(hosts, names, nodes)
time.sleep(10)
c = etcd.Client(host=hosts, read_timeout=1)
try:
for i in range(2):
ids = c.ids
c.del_member(ids[0])
self.assertEqual(2 - i, len(c.members))
time.sleep(10)
finally:
utdocker.remove_container(*names)
def test_leader(self):
c = etcd.Client(host=HOSTS)
leader = c.leader
self.assertIsNotNone(leader)
self.assertIn(leader, c.members)
def test_version(self):
c = etcd.Client(host=HOSTS)
ver = c.version
self.assertIn('etcdserver', ver)
self.assertIn('etcdcluster', ver)
def test_st_store(self):
c = etcd.Client(host=HOSTS)
store = c.st_store
expected_res = [
'getsSuccess',
'getsFail',
'setsSuccess',
'setsFail',
'deleteSuccess',
'deleteFail',
'updateSuccess',
'updateFail',
'createSuccess',
'createFail',
'compareAndSwapSuccess',
'compareAndSwapFail',
'compareAndDeleteSuccess',
'compareAndDeleteFail',
'expireCount',
'watchers',
]
self.assertEqual(set(expected_res), set(store.keys()))
def test_lsdir(self):
c = etcd.Client(host=HOSTS)
c.test_and_set('dir1', None, dir=True)
res = c.lsdir('dir1')
self.assertTrue(res.dir)
self.assertEqual('/dir1', res.key)
def test_etcdsslerror_exception(self):
c = etcd.Client(host=HOSTS)
self.assertRaises(etcd.EtcdSSLError,
etcd.Client,
host=HOSTS,
protocol='https')
self.assertRaises(etcd.EtcdSSLError, c._parse_url, 'https://')
def test_mkdir(self):
c = etcd.Client(host=HOSTS)
res = c.mkdir('d')
self.assertTrue(res.dir)
self.assertEqual('/d', res.key)
self.assertIn('d', c)
def test_ttl(self):
c = etcd.Client(host=HOSTS)
c.set('abc', 'val', ttl=1)
self.assertIn('abc', c)
time.sleep(2)
self.assertNotIn('abc', c)
def test_update(self):
c = etcd.Client(host=HOSTS)
res = c.set('key', 'val')
res.value += 'abc'
res = c.update(res)
self.assertEqual('valabc', res.value)
def test_etcdreadtimeouterror_exception(self):
utdocker.stop_container(*ETCD_NAMES)
c = etcd.Client(host=HOSTS, read_timeout=1)
self.assertRaises(etcd.EtcdReadTimeoutError,
c.api_execute,
'/v2/keys/abc',
'GET',
timeout=1,
raise_read_timeout=True)
def test_etcdrequestserror_exception(self):
c = etcd.Client(host=HOSTS)
self.assertRaises(etcd.EtcdRequestError, c._request,
'http://192.168.52.30:3379/v2/keys/abc', 'GETTT',
None, None, None)
self.assertRaises(etcd.EtcdRequestError,
c.write,
dir=True,
value='val',
key='key')
def test_rlsdir(self):
c = etcd.Client(host=HOSTS)
c.test_and_set('dir1', None, dir=True)
c.test_and_set('dir1/key', 'val')
res = c.rlsdir('dir1')
self.assertTrue(res.dir)
self.assertEqual('/dir1', res.key)
self.assertEqual(1, len(res._children))
self.assertEqual('val', res._children[0]['value'])
def test_auth(self):
hosts = (
('192.168.52.90', 3379),
('192.168.52.91', 3379),
('192.168.52.92', 3379),
)
names = (
'etcd_au0',
'etcd_au1',
'etcd_au2',
)
nodes = (
'node_au0',
'node_au1',
'node_au2',
)
_start_etcd_server(hosts, names, nodes)
time.sleep(10)
try:
self._set_auth(hosts)
c = etcd.Client(host=hosts)
self.assertRaises(etcd.EcodeInscientPermissions, c.set, 'key',
'val')
self.assertRaises(etcd.EcodeInscientPermissions, c.get, '')
c = etcd.Client(host=hosts, basic_auth_account='rw_user:654321')
c.set('key', 'val')
self.assertIn('key', c)
res = c.get('key')
self.assertEqual('val', res.value)
c.disable_auth('123456')
c = etcd.Client(host=hosts)
c.set('key1', 'val1')
self.assertIn('key1', c)
res = c.get('key1')
self.assertEqual('val1', res.value)
finally:
utdocker.remove_container(*names)
def test_members(self):
c = etcd.Client(host=HOSTS)
mems = c.members
for h, p in HOSTS:
succ = False
for m in mems:
if 'http://%s:%d' % (h, p) == m['clientURLs'][0]:
succ = True
break
self.assertTrue(succ)
def test_names(self):
c = etcd.Client(host=HOSTS)
expected_res = [
'node_0',
'node_1',
'node_2',
'node_3',
'node_4',
]
self.assertEqual(set(expected_res), set(c.names))
def test_set_append(self):
c = etcd.Client(host=HOSTS)
c.test_and_set('dd', None, dir=True)
c.test_and_set('dd', 'val1', append=True)
c.test_and_set('dd', 'val2', append=True)
res = c.get('dd')
self.assertEqual(2, len(res._children))
for n in res.leaves:
self.assertIn(n.value, ['val1', 'val2'])
def _set_auth(self, hosts):
root_pwd = '123456'
c = etcd.Client(host=hosts)
c.create_root(root_pwd)
c.enable_auth(root_pwd)
c.revoke_role_permissions('guest', root_pwd, {
"write": ["/*"],
"read": ["/*"]
})
c.create_role('rw_role', root_pwd, {"write": ["/*"], "read": ["/*"]})
c.create_user('rw_user', '654321', root_pwd, ["rw_role"])
time.sleep(1)
def _clear_all(self):
while True:
try:
c = etcd.Client(host=HOSTS)
res = c.get('', recursive=True)
for n in res._children:
c.delete(n['key'],
dir='dir' in n and n['dir'],
recursive=True)
break
except Exception as e:
dd(repr(e))
time.sleep(1)
def test_change_peerurls(self):
c = etcd.Client(host=HOSTS)
mem = c.members[0]
old_urls = mem['peerURLs']
new_urls = [old_urls[0] + '1']
c.change_peerurls(mem['id'], *new_urls)
self.assertIn(new_urls[0], c.peerurls)
c.change_peerurls(mem['id'], *old_urls)
self.assertIn(old_urls[0], c.peerurls)
self.assertRaises(etcd.EtcdException, c.change_peerurls, mem['id'], [])
def test_grant_revoke_role_permissions(self):
c = etcd.Client(host=HOSTS)
c.create_role('r_test', '')
try:
c.grant_role_permissions('r_test', '', {'read': ['/*']})
r = c.get_role('r_test', '')
self.assertEqual(['/*'], r['permissions']['kv']['read'])
c.revoke_role_permissions('r_test', '', {'read': ['/*']})
r = c.get_role('r_test', '')
self.assertEqual([], r['permissions']['kv']['read'])
finally:
self._clear_users_roles('')
def test_grant_revoke_user_roles(self):
c = etcd.Client(host=HOSTS)
c.create_user('u_test', '11', '')
c.create_role('r_test', '')
try:
c.grant_user_roles('u_test', '', ['r_test'])
res = c.get_user('u_test', '')
self.assertEqual('r_test', res['roles'][0]['role'])
c.revoke_user_roles('u_test', '', ['r_test'])
res = c.get_user('u_test', '')
self.assertNotIn('roles', res)
finally:
self._clear_users_roles('')
def test_machine_cache(self):
machine = list(HOSTS)
machine.pop(0)
machine = ['http://%s:%d' % (ip, port) for ip, port in machine]
cases = (
(HOSTS, 3379, True, machine),
('192.168.52.30', 3379, True, machine),
(HOSTS, 3379, False, []),
('192.168.52.30', 3379, False, []),
)
for host, port, allow_reconnect, expected_machines in cases:
c = etcd.Client(host=host,
port=port,
allow_reconnect=allow_reconnect)
self.assertEqual('http://192.168.52.30:3379', c._base_uri)
self.assertListEqual(expected_machines, c._machines_cache)
def test_set_and_get(self):
cases = (
('foo', 'f'),
('123', '456'),
('12foo', '1f'),
('*-@', 'special'),
('/bar', 'bb'),
('/789', '1000'),
('/12bar', '1bb'),
('/$*-', 'specialss'),
)
cli = etcd.Client(host=HOSTS)
for key, val in cases:
cli.set(key, val)
res = cli.get(key)
self.assertEqual(val, res.value)
def _clear_users_roles(self, root_pwd):
c = etcd.Client(host=HOSTS)
users = c.get_user(None, root_pwd)
if users is not None and users['users'] is not None:
for u in users['users']:
try:
c.delete_user(u['user'], root_pwd)
except:
continue
roles = c.get_role(None, root_pwd)
if roles is not None and roles['roles'] is not None:
for r in roles['roles']:
try:
c.delete_role(r['role'], root_pwd)
except:
continue
