t/client_server.py

#!/usr/bin/env python3
"""
# client_server.py
#
# Test fio's client/server mode.
#
# USAGE
# see python3 client_server.py --help
#
# EXAMPLES
# python3 t/client_server.py
# python3 t/client_server.py -f ./fio
#
# REQUIREMENTS
# Python 3.6
#
# This will start fio server instances listening on the interfaces below and
# will break if any ports are already occupied.
#
#
"""
import os
import sys
import time
import locale
import logging
import argparse
import tempfile
import subprocess
import configparser
from pathlib import Path
from fiotestlib import FioJobCmdTest, run_fio_tests


SERVER_LIST = [
            ",8765",
            ",8766",
            ",8767",
            ",8768",
        ]

PIDFILE_LIST = []

class ClientServerTest(FioJobCmdTest):
    """
    Client/sever test class.
    """

    def setup(self, parameters):
        """Setup a test."""

        fio_args = [
            f"--output={self.filenames['output']}",
            f"--output-format={self.fio_opts['output-format']}",
        ]
        for server in self.fio_opts['servers']:
            option = f"--client={server['client']}"
            fio_args.append(option)
            fio_args.append(server['jobfile'])

        super().setup(fio_args)



class ClientServerTestGlobalSingle(ClientServerTest):
    """
    Client/sever test class.
    One server connection only.
    The job file may or may not have a global section.
    """

    def check_result(self):
        super().check_result()

        config = configparser.ConfigParser(allow_no_value=True)
        config.read(self.fio_opts['servers'][0]['jobfile'])

        if not config.has_section('global'):
            if len(self.json_data['global options']) > 0:
                self.failure_reason = f"{self.failure_reason} non-empty 'global options' dictionary found with no global section in job file."
                self.passed = False
            return

        if len(self.json_data['global options']) == 0:
            self.failure_reason = f"{self.failure_reason} empty 'global options' dictionary found with no global section in job file."
            self.passed = False

        # Now make sure job file global section matches 'global options'
        # in JSON output
        job_file_global = dict(config['global'])
        for key, value in job_file_global.items():
            if value is None:
                job_file_global[key] = ""
        if job_file_global != self.json_data['global options']:
            self.failure_reason = f"{self.failure_reason} 'global options' dictionary does not match global section in job file."
            self.passed = False


class ClientServerTestGlobalMultiple(ClientServerTest):
    """
    Client/sever test class.
    Multiple server connections.
    Job files may or may not have a global section.
    """

    def check_result(self):
        super().check_result()

        #
        # For each job file, check if it has a global section
        # If so, make sure the 'global options' array has
        # as element for it.
        # At the end, make sure the total number of elements matches the number
        # of job files with global sections.
        #

        global_sections = 0
        for server in self.fio_opts['servers']:
            config = configparser.ConfigParser(allow_no_value=True)
            config.read(server['jobfile'])

            if not config.has_section('global'):
                continue

            global_sections += 1

            # this can only parse one server spec format
            [hostname, port] = server['client'].split(',')

            match = None
            for global_opts in self.json_data['global options']:
                if 'hostname' not in global_opts:
                    continue
                if 'port' not in global_opts:
                    continue
                if global_opts['hostname'] == hostname and int(global_opts['port']) == int(port):
                    match = global_opts
                    break

            if not match:
                self.failure_reason = f"{self.failure_reason} matching 'global options' element not found for {hostname}, {port}."
                self.passed = False
                continue

            del match['hostname']
            del match['port']

            # Now make sure job file global section matches 'global options'
            # in JSON output
            job_file_global = dict(config['global'])
            for key, value in job_file_global.items():
                if value is None:
                    job_file_global[key] = ""
            if job_file_global != match:
                self.failure_reason += " 'global options' dictionary does not match global section in job file."
                self.passed = False
            else:
                logging.debug("Job file global section matches 'global options' array element %s", server['client'])

        if global_sections != len(self.json_data['global options']):
            self.failure_reason = f"{self.failure_reason} mismatched number of elements in 'global options' array."
            self.passed = False
        else:
            logging.debug("%d elements in global options array as expected", global_sections)


