Exemple #1
0
    def get_trace_statistics(trace_path: str, dev_path: str = "", shortcut: bool = False) -> list:
        """
        Get statistics of particular trace

        :param trace_path: trace path
        :param dev_path: path of device which should be retrieved
        :param shortcut: Use shorter command
        :type trace_path: str
        :type shortcut: bool
        :return: If @dev_path specified - trace statistics, list of trace stats otherwise
        :raises Exception: if statistics are invalid
        """
        command = 'iotrace' + (' -P' if shortcut else ' --trace-parser')
        command += ' -S' if shortcut else ' --statistics'
        command += (' -p ' if shortcut else ' --path ') + f'{trace_path}'
        command += (' -f ' if shortcut else ' --format ') + 'json'

        output = TestRun.executor.run(command)
        if output.stdout == "":
            raise CmdException("Invalid IO statistics", output)

        if dev_path == "":
            return parse_json(output.stdout)[0]['statistics']

        expected_device_name  = dev_path.split('/dev/')[1].replace("/","")

        for trace_stat in parse_json(output.stdout)[0]['statistics']:
            traced_device = trace_stat["desc"]["device"]["name"]
            if  traced_device == expected_device_name:
                return trace_stat

        raise CmdException(f"No trace stats for device {dev_path}", output)
Exemple #2
0
def install_opencas():
    TestRun.LOGGER.info("Copying Open CAS repository to DUT")
    TestRun.executor.rsync(f"{TestRun.usr.repo_dir}/",
                           f"{TestRun.usr.working_dir}/",
                           exclude_list=["test/functional/results/"],
                           delete=True)

    TestRun.LOGGER.info("Building Open CAS")
    output = TestRun.executor.run(f"cd {TestRun.usr.working_dir} && "
                                  "./configure && "
                                  "make -j")
    if output.exit_code != 0:
        raise CmdException("Make command executed with nonzero status", output)

    TestRun.LOGGER.info("Installing Open CAS")
    output = TestRun.executor.run(f"cd {TestRun.usr.working_dir} && "
                                  f"make install")
    if output.exit_code != 0:
        raise CmdException("Error while installing Open CAS", output)

    TestRun.LOGGER.info("Check if casadm is properly installed.")
    output = TestRun.executor.run("casadm -V")
    if output.exit_code != 0:
        raise CmdException("'casadm -V' command returned an error", output)
    else:
        TestRun.LOGGER.info(output.stdout)
    def get_lba_histogram(trace_path: str,
                          bucket_size: Size = Size(0, Unit.Byte),
                          subrange_start: int = 0,
                          subrange_end: int = 0,
                          shortcut: bool = False) -> list:
        """
        Get lba histogram of given trace path

        :param trace_path: trace path
        :param bucket_size: bucket size
        :param subrange_start: subrange start
        :param subrange_end: subrange end
        :param shortcut: Use shorter command
        :type trace_path: str
        :type bucket_size: Size
        :type subrange_start: int
        :type subrange_end: int
        :type shortcut: bool
        :return: LBA histogram
        :raises Exception: if iotrace command or histogram is invalid
        """
        bucket_size_range = range(1, 4294967296)
        subrange_range = range(1, 9223372036854775808)
        if subrange_start and subrange_end:
            if subrange_start > subrange_end:
                subrange_start, subrange_end = subrange_end, subrange_start

        command = 'iotrace' + (' -P' if shortcut else ' --trace-parser')
        command += ' -B' if shortcut else ' --lba-histogram'
        command += (' -p ' if shortcut else ' --path ') + f'{trace_path}'

        if bucket_size is not None:
            if int(bucket_size.get_value(Unit.Byte)) not in bucket_size_range:
                raise CmdException(
                    f"Given size is out of range {bucket_size_range}.")
            command += ' -b ' if shortcut else ' --bucket-size '
            command += f'{int(bucket_size.get_value(Unit.Byte))}'

        if subrange_start is not None:
            if subrange_start not in subrange_range:
                raise CmdException(
                    f"Given start position is out of range {subrange_range}.")
            command += ' -s ' if shortcut else ' --subrange-start '
            command += f'{subrange_start}'

        if subrange_end is not None:
            if subrange_end not in subrange_range:
                raise CmdException(
                    f"Given end position is out of range {subrange_range}.")
            command += ' -e ' if shortcut else ' --subrange-end '
            command += f'{subrange_end}'
        command += (' -f ' if shortcut else ' --format ') + 'json'

        output = TestRun.executor.run(command)
        if output.stdout == "":
            raise CmdException("Invalid histogram", output)

        return parse_json(output.stdout)
