def setUp(self):
utils.zk_wipe()
self.zkocc_server = utils.zkocc_start()
self.vttopo_server = utils.vttopo_start()
self.topo = zkocc.ZkOccConnection(
"localhost:%u" % utils.zkocc_port_base, 'test_nj', 30)
self.topo.dial()
def set_up(self):
try:
environment.topo_server_setup()
utils.wait_procs([t.init_mysql() for t in self.tablets])
utils.run_vtctl(['CreateKeyspace', self.keyspace])
utils.run_vtctl([
'SetKeyspaceShardingInfo', '-force', self.keyspace,
'keyspace_id', 'uint64'
])
for t in self.tablets:
t.init_tablet(t.type, keyspace=self.keyspace, shard=t.shard)
utils.run_vtctl(['RebuildKeyspaceGraph', self.keyspace],
auto_log=True)
for t in self.tablets:
t.create_db('vt_' + self.keyspace)
t.mquery(t.dbname, create_table)
t.start_vttablet(wait_for_state=None)
for t in self.tablets:
t.wait_for_vttablet_state('SERVING')
for t in self.tablets:
if t.type == "master":
utils.run_vtctl([
'ReparentShard', '-force',
self.keyspace + '/' + t.shard, t.tablet_alias
],
auto_log=True)
utils.run_vtctl(['RebuildKeyspaceGraph', self.keyspace],
auto_log=True)
self.vtgate_server, self.vtgate_port = utils.vtgate_start()
vtgate_client = zkocc.ZkOccConnection(
"localhost:%u" % self.vtgate_port, "test_nj", 30.0)
topology.read_topology(vtgate_client)
except:
self.shutdown()
raise
def setUp(self):
environment.topo_server_wipe()
self.vtgate_zk, self.vtgate_zk_port = utils.vtgate_start()
if environment.topo_server_implementation == 'zookeeper':
self.zkocc_server = utils.zkocc_start()
self.vtgate_zkocc, self.vtgate_zkocc_port = utils.vtgate_start(topo_impl="zkocc")
self.topo = zkocc.ZkOccConnection("localhost:%u" % environment.zkocc_port_base, 'test_nj', 30)
self.topo.dial()
def setUp(self):
self.shard_index = 0
self.replica_tablet = shard_0_replica
self.keyspace_fetch_throttle = 1
vtdb_logger.register_vtdb_logger(LocalLogger())
# Lowering the keyspace refresh throttle so things are testable.
topology.set_keyspace_fetch_throttle(0.1)
self.vtgate_client = zkocc.ZkOccConnection(utils.vtgate.addr(),
'test_nj', 30.0)
def setup_tablets():
global vtgate_server
global vtgate_port
# Start up a master mysql and vttablet
logging.debug("Setting up tablets")
utils.run_vtctl(['CreateKeyspace', 'test_keyspace'])
utils.run_vtctl([
'SetKeyspaceShardingInfo', '-force', 'test_keyspace', 'keyspace_id',
'uint64'
])
shard_0_master.init_tablet('master', keyspace='test_keyspace', shard='-80')
shard_0_replica.init_tablet('replica',
keyspace='test_keyspace',
shard='-80')
shard_1_master.init_tablet('master', keyspace='test_keyspace', shard='80-')
shard_1_replica.init_tablet('replica',
keyspace='test_keyspace',
shard='80-')
utils.run_vtctl(['RebuildKeyspaceGraph', 'test_keyspace'], auto_log=True)
for t in [
shard_0_master, shard_0_replica, shard_1_master, shard_1_replica
]:
t.create_db('vt_test_keyspace')
t.mquery(shard_0_master.dbname, create_vt_insert_test)
t.mquery(shard_0_master.dbname, create_vt_a)
t.start_vttablet(wait_for_state=None)
for t in [
shard_0_master, shard_0_replica, shard_1_master, shard_1_replica
]:
t.wait_for_vttablet_state('SERVING')
utils.run_vtctl([
'ReparentShard', '-force', 'test_keyspace/-80',
shard_0_master.tablet_alias
],
auto_log=True)
utils.run_vtctl([
'ReparentShard', '-force', 'test_keyspace/80-',
shard_1_master.tablet_alias
],
auto_log=True)
utils.run_vtctl(['RebuildKeyspaceGraph', 'test_keyspace'], auto_log=True)
utils.check_srv_keyspace(
'test_nj', 'test_keyspace', 'Partitions(master): -80 80-\n' +
'Partitions(replica): -80 80-\n' + 'TabletTypes: master,replica')
vtgate_server, vtgate_port = utils.vtgate_start()
vtgate_client = zkocc.ZkOccConnection("localhost:%u" % vtgate_port,
"test_nj", 30.0)
topology.read_topology(vtgate_client)
def setUp(self):
self.vtgate_server, self.vtgate_port = utils.vtgate_start(cache_ttl='0s')
self.vtgate_client = zkocc.ZkOccConnection("localhost:%u"%self.vtgate_port,
"test_nj", 30.0)
self.vtgate_addrs = None
if vtgate_protocol == VTGATE_PROTOCOL_V1BSON:
global vtgate_addrs
self.vtgate_addrs = {"_vt": ["localhost:%s"%(self.vtgate_port),]}
self.insert_index = 0
def setUp(self):
global vtgate_port
self.shard_index = 0
self.replica_tablet = shard_0_replica
self.keyspace_fetch_throttle = 1
vtdb_logger.register_vtdb_logger(LocalLogger())
# Lowering the keyspace refresh throttle so things are testable.
topology.set_keyspace_fetch_throttle(0.1)
self.vtgate_client = zkocc.ZkOccConnection("localhost:%u" % vtgate_port,
"test_nj", 30.0)
def setup_tablets():
global vtgate_server
global vtgate_port
# Start up a master mysql and vttablet
logging.debug("Setting up tablets")
utils.run_vtctl(['CreateKeyspace', KEYSPACE_NAME])
utils.run_vtctl([
'SetKeyspaceShardingInfo', '-force', KEYSPACE_NAME, 'keyspace_id',
'uint64'
])
shard_0_master.init_tablet('master', keyspace=KEYSPACE_NAME, shard='-80')
shard_0_replica.init_tablet('replica', keyspace=KEYSPACE_NAME, shard='-80')
shard_1_master.init_tablet('master', keyspace=KEYSPACE_NAME, shard='80-')
shard_1_replica.init_tablet('replica', keyspace=KEYSPACE_NAME, shard='80-')
utils.run_vtctl(['RebuildKeyspaceGraph', KEYSPACE_NAME], auto_log=True)
for t in [
shard_0_master, shard_0_replica, shard_1_master, shard_1_replica
]:
t.create_db('vt_test_keyspace')
for create_table in create_tables:
t.mquery(shard_0_master.dbname, create_table)
t.start_vttablet(wait_for_state=None)
for t in [
shard_0_master, shard_0_replica, shard_1_master, shard_1_replica
]:
t.wait_for_vttablet_state('SERVING')
utils.run_vtctl([
'ReparentShard', '-force', KEYSPACE_NAME + '/-80',
shard_0_master.tablet_alias
],
auto_log=True)
utils.run_vtctl([
'ReparentShard', '-force', KEYSPACE_NAME + '/80-',
shard_1_master.tablet_alias
],
auto_log=True)
utils.run_vtctl(['RebuildKeyspaceGraph', KEYSPACE_NAME], auto_log=True)
utils.check_srv_keyspace(
'test_nj', KEYSPACE_NAME, 'Partitions(master): -80 80-\n' +
'Partitions(replica): -80 80-\n' + 'TabletTypes: master,replica')
vtgate_server, vtgate_port = utils.vtgate_start()
# FIXME(shrutip): this should be removed once vtgate_cursor's
# dependency on topology goes away.
vtgate_client = zkocc.ZkOccConnection("localhost:%u" % vtgate_port,
"test_nj", 30.0)
topology.read_topology(vtgate_client)
def setUp(self):
utils.VtGate().start(cache_ttl='0s')
self.vtgate_client = zkocc.ZkOccConnection(utils.vtgate.addr(),
"test_nj", 30.0)
self.vtgate_addrs = None
if client_type == VTGATE:
self.vtgate_addrs = {"vt": [utils.vtgate.addr(),]}
self.insert_index = 0
# Lowering the keyspace refresh throttle so things are testable.
self.throttle_sleep_interval = 0.1
topology.set_keyspace_fetch_throttle(0.01)
def setUp(self):
self.vtgate_server, self.vtgate_port = utils.vtgate_start(cache_ttl='0s')
self.vtgate_client = zkocc.ZkOccConnection("localhost:%u"%self.vtgate_port,
"test_nj", 30.0)
self.vtgate_addrs = None
if vtgate_protocol == VTGATE_PROTOCOL_V1BSON:
global vtgate_addrs
self.vtgate_addrs = {"_vt": ["localhost:%s"%(self.vtgate_port),]}
self.insert_index = 0
# Lowering the keyspace refresh throttle so things are testable.
self.throttle_sleep_interval = 0.1
topology.set_keyspace_fetch_throttle(0.01)
def get_vt_connection_params(db_key, port="_vtocc"):
zkocc_client = zkocc.ZkOccConnection("localhost:%u" % utils.zkocc_port_base,
"test_nj", 30.0)
keyspace, shard, db_type = db_key.split('.')
topo = topology.read_keyspaces(zkocc_client)
addr = topology.get_host_port_by_name(zkocc_client, "%s:%s" % (db_key, port))
vt_addr = "%s:%d" % (addr[0][0], addr[0][1])
vt_params = DBParams()
vt_params.addr = vt_addr
vt_params.keyspace = keyspace
vt_params.shard = shard
vt_params.timeout = 10.0
return vt_params.__dict__
def setup_tablets():
# Start up a master mysql and vttablet
logging.debug('Setting up tablets')
utils.run_vtctl(['CreateKeyspace', 'test_keyspace'])
utils.run_vtctl([
'SetKeyspaceShardingInfo', '-force', 'test_keyspace', 'keyspace_id',
'uint64'
])
shard_0_master.init_tablet('master', keyspace='test_keyspace', shard='-80')
shard_0_replica.init_tablet('replica',
keyspace='test_keyspace',
shard='-80')
shard_1_master.init_tablet('master', keyspace='test_keyspace', shard='80-')
shard_1_replica.init_tablet('replica',
keyspace='test_keyspace',
shard='80-')
utils.run_vtctl(['RebuildKeyspaceGraph', 'test_keyspace'], auto_log=True)
for t in [
shard_0_master, shard_0_replica, shard_1_master, shard_1_replica
]:
t.create_db('vt_test_keyspace')
t.mquery(shard_0_master.dbname, create_vt_insert_test)
t.mquery(shard_0_master.dbname, create_vt_a)
t.start_vttablet(wait_for_state=None)
for t in [
shard_0_master, shard_0_replica, shard_1_master, shard_1_replica
]:
t.wait_for_vttablet_state('SERVING')
utils.run_vtctl(
['InitShardMaster', 'test_keyspace/-80', shard_0_master.tablet_alias],
auto_log=True)
utils.run_vtctl(
['InitShardMaster', 'test_keyspace/80-', shard_1_master.tablet_alias],
auto_log=True)
utils.run_vtctl(['RebuildKeyspaceGraph', 'test_keyspace'], auto_log=True)
utils.check_srv_keyspace(
'test_nj', 'test_keyspace', 'Partitions(master): -80 80-\n'
'Partitions(rdonly): -80 80-\n'
'Partitions(replica): -80 80-\n')
utils.VtGate().start()
vtgate_client = zkocc.ZkOccConnection(utils.vtgate.addr(), 'test_nj', 30.0)
topology.read_topology(vtgate_client)
def set_up(self):
try:
environment.topo_server().setup()
utils.wait_procs([t.init_mysql() for t in self.tablets])
utils.run_vtctl(['CreateKeyspace', self.keyspace])
utils.run_vtctl([
'SetKeyspaceShardingInfo', '-force', self.keyspace,
'keyspace_id', 'uint64'
])
for t in self.tablets:
t.init_tablet(t.type, keyspace=self.keyspace, shard=t.shard)
utils.run_vtctl(['RebuildKeyspaceGraph', self.keyspace],
auto_log=True)
for t in self.tablets:
t.create_db('vt_' + self.keyspace)
t.start_vttablet(
wait_for_state=None,
extra_args=['-queryserver-config-schema-reload-time', '1'],
)
for t in self.tablets:
t.wait_for_vttablet_state('SERVING')
for t in self.tablets:
if t.type == "master":
utils.run_vtctl([
'ReparentShard', '-force',
self.keyspace + '/' + t.shard, t.tablet_alias
],
auto_log=True)
utils.run_vtctl(['RebuildKeyspaceGraph', self.keyspace],
auto_log=True)
if self.schema:
utils.run_vtctl([
'ApplySchemaKeyspace', '-simple', '-sql', self.schema,
self.keyspace
])
if self.vschema:
if self.vschema[0] == '{':
utils.run_vtctl(['ApplyVSchema', "-vschema", self.vschema])
else:
utils.run_vtctl(
['ApplyVSchema', "-vschema_file", self.vschema])
self.vtgate_server, self.vtgate_port = utils.vtgate_start(
cache_ttl='500s')
vtgate_client = zkocc.ZkOccConnection(
"localhost:%u" % self.vtgate_port, "test_nj", 30.0)
topology.read_topology(vtgate_client)
except:
self.shutdown()
raise
def test_vtgate(self):
# do a few vtgate topology queries to prime the cache
vtgate_client = zkocc.ZkOccConnection("localhost:%u" % vtgate_port,
"test_nj", 30.0)
vtgate_client.dial()
vtgate_client.get_srv_keyspace_names("test_nj")
vtgate_client.get_srv_keyspace("test_nj", "test_keyspace")
vtgate_client.get_end_points("test_nj", "test_keyspace", "-80", "master")
vtgate_client.close()
status = utils.get_status(vtgate_port)
self.assertIn('</html>', status) # end of page
self.assertIn('/serving_graph/test_nj">test_nj', status) # vtctld link
utils.pause("You can now run a browser and connect to http://localhost:%u%s to manually check vtgate status page" % (vtgate_port, environment.status_url))
def get_connection(db_type='master', shard_index=0, user=None, password=None):
global vtgate_protocol
global vtgate_port
timeout = 10.0
conn = None
shard = shard_names[shard_index]
vtgate_addrs = {"_vt": ["localhost:%s" % (vtgate_port),]}
vtgate_client = zkocc.ZkOccConnection("localhost:%u" % vtgate_port,
"test_nj", 30.0)
conn = vtclient.VtOCCConnection(vtgate_client, 'test_keyspace', shard,
db_type, timeout,
user=user, password=password,
vtgate_protocol=vtgate_protocol,
vtgate_addrs=vtgate_addrs)
conn.connect()
return conn
def setup_tablets():
# Start up a master mysql and vttablet
logging.debug("Setting up tablets")
utils.run_vtctl('CreateKeyspace %s' % TEST_KEYSPACE)
shard_0_master.init_tablet('master', keyspace=TEST_KEYSPACE, shard='0')
shard_0_replica.init_tablet('replica', keyspace=TEST_KEYSPACE, shard='0')
shard_1_master.init_tablet('master', keyspace=TEST_KEYSPACE, shard='1')
shard_1_replica.init_tablet('replica', keyspace=TEST_KEYSPACE, shard='1')
utils.run_vtctl('RebuildShardGraph %s/0' % TEST_KEYSPACE, auto_log=True)
utils.run_vtctl('RebuildShardGraph %s/1' % TEST_KEYSPACE, auto_log=True)
utils.validate_topology()
shard_0_master.create_db(shard_0_master.dbname)
shard_0_replica.create_db(shard_0_master.dbname)
shard_1_master.create_db(shard_0_master.dbname)
shard_1_replica.create_db(shard_0_master.dbname)
setup_schema()
utils.run_vtctl('RebuildKeyspaceGraph %s' % TEST_KEYSPACE, auto_log=True)
zkocc_server = utils.zkocc_start()
shard_0_master.start_vttablet()
shard_0_replica.start_vttablet()
shard_1_master.start_vttablet()
shard_1_replica.start_vttablet()
utils.run_vtctl('SetReadWrite ' + shard_0_master.tablet_alias)
utils.run_vtctl('SetReadWrite ' + shard_1_master.tablet_alias)
utils.check_db_read_write(62344)
for t in [shard_0_master, shard_0_replica]:
t.reset_replication()
utils.run_vtctl('ReparentShard -force test_keyspace/0 ' + shard_0_master.tablet_alias, auto_log=True)
for t in [shard_1_master, shard_1_replica]:
t.reset_replication()
utils.run_vtctl('ReparentShard -force test_keyspace/1 ' + shard_1_master.tablet_alias, auto_log=True)
# then get the topology and check it
zkocc_client = zkocc.ZkOccConnection("localhost:%u" % utils.zkocc_port_base,
"test_nj", 30.0)
topology.read_keyspaces(zkocc_client)
shard_0_master_addrs = topology.get_host_port_by_name(zkocc_client, "test_keyspace.0.master:_vtocc")
logging.debug(shard_0_master_addrs)
def test_vtgate(self):
# do a few vtgate topology queries to prime the cache
vtgate_client = zkocc.ZkOccConnection(utils.vtgate.addr(), 'test_nj',
30.0)
vtgate_client.dial()
vtgate_client.get_srv_keyspace_names('test_nj')
vtgate_client.get_srv_keyspace('test_nj', 'test_keyspace')
vtgate_client.get_end_points('test_nj', 'test_keyspace', '-80',
'master')
vtgate_client.close()
status = utils.vtgate.get_status()
self.assertIn('</html>', status) # end of page
self.assertIn('/serving_graph/test_nj">test_nj', status) # vtctld link
utils.pause(
'You can now run a browser and connect to http://%s:%d%s to '
'manually check vtgate status page' %
(socket.getfqdn(), utils.vtgate.port, environment.status_url))
def get_connection(db_type='master', shard_index=0, user=None, password=None):
timeout = 10.0
conn = None
shard = shard_names[shard_index]
vtgate_addrs = {
'vt': [
utils.vtgate.addr(),
]
}
vtgate_client = zkocc.ZkOccConnection(utils.vtgate.addr(), 'test_nj', 30.0)
conn = vtclient.VtOCCConnection(vtgate_client,
'test_keyspace',
shard,
db_type,
timeout,
user=user,
password=password,
vtgate_protocol=vtgate_protocol,
vtgate_addrs=vtgate_addrs)
conn.connect()
return conn
def setUpModule():
global vtgate_server, vtgate_port
logging.debug("in setUpModule")
try:
environment.topo_server().setup()
setup_topology()
# start mysql instance external to the test
global __tablets
setup_procs = []
for tablet in __tablets:
setup_procs.append(tablet.init_mysql())
utils.wait_procs(setup_procs)
create_db()
start_tablets()
vtgate_server, vtgate_port = utils.vtgate_start()
# FIXME(shrutip): this should be removed once vtgate_cursor's
# dependency on topology goes away.
vtgate_client = zkocc.ZkOccConnection("localhost:%u" % vtgate_port,
"test_nj", 30.0)
topology.read_topology(vtgate_client)
except:
tearDownModule()
raise
def test_zkocc(self):
# preload the test_nj cell
zkocc_14850 = utils.zkocc_start(extra_params=['-connect-timeout=2s', '-cache-refresh-interval=1s'])
time.sleep(1)
# create a python client. The first address is bad, will test the retry logic
bad_port = environment.reserve_ports(3)
zkocc_client = zkocc.ZkOccConnection("localhost:%u,localhost:%u,localhost:%u" % (bad_port, environment.zkocc_port_base, bad_port+1), "test_nj", 30)
zkocc_client.dial()
# test failure for a python client that cannot connect
bad_zkocc_client = zkocc.ZkOccConnection("localhost:%u,localhost:%u" % (bad_port+2, bad_port), "test_nj", 30)
try:
bad_zkocc_client.dial()
self.fail('exception expected')
except zkocc.ZkOccError as e:
if not str(e).startswith("Cannot dial to any server, tried: "):
self.fail('unexpected exception: %s' % str(e))
level = logging.getLogger().getEffectiveLevel()
logging.getLogger().setLevel(logging.ERROR)
# FIXME(ryszard): This can be changed into a self.assertRaises.
try:
bad_zkocc_client.get("/zk/test_nj/vt/zkocc1/data1")
self.fail('exception expected')
except zkocc.ZkOccError as e:
if not str(e).startswith("Cannot dial to any server, tried: "):
self.fail('unexpected exception: %s' % str(e))
logging.getLogger().setLevel(level)
# get test
out, err = utils.run(environment.binary_path('zkclient2')+' -server localhost:%u /zk/test_nj/vt/zkocc1/data1' % environment.zkocc_port_base, trap_output=True)
self.assertEqual(err, "/zk/test_nj/vt/zkocc1/data1 = Test data 1 (NumChildren=0, Version=0, Cached=false, Stale=false)\n")
zk_data = zkocc_client.get("/zk/test_nj/vt/zkocc1/data1")
self.assertDictContainsSubset({'Data': "Test data 1",
'Cached': True,
'Stale': False,},
zk_data)
self.assertDictContainsSubset({'NumChildren': 0, 'Version': 0}, zk_data['Stat'])
# getv test
out, err = utils.run(environment.binary_path('zkclient2')+' -server localhost:%u /zk/test_nj/vt/zkocc1/data1 /zk/test_nj/vt/zkocc1/data2 /zk/test_nj/vt/zkocc1/data3' % environment.zkocc_port_base, trap_output=True)
self.assertEqualNormalized(err, """[0] /zk/test_nj/vt/zkocc1/data1 = Test data 1 (NumChildren=0, Version=0, Cached=true, Stale=false)
[1] /zk/test_nj/vt/zkocc1/data2 = Test data 2 (NumChildren=0, Version=0, Cached=false, Stale=false)
[2] /zk/test_nj/vt/zkocc1/data3 = Test data 3 (NumChildren=0, Version=0, Cached=false, Stale=false)
""")
zk_data = zkocc_client.getv(["/zk/test_nj/vt/zkocc1/data1", "/zk/test_nj/vt/zkocc1/data2", "/zk/test_nj/vt/zkocc1/data3"])['Nodes']
self.assertEqual(len(zk_data), 3)
for i, d in enumerate(zk_data):
self.assertEqual(d['Data'], 'Test data %s' % (i + 1))
self.assertTrue(d['Cached'])
self.assertFalse(d['Stale'])
self.assertDictContainsSubset({'NumChildren': 0, 'Version': 0}, d['Stat'])
# children test
out, err = utils.run(environment.binary_path('zkclient2')+' -server localhost:%u -mode children /zk/test_nj/vt' % environment.zkocc_port_base, trap_output=True)
self.assertEqualNormalized(err, """Path = /zk/test_nj/vt
Child[0] = zkocc1
Child[1] = zkocc2
NumChildren = 2
CVersion = 2
Cached = false
Stale = false
""")
# zk command tests
self._check_zk_output("cat /zk/test_nj/vt/zkocc1/data1", "Test data 1")
self._check_zk_output("ls -l /zk/test_nj/vt/zkocc1", """total: 3
-rw-rw-rw- zk zk 11 %s data1
-rw-rw-rw- zk zk 11 %s data2
-rw-rw-rw- zk zk 11 %s data3
""" % (_format_time(zk_data[0]['Stat']['MTime']),
_format_time(zk_data[1]['Stat']['MTime']),
_format_time(zk_data[2]['Stat']['MTime'])))
# test /zk/local is not resolved and rejected
out, err = utils.run(environment.binary_path('zkclient2')+' -server localhost:%u /zk/local/vt/zkocc1/data1' % environment.zkocc_port_base, trap_output=True, raise_on_error=False)
self.assertIn("zkocc: cannot resolve local cell", err)
# start a background process to query the same value over and over again
# while we kill the zk server and restart it
outfd = tempfile.NamedTemporaryFile(dir=environment.tmproot, delete=False)
filename = outfd.name
querier = utils.run_bg('/bin/bash -c "while true ; do '+environment.binary_path('zkclient2')+' -server localhost:%u /zk/test_nj/vt/zkocc1/data1 ; sleep 0.1 ; done"' % environment.zkocc_port_base, stderr=outfd.file)
outfd.close()
time.sleep(1)
# kill zk server, sleep a bit, restart zk server, sleep a bit
utils.run(environment.binary_path('zkctl')+' -zk.cfg 1@'+utils.hostname+':%u:%u:%u shutdown' % (environment.zk_port_base, environment.zk_port_base+1, environment.zk_port_base+2))
time.sleep(3)
utils.run(environment.binary_path('zkctl')+' -zk.cfg 1@'+utils.hostname+':%u:%u:%u start' % (environment.zk_port_base, environment.zk_port_base+1, environment.zk_port_base+2))
time.sleep(3)
utils.kill_sub_process(querier)
logging.debug("Checking %s", filename)
fd = open(filename, "r")
state = 0
for line in fd:
if line == "/zk/test_nj/vt/zkocc1/data1 = Test data 1 (NumChildren=0, Version=0, Cached=true, Stale=false)\n":
stale = False
elif line == "/zk/test_nj/vt/zkocc1/data1 = Test data 1 (NumChildren=0, Version=0, Cached=true, Stale=true)\n":
stale = True
else:
self.fail('unexpected line: %s' % line)
if state == 0:
if stale:
state = 1
elif state == 1:
if not stale:
state = 2
else:
if stale:
self.fail('unexpected stale state')
self.assertEqual(state, 2)
fd.close()
utils.zkocc_kill(zkocc_14850)
# check that after the server is gone, the python client fails correctly
level = logging.getLogger().getEffectiveLevel()
logging.getLogger().setLevel(logging.ERROR)
try:
zkocc_client.get("/zk/test_nj/vt/zkocc1/data1")
self.fail('exception expected')
except zkocc.ZkOccError as e:
if not str(e).startswith("Cannot dial to any server, tried: "):
self.fail('unexpected exception: %s', str(e))
logging.getLogger().setLevel(level)
def setUp(self):
self.vtgate_client = zkocc.ZkOccConnection(utils.vtgate.addr(),
"test_nj", 30.0)
topology.read_topology(self.vtgate_client)
self.perform_insert(400)
def setUp(self):
self.vtgate_client = zkocc.ZkOccConnection(vtgate_socket_file,
"test_nj", 30.0)
topology.read_topology(self.vtgate_client)
def run_test_secure():
zkocc_server = utils.zkocc_start()
# start the tablets
shard_0_master.start_vttablet(cert=cert_dir + "/vt-server-cert.pem",
key=cert_dir + "/vt-server-key.pem")
shard_0_slave.start_vttablet(cert=cert_dir + "/vt-server-cert.pem",
key=cert_dir + "/vt-server-key.pem",
repl_extra_flags={
'flags': 2048,
'ssl_ca': cert_dir + "/ca-cert.pem",
'ssl_cert': cert_dir + "/client-cert.pem",
'ssl_key': cert_dir + "/client-key.pem",
})
# Reparent using SSL
for t in [shard_0_master, shard_0_slave]:
t.reset_replication()
utils.run_vtctl('ReparentShard -force test_keyspace/0 ' +
shard_0_master.tablet_alias,
auto_log=True)
# then get the topology and check it
zkocc_client = zkocc.ZkOccConnection(
"localhost:%u" % utils.zkocc_port_base, "test_nj", 30.0)
topology.read_keyspaces(zkocc_client)
shard_0_master_addrs = topology.get_host_port_by_name(
zkocc_client, "test_keyspace.0.master:_vts")
if len(shard_0_master_addrs) != 1:
raise utils.TestError(
'topology.get_host_port_by_name failed for "test_keyspace.0.master:_vts", got: %s'
% " ".join([
"%s:%u(%s)" % (h, p, str(e))
for (h, p, e) in shard_0_master_addrs
]))
if shard_0_master_addrs[0][2] != True:
raise utils.TestError(
'topology.get_host_port_by_name failed for "test_keyspace.0.master:_vts" is not encrypted'
)
utils.debug("shard 0 master addrs: %s" % " ".join(
["%s:%u(%s)" % (h, p, str(e)) for (h, p, e) in shard_0_master_addrs]))
# make sure asking for optionally secure connections works too
auto_addrs = topology.get_host_port_by_name(
zkocc_client, "test_keyspace.0.master:_vtocc", encrypted=True)
if auto_addrs != shard_0_master_addrs:
raise utils.TestError(
'topology.get_host_port_by_name doesn\'t resolve encrypted addresses properly: %s != %s'
% (str(shard_0_master_addrs), str(auto_addrs)))
# try to connect with regular client
try:
conn = tablet3.TabletConnection(
"%s:%u" % (shard_0_master_addrs[0][0], shard_0_master_addrs[0][1]),
"test_keyspace", "0", 10.0)
conn.dial()
raise utils.TestError("No exception raised to secure port")
except tablet3.FatalError as e:
if not e.args[0][0].startswith('Unexpected EOF in handshake to'):
raise utils.TestError("Unexpected exception: %s" % str(e))
sconn = utils.get_vars(shard_0_master.port)["SecureConns"]
if sconn != 0:
raise utils.TestError("unexpected conns %s" % sconn)
# connect to encrypted port
conn = tablet3.TabletConnection(
"%s:%u" % (shard_0_master_addrs[0][0], shard_0_master_addrs[0][1]),
"test_keyspace",
"0",
5.0,
encrypted=True)
conn.dial()
(results, rowcount, lastrowid,
fields) = conn._execute("select 1 from dual", {})
if (len(results) != 1 or \
results[0][0] != 1):
print "conn._execute returned:", results
raise utils.TestError('wrong conn._execute output')
sconn = utils.get_vars(shard_0_master.port)["SecureConns"]
if sconn != 1:
raise utils.TestError("unexpected conns %s" % sconn)
saccept = utils.get_vars(shard_0_master.port)["SecureAccepts"]
if saccept == 0:
raise utils.TestError("unexpected accepts %s" % saccept)
# trigger a time out on a secure connection, see what exception we get
try:
conn._execute("select sleep(100) from dual", {})
raise utils.TestError("No timeout exception")
except tablet3.TimeoutError as e:
utils.debug("Got the right exception for SSL timeout: %s" % str(e))
# kill everything
utils.kill_sub_process(zkocc_server)
def test_sharding(self):
shard_0_master.init_tablet('master', 'test_keyspace', '-80')
shard_0_replica.init_tablet('replica', 'test_keyspace', '-80')
shard_1_master.init_tablet('master', 'test_keyspace', '80-')
shard_1_replica.init_tablet('replica', 'test_keyspace', '80-')
utils.run_vtctl(
'RebuildShardGraph /zk/global/vt/keyspaces/test_keyspace/shards/*',
auto_log=True)
utils.run_vtctl('RebuildKeyspaceGraph /zk/global/vt/keyspaces/*',
auto_log=True)
# run checks now before we start the tablets
utils.validate_topology()
# create databases
shard_0_master.create_db('vt_test_keyspace')
shard_0_replica.create_db('vt_test_keyspace')
shard_1_master.create_db('vt_test_keyspace')
shard_1_replica.create_db('vt_test_keyspace')
# start the tablets
shard_0_master.start_vttablet()
shard_0_replica.start_vttablet()
shard_1_master.start_vttablet()
shard_1_replica.start_vttablet()
# apply the schema on the first shard through vtctl, so all tablets
# are the same (replication is not enabled yet, so allow_replication=false
# is just there to be tested)
utils.run_vtctl([
'ApplySchema', '-stop-replication',
'-sql=' + create_vt_select_test.replace("\n", ""),
shard_0_master.tablet_alias
])
utils.run_vtctl([
'ApplySchema', '-stop-replication',
'-sql=' + create_vt_select_test.replace("\n", ""),
shard_0_replica.tablet_alias
])
# start zkocc, we'll use it later
zkocc_server = utils.zkocc_start()
for t in [
shard_0_master, shard_0_replica, shard_1_master,
shard_1_replica
]:
t.reset_replication()
utils.run_vtctl('ReparentShard -force test_keyspace/-80 ' +
shard_0_master.tablet_alias,
auto_log=True)
utils.run_vtctl('ReparentShard -force test_keyspace/80- ' +
shard_1_master.tablet_alias,
auto_log=True)
# apply the schema on the second shard using a simple schema upgrade
utils.run_vtctl([
'ApplySchemaShard', '-simple',
'-sql=' + create_vt_select_test_reverse.replace("\n", ""),
'test_keyspace/80-'
])
# insert some values directly (db is RO after minority reparent)
# FIXME(alainjobart) these values don't match the shard map
utils.run_vtctl('SetReadWrite ' + shard_0_master.tablet_alias)
utils.run_vtctl('SetReadWrite ' + shard_1_master.tablet_alias)
shard_0_master.mquery(
'vt_test_keyspace',
"insert into vt_select_test (id, msg) values (1, 'test 1')",
write=True)
shard_1_master.mquery(
'vt_test_keyspace',
"insert into vt_select_test (id, msg) values (10, 'test 10')",
write=True)
utils.validate_topology(ping_tablets=True)
utils.pause("Before the sql scatter query")
# note the order of the rows is not guaranteed, as the go routines
# doing the work can go out of order
self._check_rows(["Index\tid\tmsg", "1\ttest 1", "10\ttest 10"])
# write a value, re-read them all
utils.vtclient2(
3803,
"/test_nj/test_keyspace/master",
"insert into vt_select_test (id, msg) values (:keyspace_id, 'test 2')",
bindvars='{"keyspace_id": 2}',
driver="vtdb",
verbose=True)
self._check_rows(
["Index\tid\tmsg", "1\ttest 1", "2\ttest 2", "10\ttest 10"])
# make sure the '2' value was written on first shard
rows = shard_0_master.mquery(
'vt_test_keyspace',
"select id, msg from vt_select_test order by id")
self.assertEqual(rows, (
(1, 'test 1'),
(2, 'test 2'),
), 'wrong mysql_query output: %s' % str(rows))
utils.pause("After db writes")
# now use zkocc or streaming or both for the same query
self._check_rows(
["Index\tid\tmsg", "1\ttest 1", "2\ttest 2", "10\ttest 10"],
driver="vtdb-zkocc")
self._check_rows(
["Index\tid\tmsg", "1\ttest 1", "2\ttest 2", "10\ttest 10"],
driver="vtdb-streaming")
self._check_rows(
["Index\tid\tmsg", "1\ttest 1", "2\ttest 2", "10\ttest 10"],
driver="vtdb-zkocc-streaming")
# make sure the schema checking works
self._check_rows_schema_diff("vtdb-zkocc")
self._check_rows_schema_diff("vtdb")
# throw in some schema validation step
# we created the schema differently, so it should show
utils.run_vtctl('ValidateSchemaShard test_keyspace/-80')
utils.run_vtctl('ValidateSchemaShard test_keyspace/80-')
out, err = utils.run_vtctl('ValidateSchemaKeyspace test_keyspace',
trap_output=True,
raise_on_error=False)
if "test_nj-0000062344 and test_nj-0000062346 disagree on schema for table vt_select_test:\nCREATE TABLE" not in err or \
"test_nj-0000062344 and test_nj-0000062347 disagree on schema for table vt_select_test:\nCREATE TABLE" not in err:
self.fail('wrong ValidateSchemaKeyspace output: ' + err)
# validate versions
utils.run_vtctl('ValidateVersionShard test_keyspace/-80',
auto_log=True)
utils.run_vtctl('ValidateVersionKeyspace test_keyspace', auto_log=True)
# show and validate permissions
utils.run_vtctl('GetPermissions test_nj-0000062344', auto_log=True)
utils.run_vtctl('ValidatePermissionsShard test_keyspace/-80',
auto_log=True)
utils.run_vtctl('ValidatePermissionsKeyspace test_keyspace',
auto_log=True)
# and create zkns on this complex keyspace, make sure a few files are created
utils.run_vtctl('ExportZknsForKeyspace test_keyspace')
out, err = utils.run(utils.vtroot +
'/bin/zk ls -R /zk/test_nj/zk?s/vt/test_keysp*',
trap_output=True)
lines = out.splitlines()
for base in ['-80', '80-']:
for db_type in ['master', 'replica']:
for sub_path in ['', '.vdns', '/0', '/_vtocc.vdns']:
expected = '/zk/test_nj/zkns/vt/test_keyspace/' + base + '/' + db_type + sub_path
if expected not in lines:
self.fail('missing zkns part:\n%s\nin:%s' %
(expected, out))
# now try to connect using the python client and shard-aware connection
# to both shards
# first get the topology and check it
zkocc_client = zkocc.ZkOccConnection(
"localhost:%u" % utils.zkocc_port_base, "test_nj", 30.0)
topology.read_keyspaces(zkocc_client)
shard_0_master_addrs = topology.get_host_port_by_name(
zkocc_client, "test_keyspace.-80.master:_vtocc")
if len(shard_0_master_addrs) != 1:
self.fail(
'topology.get_host_port_by_name failed for "test_keyspace.-80.master:_vtocc", got: %s'
% " ".join([
"%s:%u(%s)" % (h, p, str(e))
for (h, p, e) in shard_0_master_addrs
]))
logging.debug(
"shard 0 master addrs: %s", " ".join([
"%s:%u(%s)" % (h, p, str(e))
for (h, p, e) in shard_0_master_addrs
]))
# connect to shard -80
conn = tablet3.TabletConnection(
"%s:%u" % (shard_0_master_addrs[0][0], shard_0_master_addrs[0][1]),
"test_keyspace", "-80", 10.0)
conn.dial()
(results, rowcount, lastrowid, fields) = conn._execute(
"select id, msg from vt_select_test order by id", {})
self.assertEqual(results, [
(1, 'test 1'),
(2, 'test 2'),
], 'wrong conn._execute output: %s' % str(results))
# connect to shard 80-
shard_1_master_addrs = topology.get_host_port_by_name(
zkocc_client, "test_keyspace.80-.master:_vtocc")
conn = tablet3.TabletConnection(
"%s:%u" % (shard_1_master_addrs[0][0], shard_1_master_addrs[0][1]),
"test_keyspace", "80-", 10.0)
conn.dial()
(results, rowcount, lastrowid, fields) = conn._execute(
"select id, msg from vt_select_test order by id", {})
self.assertEqual(results, [
(10, 'test 10'),
], 'wrong conn._execute output: %s' % str(results))
# try to connect with bad shard
try:
conn = tablet3.TabletConnection(
"localhost:%u" % shard_0_master.port, "test_keyspace", "-90",
10.0)
conn.dial()
self.fail('expected an exception')
except Exception as e:
if "fatal: Shard mismatch, expecting -80, received -90" not in str(
e):
self.fail('unexpected exception: ' + str(e))
utils.kill_sub_process(zkocc_server)
shard_0_master.kill_vttablet()
shard_0_replica.kill_vttablet()
shard_1_master.kill_vttablet()
shard_1_replica.kill_vttablet()
def connect(zkocc_addrs, local_cell, keyspace_name, db_type, use_streaming,
timeout, user, password, dbname):
zk_client = zkocc.ZkOccConnection(zkocc_addrs, local_cell, timeout)
return ShardedClient(zk_client, keyspace_name, db_type, use_streaming,
timeout, user, password, dbname)
def test_secure(self):
zkocc_server = utils.zkocc_start()
# start the tablets
shard_0_master.start_vttablet(cert=cert_dir + "/vt-server-cert.pem",
key=cert_dir + "/vt-server-key.pem")
shard_0_slave.start_vttablet(cert=cert_dir + "/vt-server-cert.pem",
key=cert_dir + "/vt-server-key.pem",
repl_extra_flags={
'flags': "2048",
'ssl-ca': cert_dir + "/ca-cert.pem",
'ssl-cert':
cert_dir + "/client-cert.pem",
'ssl-key':
cert_dir + "/client-key.pem",
})
# Reparent using SSL
for t in [shard_0_master, shard_0_slave]:
t.reset_replication()
utils.run_vtctl('ReparentShard -force test_keyspace/0 ' +
shard_0_master.tablet_alias,
auto_log=True)
# then get the topology and check it
zkocc_client = zkocc.ZkOccConnection(
"localhost:%u" % environment.zkocc_port_base, "test_nj", 30.0)
topology.read_keyspaces(zkocc_client)
shard_0_master_addrs = topology.get_host_port_by_name(
zkocc_client, "test_keyspace.0.master:_vts")
if len(shard_0_master_addrs) != 1:
self.fail(
'topology.get_host_port_by_name failed for "test_keyspace.0.master:_vts", got: %s'
% " ".join([
"%s:%u(%s)" % (h, p, str(e))
for (h, p, e) in shard_0_master_addrs
]))
if shard_0_master_addrs[0][2] != True:
self.fail(
'topology.get_host_port_by_name failed for "test_keyspace.0.master:_vts" is not encrypted'
)
logging.debug(
"shard 0 master addrs: %s", " ".join([
"%s:%u(%s)" % (h, p, str(e))
for (h, p, e) in shard_0_master_addrs
]))
# make sure asking for optionally secure connections works too
auto_addrs = topology.get_host_port_by_name(
zkocc_client, "test_keyspace.0.master:_vtocc", encrypted=True)
if auto_addrs != shard_0_master_addrs:
self.fail(
'topology.get_host_port_by_name doesn\'t resolve encrypted addresses properly: %s != %s'
% (str(shard_0_master_addrs), str(auto_addrs)))
# try to connect with regular client
try:
conn = tablet3.TabletConnection(
"%s:%u" %
(shard_0_master_addrs[0][0], shard_0_master_addrs[0][1]), "",
"test_keyspace", "0", 10.0)
conn.dial()
self.fail("No exception raised to secure port")
except dbexceptions.FatalError as e:
if not e.args[0][0].startswith('Unexpected EOF in handshake to'):
self.fail("Unexpected exception: %s" % str(e))
sconn = utils.get_vars(shard_0_master.port)["SecureConnections"]
if sconn != 0:
self.fail("unexpected conns %s" % sconn)
# connect to encrypted port
conn = tablet3.TabletConnection(
"%s:%u" % (shard_0_master_addrs[0][0], shard_0_master_addrs[0][1]),
"",
"test_keyspace",
"0",
5.0,
encrypted=True)
conn.dial()
(results, rowcount, lastrowid,
fields) = conn._execute("select 1 from dual", {})
self.assertEqual(results, [
(1, ),
], 'wrong conn._execute output: %s' % str(results))
sconn = utils.get_vars(shard_0_master.port)["SecureConnections"]
if sconn != 1:
self.fail("unexpected conns %s" % sconn)
saccept = utils.get_vars(shard_0_master.port)["SecureAccepts"]
if saccept == 0:
self.fail("unexpected accepts %s" % saccept)
# trigger a time out on a secure connection, see what exception we get
try:
conn._execute("select sleep(100) from dual", {})
self.fail("No timeout exception")
except dbexceptions.TimeoutError as e:
logging.debug("Got the right exception for SSL timeout: %s",
str(e))
# start a vtgate to connect to that tablet
gate_proc, gate_port, gate_secure_port = utils.vtgate_start(
tablet_bson_encrypted=True,
cert=cert_dir + "/vt-server-cert.pem",
key=cert_dir + "/vt-server-key.pem")
# try to connect to vtgate with regular client
timeout = 2.0
try:
conn = vtgatev2.connect([
"localhost:%s" % (gate_secure_port),
], timeout)
self.fail("No exception raised to VTGate secure port")
except dbexceptions.OperationalError as e:
exception_type = e.args[2]
exception_msg = str(e.args[2][0][0])
self.assertIsInstance(exception_type, dbexceptions.FatalError,
"unexpected exception type")
if not exception_msg.startswith('Unexpected EOF in handshake to'):
self.fail("Unexpected exception message: %s" % exception_msg)
sconn = utils.get_vars(gate_port)["SecureConnections"]
if sconn != 0:
self.fail("unexpected conns %s" % sconn)
# connect to vtgate with encrypted port
conn = vtgatev2.connect([
"localhost:%s" % (gate_secure_port),
],
timeout,
encrypted=True)
(results, rowcount, lastrowid, fields) = conn._execute(
"select 1 from dual", {},
"test_keyspace",
"master",
keyranges=[
keyrange.KeyRange(keyrange_constants.NON_PARTIAL_KEYRANGE),
])
self.assertEqual(rowcount, 1, "want 1, got %d" % (rowcount))
self.assertEqual(len(fields), 1, "want 1, got %d" % (len(fields)))
self.assertEqual(results, [
(1, ),
], 'wrong conn._execute output: %s' % str(results))
sconn = utils.get_vars(gate_port)["SecureConnections"]
if sconn != 1:
self.fail("unexpected conns %s" % sconn)
saccept = utils.get_vars(gate_port)["SecureAccepts"]
if saccept == 0:
self.fail("unexpected accepts %s" % saccept)
# trigger a time out on a vtgate secure connection, see what exception we get
try:
conn._execute("select sleep(4) from dual", {},
"test_keyspace",
"master",
keyranges=[
keyrange.KeyRange(
keyrange_constants.NON_PARTIAL_KEYRANGE),
])
self.fail("No timeout exception")
except dbexceptions.TimeoutError as e:
logging.debug("Got the right exception for SSL timeout: %s",
str(e))
conn.close()
utils.vtgate_kill(gate_proc)
# kill everything
utils.kill_sub_process(zkocc_server)
def run_test_zkocc():
_populate_zk()
# preload the test_nj cell
zkocc_14850 = utils.zkocc_start(
extra_params=['-connect-timeout=2s', '-cache-refresh-interval=1s'])
time.sleep(1)
# create a python client. The first address is bad, will test the retry logic
bad_port = utils.reserve_ports(3)
zkocc_client = zkocc.ZkOccConnection(
"localhost:%u,localhost:%u,localhost:%u" %
(bad_port, utils.zkocc_port_base, bad_port + 1), "test_nj", 30)
zkocc_client.dial()
# test failure for a python client that cannot connect
bad_zkocc_client = zkocc.ZkOccConnection(
"localhost:%u,localhost:%u" % (bad_port + 2, bad_port), "test_nj", 30)
try:
bad_zkocc_client.dial()
raise utils.TestError('exception expected')
except zkocc.ZkOccError as e:
if str(e) != "Cannot dial to any server":
raise utils.TestError('Unexpected exception: ', str(e))
logging.getLogger().setLevel(logging.ERROR)
try:
bad_zkocc_client.get("/zk/test_nj/zkocc1/data1")
raise utils.TestError('exception expected')
except zkocc.ZkOccError as e:
if str(e) != "Cannot dial to any server":
raise utils.TestError('Unexpected exception: ', str(e))
logging.getLogger().setLevel(logging.WARNING)
# get test
out, err = utils.run(
utils.vtroot +
'/bin/zkclient2 -server localhost:%u /zk/test_nj/zkocc1/data1' %
utils.zkocc_port_base,
trap_output=True)
if err != "/zk/test_nj/zkocc1/data1 = Test data 1 (NumChildren=0, Version=0, Cached=false, Stale=false)\n":
raise utils.TestError('unexpected get output: ', err)
zkNode = zkocc_client.get("/zk/test_nj/zkocc1/data1")
if (zkNode['Data'] != "Test data 1" or \
zkNode['Stat']['NumChildren'] != 0 or \
zkNode['Stat']['Version'] != 0 or \
zkNode['Cached'] != True or \
zkNode['Stale'] != False):
raise utils.TestError('unexpected zkocc_client.get output: ', zkNode)
# getv test
out, err = utils.run(
utils.vtroot +
'/bin/zkclient2 -server localhost:%u /zk/test_nj/zkocc1/data1 /zk/test_nj/zkocc1/data2 /zk/test_nj/zkocc1/data3'
% utils.zkocc_port_base,
trap_output=True)
if err != """[0] /zk/test_nj/zkocc1/data1 = Test data 1 (NumChildren=0, Version=0, Cached=true, Stale=false)
[1] /zk/test_nj/zkocc1/data2 = Test data 2 (NumChildren=0, Version=0, Cached=false, Stale=false)
[2] /zk/test_nj/zkocc1/data3 = Test data 3 (NumChildren=0, Version=0, Cached=false, Stale=false)
""":
raise utils.TestError('unexpected getV output: ', err)
zkNodes = zkocc_client.getv([
"/zk/test_nj/zkocc1/data1", "/zk/test_nj/zkocc1/data2",
"/zk/test_nj/zkocc1/data3"
])
if (zkNodes['Nodes'][0]['Data'] != "Test data 1" or \
zkNodes['Nodes'][0]['Stat']['NumChildren'] != 0 or \
zkNodes['Nodes'][0]['Stat']['Version'] != 0 or \
zkNodes['Nodes'][0]['Cached'] != True or \
zkNodes['Nodes'][0]['Stale'] != False or \
zkNodes['Nodes'][1]['Data'] != "Test data 2" or \
zkNodes['Nodes'][1]['Stat']['NumChildren'] != 0 or \
zkNodes['Nodes'][1]['Stat']['Version'] != 0 or \
zkNodes['Nodes'][1]['Cached'] != True or \
zkNodes['Nodes'][1]['Stale'] != False or \
zkNodes['Nodes'][2]['Data'] != "Test data 3" or \
zkNodes['Nodes'][2]['Stat']['NumChildren'] != 0 or \
zkNodes['Nodes'][2]['Stat']['Version'] != 0 or \
zkNodes['Nodes'][2]['Cached'] != True or \
zkNodes['Nodes'][2]['Stale'] != False):
raise utils.TestError('unexpected zkocc_client.getv output: ', zkNodes)
# children test
out, err = utils.run(
utils.vtroot +
'/bin/zkclient2 -server localhost:%u -mode children /zk/test_nj' %
utils.zkocc_port_base,
trap_output=True)
if err != """Path = /zk/test_nj
Child[0] = zkocc1
Child[1] = zkocc2
NumChildren = 2
CVersion = 4
Cached = false
Stale = false
""":
raise utils.TestError('unexpected children output: ', err)
# zk command tests
_check_zk_output("cat /zk/test_nj/zkocc1/data1", "Test data 1")
_check_zk_output(
"ls -l /zk/test_nj/zkocc1", """total: 3
-rw-rw-rw- zk zk 11 %s data1
-rw-rw-rw- zk zk 11 %s data2
-rw-rw-rw- zk zk 11 %s data3
""" % (_format_time(zkNodes['Nodes'][0]['Stat']['MTime']),
_format_time(zkNodes['Nodes'][1]['Stat']['MTime']),
_format_time(zkNodes['Nodes'][2]['Stat']['MTime'])))
# test /zk/local is not resolved and rejected
out, err = utils.run(
utils.vtroot +
'/bin/zkclient2 -server localhost:%u /zk/local/zkocc1/data1' %
utils.zkocc_port_base,
trap_output=True,
raise_on_error=False)
if "zkocc: cannot resolve local cell" not in err:
raise utils.TestError('unexpected get output, not local cell error: ',
err)
# start a background process to query the same value over and over again
# while we kill the zk server and restart it
outfd = tempfile.NamedTemporaryFile(dir=utils.tmp_root, delete=False)
filename = outfd.name
querier = utils.run_bg(
'/bin/bash -c "while true ; do ' + utils.vtroot +
'/bin/zkclient2 -server localhost:%u /zk/test_nj/zkocc1/data1 ; sleep 0.1 ; done"'
% utils.zkocc_port_base,
stderr=outfd.file)
outfd.close()
time.sleep(1)
# kill zk server, sleep a bit, restart zk server, sleep a bit
utils.run(
utils.vtroot + '/bin/zkctl -zk.cfg 1@' + utils.hostname +
':%u:%u:%u shutdown' %
(utils.zk_port_base, utils.zk_port_base + 1, utils.zk_port_base + 2))
time.sleep(3)
utils.run(
utils.vtroot + '/bin/zkctl -zk.cfg 1@' + utils.hostname +
':%u:%u:%u start' %
(utils.zk_port_base, utils.zk_port_base + 1, utils.zk_port_base + 2))
time.sleep(3)
utils.kill_sub_process(querier)
utils.debug("Checking " + filename)
fd = open(filename, "r")
state = 0
for line in fd:
if line == "/zk/test_nj/zkocc1/data1 = Test data 1 (NumChildren=0, Version=0, Cached=true, Stale=false)\n":
stale = False
elif line == "/zk/test_nj/zkocc1/data1 = Test data 1 (NumChildren=0, Version=0, Cached=true, Stale=true)\n":
stale = True
else:
raise utils.TestError('unexpected line: ', line)
if state == 0:
if stale:
state = 1
elif state == 1:
if not stale:
state = 2
else:
if stale:
raise utils.TestError('unexpected stale state')
if state != 2:
raise utils.TestError('unexpected ended stale state')
fd.close()
utils.zkocc_kill(zkocc_14850)
# check that after the server is gone, the python client fails correctly
logging.getLogger().setLevel(logging.ERROR)
try:
zkocc_client.get("/zk/test_nj/zkocc1/data1")
raise utils.TestError('exception expected')
except zkocc.ZkOccError as e:
if str(e) != "Cannot dial to any server":
raise utils.TestError('Unexpected exception: ', str(e))
logging.getLogger().setLevel(logging.WARNING)
UNSHARDED = [keyrange.KeyRange(keyrange_constants.NON_PARTIAL_KEYRANGE)]
# Parse args
parser = argparse.ArgumentParser()
parser.add_argument('--server', dest='server', default='localhost:15001')
parser.add_argument('--timeout', dest='timeout', type=float, default='10.0')
args = parser.parse_args()
vtgate_addrs = {"vt": [args.server]}
# Connect
conn = vtgatev2.connect(vtgate_addrs, args.timeout)
# Read topology
# This is a temporary work-around until the VTGate V2 client is topology-free.
topoconn = zkocc.ZkOccConnection(args.server, 'test', args.timeout)
topology.read_topology(topoconn)
topoconn.close()
# Insert something.
print('Inserting into master...')
cursor = conn.cursor('test_keyspace', 'master',
keyranges=UNSHARDED, writable=True)
cursor.begin()
cursor.execute(
"INSERT INTO test_table (msg) VALUES (%(msg)s)",
{'msg': 'V is for speed'})
cursor.commit()
# Read it back from the master.
def setUp(self):
self.vtgate_client = zkocc.ZkOccConnection(utils.vtgate.addr(),
'test_nj', 30.0)
topology.read_topology(self.vtgate_client)
def _read_keyspace(self, keyspace_name):
global vtgate_port
vtgate_client = zkocc.ZkOccConnection("localhost:%u" % vtgate_port,
"test_nj", 30.0)
return keyspace.read_keyspace(vtgate_client, keyspace_name)