cfg_checker/modules/ceph/__init__.py

from cfg_checker.agent.fio_runner import get_fio_options
from cfg_checker.agent.fio_runner import seq_modes, mix_modes
from cfg_checker.common import logger_cli
from cfg_checker.common.settings import ENV_TYPE_KUBE
from cfg_checker.helpers import args_utils
from cfg_checker.modules.ceph import info, bench

command_help = "Ceph Storage information and benchmarks"
supported_envs = [ENV_TYPE_KUBE]


# def _selectClass(_env, strClassHint="checker"):
#     _class = None
#     if _env == ENV_TYPE_SALT:
#         if strClassHint == "info":
#             _class = info.SaltCephInfo
#         elif strClassHint == "bench":
#             _class = bench.SaltCephInfo
#     elif _env == ENV_TYPE_KUBE:
#         if strClassHint == "info":
#             _class = info.KubeCephInfo
#         elif strClassHint == "bench":
#             _class = bench.KubeCephBench
#     if not _class:
#         raise CheckerException(
#             "Unknown hint for selecting Ceph handler Class: '{}'".format(
#                 strClassHint
#             )
#         )
#     else:
#         return _class

def _get_param_and_log(arg, param_str):
    _value = args_utils.get_arg(arg, param_str)
    logger_cli.info("    {}={}".format(param_str, _value))
    return _value


def init_parser(_parser):
    # network subparser
    ceph_subparsers = _parser.add_subparsers(dest='type')

    ceph_info_parser = ceph_subparsers.add_parser(
        'info',
        help="Gather Ceph Cluster information"
    )

    ceph_info_parser.add_argument(
        '--detailed',
        action="store_true", default=False,
        help="Print additional details"
    )

    ceph_info_parser.add_argument(
        '--tgz',
        metavar='ceph_tgz_filename',
        help="HTML filename to save report"
    )

    ceph_report_parser = ceph_subparsers.add_parser(
        'report',
        help="Generate network check report"
    )

    ceph_report_parser.add_argument(
        '--html',
        metavar='ceph_html_filename',
        help="HTML filename to save report"
    )

    ceph_bench_parser = ceph_subparsers.add_parser(
        'bench',
        help="Run ceph benchmark"
    )

    ceph_bench_parser.add_argument(
        '--task-list',
        metavar='ceph_tasks_filename',
        help="List file with data for Ceph bench testrun"
    )
    ceph_bench_parser.add_argument(
        '--agents',
        type=int, metavar='agent_count', default=5,
        help="List file with data for Ceph bench testrun"
    )
    ceph_bench_parser.add_argument(
        '--html',
        metavar='ceph_html_filename',
        help="HTML filename to save report"
    )
    ceph_bench_parser.add_argument(
        '--storage-class',
        metavar='storage_class',
        help="Storage class to be used in benchmark"
    )
    ceph_bench_parser.add_argument(
        '--task-file',
        metavar='task_file',
        help="Task file for benchmark"
    )
    ceph_bench_parser.add_argument(
        '--no-cleanup',
        action="store_true", default=False,
        help="Do not cleanup services, agents, pvc, and pv"
    )
    ceph_bench_parser.add_argument(
        '--cleanup-only',
        action="store_true", default=False,
        help="Cleanup resources related to benchmark"
    )
    ceph_bench_parser.add_argument(
        '--dump-path',
        metavar="dump_results", default="/tmp",
        help="Dump result after each test run to use them later"
    )
    ceph_bench_parser.add_argument(
        '--name',
        metavar="name", default="cephbench",
        help="Dump result after each test run to use them later"
    )
    ceph_bench_parser.add_argument(
        '--bs',
        metavar="blocksize", default="16k",
        help="Block size for single run"
    )
    ceph_bench_parser.add_argument(
        '--iodepth',
        metavar="iodepth", default="16",
        help="IO Depth for single run"
    )
    ceph_bench_parser.add_argument(
        '--size',
        metavar="size", default="10G",
        help="Persistent volume size (M, G)"
    )
    ceph_bench_parser.add_argument(
        '--readwrite',
        metavar="readwrite", default="randrw",
        help="Test mode for single run"
    )
    ceph_bench_parser.add_argument(
        '--rwmixread',
        metavar="rwmixread", default="50",
        help="Percent of read in randon mixed mode (randrw)"
    )
    ceph_bench_parser.add_argument(
        '--ramp-time',
        metavar="ramp_time", default="5s",
        help="Warmup time before test"
    )
    ceph_bench_parser.add_argument(
        '--runtime',
        metavar="runtime", default="60s",
        help="Time based test run longevity"
    )
    ceph_bench_parser.add_argument(
        '--ioengine',
        metavar="ioengine", default="libaio",
        help="IO Engine used by fio. See eng-help output in fio for list"
    )
    ceph_bench_parser.add_argument(
        '--offset-increment',
        metavar="offset_increment", default="500M",
        help="IO Engine used by fio. See eng-help output in fio for list"
    )

    return _parser


