# Copyright (c) 2017 Cisco 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.

import socket
import multiprocessing
import argparse
from time import time


class Counter(object):
    """Counter used for stats collection."""
    def __init__(self, start=0):
        """Initializer."""
        self.lock = multiprocessing.Lock()
        self.value = start

    def increment(self, value=1):
        """Increment counter and return the new value."""
        self.lock.acquire()
        val = self.value
        try:
            self.value += value
        finally:
            self.lock.release()
        return val


class timer(object):
    """Timer used used during test execution."""
    def __init__(self, verbose=False):
        self.verbose = verbose

    def __enter__(self):
        """Start the timer."""
        self.start = time()
        return self

    def __exit__(self, *args):
        """Stop the timer and save current value."""
        self.end = time()
        self.secs = self.end - self.start
        self.msecs = self.secs * 1000  # millisecs
        if self.verbose:
            print("elapsed time: {0} ms".format(self.msecs))


class ConfigBlaster(object):
    """Generates Netconf requests, receives replies and collects statistics."""

    TIMEOUT = 10

    # Hello message with capabilities list for Netconf sessions.
    hello = u"""<hello xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"
    message-id="m-0">
    <capabilities>
    <capability>urn:ietf:params:netconf:base:1.0</capability>
    </capabilities>
    </hello>
    ]]>]]>"""

    # RPC to retrieve VPP version (minimal processing in VPP)
    request_template = u"""<rpc xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"
    message-id="m-1">
    <get>
    <filter xmlns:ns0="urn:ietf:params:xml:ns:netconf:base:1.0"
    ns0:type="subtree">
    <vpp-state xmlns="urn:opendaylight:params:xml:ns:yang:vpp:management">
    <version/>
    </vpp-state>
    </filter>
    </get>
    </rpc>
    ]]>]]>"""

    class Stats(object):
        """Stores and further processes statistics collected by worker
        threads during their execution.
        """

        def __init__(self):
            """Initializer."""
            self.ok_rqst_rate = Counter(0)
            self.total_rqst_rate = Counter(0)
            self.ok_rqsts = Counter(0)
            self.total_rqsts = Counter(0)

        def process_stats(self, rqst_stats, elapsed_time):
            """Calculates the stats for request/reply throughput, and aggregates
            statistics across all threads.

            :param rqst_stats: Request statistics dictionary.
            :param elapsed_time: Elapsed time for the test.
            :type rqst_stats: dict
            :type elapsed_time: int
            :returns: Rates (requests/sec) for successfully finished requests
                     and the total number of requests.
            :rtype: tuple
            """
            ok_rqsts = rqst_stats["OK"]
            total_rqsts = sum(rqst_stats.values())

            ok_rqst_rate = ok_rqsts / elapsed_time
            total_rqst_rate = total_rqsts / elapsed_time

            self.ok_rqsts.increment(ok_rqsts)
            self.total_rqsts.increment(total_rqsts)

            self.ok_rqst_rate.increment(ok_rqst_rate)
            self.total_rqst_rate.increment(total_rqst_rate)

            return ok_rqst_rate, total_rqst_rate

        @property
        def get_ok_rqst_rate(self):
            return self.ok_rqst_rate.value

        @property
        def get_total_rqst_rate(self):
            return self.total_rqst_rate.value

        @property
        def get_ok_rqsts(self):
            return self.ok_rqsts.value

        @property
        def get_total_rqsts(self):
            return self.total_rqsts.value

    def __init__(self, host, port, ncycles, nthreads, nrequests):
        """Initializer.

        :param host: Target IP address.
        :param port: Target port.
        :param ncycles: Number of test cycles.
        :param nthreads: Number of threads for packet generation.
        :param nrequests: Number of requests to send per thread.
        :type host: str
        :type port: int
        :type ncycles: int
        :type nthreads: int
        :type nrequests: int
        """

        self.host = host
        self.port = port
        self.ncycles = ncycles
        self.nthreads = nthreads
        self.nrequests = nrequests

        self.stats = self.Stats()
        self.total_ok_rqsts = 0

        self.print_lock = multiprocessing.Lock()
        self.cond = multiprocessing.Condition()
        self.threads_done = 0

        self.recv_buf = 8192

    def send_request(self, sock):
        """Send Netconf request and receive the reply.

        :param sock: Socket object to use for transfer.
        :type sock: socket object
        :returns: Response to request or error message.
        :rtype: str
        """

        sock.send(self.request_template)
        try:
            return sock.recv(self.recv_buf)
        except socket.timeout:
            return "timeout"
        except socket.error:
            return "error"

    def send_requests(self, tid, stats):
        """Read entries from the Honeycomb operational data store. This function
        is executed by a worker thread.

        :param tid: Thread ID - used to id the Blaster thread when
        statistics for the thread are printed out.
        :param stats: Synchronized queue object for returning execution stats.
        :type tid: int
        :type stats: multiprocessing.Queue
        """

        rqst_stats = {"OK": 0, "Error": 0, "Timeout": 0}

        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(5)
        # Initiate connection
        sock.connect((self.host, self.port))
        # Send hello message
        sock.send(self.hello)
        # Receive hello message
        sock.recv(self.recv_buf)
        # Determine length of expected responses
        self.recv_buf = len(self.send_request(sock))

        with self.print_lock:
            print("\n    Thread {0}:\n"
                  "        Sending {1} requests".format(tid,
                                                        self.nrequests))

        replies = [None]*self.nrequests
        with timer() as t:
            for x in range(self.nrequests):
                sts = self.send_request(sock)
                replies[x] = sts

        for reply in replies:
            if reply == "timeout":
                rqst_stats["Timeout"] += 1
            elif "error" in reply:
                rqst_stats["Error"] += 1
            else:
                rqst_stats["OK"] += 1

        ok_rps, total_rps = self.stats.process_stats(
            rqst_stats, t.secs)

        with self.print_lock:
            print("\n    Thread {0} results (READ): ".format(tid))
            print("        Elapsed time: {0:.2f}s,".format(t.secs))
            print("        Requests/s: {0:.2f} OK, {1:.2f} Total".format(
                ok_rps, total_rps))
            print("        Stats ({Requests}, {entries}): "),
            print(rqst_stats)
            self.threads_done += 1

        sock.close()

        stats.put({"stats": rqst_stats, "time": t.secs})

        with self.cond:
            self.cond.notify_all()

    def run_cycle(self, function):
        """Runs a test cycle. Each test consists of <cycles> test cycles, where
        <threads> worker threads are started in each test cycle. Each thread
        reads <requests> entries using Netconf RPCs.

        :param function: Function to be executed in each thread.
        :type function: function
        :return: None
        """

        self.total_ok_rqsts = 0
        stats_queue = multiprocessing.Queue()

        for c in range(self.ncycles):
            self.stats = self.Stats()
            with self.print_lock:
                print "\nCycle {0}:".format(c)

            threads = []
            thread_stats = []
            for i in range(self.nthreads):
                t = multiprocessing.Process(target=function,
                                            args=(i, stats_queue))
                threads.append(t)
                t.start()

            # Wait for all threads to finish and measure the execution time
            with timer() as t:
                for _ in threads:
                    thread_stats.append(stats_queue.get())
                for thread in threads:
                    thread.join()

            for item in thread_stats:
                self.stats.process_stats(item["stats"], item["time"])

            with self.print_lock:
                print("\n*** Test summary:")
                print("    Elapsed time:    {0:.2f}s".format(t.secs))
                print(
                    "    Peak requests/s: {0:.2f} OK, {1:.2f} Total".format(
                        self.stats.get_ok_rqst_rate,
                        self.stats.get_total_rqst_rate))
                print(
                    "    Avg. requests/s: {0:.2f} OK, {1:.2f} Total ({2:.2f} "
                    "of peak total)".format(
                        self.stats.get_ok_rqsts / t.secs,
                        self.stats.get_total_rqsts / t.secs,
                        (self.stats.get_total_rqsts / t.secs * 100) /
                        self.stats.get_total_rqst_rate))

            self.total_ok_rqsts += self.stats.get_ok_rqsts

            self.threads_done = 0

    def add_blaster(self):
        """Run the test."""
        self.run_cycle(self.send_requests)

    @property
    def get_ok_rqsts(self):
        return self.total_ok_rqsts


