def run(self):
topology = fun_test.shared_variables["topology"]
dut_instance0 = topology.get_dut_instance(index=0)
fun_test.test_assert(dut_instance0, "Retrieved dut instance 0")
# linux_host = topology.get_tg_instance(tg_index=0)
config_file = fun_test.get_script_parent_directory(
) + "/thin_block_volume_sanity_config.json"
fun_test.log("Config file being used: {}".format(config_file))
config_dict = {}
config_dict = utils.parse_file_to_json(config_file)
# parameters required for dpcsh command execution
volume_capacity = config_dict["FunTestCase1"]["volume_params"][
"capacity"]
block_size = config_dict["FunTestCase1"]["volume_params"]["block_size"]
volume_name = config_dict["FunTestCase1"]["volume_params"]["name"]
# ns_id = config_dict["FunTestCase1"]["volume_params"]["ns_id"]
# volume_type = config_dict["FunTestCase1"]["volume_params"]["type"]
storage_controller = StorageController(
target_ip=dut_instance0.host_ip,
target_port=dut_instance0.external_dpcsh_port)
# Configuring controller
result_ip_cfg = storage_controller.ip_cfg(
ip=dut_instance0.data_plane_ip)
fun_test.test_assert(
result_ip_cfg["status"],
"ip_cfg {} on Dut Instance".format(dut_instance0.data_plane_ip))
# TODO: To add more stress, should we do multi-threading? iterator value
for iterator in xrange(0, 1001, 1):
thin_uuid = utils.generate_uuid()
# Creating Thin block volume
fun_test.log(
"============ Iteration #{} ============".format(iterator))
result_create_volume = storage_controller.create_thin_block_volume(
capacity=volume_capacity,
block_size=block_size,
uuid=thin_uuid,
name=volume_name)
fun_test.test_assert(
result_create_volume["status"],
"Iter {} - Thin Block volume is created".format(iterator))
# Deleting Thin block volume
result_delete_volume = storage_controller.delete_thin_block_volume(
capacity=volume_capacity,
uuid=thin_uuid,
block_size=block_size,
name=volume_name)
fun_test.test_assert(
result_delete_volume["status"],
"Iter {} - Thin Block volume is deleted".format(iterator))
'''
def setup(self):
testcase = self.__class__.__name__
self.need_dpc_server_start = True
# Parse configuration file
config_file = fun_test.get_script_name_without_ext() + ".json"
fun_test.log("Benchmark file being used: {}".format(config_file))
benchmark_dict = utils.parse_file_to_json(config_file)
for k, v in benchmark_dict[testcase].iteritems():
setattr(self, k, v)
# End of Config json file parsing
self.topology = fun_test.shared_variables["topology"]
self.dut = self.topology.get_dut_instance(index=0)
fun_test.test_assert(self.dut, "Retrieved dut instance 0")
self.host = self.topology.get_host_instance(dut_index=0,
interface_index=0,
host_index=0)
self.qemu = QemuStorageTemplate(host=self.host, dut=self.dut)
self.funos_running = True
# Preserving the funos-posix and qemu commandline
self.funos_cmdline = self.qemu.get_process_cmdline(
F1.FUN_OS_SIMULATION_PROCESS_NAME)
fun_test.log("\nfunos-posix commandline: {}".format(
self.funos_cmdline))
self.qemu_cmdline = self.qemu.get_process_cmdline(
DockerContainerOrchestrator.QEMU_PROCESS)
fun_test.log("\nQemu commandline: {}".format(self.qemu_cmdline))
self.qemu_cmdline = re.sub(r'(.*append)\s+(root.*mem=\d+M)(.*)',
r'\1 "\2"\3', self.qemu_cmdline)
fun_test.log("\nProcessed Qemu commandline: {}".format(
self.qemu_cmdline))
# Starting the dpc server in the qemu host
if self.need_dpc_server_start:
self.qemu.start_dpc_server()
fun_test.sleep(
"Waiting for the DPC server and DPCSH TCP proxy to settle down",
self.iter_interval)
self.need_dpc_server_start = False
self.volume_name = self.nvme_device.replace("/dev/", "") + "n" + str(
self.ns_id)
self.nvme_block_device = self.nvme_device + "n" + str(self.ns_id)
self.volume_attached = False
def run(self):
topology = fun_test.shared_variables["topology"]
dut_instance0 = topology.get_dut_instance(index=0)
fun_test.test_assert(dut_instance0, "Retrieved dut instance 0")
linux_host = topology.get_tg_instance(tg_index=0)
config_file = fun_test.get_script_parent_directory() + "/swos_3230_config.json"
fun_test.log("Config file being used: {}".format(config_file))
config_dict = utils.parse_file_to_json(config_file)
# Config parameters required for volume operations
thin_uuid = utils.generate_uuid()
volume_capacity = config_dict["FunTestCase1"]["volume_params"]["capacity"]
block_size = config_dict["FunTestCase1"]["volume_params"]["block_size"]
volume_name = config_dict["FunTestCase1"]["volume_params"]["name"]
ns_id = config_dict["FunTestCase1"]["volume_params"]["ns_id"]
storage_controller = StorageController(target_ip=dut_instance0.host_ip,
target_port=dut_instance0.external_dpcsh_port)
result_ip_cfg = storage_controller.ip_cfg(ip=dut_instance0.data_plane_ip)
fun_test.test_assert(result_ip_cfg["status"], "ip_cfg {} on Dut Instance".format(dut_instance0.data_plane_ip))
# Creating Thin volume
result_create_volume = storage_controller.create_thin_block_volume(capacity=volume_capacity,
block_size=block_size, uuid=thin_uuid,
name=volume_name)
fun_test.test_assert(result_create_volume["status"], "Thin Block volume is created")
# Attaching volume to remote server
result_attach_volume = storage_controller.volume_attach_remote(ns_id=ns_id, uuid=thin_uuid,
remote_ip=linux_host.internal_ip)
fun_test.test_assert(result_attach_volume["status"], "Thin Block volume is attached")
# Detaching volume - this should not fail or cause funos to crash
result_detach_volume = storage_controller.volume_detach_remote(ns_id=ns_id, uuid=thin_uuid,
remote_ip=dut_instance0.data_plane_ip)
fun_test.test_assert(result_detach_volume["status"], "Thin Block volume is detached")
def run(self):
topology = fun_test.shared_variables["topology"]
dut_instance0 = topology.get_dut_instance(index=0)
fun_test.test_assert(dut_instance0, "Retrieved dut instance 0")
linux_host = topology.get_tg_instance(tg_index=0)
config_file = fun_test.get_script_parent_directory(
) + "/thin_block_volume_sanity_config.json"
fun_test.log("Config file being used: {}".format(config_file))
config_dict = {}
config_dict = utils.parse_file_to_json(config_file)
# parameters required for dpcsh command execution
thin_uuid = utils.generate_uuid()
volume_capacity = config_dict["FunTestCase1"]["volume_params"][
"capacity"]
block_size = config_dict["FunTestCase1"]["volume_params"]["block_size"]
volume_name = config_dict["FunTestCase1"]["volume_params"]["name"]
ns_id = config_dict["FunTestCase1"]["volume_params"]["ns_id"]
volume_type = config_dict["FunTestCase1"]["volume_params"]["type"]
storage_controller = StorageController(
target_ip=dut_instance0.host_ip,
target_port=dut_instance0.external_dpcsh_port)
# Configuring controller
result_ip_cfg = storage_controller.ip_cfg(
ip=dut_instance0.data_plane_ip)
fun_test.test_assert(
result_ip_cfg["status"],
"ip_cfg {} on Dut Instance".format(dut_instance0.data_plane_ip))
# Creating Thin block volume
result_create_volume = storage_controller.create_thin_block_volume(
capacity=volume_capacity,
block_size=block_size,
uuid=thin_uuid,
name=volume_name)
fun_test.test_assert(result_create_volume["status"],
"Thin Block volume is created")
# Attaching volume to remote server - to linux container
result_attach_volume = storage_controller.volume_attach_remote(
uuid=thin_uuid, ns_id=ns_id, remote_ip=linux_host.internal_ip)
fun_test.test_assert(result_attach_volume["status"],
"Thin Block volume is attached")
storage_props_tree = "{}/{}/{}/{}/{}".format("storage", "volumes",
volume_type, thin_uuid,
"stats")
initial_volume_status = {}
command_result = storage_controller.peek(storage_props_tree)
fun_test.simple_assert(command_result["status"],
"Initial volume stats of DUT Instance 0")
initial_volume_status = command_result["data"]
fun_test.log("Volume Status at the beginning of the test:")
fun_test.log(initial_volume_status)
volume_status_read = command_result["data"]["num_reads"]
volume_status_write = command_result["data"]["num_writes"]
initial_counter_stat = 0
fun_test.test_assert_expected(expected=initial_counter_stat,
actual=volume_status_write,
message="Write counter is correct")
fun_test.test_assert_expected(expected=initial_counter_stat,
actual=volume_status_read,
message="Read counter is correct")
# Generating traffic from remote server using fio
destination_ip = dut_instance0.data_plane_ip
# Parameters required for fio execution
# rw_mode = config_dict["FunTestCase1"]["fio_params"]["rw_mode"]
write_mode = config_dict["FunTestCase1"]["fio_params"]["write_mode"]
read_mode = config_dict["FunTestCase1"]["fio_params"]["read_mode"]
fio_block_size = config_dict["FunTestCase1"]["fio_params"][
"fio_block_size"]
fio_iodepth = config_dict["FunTestCase1"]["fio_params"]["fio_iodepth"]
size = config_dict["FunTestCase1"]["fio_params"]["size"]
fio_result = linux_host.remote_fio(destination_ip=destination_ip,
rw=write_mode,
bs=fio_block_size,
iodepth=fio_iodepth,
size=size)
fio_result = linux_host.remote_fio(destination_ip=destination_ip,
rw=read_mode,
bs=fio_block_size,
iodepth=fio_iodepth,
size=size)
volume_status = {}
command_result = storage_controller.peek(storage_props_tree)
fun_test.simple_assert(command_result["status"],
"Volume stats of DUT Instance 0 after IO")
volume_status = command_result["data"]
fun_test.log(volume_status)
volume_status_write = command_result["data"]["num_writes"]
volume_status_read = command_result["data"]["num_reads"]
expected_counter_stat = int(filter(str.isdigit, str(size))) / int(
filter(str.isdigit, str(fio_block_size)))
fun_test.log(expected_counter_stat)
fun_test.test_assert_expected(expected=expected_counter_stat,
actual=volume_status_write,
message="Write counter is correct")
fun_test.test_assert_expected(expected=expected_counter_stat,
actual=volume_status_read,
message="Read counter is correct")
# F1 restart - simulated by killing dpcsh and dpc-server then starting them again
storage_controller.disconnect()
# TODO: Create generic function to restart F1
dut_instance0.command("pkill dpcsh")
fun_test.sleep(message="sleeping for 1s.. zzzz", seconds=1)
dut_instance0.command("pkill funos")
fun_test.sleep(message="sleeping for 1s.. zzzz", seconds=1)
dut_instance0.command(
"//funos-posix app=mdt_test nvfile=nvfile &> /tmp/f1.log.txt")
fun_test.sleep(message="Sleeping 5sec.. zzzz", seconds=5)
dut_instance0.command(
"nohup //funos-posix --dpc-server app=load_mods >&/tmp/f1.log.txt &"
)
fun_test.sleep(message="Sleeping 5sec.. zzzz", seconds=5)
dut_instance0.command(
"nohup //dpcsh --tcp_proxy=5000 >&/tmp/dpcsh_proxy.log.txt &")
fun_test.sleep(message="Sleeping 5sec.. zzzz", seconds=5)
storage_controller = StorageController(
target_ip=dut_instance0.host_ip,
target_port=dut_instance0.external_dpcsh_port)
# Configuring controller
result_ip_cfg = storage_controller.ip_cfg(
ip=dut_instance0.data_plane_ip)
fun_test.test_assert(
result_ip_cfg["status"],
"ip_cfg {} on Dut Instance".format(dut_instance0.data_plane_ip))
# Attaching volume to remote server - to linux container
# TODO: BLT volume should not require re-attaching on restart F1 should automatic mount/attach the volume -
# Refer SWOS-3226
result_attach_volume = storage_controller.volume_attach_remote(
uuid=thin_uuid, ns_id=ns_id, remote_ip=linux_host.internal_ip)
fun_test.test_assert(result_attach_volume["status"],
"Thin Block volume is attached")
fio_result = linux_host.remote_fio(destination_ip=destination_ip,
rw=read_mode,
bs=fio_block_size,
iodepth=fio_iodepth,
size=size)
volume_status = {}
command_result = storage_controller.peek(storage_props_tree)
fun_test.simple_assert(command_result["status"],
"Volume stats of DUT Instance 0 after IO")
volume_status = command_result["data"]
fun_test.log(volume_status)
volume_status_write = command_result["data"]["num_writes"]
volume_status_read = command_result["data"]["num_reads"]
expected_counter_stat = int(filter(str.isdigit, str(size))) / int(
filter(str.isdigit, str(fio_block_size)))
fun_test.log(expected_counter_stat)
fun_test.test_assert_expected(expected=expected_counter_stat,
actual=volume_status_read,
message="Read counter is correct")
result_detach_volume = storage_controller.volume_detach_remote(
ns_id=ns_id, uuid=thin_uuid, remote_ip=linux_host.internal_ip)
fun_test.test_assert(result_detach_volume["status"],
"Thin Block volume is detached")
command_result = storage_controller.peek(storage_props_tree)
fun_test.log(command_result)
fun_test.test_assert_expected(expected=True,
actual=command_result["status"],
message="Volume is detached")
result_delete_volume = storage_controller.delete_thin_block_volume(
capacity=volume_capacity,
uuid=thin_uuid,
block_size=block_size,
name=volume_name)
fun_test.test_assert(result_delete_volume["status"],
"Thin Block volume is deleted")
command_result = storage_controller.peek(storage_props_tree)
fun_test.log(command_result)
fun_test.test_assert_expected(expected=False,
actual=command_result["status"],
message="Stat and Counters are "
"reset after deleting "
"volume")
def run(self):
topology = fun_test.shared_variables["topology"]
dut_instance0 = topology.get_dut_instance(index=0)
fun_test.test_assert(dut_instance0, "Retrieved dut instance 0")
linux_host = topology.get_tg_instance(tg_index=0)
config_file = fun_test.get_script_parent_directory() + "/funos_posix_basic_flow_config.json"
fun_test.log("Config file being used: {}".format(config_file))
config_dict = {}
config_dict = utils.parse_file_to_json(config_file)
# parameters required for dpcsh command execution
thin_uuid = utils.generate_uuid()
volume_capacity = config_dict["FunTestCase1"]["volume_params"]["capacity"]
block_size = config_dict["FunTestCase1"]["volume_params"]["block_size"]
volume_name = config_dict["FunTestCase1"]["volume_params"]["name"]
ns_id = config_dict["FunTestCase1"]["volume_params"]["ns_id"]
volume_type = config_dict["FunTestCase1"]["volume_params"]["type"]
use_ls = config_dict["FunTestCase1"]["volume_params"]["use_ls"]
storage_controller = StorageController(target_ip=dut_instance0.host_ip,
target_port=dut_instance0.external_dpcsh_port)
# Configuring controller
result_ip_cfg = storage_controller.ip_cfg(ip=dut_instance0.data_plane_ip)
fun_test.test_assert(result_ip_cfg["status"], "ip_cfg {} on Dut Instance".format(dut_instance0.data_plane_ip))
# Creating Thin block volume with log_store enabled
result_create_volume = storage_controller.create_thin_block_volume(capacity=volume_capacity,
block_size=block_size, uuid=thin_uuid,
name=volume_name, use_ls=use_ls)
fun_test.test_assert(result_create_volume["status"], "Thin Block volume is created")
# Attaching volume to remote server - to linux container
result_attach_volume = storage_controller.volume_attach_remote(uuid=thin_uuid, ns_id= ns_id,
remote_ip=linux_host.internal_ip)
fun_test.test_assert(result_attach_volume["status"], "Thin Block volume is attached")
storage_props_tree = "{}/{}/{}/{}".format("storage", "volumes", volume_type, thin_uuid)
initial_volume_status = {}
command_result = storage_controller.peek(storage_props_tree)
fun_test.simple_assert(command_result["status"], "Initial volume stats of DUT Instance 0")
initial_volume_status = command_result["data"]
fun_test.log("Volume Status at the beginning of the test:")
fun_test.log(initial_volume_status)
volume_status_read = command_result["data"]["num_reads"]
volume_status_write = command_result["data"]["num_writes"]
initial_counter_stat = 0
fun_test.test_assert_expected(expected=initial_counter_stat, actual=volume_status_write,
message="Write counter is correct")
fun_test.test_assert_expected(expected=initial_counter_stat, actual=volume_status_read,
message="Read counter is correct")
# Generating traffic from remote server using fio
destination_ip = dut_instance0.data_plane_ip
# Parameters required for fio execution
# rw_mode = config_dict["FunTestCase1"]["fio_params"]["rw_mode"]
write_mode = config_dict["FunTestCase1"]["fio_params"]["write_mode"]
read_mode = config_dict["FunTestCase1"]["fio_params"]["read_mode"]
fio_block_size = config_dict["FunTestCase1"]["fio_params"]["fio_block_size"]
fio_iodepth = config_dict["FunTestCase1"]["fio_params"]["fio_iodepth"]
size = config_dict["FunTestCase1"]["fio_params"]["size"]
fio_result = linux_host.remote_fio(destination_ip=destination_ip, rw=write_mode,
bs=fio_block_size, iodepth=fio_iodepth, size=size)
fio_result = linux_host.remote_fio(destination_ip=destination_ip, rw=read_mode,
bs=fio_block_size, iodepth=fio_iodepth, size=size)
volume_status = {}
command_result = storage_controller.peek(storage_props_tree)
fun_test.simple_assert(command_result["status"], "Volume stats of DUT Instance 0 after IO")
volume_status = command_result["data"]
fun_test.log(volume_status)
volume_status_write = command_result["data"]["num_writes"]
volume_status_read = command_result["data"]["num_reads"]
expected_counter_stat = int(filter(str.isdigit, str(size)))/int(filter(str.isdigit, str(fio_block_size)))
fun_test.log(expected_counter_stat)
fun_test.test_assert_expected(expected=expected_counter_stat, actual=volume_status_write,
message="Write counter is correct")
fun_test.test_assert_expected(expected=expected_counter_stat, actual=volume_status_read,
message="Read counter is correct")
result_detach_volume = storage_controller.volume_detach_remote(ns_id=ns_id, uuid=thin_uuid,
remote_ip=linux_host.internal_ip)
fun_test.test_assert(result_detach_volume["status"], "Thin Block volume is detached")
result_delete_volume = storage_controller.delete_thin_block_volume(capacity=volume_capacity, uuid=thin_uuid,
block_size=block_size, name=volume_name)
fun_test.test_assert(result_delete_volume["status"], "Thin Block volume is deleted")