Exemple #4
0
def uninstall_opencas():
    TestRun.LOGGER.info("Uninstalling Open CAS")
    output = TestRun.executor.run("casadm -V")
    if output.exit_code != 0:
        raise CmdException("Open CAS is not properly installed", output)
    else:
        TestRun.executor.run(f"cd {TestRun.usr.working_dir} && "
                             f"make uninstall")
        if output.exit_code != 0:
            raise CmdException("There was an error during uninstall process",
                               output)
Exemple #5
0
def install_opencas():
    TestRun.LOGGER.info("Installing Open CAS")
    output = TestRun.executor.run(f"cd {TestRun.usr.working_dir} && "
                                  f"make install")
    if output.exit_code != 0:
        raise CmdException("Error while installing Open CAS", output)

    TestRun.LOGGER.info("Check if casadm is properly installed.")
    output = TestRun.executor.run("casadm -V")
    if output.exit_code != 0:
        raise CmdException("'casadm -V' command returned an error", output)
    else:
        TestRun.LOGGER.info(output.stdout)
def set_param_cleaning_acp(cache_id: int, wake_up: int = None, flush_max_buffers: int = None):
    output = TestRun.executor.run(
        set_param_cleaning_acp_cmd(cache_id=str(cache_id), wake_up=str(wake_up),
                                   flush_max_buffers=str(flush_max_buffers)))
    if output.exit_code != 0:
        raise CmdException("Error while setting acp cleaning policy parameters.", output)
    return output
Exemple #7
0
    def get_trace_events(trace_path: str, raw: bool = False, shortcut: bool = False) -> list:
        """
        Get all trace events of given trace path

        :param trace_path: trace path
        :param raw: output without processing
        :param shortcut: Use shorter command
        :type trace_path: str
        :type raw: bool
        :type shortcut: bool
        :return: trace events
        :raises Exception: if traces are invalid
        """
        command = 'iotrace' + (' -P' if shortcut else ' --trace-parser')
        command += ' -P' if shortcut else ' --io'
        command += (' -p ' if shortcut else ' --path ') + f'{trace_path}'
        command += (' -f ' if shortcut else ' --format ') + 'json'

        if raw:
            command += ' -r ' if shortcut else ' --raw '

        output = TestRun.executor.run(command)
        if output.stdout == "":
            raise CmdException("Invalid traces", output)

        return parse_json(output.stdout)
Exemple #8
0
def _clean_opencas_repo():
    TestRun.LOGGER.info("Cleaning Open CAS repo")
    output = TestRun.executor.run(
        f"cd {TestRun.usr.working_dir} && "
        "make distclean")
    if output.exit_code != 0:
        raise CmdException("make distclean command executed with nonzero status", output)
