/base/Applications/Network/UdpGulp/UdpGulp.cs

////////////////////////////////////////////////////////////////////////////////

//

//  Microsoft Research Singularity

//

//  Copyright (c) Microsoft Corporation.  All rights reserved.

//

//  Note:   Simple Singularity test program.

//

using System;

using System.Diagnostics;

using System.Net.IP;

using System.Threading;



using Microsoft.Singularity;

using Microsoft.SingSharp;

using Microsoft.Singularity.Channels;

using Microsoft.Singularity.Directory;

using NetStack.Contracts;

using NetStack.Channels.Public;



using Microsoft.Contracts;

using Microsoft.SingSharp.Reflection;

using Microsoft.Singularity.Applications;

using Microsoft.Singularity.Io;

using Microsoft.Singularity.Configuration;

[assembly: Transform(typeof(ApplicationResourceTransform))]



namespace Microsoft.Singularity.Applications.Network

{

    [ConsoleCategory(HelpMessage="Receive UDP data from a ipAddress, port",

                     DefaultAction = true)]

    internal class Parameters

    {

        [InputEndpoint("data")]

        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;



        [OutputEndpoint("data")]

        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;



        [Endpoint]

        public readonly TRef<UdpContract.Imp:Start> udpRef;



        [LongParameter("t", Mandatory = false, HelpMessage = "Seconds to send packets for", Default = 30)]

        internal long seconds;



        [StringParameter("a", Mandatory = false, HelpMessage = "Local address to bind to.", Default = "0.0.0.0")]

        internal string address;



        [LongParameter("port", Mandatory = true, Position = 0, HelpMessage = "port to gulp from")]

        internal long port;



        reflective internal Parameters();



        internal int AppMain()

        {

            return UdpGulp.AppMain(this);

        }

    }



    public class UdpGulp

    {

        private const int FixedHeaderBytes = 42;    // Ether + IP + UDP



        private static void

        ReceivePackets(

            UdpConnectionContract.Imp:ReadyState! udpConn,

            long totalSeconds

            )

        {

            int bytesThisRound   = 0;

            int packetsThisRound = 0;



            DateTime now        = DateTime.Now;

            DateTime epochEnd   = now + TimeSpan.FromSeconds(1);

            DateTime epochStart = now;



            while (--totalSeconds >= 0) {

                while (now < epochEnd) {

                    udpConn.SendPollRead((epochEnd - now).Milliseconds);

                    switch receive {

                        case udpConn.NoData() :

                            // No data to read. This doesn't

                            // necessarily mean the connection

                            // is closed.

                            Thread.Yield();

                            break;

                            case udpConn.Data(uint addr, ushort port2, byte[]! in ExHeap data):

                                bytesThisRound += data.Length + FixedHeaderBytes;

                                packetsThisRound++;

                                delete data;

                                break;

                        case udpConn.ChannelClosed():

                            throw new Exception("udpConn channel closed");

                    }

                    now = DateTime.Now;

                }



                TimeSpan delta = now - epochStart;

                string msg = String.Format(

                    "Duration(s) {0:f2} rate {1:e3} bps, {2:e3} bytes/sec, {3:e3} pps",

                    delta.TotalSeconds,

                    8.0 * bytesThisRound / delta.TotalSeconds,

                    8.0 * bytesThisRound / delta.TotalSeconds,

                    1.0 * packetsThisRound / delta.TotalSeconds

                    );



                Console.WriteLine(msg);

                DebugStub.WriteLine(msg);



                bytesThisRound = 0;

                packetsThisRound = 0;

                epochStart     = DateTime.Now;

                epochEnd       = epochStart + TimeSpan.FromSeconds(1);

            }

        }



        public static int

        Gulp([Claims] UdpConnectionContract.Imp:ReadyState! udpConn,

             IPv4   address,

             ushort port,

             long   totalSeconds)

        {

            Console.WriteLine("UdpGulp({0}, {1})", address, port);



            try {

                // Bind local endpoint

                udpConn.SendBindLocalEndPoint((uint)address, port);



                switch receive {

                    case udpConn.OK() :

                        // success;

                        Console.WriteLine("Connected");

                        break;



                    case udpConn.InvalidEndPoint(ip, rejectedPort) :

                        throw new Exception("udpConn address and port rejected");



                    case udpConn.ChannelClosed() :

                        throw new Exception("udpConn channel closed");

                }



                ReceivePackets(udpConn, totalSeconds);



                Console.WriteLine("Closing connection");

                udpConn.SendClose();

            }

            catch (Exception e) {

                Console.WriteLine("Unexpected exception: {0}", e);

            }

            finally {

                delete udpConn;

            }

            return 0;

        }



        internal static int AppMain(Parameters! config)

        {

            IPv4 host;

            try {

                host = IPv4.Parse(config.address);

            }

            catch (FormatException e) {

                Console.WriteLine("{0}: {1}", e, config.address);

                return -1;

            }



            if (config.port > 0xffff || config.port < 0) {

                Console.WriteLine("Port number out of range: {0}",

                                  config.port);

                return -1;

            }

            ushort port = (ushort) config.port;



            UdpContract.Imp udpConn = ((!)config.udpRef).Acquire();

            if (udpConn == null) {

                Console.WriteLine("Could not initialize TCP endpoint.");

                return 1;

            }



            Console.WriteLine("Waiting for ready");

            udpConn.RecvReady();



            UdpConnectionContract.Imp! connImp;

            UdpConnectionContract.Exp! connExp;

            UdpConnectionContract.NewChannel(out connImp, out connExp);



            Console.WriteLine("Creating session");

            udpConn.SendCreateUdpSession(connExp);

            connImp.RecvReady();

            delete udpConn;

            Console.WriteLine("Ready");

            return Gulp(connImp, host, port, config.seconds);

        }

    } // end class UdpGulp

}