#!/usr/bin/env python

from server import *
from ccserver import *
from queue import *
from optparse import OptionParser
from network import Network
import sys

#####################################################################
##  Parse options / start network
#####################################################################

def makeMultiServerParser():
    """Parse server options
    """

    host = gethostname()
    ports = []
    window = 4
    chunk_size = 700
    loss = 0
    debug = False
    delays = []
    losses = []
    rate = 0
    queue_size = 0
   
    

    parser = OptionParser()
    parser.add_option("-p", "--port", dest="ports", type="int", default=ports,
                      action="append",
                      help="""port to listen on -- can specify more than once
                      to create multiple servers""")
    parser.add_option("-e", "--delay", dest="delays", type="float",
                      default=delays, action="append",
                      help="""delay in seconds for a network -- can specify
                      more than once, corresponding to ports""")
    parser.add_option("-r", "--rate", dest="rate", type="int",
                      default=rate, action="store",
                      help="""number of packets per second through the
                      shared bottleneck (0 = no rate control)""")
    parser.add_option("-l", "--loss", dest="losses", type="float",
                      default=losses, action="append",
                      help="""loss rate of the channel -- can specify
                      more than once, corresponding to ports""")
    parser.add_option("-q", "--queue-size", dest="queue_size", type="int",
                      default=queue_size, action="store",
                      help="""maximum number of packets in the queue of the
                      shared bottleneck (0 = no max size)""")
    parser.add_option("-s", "--size", dest="size", type="int",
                      default=chunk_size, action="store",
                      help="data chunk size")
    parser.add_option("-d", "--debug", dest="debug",
                      default=debug, action="store_true",
                      help="print network debug info")
    parser.add_option("-b", "--bind", dest="host", type="string",
                      default=host, action="store",
                      help="host name to bind to")
    
    return parser

def main(argv=None):
    """Run multiple servers sharing the same bottleneck.

    Parse options, and enter the L{Network <network.Network>} event loop.
    """
    
    if argv is None:
        argv = sys.argv

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

    window = 4
    ports = options.ports
    chunk_size = 1000
    host = options.host
    debug = options.debug
    delays = options.delays
    losses = options.losses
    rate = options.rate
    queue_size = options.queue_size

    queue = Queue( int(rate), int(queue_size) )

    serverlist = []
    
    if( len(ports) < 1 ):
        ports = [6829]

    while( len(delays) < len(ports) ):
        delays.append(0.0)

    while( len(losses) < len(ports) ):
        losses.append(0.0)

    for p,d,l in zip( ports, delays, losses ):

        network = Network( gethostname(), l, p, debug, queue, d )
        data = AIMDData()
        server = AIMDReliableServer( data,network, window, chunk_size )
        #server.openCwndLog()
        serverlist.append(server)

    try:
        Network.loop()
    except KeyboardInterrupt:
        for s in serverlist:
            s.closeCwndLog()
        print "Exiting on command.  Goodbye."

if __name__ == "__main__":
    sys.exit(main())