Exemple #9
0
def remove_detached(core_device: Device, shortcut: bool = False):
    output = TestRun.executor.run(
        remove_detached_cmd(core_device=core_device.system_path,
                            shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Failed to remove detached core.", output)
    return output
Exemple #10
0
def print_version(output_format: OutputFormat = None, shortcut: bool = False):
    _output_format = None if output_format is None else output_format.name
    output = TestRun.executor.run(
        version_cmd(output_format=_output_format, shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Failed to print version.", output)
    return output
Exemple #11
0
def list_caches(output_format: OutputFormat = None, shortcut: bool = False):
    _output_format = None if output_format is None else output_format.name
    output = TestRun.executor.run(
        list_cmd(output_format=_output_format, shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Failed to list caches.", output)
    return output
Exemple #12
0
def build_opencas():
    TestRun.LOGGER.info("Building Open CAS")
    output = TestRun.executor.run(f"cd {TestRun.usr.working_dir} && "
                                  "./configure && "
                                  "make -j")
    if output.exit_code != 0:
        raise CmdException("Make command executed with nonzero status", output)
Exemple #13
0
def reset_counters(cache_id: int, core_id: int = None, shortcut: bool = False):
    _core_id = None if core_id is None else str(core_id)
    output = TestRun.executor.run(
        reset_counters_cmd(cache_id=str(cache_id), core_id=_core_id, shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Failed to reset counters.", output)
    return output
Exemple #14
0
def print_statistics(cache_id: int,
                     core_id: int = None,
                     per_io_class: bool = False,
                     io_class_id: int = None,
                     filter: List[StatsFilter] = None,
                     output_format: OutputFormat = None,
                     shortcut: bool = False):
    _output_format = None if output_format is None else output_format.name
    _core_id = None if core_id is None else str(core_id)
    _io_class_id = None if io_class_id is None else str(io_class_id)
    if filter is None:
        _filter = filter
    else:
        names = (x.name for x in filter)
        _filter = ",".join(names)
    output = TestRun.executor.run(
        print_statistics_cmd(cache_id=str(cache_id),
                             core_id=_core_id,
                             per_io_class=per_io_class,
                             io_class_id=_io_class_id,
                             filter=_filter,
                             output_format=_output_format,
                             shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Printing statistics failed.", output)
    return output
Exemple #15
0
def load_cache(device: Device, shortcut: bool = False):
    output = TestRun.executor.run(
        load_cmd(cache_dev=device.system_path, shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Failed to load cache.", output)

    return Cache(device)
Exemple #16
0
def start_cache(cache_dev: Device,
                cache_mode: CacheMode = None,
                cache_line_size: CacheLineSize = None,
                cache_id: int = None,
                force: bool = False,
                load: bool = False,
                shortcut: bool = False,
                kernel_params: KernelParameters = KernelParameters()):
    if kernel_params != KernelParameters.read_current_settings():
        reload_kernel_module("cas_cache",
                             kernel_params.get_parameter_dictionary())

    _cache_line_size = None if cache_line_size is None else str(
        int(cache_line_size.value.get_value(Unit.KibiByte)))
    _cache_id = None if cache_id is None else str(cache_id)
    _cache_mode = None if cache_mode is None else cache_mode.name.lower()
    output = TestRun.executor.run(
        start_cmd(cache_dev=cache_dev.path,
                  cache_mode=_cache_mode,
                  cache_line_size=_cache_line_size,
                  cache_id=_cache_id,
                  force=force,
                  load=load,
                  shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Failed to start cache.", output)
    return Cache(cache_dev)
Exemple #17
0
def detach_core(cache_id: int, core_id: int):
    output = TestRun.executor.run(
        script_detach_core_cmd(str(cache_id), str(core_id)))
    if output.exit_code != 0:
        raise CmdException("Failed to execute detach core script command.",
                           output)
    return output
Exemple #18
0
def try_add(core_device: Device, cache_id: int, core_id: int = None):
    output = TestRun.executor.run(
        script_try_add_cmd(str(cache_id), core_device.path,
                           str(core_id) if core_id is not None else None))
    if output.exit_code != 0:
        raise CmdException("Failed to execute try add script command.", output)
    return Core(core_device.path, cache_id)
Exemple #19
0
def get_param_cleaning(cache_id: int, output_format: OutputFormat = None, shortcut: bool = False):
    _output_format = None if output_format is None else output_format.name
    output = TestRun.executor.run(
        get_param_cleaning_cmd(cache_id=str(cache_id), output_format=_output_format,
                               shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Getting cleaning policy params failed.", output)
    return output
def add_core(cache: Cache, core_dev: Device, core_id: int = None, shortcut: bool = False):
    _core_id = None if core_id is None else str(id)
    output = TestRun.executor.run(
        add_core_cmd(cache_id=str(cache.cache_id), core_dev=core_dev.system_path,
                     core_id=_core_id, shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Failed to add core.", output)
    return Core(core_dev.system_path, cache.cache_id)
Exemple #21
0
def stop_all_caches():
    if "No caches running" in list_caches().stdout:
        return
    TestRun.LOGGER.info("Stop all caches")
    casctl_stop()
    output = list_caches()
    if "No caches running" not in output.stdout:
        raise CmdException("Error while stopping caches.", output)
Exemple #22
0
 def get_io_stats(device_id):
     stats_output = TestRun.executor.run_expect_success(
         f"cat /proc/diskstats | grep '{device_id} '")
     if not stats_output.stdout.strip():
         raise CmdException(
             "Failed to get statistics for device " + device_id,
             stats_output)
     return IoStats.parse(stats_line=stats_output.stdout.splitlines()[0])
Exemple #23
0
def list_io_classes(cache_id: int, output_format: OutputFormat, shortcut: bool = False):
    _output_format = None if output_format is None else output_format.name
    output = TestRun.executor.run(
        list_io_classes_cmd(cache_id=str(cache_id),
                            output_format=_output_format, shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("List IO class command failed.", output)
    return output
Exemple #24
0
def load_io_classes(cache_id: int, file: str, shortcut: bool = False):
    output = TestRun.executor.run(
        load_io_classes_cmd(cache_id=str(cache_id),
                            file=file,
                            shortcut=shortcut))
    if output.exit_code != 0:
        raise CmdException("Load IO class command failed.", output)
    return output
Exemple #25
0
 def execute_unplug_command(self):
     if TestRun.executor.run(
             f"echo 1 > /sys/block/{self.device_name}/device/remove"
     ).exit_code != 0:
         output = TestRun.executor.run(
             f"echo 1 > /sys/block/{self.device_name}/device/device/remove")
         if output.exit_code != 0:
             raise CmdException(f"Failed to unplug PCI disk using sysfs.",
                                output)
Exemple #26
0
 def run_expect_fail(self,
                     command,
                     timeout: timedelta = timedelta(minutes=30)):
     output = self.run(command)
     if output.exit_code == 0:
         raise CmdException(
             f"Command '{command}' executed properly but error was expected.",
             output)
     return output
def set_param_cleaning_alru(cache_id: int, wake_up: int = None, staleness_time: int = None,
                            flush_max_buffers: int = None, activity_threshold: int = None):
    output = TestRun.executor.run(
        set_param_cleaning_alru_cmd(
            cache_id=str(cache_id), wake_up=str(wake_up), staleness_time=str(staleness_time),
            flush_max_buffers=str(flush_max_buffers), activity_threshold=str(activity_threshold)))
    if output.exit_code != 0:
        raise CmdException("Error while setting alru cleaning policy parameters.", output)
    return output
def run_as_other_user(command, user: str, sudo: bool = False):
    prefix = f'sudo -u {user}'
    if sudo:
        command = 'sudo ' + command
    command = f'{prefix} {command}'
    output = TestRun.executor.run(command)
    if output.exit_code != 0 or output.stderr is not "":
        raise CmdException("Must be run as root.", output)
    return output
Exemple #29
0
def stop_all_caches():
    if "No caches running" in list_caches().stdout:
        return
    TestRun.LOGGER.info("Stop all caches")
    stop_output = casctl_stop()
    caches_output = list_caches()
    if "No caches running" not in caches_output.stdout:
        raise CmdException(f"Error while stopping caches. "
                           f"Listing caches: {caches_output}", stop_output)
Exemple #30
0
def flush(cache_id: int, core_id: int = None, shortcut: bool = False):
    if core_id is None:
        command = flush_cache_cmd(cache_id=str(cache_id), shortcut=shortcut)
    else:
        command = flush_core_cmd(cache_id=str(cache_id), core_id=str(core_id), shortcut=shortcut)
    output = TestRun.executor.run(command)
    if output.exit_code != 0:
        raise CmdException("Flushing failed.", output)
    return output