def create_arguments_parser():
    """Creates argument parser for test script.
    Shorthand to arg parser on library level in order to access and
    eventually enhance in ancestors.

    :returns: argument parser supporting arguments and parameters
    :rtype: argparse.ArgumentParser
    """
    my_parser = argparse.ArgumentParser(
        description="entry reading performance test: Reads entries from "
                    "the config tree, as specified by optional parameters.")

    my_parser.add_argument(
        "--host", default="127.0.0.1",
        help="Host where odl controller is running (default is 127.0.0.1).")
    my_parser.add_argument(
        "--port", default=7777,
        help="Port on which Honeycomb's Netconf is listening"
             " (default is 7777 for TCP)")
    my_parser.add_argument(
        "--cycles", type=int, default=1,
        help="Number of entry read cycles; default 1. <THREADS> worker threads "
             "are started in each cycle and the cycle ends when all threads "
             "finish. Another cycle is started when the previous cycle "
             "is finished.")
    my_parser.add_argument(
        "--threads", type=int, default=1,
        help="Number of request worker threads to start in each cycle; "
             "default=1. Each thread will read <entries> entries.")
    my_parser.add_argument(
        "--requests", type=int, default=10,
        help="Number of requests that will be made by each worker thread "
             "in each cycle; default 10")

    return my_parser

if __name__ == "__main__":

    parser = create_arguments_parser()
    in_args = parser.parse_args()

    fct = ConfigBlaster(in_args.host, in_args.port, in_args.cycles,
                        in_args.threads, in_args.requests)

    # Run through <cycles>, where <threads> are started in each cycle and
    # <entries> are added from each thread
    fct.add_blaster()

    print "    Successful reads:  {0}\n".format(fct.get_ok_rqsts)