ClientStub.cs

using System;
using System.Threading;
using Common;

namespace Server {
        /*************************************************************************/
        public class ClientStub {
                ushort deviceID; // the ID of the client we're communicating with
                MessageQueue fromClientMsgQ; // the messages we are supposed to process
                HTTPObjectQueue outgoingRequestQ; 
                Thread processingThread;
                MCP mcp;

                public ClientStub(ushort deviceID, MessageQueue incomingMessages, HTTPObjectQueue outgoingRequestQueue, MCP mcp) {
                        this.mcp = mcp;
                        this.deviceID = deviceID;
                        this.fromClientMsgQ = incomingMessages;
                        this.outgoingRequestQ = outgoingRequestQueue;
                }

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

                void run() {
                        Message currentMsg;
                        try{
                                while(true) {
                                        currentMsg = fromClientMsgQ.DequeueBlocking();
                                        currentMsg.source = deviceID;
                                        ActionMessage(currentMsg);                      
                                }
                        } catch (ThreadInterruptedException) {
                                Console.WriteLine("[ClientStub for Device {0} shutting down queue processing]", deviceID);
                        }
                }

                public void ActionMessage(Message msg) {
                        switch(msg.Type) {
                                case MessageType.HTTPResponse: {
                                        // we should not be receiving responses at the client
                                        throw new Exception("Warning! HTTP Response received from client at server");
                                }
                                case MessageType.HTTPRequest: {
                                        // we should not be receiving requests at the client
                                        ActionHTTPRequest((HTTPRequestMessage)msg);
                                        break;
                                }
                                case MessageType.CacheIndex: {
                                        ActionCacheIndexMessage((CacheIndexMessage)msg);
                                        break;
                                }
                                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 Exception("Unrecognised message type in Client Stub receive queue processing");
                                }
                        }
                }

                public void ActionHTTPRequest(HTTPRequestMessage reqMsg) {
                        HTTPRequestQueueObject reqQObj = new HTTPRequestQueueObject(reqMsg.encodedRequest.Decode());
                        Console.WriteLine("--> HTTP Request recieved from client proxy for {0}", reqQObj.URI);
                        reqQObj.sourceDeviceID = reqMsg.source;
                        reqQObj.callbackReceipt = reqMsg.callbackReceipt;
                        reqQObj.originalChk = reqMsg.CHK;
                        outgoingRequestQ.EnqueueBlocking(reqQObj);
                }

                public void ActionCacheIndexMessage(CacheIndexMessage msg) {
                        Console.WriteLine("> Cache Index message received from client proxy");
                        mcp.UpdateChkList(msg.source, msg.index);
                }
        }
        /*************************************************************************/
}

---