def setUp(self):
super(TestSlave, self).setUp()
utdocker.create_network()
utdocker.start_container('redis-0', redis_tag, '192.168.52.40', '')
dd('started redis in docker')
redisutil.wait_serve(('192.168.52.40', redis_port))
self.redis_cli = redisutil.get_client(('192.168.52.40', redis_port))
self.journal_id_path = "tx/journal_id_set"
self.storage = zktx.RedisStorage(self.redis_cli, self.journal_id_path)
self.zk.create('tx', 'tx')
self.zk.create('tx/journal_id_set', '{}')
self.zk.create('tx/alive', '{}')
self.zk.create('tx/txid_maker', '{}')
self.zk.create('tx/journal', '{}')
for d in ('lock', 'record'):
self.zk.create(d, '{}')
for d1 in ('leader', 'meta', 'job'):
self.zk.create('/'.join([d, d1]), '{}')
for d2 in ('block_group', 'global', 'region', 'server'):
self.zk.create('/'.join([d, d1, d2]), '{}')
self.zke, _ = zkutil.kazoo_client_ext(self.zk)
self.slave = zktx.Slave(self.zke, self.storage)
def setUp(self):
utdocker.create_network()
utdocker.start_container(zk_name, zk_tag, port_bindings={2181: 21811})
dd('start zk-test in docker')
def setUp(self):
config.zk_acl = zk_test_acl
config.zk_auth = zk_test_auth
self.counter = 0
self.running = True
utdocker.create_network()
utdocker.start_container(
zk_test_name,
zk_test_tag,
env={
"ZOO_MY_ID": 1,
"ZOO_SERVERS": "server.1=0.0.0.0:2888:3888",
},
port_bindings={
2181: 21811,
}
)
self.zk = KazooClient(hosts='127.0.0.1:21811')
self.zk.start()
scheme, name, passw = zk_test_auth
self.zk.add_auth(scheme, name + ':' + passw)
# create lock base dir
acl = zkutil.make_kazoo_digest_acl(zk_test_acl)
self.zk.create('lock/', acl=acl)
self.lck = zkutil.ZKLock('foo_name', zkclient=self.zk)
def setUp(self):
utdocker.start_container(
mysql_test_name,
mysql_test_tag,
ip=mysql_test_ip,
env={
'MYSQL_ROOT_PASSWORD': mysql_test_password,
},
port_bindings={mysql_test_port: mysql_test_port})
addr = (mysql_test_ip, mysql_test_port)
# some time it takes several seconds to start listening
for ii in range(40):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.connect(addr)
break
except socket.error:
dd('trying to connect to {0} failed'.format(str(addr)))
sock.close()
time.sleep(.4)
else:
raise
self.pool = mysqlconnpool.make({
'host': mysql_test_ip,
'port': mysql_test_port,
'user': mysql_test_user,
'passwd': mysql_test_password,
})
def setUp(self):
utdocker.create_network()
utdocker.start_container('redis-0', redis_tag, '192.168.52.40', '')
dd('started redis in docker')
redisutil.wait_serve(('192.168.52.40', redis_port))
self.redis_cli = redisutil.get_client(('192.168.52.40', redis_port))
self.journal_id_set_path = "tx/journal_id_set"
self.storage = zktx.RedisStorage(self.redis_cli, self.journal_id_set_path)
def setUp(self):
utdocker.create_network()
utdocker.start_container('redis-0', redis_tag, '192.168.52.40', '')
dd('started redis in docker')
redisutil.wait_serve(('192.168.52.40', redis_port))
self.redis_cli = redisutil.get_client(('192.168.52.40', redis_port))
self.txid_path = "tx/txidset"
self.storage = zktx.RedisStorage(self.redis_cli, self.txid_path)
def _start_etcd_server(hosts, names, nodes, state='new'):
utdocker.create_network()
for i in range(len(hosts)):
name = names[i]
ip, _ = hosts[i]
command = _generate_command(i, hosts, nodes, state=state)
utdocker.start_container(name, etcd_test_tag, ip, command)
def setUp(self):
utdocker.create_network()
utdocker.start_container(
zk_name,
zk_tag,
port_bindings={2181: 21811}
)
dd('start zk-test in docker')
def setUp(self):
utdocker.create_network()
utdocker.start_container(mysql_test_name,
mysql_test_tag,
ip=mysql_test_ip,
env={
'MYSQL_ROOT_PASSWORD':
mysql_test_password,
})
ututil.wait_listening(mysql_test_ip, mysql_test_port)
def setUp(self):
utdocker.create_network()
utdocker.start_container(
mysql_test_name,
mysql_test_tag,
ip=mysql_test_ip,
env={
'MYSQL_ROOT_PASSWORD': mysql_test_password,
}
)
ututil.wait_listening(mysql_test_ip, mysql_test_port)
def setUp(self):
utdocker.create_network()
utdocker.start_container(zk_name,
zk_tag,
env={
"ZOO_MY_ID": 1,
"ZOO_SERVERS":
"server.1=0.0.0.0:2888:3888",
},
port_bindings={2181: 21811})
self.zk = KazooClient('127.0.0.1:21811')
self.zk.start()
dd('start zk-test in docker')
def setUp(self):
utdocker.create_network()
utdocker.start_container(zk_test_name,
zk_test_tag,
env={
"ZOO_MY_ID": 1,
"ZOO_SERVERS":
"server.1=0.0.0.0:2888:3888",
},
port_bindings={
2181: 21811,
})
self.zk = KazooClient(hosts='127.0.0.1:21811')
self.zk.start()
self.val = {'a': 1, 'b': 2}
self.zk.create('foo', utfjson.dump(self.val))
def setUp(self):
utdocker.create_network()
utdocker.start_container(
zk_name,
zk_tag,
env={
"ZOO_MY_ID": 1,
"ZOO_SERVERS": "server.1=0.0.0.0:2888:3888",
},
port_bindings={2181: 21811}
)
self.zk = KazooClient('127.0.0.1:21811')
self.zk.start()
dd('start zk-test in docker')
def setUp(self):
utdocker.create_network()
utdocker.start_container(
zk_test_name,
zk_test_tag,
env={
"ZOO_MY_ID": 1,
"ZOO_SERVERS": "server.1=0.0.0.0:2888:3888",
},
port_bindings={
2181: 21811,
}
)
self.zk = KazooClient(hosts='127.0.0.1:21811')
self.zk.start()
self.val = {'a': 1, 'b': 2}
self.zk.create('foo', utfjson.dump(self.val))
def setUp(self):
utdocker.create_network()
utdocker.start_container(mysql_test_name,
mysql_test_tag,
ip=mysql_test_ip,
env={
'MYSQL_ROOT_PASSWORD':
mysql_test_password,
})
ututil.wait_listening(mysql_test_ip, mysql_test_port)
self.pool = mysqlconnpool.make({
'host': mysql_test_ip,
'port': mysql_test_port,
'user': mysql_test_user,
'passwd': mysql_test_password,
})
def setUp(self):
self.containers = [
('redis-0', redis_tag, '192.168.52.40'),
('redis-1', redis_tag, '192.168.52.41'),
]
# for single redis cases:
self.docker_name = 'redis-0'
self.ip = '192.168.52.40'
self.is_child = False
utdocker.create_network()
for args in self.containers:
utdocker.start_container(*(args + ('', )))
dd('started redis in docker: ' + repr(args))
redisutil.wait_serve((args[2], redis_port))
self.rcl = redisutil.get_client((self.ip, redis_port))
def setUp(self):
utdocker.create_network()
utdocker.start_container(
zk_name,
zk_tag,
env={
"ZOO_MY_ID": 1,
"ZOO_SERVERS": "server.1=0.0.0.0:2888:3888",
},
port_bindings={2181: 21811}
)
self.zk = KazooClient('127.0.0.1:21811')
self.zk.start()
self.zkauthed, _ = zkutil.kazoo_client_ext(
{'hosts': '127.0.0.1:21811', 'auth': ('digest', 'xp', '123'),
'acl': (('xp', '123', 'cdrwa'), ('foo', 'bar', 'rw'))})
dd('start zk-test in docker')
def setUp(self):
utdocker.create_network()
utdocker.start_container(
mysql_test_name,
mysql_test_tag,
ip=mysql_test_ip,
env={
'MYSQL_ROOT_PASSWORD': mysql_test_password,
}
)
ututil.wait_listening(mysql_test_ip, mysql_test_port)
self.pool = mysqlconnpool.make({
'host': mysql_test_ip,
'port': mysql_test_port,
'user': mysql_test_user,
'passwd': mysql_test_password,
})
def setUp(self):
utdocker.create_network()
utdocker.start_container(zk_name,
zk_tag,
env={
"ZOO_MY_ID": 1,
"ZOO_SERVERS":
"server.1=0.0.0.0:2888:3888",
},
port_bindings={2181: 21811})
self.zk = KazooClient('127.0.0.1:21811')
self.zk.start()
self.zkauthed, _ = zkutil.kazoo_client_ext({
'hosts':
'127.0.0.1:21811',
'auth': ('digest', 'xp', '123'),
'acl': (('xp', '123', 'cdrwa'), ('foo', 'bar', 'rw'))
})
dd('start zk-test in docker')
def test_add_member(self):
hosts = [
('192.168.52.70', 3379),
('192.168.52.71', 3379),
]
names = ['etcd_a0', 'etcd_a1']
nodes = ['node_a0', 'node_a1']
_start_etcd_server(hosts, names, nodes)
time.sleep(10)
cases = (
('192.168.52.72', 'etcd_a2', 'node_a2', 3),
('192.168.52.73', 'etcd_a3', 'node_a3', 4),
)
c = etcd.Client(host=hosts)
try:
for ip, name, node, count in cases:
c.add_member(*['http://%s:3380' % (ip)])
hosts.append((ip, 3379))
nodes.append(node)
names.append(name)
utdocker.start_container(
name, etcd_test_tag, ip,
_generate_command(len(hosts) - 1,
hosts,
nodes,
state='existing'))
time.sleep(10)
self.assertEqual(count, len(c.members))
finally:
utdocker.remove_container(*names)
