singrdk/base/Applications/Network/BlastServer/BlastServer.cs

////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  Note:   Simple Singularity test program.
//

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Collections;

#if SINGULARITY
using Microsoft.Contracts;
using System.IO;
using System.Runtime.InteropServices;

using Microsoft.SingSharp;
using Microsoft.Singularity;
using Microsoft.Singularity.Channels;
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))]
#endif
 

namespace Microsoft.Singularity.Applications.Network
{
#if SINGULARITY
    [ConsoleCategory(HelpMessage="BlastServer TCP data to 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<TcpContract.Imp:Start> tcpRef;


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


        [LongParameter( "numBytes", Mandatory=false, Position=1, HelpMessage="Total bytes to send", Default = 10000)]
        internal long numBytes;


        [LongParameter( "chunkSize", Mandatory=false, Position=2, HelpMessage="Chunks size to send", Default = 256)]
        internal long chunkSize;

        reflective internal Parameters();

        internal int AppMain() {
            return BlastServer.AppMain(this);
        }
    }
#endif 

    public class BlastServer
    {
        ///////////////////////////////////////////////////////////////////////
        // Constants
        private const int WorkerThreads = 32;
        private const int MaxWorkItems  = 32 * WorkerThreads;
        private const string RepeatPattern = "Here is a repeating string of text that serves as content. ";

        ///////////////////////////////////////////////////////////////////////
        // class variables 
        ushort      port;
        uint        numBytes;
        uint        chunkSize;
        byte[]      chunkBuffer; 
        ThreadPool  threadPool;
        
        private void DispatchRequest(object dispatchObject)
        {
            Console.WriteLine(dispatchObject as string);
            Console.WriteLine("We should Never get here");
#if SINGULARITY
            DebugStub.Break();
#endif            
        }

        private void test (object dispatchObject)
        {
            Console.Write(dispatchObject as string);
        }
        
        private void Blaster (object sock)
        {
            Socket socket = sock as Socket; 
#if SINGULARITY
            assert socket != null; 
#endif            
            int bytesSent = 0;
            int iterations =0;
            
            Console.WriteLine("Got connection...");

            uint bytesLeft = numBytes, patternLength = (uint)RepeatPattern.Length;
            try {
                while (bytesLeft > 0) {
                    uint thisPass = chunkSize < bytesLeft ? chunkSize : bytesLeft;
                    if (thisPass == chunkSize) {
                        socket.Send(chunkBuffer);
                    }
                    else {
                        byte[] thisPassBuffer = new byte[thisPass]; 
                        for (uint i = 0; i < thisPass; i++) {
                            thisPassBuffer [(int)i] = (byte)RepeatPattern[(int)i % (int)patternLength];
                        }   
                        socket.Send(thisPassBuffer);
                    }
                   bytesLeft -= thisPass;
                   bytesSent += (int) thisPass;
                   iterations++;
                   Console.Write(".");
                }
            }
            catch (ArgumentNullException ae) {
                Console.WriteLine("ArgumentNullException : {0}", ae.ToString());
            }
            catch (SocketException se) {
                Console.WriteLine("SocketException : {0}", se.ToString());
            }
            catch (Exception e) {
                Console.WriteLine("Unexpected exception : {0}", e.ToString());
            }

            Console.WriteLine("\nSent {0} bytes in {1} iterations",bytesSent,iterations); 

            socket.Shutdown(SocketShutdown.Both);
            socket.Close(); 
            Thread.Sleep(2);
        }
        
        private void Listen() {
            Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socket.Bind(new IPEndPoint(IPAddress.Any, (int)this.port));
            socket.Listen((int)SocketOptionName.MaxConnections);
            while (true) {
                Socket s = socket.Accept();
                threadPool.QueueUserWorkItem(new ThreadPool.WorkCallback(Blaster), s);
            }
        }

#if SINGULARITY
        [NotDelayed]
#endif
        public BlastServer (ushort port, uint numBytes, uint chunkSize)
        {
            this.port = port; 
            this.numBytes = numBytes; 
            this.chunkSize = chunkSize;
            
            chunkBuffer = new byte[chunkSize]; 
            for (uint i = 0; i < chunkSize; i++) {
                chunkBuffer [(int)i] = (byte)RepeatPattern[(int)i % (int)RepeatPattern.Length];
            }

            Console.WriteLine("BlastServer listening on  port {0} for {1} bytes in {2}-byte chunks",
                              port, numBytes, chunkSize);

            threadPool = new ThreadPool(
                            WorkerThreads, MaxWorkItems,
                            new ThreadPool.WorkCallback(DispatchRequest)
                            );
#if blee                            
           for (int i = 0; i < 50; i++) {
                for (int j = 0; j < 40; j++) {
                    bool isFull = threadPool.QueueUserWorkItem(new ThreadPool.WorkCallback(test), ".");
                    while (isFull) {
                        Thread.Sleep(2); 
                        isFull = threadPool.QueueUserWorkItem(new ThreadPool.WorkCallback(test), "yes\n");
                    }
                }
                Thread.Sleep(300);
            }
#endif 
        }

        public static void Usage()
        {
            Console.WriteLine("blastserver  <port> <numBytes> <chunkSize>");
        }
        
        public void  Shutdown()
        {
            threadPool.Shutdown(); 
        }
#if SINGULARITY        
        internal static int AppMain(Parameters! config)
        {
        
            if (config.port > 65536 || config.port < 0) {
                Console.WriteLine("Port number out of range: {0}", config.port);
                return -1;
            }
        
            ushort port = (ushort) config.port; 
            uint numBytes = (uint) config.numBytes;
            uint chunkSize = (uint) config.chunkSize;
            BlastServer bs = new BlastServer( port, numBytes, chunkSize); 
                    
            bs.Listen();            
            bs.Shutdown(); 
            return 0; 
        }
#else         
        public static int Main(string[] /*!*/ args)
        {
            int start = -1;
            if (args.Length < 4 + start) {
                Usage();
                return 1;
            }

            ushort port;

            try {
                port = UInt16.Parse(args[1+start]);
            }
            catch (FormatException) {
                Console.WriteLine("Malformed port number: {0}", args[1+start]);
                return -1;
            }
            catch (OverflowException) {
                Console.WriteLine("Port number out of range: {0}", args[1+start]);
                return -1;
            }

            uint numBytes;

            try {
                numBytes = UInt32.Parse(args[2+start]);
            }

            catch (FormatException) {
                Console.WriteLine("Malformed number of bytes: {0}", args[2+start]);
                return -1;
            }
            catch (OverflowException) {
                Console.WriteLine("Byte count out of range: {0}", args[2+start]);
                return -1;
            }

            uint chunkSize;

            try {
                chunkSize = UInt32.Parse(args[3+start]);
            }
            catch (FormatException) {
                Console.WriteLine("Malformed chunk size: {0}", args[3+start]);
                return -1;
            }
            catch (OverflowException) {
                Console.WriteLine("Chunk size out of range: {0}", args[3+start]);
                return -1;
            }
            BlastServer bs = new BlastServer( port, numBytes, chunkSize); 
            
            bs.Listen();            
            bs.Shutdown(); 
            return 0; 
        }
#endif        
    } // end class TcpBlast
}