X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Ftools%2Fab%2FABFork.py;fp=resources%2Ftools%2Fab%2FABFork.py;h=8436ed38be03adf387ec2d2bbc56c34b50b318ab;hp=0000000000000000000000000000000000000000;hb=9377c956a86e42727039d9dab8879c10c9399f4c;hpb=d4f082106d3e8cfda1c0d52bcafb177b46562944 diff --git a/resources/tools/ab/ABFork.py b/resources/tools/ab/ABFork.py new file mode 100755 index 0000000000..8436ed38be --- /dev/null +++ b/resources/tools/ab/ABFork.py @@ -0,0 +1,248 @@ +#!/usr/bin/env python3 +# Copyright (c) 2021 Intel and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""ab fork library.""" + +from multiprocessing import Pool +import subprocess +import argparse +import re + +REGEX_RPS = r"Requests per second:\s*" \ + r"(\d*\.*\S*)" +REGEX_LATENCY = r"Time per request:\s*" \ + r"(\d*\.*\S*)" +REGEX_PROCESS = r"Time per request:\s*" \ + r"(\d*\.*\S*)" +REGEX_TR = r"Transfer rate:\s*" \ + r"(\d*\.*\S*)" +REGEX_TT = r"Total transferred:\s*" \ + r"(\d*)" +REGEX_OK_NUM = r"Complete requests:\s*" \ + r"(\d*)" +REGEX_FAILED_NUM = r"Failed requests:\s*" \ + r"(\d*)" +REGEX_NUM = r"(\d*\.*\d*)(\D*)" + + +def main(): + """ main function. get option and run ab test. + + :returns: Nothing. + """ + + # Get option. + parser = argparse.ArgumentParser(description=u"Get option and run ab test") + + # Number of requests to perform. + parser.add_argument(u"-r", u"--requests", type=int, + required=True, help=u"Number of requests to perform.") + + # Server port number to use. + parser.add_argument(u"-p", u"--port", type=int, required=True, + help=u"Server port number to use.") + + # Number of clients being processed at the same time. + parser.add_argument(u"-c", u"--clients", type=int, required=True, + help=u"Number of clients being processed at " + u"the same time.") + + # Filename to be requested from the servers. + parser.add_argument(u"-f", u"--files", type=str, required=True, + help="Filename to be requested from the servers.") + + # Server ip address. + parser.add_argument(u"-i", u"--ip", type=str, required=True, + help=u"Server bind IP address.") + + # Tg ip address. + parser.add_argument(u"-g", u"--tip", type=str, required=True, + help=u"TG bind IP address.") + + # Specify SSL/TLS cipher suite. + parser.add_argument(u"-z", u"--cipher", type=str, default=u"0", + help=u"Specify SSL/TLS cipher.") + + # Specify SSL/TLS protocol. + parser.add_argument(u"-t", u"--protocol", type=str, default=u"0", + help=u"Specify SSL/TLS protocol.") + + # Mode: RPS or CPS. + parser.add_argument(u"-m", u"--mode", type=str, required=True, + help=u"Send requests mode:RPS/CPS.") + + args = parser.parse_args() + + req_num = args.requests + port = args.port + cli_num = args.clients + files = args.files + ip_address = args.ip + tg_address = args.tip + cipher = args.cipher + protocol = args.protocol + mode = args.mode + + if req_num == 0: + print(u"Failed number of req_num!") + return 1 + + # The number of processing units available to the current process. + _, cpu_num = subprocess.getstatusoutput(u"nproc --all") + cpu_num = int(cpu_num) + if cpu_num > 70: + cpu_num = 70 + + # Requests and Clients are evenly distributed on each CPU. + per_req = round(req_num / cpu_num) + per_cli = round(cli_num / cpu_num) + + # Revise rounding request, This will be in the first ab request + all_total = per_req * cpu_num + per_req_1st = per_req + (req_num - all_total) + + results = [] + # Start process pool. + pool = Pool(processes=cpu_num) + + for i in range(1, cpu_num + 1): + results.append( + pool.apply_async(one, ( + i, per_req_1st if i == 1 else per_req, per_cli, cipher, + protocol, ip_address, tg_address, files, port, mode))) + + pool.close() + pool.join() + + info_list = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + + # Statistical test results. + for res in results: + stats = res.get() + if stats: + info_list = [a + b for a, b in zip(info_list, stats)] + + # Output results. + print(f"Transfer Rate: {round(info_list[6], 2)} [Kbytes/sec]") + print(f"Latency: {round(info_list[4] / 8, 2)} ms") + print(f"Connection {mode} rate:{round(info_list[3], 2)} per sec") + print(f"Total data transferred: {round(info_list[2])} bytes") + print(f"Completed requests: {round(info_list[0])} ") + print(f"Failed requests: {round(info_list[1])} ") + + +def one(cpu, requests, clients, cipher, protocol, ip_addr, tg_addr, files, port, + mode): + """Run one test. + + :param cpu: Core number id. + :param requests: Request number. + :param clients: Clients number. + :param cipher: Specify SSL/TLS cipher suite. + :param protocol: Specify SSL/TLS protocol. + :param ip_addr: Server ip address. + :param tg_addr: Tg ip address. + :param files: Filename to be requested from the servers. + :param port: Server port. + :type cpu: int + :type requests: int + :type clients: int + :type cipher: str + :type protocol: str + :type ip_addr: str + :type tg_addr: str + :type files: str + :type port: int + :type mode: str + :returns: Test results. + :rtype: list + """ + + cmd = f"sudo -E -S taskset --cpu-list {cpu} ab -n {requests} -c {clients}" + cmd = f"{cmd} -B {tg_addr} -r " + if mode == u"rps": + cmd = f"{cmd} -k" + + if port == 80: + cmd = f"{cmd} http://{ip_addr}:{port}/{files}" + else: + cmd = f"{cmd} -Z {cipher} -f {protocol}" + cmd = f"{cmd} https://{ip_addr}:{port}/{files}" + + _, output = subprocess.getstatusoutput(cmd) + ret = _parse_output(output) + + return ret + + +def _parse_output(msg): + """Parse the stdout with the results. + + :param msg: stdout of ab. + :type msg: str + :returns: Parsed results. + :rtype: list + """ + + msg_lst = msg.splitlines(False) + + stats = [] + for line in msg_lst: + if u"Requests per second" in line: + stats.append( + _float_number(re.search(REGEX_RPS, line).group(1)) + ) + elif u"Time per request" in line: + stats.append( + _float_number(re.search(REGEX_LATENCY, line).group(1)) + ) + elif u"Transfer rate" in line: + stats.append( + _float_number(re.search(REGEX_TR, line).group(1)) + ) + elif u"Total transferred" in line: + stats.append( + _float_number(re.search(REGEX_TT, line).group(1)) + ) + elif u"Complete requests" in line: + stats.append( + _float_number(re.search(REGEX_OK_NUM, line).group(1)) + ) + elif u"Failed requests" in line: + stats.append( + _float_number(re.search(REGEX_FAILED_NUM, line).group(1)) + ) + + return stats + + +def _float_number(num): + """float value of the number. + + :param num: Number to evaluate. + :type num: str + :returns: float number. + :rtype: float + """ + + val = re.search(REGEX_NUM, num) + try: + val_num = float(val.group(1)) + except ValueError: + raise RuntimeError(u"The output of ab does not include the results.") + return val_num + + +if __name__ == "__main__": + main()