def do_info(args, config):
    # Ceph info
    # Gather ceph info and create an archive with data
    args_utils.check_supported_env(ENV_TYPE_KUBE, args, config)
    # check tgz
    _tgzfile = "ceph_info_archive.tgz" if not args.tgz else args.tgz

    # _class = _selectClass(_env)
    ceph_info = info.KubeCephInfo(config)

    logger_cli.info("# Collecting Ceph cluster information")
    ceph_info.gather_info()

    # Debug, enable if needed to debug report generation
    # without actuall data collecting each time
    # ceph_info.dump_info()
    # ceph_info.load_info()
    # end debug

    ceph_info.generate_archive(_tgzfile)
    ceph_info.print_summary()

    return


def do_report(args, config):
    # Ceph Report
    # Gather ceph info and create HTML report with all of the data
    args_utils.check_supported_env(ENV_TYPE_KUBE, args, config)
    _filename = args_utils.get_arg(args, 'html')
    logger_cli.info("# Ceph cluster Configuration report")

    # _class = _selectClass(_env)
    ceph_info = info.KubeCephInfo(config)
    # Debug, enable if needed to debug report generation
    # without actuall data collecting each time
    # ceph_info.load_info()
    # end debug
    ceph_info.gather_info()
    ceph_info.get_transposed_latency_table()
    ceph_info.get_latest_health_readout()
    ceph_info.create_html_report(_filename)

    return


def do_bench(args, config):
    # Ceph Benchmark using multiple pods
    # if only cleanup needed do it and exit
    _cleanup_only = args_utils.get_arg(args, 'cleanup_only')
    config.resource_prefix = "cfgagent"
    if _cleanup_only:
        # Do forced resource cleanup and exit
        config.bench_mode = "cleanup"
        config.bench_agent_count = -1
        ceph_bench = bench.KubeCephBench(config)
        logger_cli.info(
            "# Discovering benchmark resources using prefix of '{}'".format(
                config.resource_prefix
            )
        )
        ceph_bench.prepare_cleanup()
        ceph_bench.cleanup()
        return

    # gather Ceph info
    logger_cli.info("# Collecting Ceph cluster information")
    ceph_info = info.KubeCephInfo(config)

    # Prepare the tasks and do synced testrun or a single one
    logger_cli.info("# Initializing ceph benchmark module")
    args_utils.check_supported_env(ENV_TYPE_KUBE, args, config)
    # Report filename
    _filename = args_utils.get_arg(args, 'html')
    # agents count option
    config.bench_agent_count = args_utils.get_arg(args, "agents")
    logger_cli.info("-> using {} agents".format(config.bench_agent_count))
    # Cleaning option
    config.no_cleaning_after_benchmark = args_utils.get_arg(args, "no_cleanup")
    # storage class
    _storage_class = args_utils.get_arg(args, "storage_class")
    logger_cli.info("-> using storage class of '{}'".format(_storage_class))
    config.bench_storage_class = _storage_class
    # dump results options
    _dump_path = args_utils.get_arg(args, "dump_path")
    if _dump_path:
        logger_cli.info("# Results will be dumped to '{}'".format(_dump_path))
        config.bench_results_dump_path = _dump_path
    else:
        logger_cli.info(
            "# No result dump path set. "
            "Consider setting it if running long task_file based test runs"
        )
        config.bench_results_dump_path = _dump_path
    # Task files or options
    _opts = get_fio_options()
    _task_file = args_utils.get_arg(args, "task_file", nofail=True)
    if not _task_file:
        logger_cli.info("-> Running single benchmark run")
        config.bench_mode = "single"
        # Updating _opts from arguments
        _params = [
            "bs",
            "iodepth",
            "size",
            "readwrite",
            "ramp_time",
            "runtime",
            "ioengine"
        ]
        for _p in _params:
            _opts[_p] = _get_param_and_log(args, _p)
        if _opts["readwrite"] in seq_modes:
            _p = "offset_increment"
            _opts[_p] = _get_param_and_log(args, _p)
        elif _opts["readwrite"] in mix_modes:
            _p = "rwmixread"
            _opts[_p] = _get_param_and_log(args, _p)
    else:
        logger_cli.info("-> running with tasks from '{}'".format(_task_file))
        config.bench_task_file = _task_file
        config.bench_mode = "tasks"
    config.bench_name = args_utils.get_arg(args, "name")
    _opts["name"] = config.bench_name
    logger_cli.info(
        "# Using '{}' as ceph bench jobs name".format(_opts["name"])
    )
    logger_cli.debug("... default/selected options for fio:")
    for _k in _opts.keys():
        # TODO: Update options for single run
        logger_cli.debug("    {} = {}".format(_k, _opts[_k]))

    # handle option inavailability from command line for single mode

    # init the Bench class
    ceph_bench = bench.KubeCephBench(config)
    ceph_bench.set_ceph_info_class(ceph_info)
    # Preload previous results for this name
    ceph_bench.preload_results()
    # Do the testrun
    ceph_bench.prepare_agents(_opts)
    ceph_bench.wait_ceph_cooldown()

    #  DEBUG of report in progress
    if not ceph_bench.run_benchmark(_opts):
        # No cleaning and/or report if benchmark was not finished
        logger_cli.info("# Abnormal benchmark run, no cleaning performed")
        return
    # Remove after DEBUG
    # ceph_bench.collect_results(_opts)
    # END DEBUG

    # Cleaning
    if not config.no_cleaning_after_benchmark:
        ceph_bench.cleanup()
    else:
        logger_cli.info(
            "# '--no-cleaning' option set. Cleaning not conducted."
        )

    # Create report
    ceph_bench.create_report(_filename)

    return