#!/usr/bin/python -i

# Copyright (c)2010-2013 the Boeing Company.
# See the LICENSE file included in this distribution.

# A distributed example where CORE API messaging is used to create a session
# on a daemon server. The daemon server defaults to 127.0.0.1:4038
# to target a remote machine specify "-d <ip address>" parameter, it needs to be
# running the daemon with listenaddr=0.0.0.0 in the core.conf file.
# This script creates no nodes locally and therefore can be run as an
# unprivileged user.

import datetime
import optparse
import sys
from builtins import range

import core.nodes.base
import core.nodes.network
from core.api.tlv import coreapi, dataconversion
from core.api.tlv.coreapi import CoreExecuteTlv
from core.emulator.enumerations import (
    CORE_API_PORT,
    EventTlvs,
    EventTypes,
    ExecuteTlvs,
    LinkTlvs,
    LinkTypes,
    MessageFlags,
    MessageTypes,
)
from core.emulator.session import Session
from core.nodes import ipaddress

# declare classes for use with Broker

# node list (count from 1)
n = [None]
exec_num = 1


def cmd(node, exec_cmd):
    """
    :param node: The node the command should be issued too
    :param exec_cmd: A string with the command to be run
    :return: Returns the result of the command
    """
    global exec_num

    # Set up the command api message
    tlvdata = CoreExecuteTlv.pack(ExecuteTlvs.NODE.value, node.id)
    tlvdata += CoreExecuteTlv.pack(ExecuteTlvs.NUMBER.value, exec_num)
    tlvdata += CoreExecuteTlv.pack(ExecuteTlvs.COMMAND.value, exec_cmd)
    msg = coreapi.CoreExecMessage.pack(
        MessageFlags.STRING.value | MessageFlags.TEXT.value, tlvdata
    )
    node.session.broker.handlerawmsg(msg)
    exec_num += 1

    # Now wait for the response
    server = node.session.broker.servers["localhost"]
    server.sock.settimeout(50.0)

    # receive messages until we get our execute response
    result = None
    while True:
        msghdr = server.sock.recv(coreapi.CoreMessage.header_len)
        msgtype, msgflags, msglen = coreapi.CoreMessage.unpack_header(msghdr)
        msgdata = server.sock.recv(msglen)

        # If we get the right response return the results
        print("received response message: %s" % MessageTypes(msgtype))
        if msgtype == MessageTypes.EXECUTE.value:
            msg = coreapi.CoreExecMessage(msgflags, msghdr, msgdata)
            result = msg.get_tlv(ExecuteTlvs.RESULT.value)
            break

    return result


def main():
    usagestr = "usage: %prog [-n] number of nodes [-d] daemon address"
    parser = optparse.OptionParser(usage=usagestr)
    parser.set_defaults(numnodes=5, daemon="127.0.0.1:" + str(CORE_API_PORT))

    parser.add_option(
        "-n", "--numnodes", dest="numnodes", type=int, help="number of nodes"
    )
    parser.add_option(
        "-d",
        "--daemon-server",
        dest="daemon",
        type=str,
        help="daemon server IP address",
    )

    def usage(msg=None, err=0):
        sys.stdout.write("\n")
        if msg:
            sys.stdout.write(msg + "\n\n")
        parser.print_help()
        sys.exit(err)

    # parse command line options
    (options, args) = parser.parse_args()

    if options.numnodes < 1:
        usage("invalid number of nodes: %s" % options.numnodes)
    if not options.daemon:
        usage("daemon server IP address (-d) is a required argument")

    for a in args:
        sys.stderr.write("ignoring command line argument: %s\n" % a)

    start = datetime.datetime.now()

    prefix = ipaddress.Ipv4Prefix("10.83.0.0/16")
    session = Session(1)
    server = globals().get("server")
    if server:
        server.addsession(session)

    # distributed setup - connect to daemon server
    daemonport = options.daemon.split(":")
    daemonip = daemonport[0]

    # Localhost is already set in the session but we change it to be the remote daemon
    # This stops the remote daemon trying to build a tunnel back which would fail
    daemon = "localhost"
    if len(daemonport) > 1:
        port = int(daemonport[1])
    else:
        port = CORE_API_PORT
    print("connecting to daemon at %s:%d" % (daemon, port))
    session.broker.addserver(daemon, daemonip, port)

    # Set the local session id to match the port.
    # Not necessary but seems neater.
    session.broker.setupserver(daemon)

    # We do not want the recvloop running as we will deal ourselves
    session.broker.dorecvloop = False

    # Change to configuration state on both machines
    session.set_state(EventTypes.CONFIGURATION_STATE)
    tlvdata = coreapi.CoreEventTlv.pack(
        EventTlvs.TYPE.value, EventTypes.CONFIGURATION_STATE.value
    )
    session.broker.handlerawmsg(coreapi.CoreEventMessage.pack(0, tlvdata))

    flags = MessageFlags.ADD.value
    switch = core.nodes.network.SwitchNode(session=session, name="switch", start=False)
    switch.setposition(x=80, y=50)
    switch.server = daemon
    switch_data = switch.data(flags)
    switch_message = dataconversion.convert_node(switch_data)
    session.broker.handlerawmsg(switch_message)

    number_of_nodes = options.numnodes

    print(
        "creating %d remote nodes with addresses from %s" % (options.numnodes, prefix)
    )

    # create remote nodes via API
    for i in range(1, number_of_nodes + 1):
        node = core.nodes.base.CoreNode(
            session=session, _id=i, name="n%d" % i, start=False
        )
        node.setposition(x=150 * i, y=150)
        node.server = daemon
        node_data = node.data(flags)
        node_message = dataconversion.convert_node(node_data)
        session.broker.handlerawmsg(node_message)
        n.append(node)

    # create remote links via API
    for i in range(1, number_of_nodes + 1):
        tlvdata = coreapi.CoreLinkTlv.pack(LinkTlvs.N1_NUMBER.value, switch.id)
        tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.N2_NUMBER.value, i)
        tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.TYPE.value, LinkTypes.WIRED.value)
        tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_NUMBER.value, 0)
        tlvdata += coreapi.CoreLinkTlv.pack(
            LinkTlvs.INTERFACE2_IP4.value, prefix.addr(i)
        )
        tlvdata += coreapi.CoreLinkTlv.pack(
            LinkTlvs.INTERFACE2_IP4_MASK.value, prefix.prefixlen
        )
        msg = coreapi.CoreLinkMessage.pack(flags, tlvdata)
        session.broker.handlerawmsg(msg)

    # We change the daemon to Instantiation state
    # We do not change the local session as it would try and build a tunnel and fail
    tlvdata = coreapi.CoreEventTlv.pack(
        EventTlvs.TYPE.value, EventTypes.INSTANTIATION_STATE.value
    )
    msg = coreapi.CoreEventMessage.pack(0, tlvdata)
    session.broker.handlerawmsg(msg)

    # Get the ip or last node and ping it from the first
    print("Pinging from the first to the last node")
    pingip = cmd(n[-1], "ip -4 -o addr show dev eth0").split()[3].split("/")[0]
    print(cmd(n[1], "ping -c 5 " + pingip))
    print("elapsed time: %s" % (datetime.datetime.now() - start))
    print(
        "To stop this session, use the core-cleanup script on the remote daemon server."
    )
    input("press enter to exit")


if __name__ == "__main__" or __name__ == "__builtin__":
    main()