class ClientServerTestAllClientsLat(ClientServerTest):
    """
    Client/sever test class.
    Make sure the "All clients" job has latency percentile data.
    Assumes that a job named 'test' is run with no global section.
    Only check read data.
    """

    def check_result(self):
        super().check_result()

        config = configparser.ConfigParser(allow_no_value=True)
        config.read(self.fio_opts['servers'][0]['jobfile'])

        lats = { 'clat': True, 'lat': False, 'slat': False }
        for key in lats:
            opt = f"{key}_percentiles"
            if opt in config.options('test'):
                lats[key] = config.getboolean('test', opt)
                logging.debug("%s set to %s", opt, lats[key])

        all_clients = None
        client_stats = self.json_data['client_stats']
        for client in client_stats:
            if client['jobname'] == "All clients":
                all_clients = client
                break

        if not all_clients:
            self.failure_reason = f"{self.failure_reason} Could not find 'All clients' output"
            self.passed = False

        for key, value in lats.items():
            if value:
                if 'percentile' not in all_clients['read'][f"{key}_ns"]:
                    self.failure_reason += f" {key} percentiles not found"
                    self.passed = False
                    break

                logging.debug("%s percentiles found as expected", key)
            else:
                if 'percentile' in all_clients['read'][f"{key}_ns"]:
                    self.failure_reason += f" {key} percentiles found unexpectedly"
                    self.passed = False
                    break

                logging.debug("%s percentiles appropriately not found", key)



TEST_LIST = [
    {   # Smoke test
        "test_id": 1,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 0, # index into the SERVER_LIST array
                        "jobfile": "test01.fio",
                    },
                ]
            },
        "test_class": ClientServerTest,
    },
    {   # try another client
        "test_id": 2,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 1,
                        "jobfile": "test01.fio",
                    },
                ]
            },
        "test_class": ClientServerTest,
    },
    {   # single client global section
        "test_id": 3,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 2,
                        "jobfile": "test01.fio",
                    },
                ]
            },
        "test_class": ClientServerTestGlobalSingle,
    },
    {   # single client no global section
        "test_id": 4,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 3,
                        "jobfile": "test04-noglobal.fio",
                    },
                ]
            },
        "test_class": ClientServerTestGlobalSingle,
    },
    {   # multiple clients, some with global, some without
        "test_id": 5,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 0,
                        "jobfile": "test04-noglobal.fio",
                    },
                    {
                        "client" : 1,
                        "jobfile": "test01.fio",
                    },
                    {
                        "client" : 2,
                        "jobfile": "test04-noglobal.fio",
                    },
                    {
                        "client" : 3,
                        "jobfile": "test01.fio",
                    },
                ]
            },
        "test_class": ClientServerTestGlobalMultiple,
    },
    {   # multiple clients, all with global sections
        "test_id": 6,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 0,
                        "jobfile": "test01.fio",
                    },
                    {
                        "client" : 1,
                        "jobfile": "test01.fio",
                    },
                    {
                        "client" : 2,
                        "jobfile": "test01.fio",
                    },
                    {
                        "client" : 3,
                        "jobfile": "test01.fio",
                    },
                ]
            },
        "test_class": ClientServerTestGlobalMultiple,
    },
    {   # Enable submission latency
        "test_id": 7,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 0,
                        "jobfile": "test07-slat.fio",
                    },
                    {
                        "client" : 1,
                        "jobfile": "test07-slat.fio",
                    },
                ]
            },
        "test_class": ClientServerTestAllClientsLat,
    },
    {   # Enable completion latency
        "test_id": 8,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 0,
                        "jobfile": "test08-clat.fio",
                    },
                    {
                        "client" : 1,
                        "jobfile": "test08-clat.fio",
                    },
                ]
            },
        "test_class": ClientServerTestAllClientsLat,
    },
    {   # Enable total latency
        "test_id": 9,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 0,
                        "jobfile": "test09-lat.fio",
                    },
                    {
                        "client" : 1,
                        "jobfile": "test09-lat.fio",
                    },
                ]
            },
        "test_class": ClientServerTestAllClientsLat,
    },
    {   # Disable completion latency
        "test_id": 10,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 0,
                        "jobfile": "test10-noclat.fio",
                    },
                    {
                        "client" : 1,
                        "jobfile": "test10-noclat.fio",
                    },
                ]
            },
        "test_class": ClientServerTestAllClientsLat,
    },
    {   # Enable submission, completion, total latency
        "test_id": 11,
        "fio_opts": {
            "output-format": "json",
            "servers": [
                    {
                        "client" : 0,
                        "jobfile": "test11-alllat.fio",
                    },
                    {
                        "client" : 1,
                        "jobfile": "test11-alllat.fio",
                    },
                ]
            },
        "test_class": ClientServerTestAllClientsLat,
    },
]


