def test_upgrade(
grpc_engine_manager, # NOQA
grpc_controller, # NOQA
grpc_fixed_dir_replica1,
grpc_fixed_dir_replica2, # NOQA
grpc_extra_replica1,
grpc_extra_replica2): # NOQA
dev = get_dev(grpc_fixed_dir_replica1, grpc_fixed_dir_replica2,
grpc_controller)
offset = 0
length = 128
data = random_string(length)
verify_data(dev, offset, data)
# both set pointed to the same volume underlying
r1_url = grpc_fixed_dir_replica1.url
r2_url = grpc_fixed_dir_replica2.url
upgrade_r1_url = grpc_extra_replica1.url
upgrade_r2_url = grpc_extra_replica2.url
v = grpc_controller.volume_start(replicas=[r1_url, r2_url])
assert v.replicaCount == 2
upgrade_e = upgrade_engine(grpc_engine_manager,
LONGHORN_UPGRADE_BINARY,
ENGINE_NAME,
VOLUME_NAME,
replicas=[upgrade_r1_url, upgrade_r2_url])
assert upgrade_e.spec.binary == LONGHORN_UPGRADE_BINARY
verify_data(dev, offset, data)
grpc_controller.client_upgrade(get_process_address(upgrade_e))
wait_for_process_running(grpc_engine_manager, ENGINE_NAME)
info = grpc_controller.volume_get()
assert info.endpoint == path.join(LONGHORN_DEV_DIR, VOLUME_NAME)
# cannot start with same binary
# with pytest.raises(grpc.RpcError):
# grpc_engine_manager.engine_upgrade(
# ENGINE_NAME, LONGHORN_UPGRADE_BINARY,
# SIZE, [r1_url, r2_url])
# verify_data(dev, offset, data)
# cannot start with wrong replica, would trigger rollback
with pytest.raises(grpc.RpcError):
upgrade_engine(grpc_engine_manager, LONGHORN_BINARY, ENGINE_NAME,
VOLUME_NAME, ["random"])
verify_data(dev, offset, data)
grpc_fixed_dir_replica1 = cleanup_replica(grpc_fixed_dir_replica1)
grpc_fixed_dir_replica2 = cleanup_replica(grpc_fixed_dir_replica2)
open_replica(grpc_fixed_dir_replica1)
open_replica(grpc_fixed_dir_replica2)
e = upgrade_engine(grpc_engine_manager, LONGHORN_BINARY, ENGINE_NAME,
VOLUME_NAME, [r1_url, r2_url])
assert e.spec.binary == LONGHORN_BINARY
verify_data(dev, offset, data)
grpc_controller.client_upgrade(get_process_address(e))
wait_for_process_running(grpc_engine_manager, ENGINE_NAME)
time.sleep(3)
info = grpc_controller.volume_get()
assert info.endpoint == path.join(LONGHORN_DEV_DIR, VOLUME_NAME)
def test_engine_upgrade(pm_client, em_client): # NOQA
rs = pm_client.process_list()
assert len(rs) == 0
dir_base = "/tmp/replica"
cnt = 3
for i in range(cnt):
replica_args = []
dir = dir_base + str(i)
replica_name = REPLICA_NAME_BASE + str(i)
r = create_replica_process(pm_client,
name=replica_name,
replica_dir=dir)
assert r.spec.name == replica_name
assert r.status.state == PROC_STATE_RUNNING
r = pm_client.process_get(name=replica_name)
assert r.spec.name == replica_name
assert r.status.state == PROC_STATE_RUNNING
rs = pm_client.process_list()
assert len(rs) == i + 1
assert replica_name in rs
r = rs[replica_name]
assert r.spec.name == replica_name
assert r.status.state == PROC_STATE_RUNNING
replica_args.append("tcp://localhost:" + str(r.status.port_start))
engine_name = ENGINE_NAME_BASE + str(i)
volume_name = VOLUME_NAME_BASE + str(i)
e = create_engine_process(em_client,
name=engine_name,
volume_name=volume_name,
replicas=replica_args)
assert e.spec.name == engine_name
check_dev_existence(volume_name)
es = em_client.process_list()
assert len(es) == i + 1
assert engine_name in es
e = es[engine_name]
assert e.spec.name == engine_name
assert e.status.state == PROC_STATE_RUNNING
dir = dir_base + "0"
engine_name = ENGINE_NAME_BASE + "0"
replica_name = REPLICA_NAME_BASE + "0"
volume_name = VOLUME_NAME_BASE + "0"
replica_name_upgrade = REPLICA_NAME_BASE + "0-upgrade"
r = create_replica_process(pm_client,
name=replica_name_upgrade,
binary=LONGHORN_UPGRADE_BINARY,
replica_dir=dir)
assert r.spec.name == replica_name_upgrade
assert r.status.state == PROC_STATE_RUNNING
replicas = ["tcp://localhost:" + str(r.status.port_start)]
e = upgrade_engine(em_client, LONGHORN_UPGRADE_BINARY, engine_name,
volume_name, replicas)
assert e.spec.name == engine_name
check_dev_existence(volume_name)
r = pm_client.process_delete(name=replica_name)
assert r.spec.name == replica_name
assert r.status.state in (PROC_STATE_STOPPING, PROC_STATE_STOPPED)
wait_for_process_deletion(pm_client, replica_name)
check_dev_existence(volume_name)
wait_for_process_running(em_client, engine_name)
es = em_client.process_list()
assert engine_name in es
e = es[engine_name]
assert e.spec.name == engine_name
assert e.status.state == PROC_STATE_RUNNING
delete_process(em_client, engine_name)
wait_for_process_deletion(em_client, engine_name)
wait_for_dev_deletion(volume_name)