ClientControl.cs

using System;
using System.Threading;
using System.IO;
using Common;

namespace Client {
        public class ClientControl {
                internal ConnectionManager connectionManager;
                internal ClientCacheManager clientCacheManager;
                internal ServerStub serverStub;
                internal HTTPObjectQueue userRequests; 
                internal ClientSettings settings;

                public MessageLogger msgLog;

                Thread processingThread;

                public ClientControl() {
                        try {
                                Console.WriteLine("Initialising GRPSWeb Client Library (Version {0}, Build {1})", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(2), System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.Build);
                                this.settings = new ClientSettings(this);
                                this.msgLog = new MessageLogger(Console.Out);
                                this.connectionManager = new ConnectionManager(this);
                                this.userRequests = new HTTPObjectQueue();
                                this.clientCacheManager = new ClientCacheManager(this);
                                this.serverStub = new ServerStub(this);
                        } catch (ApplicationException appEx) {
                                throw new ApplicationException("Unable to create Client Control object", appEx);
                        }
                }
                        
                public void ResetConnection() {
                        Console.Error.WriteLine("*** CONNECTION RESET ***");
                        serverStub.ResetConnection();
                }

                void run() {
                        ClientHTTPRequestQueueObject currentReqQObj; 
                        Connection client;
                        try {
                                while(true) {
                                        // dequeue request
                                        currentReqQObj = (ClientHTTPRequestQueueObject)userRequests.DequeueBlocking();

                                        // Assign to client the connection we want to send the results to
                                        client = currentReqQObj.connection;

                                        // check to see if request can be serviced by cache
                                        try {
                                                //if (clientCacheManager.CanService(currentReqQObj) && !currentReqQObj.HasPragmaNoCacheSet) { /*DISABLE CACHE*/
                                                //      clientCacheManager.ServiceReq(currentReqQObj, client); /*DISABLE CACHE*/
                                                //} else { // service from upstream /*DISABLE CACHE*/
                                                        if (currentReqQObj.HasPragmaNoCacheSet) {
                                                                Console.WriteLine("    Pragma: no-cache set for {0}", currentReqQObj.URI);
                                                        }
                                                        serverStub.ServiceReq(currentReqQObj, client);
                                                //}/*DISABLE CACHE*/    
                                        } catch (CacheNotFoundException ex) {
                                                Console.WriteLine("*** "+ ex.ToString() + " ***");
                                                Console.WriteLine("    Issuing regular request");
                                                serverStub.ServiceReq(currentReqQObj, client);
                                        }
                                }
                        } catch (ThreadAbortException) {
                                Console.WriteLine("[Caught Thread Abort Exception: Shutting down Request Queue processor]");
                        } catch (Exception ex) {
                                Console.Error.WriteLine("*** Unhandled error in client library. Shutting Down ***\n{0}", ex);
                                Stop();
                        }
                }
 
                public void Start() {
                        this.processingThread = new Thread(new ThreadStart(run));
                        serverStub.Start();
                        processingThread.Start();
                        connectionManager.Start();
                        //CacheIndexMessage ciMsg = clientCacheManager.GetCacheIndexMessage();/*DISABLE CACHE*/                 
                        //ciMsg.Destination = settings.ServerID;/*DISABLE CACHE*/                       
                        //serverStub.SendCacheIndexMessage(ciMsg);/*DISABLE CACHE*/                     
                }

                public void Stop() {
                        Console.WriteLine("+++ Stopping Client Control library +++");
                        if (processingThread != null && processingThread.IsAlive) {
                                processingThread.Abort();
                        }
                        // stop child processes
                        connectionManager.Stop();
                        clientCacheManager.Stop();
                        serverStub.Stop();
                        // wait for termination of client control thread
                        if (processingThread != null && processingThread.IsAlive) {
                                processingThread.Join();
                        }
                        Console.WriteLine("+++ Client Control library Stopped +++");
                }

                public void Join() {
                        processingThread.Join();
                }
        } 

        /*************************************************************************/


        class ClientHTTPRequestQueueObject : HTTPRequestQueueObject {
                public Connection connection;
                public ClientHTTPRequestQueueObject(System.Net.Sockets.NetworkStream s) : base(s) {}
                public ClientHTTPRequestQueueObject(HTTPRequest req) : base(req) {}
        }

        /*************************************************************************/
        public class Logger {
                StreamWriter textOut;
                bool started;
                ClientSettings settings;

                public Logger(ClientSettings settings) {
                        this.settings = settings;
                        started = false;
                        if (settings.LogRequests) { 
                                Start(); 
                        }
                }

                public void Log(Uri requestUri, DateTime startTime, DateTime endTime) {
                        try {
                                if (started) {
                                        TimeSpan delta = endTime - startTime;
                                        textOut.WriteLine("{0}\t{1}\t{2}\t{3}", requestUri.ToString(), delta.ToString(), startTime.ToString(), endTime.ToString()); 
                                        textOut.Flush();
                                }
                        } catch (Exception ex) {
                                Console.Error.WriteLine("*** Error Writing to Client Log: ***\n{0}", ex);
                        }
                }

                public void Start() {
                        try {
                                if (!started) {
                                        textOut = new StreamWriter("usage.log", true); 
                                        textOut.WriteLine("Logging started {0}", DateTime.Now.ToString());
                                        started = true;
                                } 
                        } catch (Exception ex) {
                                Console.Error.WriteLine("*** Error Starting Client Log: ***\n{0}", ex);
                        }
                }

                public void Stop() {
                        try {
                                if (started) {
                                        textOut.WriteLine("Logging stopped {0}", DateTime.Now.ToString());
                                        textOut.WriteLine();
                                        textOut.Close();
                                }
                        } catch (Exception ex) {
                                Console.Error.WriteLine("*** Error Closing Client Log: ***\n{0}", ex);
                        }
                }
        }
}

---