ServerStub.cs

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Threading;
using Common;
using ProtocolStack;

namespace Client {
        public class ServerStub {
                public delegate void ServerStubCallback(object o);
                public MessageQueue toServerMsgQ;
                public MessageQueue fromServerMsgQ;
                private StackInterface customProtocolStack;
                private Thread processingThread;
                private CallbackList callbackList;
                ClientControl clientControl;

                public PendingRequestManager pendingRequestManager;


                public ServerStub(ClientControl clientControl) {
                        try {
                                this.clientControl = clientControl;
                                customProtocolStack = new StackInterface(new ConnectionResetDelegate(clientControl.ResetConnection));
                                pendingRequestManager = new PendingRequestManager(clientControl);
                                toServerMsgQ = customProtocolStack.MessagesToSend;
                                fromServerMsgQ = customProtocolStack.ReceivedMessages;
                                callbackList = new CallbackList();
                        } catch (ApplicationException appEx) {
                                throw new ApplicationException("Unable to create Server Proxy interface in Client Library", appEx);
                        }
                }

                public void ResetConnection() {
                        Console.WriteLine("### TODO: Server stub specific connection reset code ###");
                        customProtocolStack.ResetConnection();
                }

                public void ServiceReq(HTTPRequest req, Connection client) {
                        // register for callback when response arrives
                        HTTPResponseHandler handler = new HTTPResponseHandler(req, client, clientControl);
                        int callbackRcpt = callbackList.RegisterHandler(handler);
                        //int callbackRcpt = callbackList.RegisterCallback(new ServerStubCallback(client.SendResponseCallback));
                        // delta encode / compress the request 
                        EncodedHTTPRequest encodedReq = new EncodedHTTPRequest(req);
                        // form message
                        HTTPRequestMessage outgoingMessage = new HTTPRequestMessage(encodedReq, callbackRcpt, null);
                        outgoingMessage.Destination = clientControl.settings.ServerID;
                        // send to pending request manager
                        pendingRequestManager.ServiceRequest(req.URI, outgoingMessage, handler);
                        toServerMsgQ.EnqueueBlocking(outgoingMessage);
                }

                public void Freshen(byte[] CHK, HTTPRequest request, HTTPResponseHandler responseHandler) {
                        // do the freshening thing,
                        int callback = callbackList.RegisterHandler(responseHandler);
                        HTTPRequestMessage reqMsg = new HTTPRequestMessage(new EncodedHTTPRequest(request), callback, CHK);
                        reqMsg.Destination = clientControl.settings.ServerID;
//                      Console.WriteLine("> Freshen request issued for {0} (Identical to HTTP Request)", request.URI);
//                      toServerMsgQ.EnqueueBlocking(reqMsg);
                        pendingRequestManager.ServiceRequest(request.URI, reqMsg, responseHandler);
                }

                public void SendCacheIndexMessage(CacheIndexMessage msg) {
                        toServerMsgQ.EnqueueBlocking(msg);
                        clientControl.msgLog.LogSend("CLIENT CACHE INDEX MESSAGE Sent");
                }

                public void Start() {
                        customProtocolStack.Start();
                        if (processingThread == null || !processingThread.IsAlive) {
                                processingThread = new Thread(new ThreadStart(this.run));
                                processingThread.Start();
                        }
                }

                public void Stop() {
                        customProtocolStack.Stop();
                        if (processingThread != null && processingThread.IsAlive) {
                                processingThread.Abort();
                                processingThread.Join();
                        }
                }

                public void run() {
                        Message currentMsg;
                        try {
                                while(true) {
                                        try {
                                                currentMsg = fromServerMsgQ.DequeueBlocking();
                                                // perform appropriate action based on type of message.
                                                ActionMessage(currentMsg);
                                        } catch (ApplicationException appEx) {
                                                Console.Error.WriteLine("*** Error processing incoming message ***\n{0}", appEx);
                                        }
                                }
                        } catch (ThreadAbortException) {
                                Console.WriteLine("Shuting down 'from server' message queue processing");
                        }
                }

                public void ActionMessage(Message msg) {
                        // TODO: Change so it swicthes on msg.GetType, or possibly 'implements' interface type for cache update 
                        switch(msg.Type) {
                                case MessageType.NoChange: 
                                case MessageType.HTTPResponse: {
                                        IResponseHandler respHandler = (IResponseHandler)callbackList[((IContainsCallback)msg).CallbackReceipt];
                                        respHandler.Handle(msg);
                                        clientControl.serverStub.pendingRequestManager.HandleRemainingRequests(((HTTPResponseHandler)respHandler).RequestUri, msg, true);
                                        break;
                                }
                                case MessageType.CacheUpdateHTTPResponse: {
                                        clientControl.clientCacheManager.Handle(msg);
                                        clientControl.serverStub.pendingRequestManager.HandleRemainingRequests(((ICacheUpdateMessage)msg).RequestUri, msg, false);
                                        break;
                                }
                                case MessageType.CacheUpdateNoChange: {
                                        clientControl.clientCacheManager.Handle(msg);
                                        clientControl.serverStub.pendingRequestManager.HandleRemainingRequests(((ICacheUpdateMessage)msg).RequestUri, msg, false);
                                        break;
                                }
                                case MessageType.CacheIndexRequest: {
                                        clientControl.clientCacheManager.Handle(msg);
                                        break;
                                }
                                case MessageType.HTTPRequest: {
                                        // we should not be receiving requests at the client
                                        throw new Exception("Warning! HTTP Request received at client");
                                }
                                case MessageType.Retransmission: {
                                        // this type of message should not be here
                                        throw new Exception("Warning! Retransmission message made it past the protocol level");
                                }
                                case MessageType.Noop: {
                                        break; // do nothing
                                }
                                default: {
                                        throw new ApplicationException(String.Format("Unrecognised message of type \"{0}\" in Server Stub receive queue processing", msg.Type));
                                }
                        }
                }

        }

        /*************************************************************************/
        // on receipt of some message, look up here what we're supposed to call back.
        // callback gives an integer receipt, which is used to index into the callbacks on return. 
        class CallbackList : ListDictionary {
                Random rand;

                public CallbackList() {
                        rand = new Random();
                }
                        
                public int RegisterHandler(IResponseHandler responseHandler) {
                        int receipt = rand.Next();
                        while (this.Contains(receipt)) {
                                receipt = rand.Next();
                        }
                        this.Add(receipt, responseHandler);
                        return receipt;
                }
                
        }

        /*************************************************************************/
}

---