def parse_args():
    """Parse command-line arguments."""

    parser = argparse.ArgumentParser()
    parser.add_argument('-d', '--debug', help='Enable debug messages', action='store_true')
    parser.add_argument('-f', '--fio', help='path to file executable (e.g., ./fio)')
    parser.add_argument('-a', '--artifact-root', help='artifact root directory')
    parser.add_argument('-s', '--skip', nargs='+', type=int,
                        help='list of test(s) to skip')
    parser.add_argument('-o', '--run-only', nargs='+', type=int,
                        help='list of test(s) to run, skipping all others')
    args = parser.parse_args()

    return args


def start_servers(fio_path, servers=SERVER_LIST):
    """Start servers for our tests."""

    for server in servers:
        tmpfile = tempfile.mktemp()
        cmd = [fio_path, f"--server={server}", f"--daemonize={tmpfile}"]
        cmd_result = subprocess.run(cmd, capture_output=True, check=False,
                                   encoding=locale.getpreferredencoding())
        if cmd_result.returncode != 0:
            logging.error("Unable to start server on %s: %s", server, cmd_result.stderr)
            return False

        logging.debug("Started server %s", server)
        PIDFILE_LIST.append(tmpfile)

    return True


def stop_servers(pidfiles=PIDFILE_LIST):
    """Stop running fio server invocations."""

    for pidfile in pidfiles:
        with open(pidfile, "r", encoding=locale.getpreferredencoding()) as file:
            pid = file.read().strip()

        cmd = ["kill", f"{pid}"]
        cmd_result = subprocess.run(cmd, capture_output=True, check=False,
                                   encoding=locale.getpreferredencoding())
        if cmd_result.returncode != 0:
            logging.error("Unable to kill server with PID %s: %s", pid, cmd_result.stderr)
            return False
        logging.debug("Sent stop signal to PID %s", pid)

    return True


def main():
    """Run tests for fio's client/server mode."""

    args = parse_args()

    if args.debug:
        logging.basicConfig(level=logging.DEBUG)
    else:
        logging.basicConfig(level=logging.INFO)

    artifact_root = args.artifact_root if args.artifact_root else \
        f"client_server-test-{time.strftime('%Y%m%d-%H%M%S')}"
    os.mkdir(artifact_root)
    print(f"Artifact directory is {artifact_root}")

    if args.fio:
        fio_path = str(Path(args.fio).absolute())
    else:
        fio_path = os.path.join(os.path.dirname(__file__), '../fio')
    print(f"fio path is {fio_path}")

    if not start_servers(fio_path):
        sys.exit(1)
    print("Servers started")

    job_path = os.path.join(os.path.dirname(__file__), "client_server")
    for test in TEST_LIST:
        opts = test['fio_opts']
        for server in opts['servers']:
            server['client'] = SERVER_LIST[server['client']]
            server['jobfile'] = os.path.join(job_path, server['jobfile'])

    test_env = {
              'fio_path': fio_path,
              'fio_root': str(Path(__file__).absolute().parent.parent),
              'artifact_root': artifact_root,
              'basename': 'client_server',
              }

    _, failed, _ = run_fio_tests(TEST_LIST, test_env, args)

    stop_servers()
    sys.exit(failed)

if __name__ == '__main__':
    main()