MCP.cs

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Threading;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Drawing;
using System.Drawing.Imaging;
using Common;
using ProtocolStack;

namespace Server {
        public class MCP {
                // TODO: Remove this hack
                const ushort HACK_CLIENT_ID = 1;



                public HTTPObjectQueue requestQueue;
                public ClientStub clientStub;
                StackInterface customProtocolStack;
                public ServerCacheManager cacheManager;

                public HTTPStub httpStub; 

                OutgoingMessageQueue messageOutputQ;
                
                Thread processingThread;

                ClientChkLists chkLists;

                BackgroundFetcher backgroundFetcher;

                internal MessageLogger msgLog;

                internal ServerSettings settings;






                public MCP() {
                        msgLog = new MessageLogger(Console.Out);
                        settings = new ServerSettings();
                        msgLog.LogStartBegin("GPRSWeb Server Library (version {0}, build {1})", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(2), System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.Build);
                        customProtocolStack = new StackInterface(new ConnectionResetDelegate(ResetConnection));
                        requestQueue = new HTTPObjectQueue();
                        clientStub = new ClientStub(HACK_CLIENT_ID, customProtocolStack.ReceivedMessages, requestQueue, this);
                        messageOutputQ = customProtocolStack.MessagesToSend;
                        cacheManager = new ServerCacheManager(this);
                        backgroundFetcher = new BackgroundFetcher(this);
                        httpStub = new HTTPStub();
                        chkLists = new ClientChkLists();
                        processingThread = new Thread(new ThreadStart(run));
                        msgLog.LogStartComplete("GPRSWeb Server Library");
                }

                public void ResetConnection() {
                        msgLog.LogError("CONNECTION RESET");
                        customProtocolStack.ResetConnection();
                }

                public void Start() {
                        msgLog.LogStartBegin("GPRSWeb Server Processing");
                        /* start other threads in correct order */
                        clientStub.Start();
                        backgroundFetcher.Start();
                        customProtocolStack.Start();
                        /* start this thead */
                        processingThread.Start();
                        msgLog.LogStartComplete("GPRSWeb Server Processing");
                }

                public void Stop() {
                        msgLog.LogStopBegin("GPRSWeb Server processing");
                        /* abort threads in correct order */
                        clientStub.Stop();
                        backgroundFetcher.Stop();
                        /* abort this thread */
                        processingThread.Abort();
                }

                void run() {
                        HTTPRequestQueueObject reqQObj;
                        HTTPResponse response;
                        try {
                                while (true) {
                                        // get request from Request Queue
                                        reqQObj = (HTTPRequestQueueObject)requestQueue.DequeueBlocking();
                                        response = ServiceHTTPRequest(reqQObj);
                                        SendResponse(response, reqQObj, false);
                                }
                        } catch (ThreadAbortException) {
                                Console.WriteLine("(Server MCP: Shutting Down Request Processing Thread)");
                        }
                }

                public HTTPResponse ServiceHTTPRequest(HTTPRequestQueueObject request) {
                        HTTPResponse response; 
                        // obtain response, from cache or from server
                        if (cacheManager.CanService(request) && !request.HasPragmaNoCacheSet) {/*DISABLE CACHE*/
                                // cache update optional, depending on if we freshened /*DISABLE CACHE*/
                                // update occurs in-cache. /*DISABLE CACHE*/
                                response = cacheManager.ServiceRequest(request); /*DISABLE CACHE*/
                        } else { /*DISABLE CACHE*/
                                if (request.HasPragmaNoCacheSet) {
                                        Console.WriteLine("- Pragma: no-cache is set in request for {0}", request.URI);
                                }
                                response = httpStub.ServiceRequest(request);
                                // always update cache when we've fetched new stuff
                                if (response != null && response.StatusCode != 304) {
                                        cacheManager.UpdateCache(response, request.URI); /*DISABLE CACHE*/
                                }
                        } /*DISABLE CACHE*/

                        // hooks for extra processing based on content type
                        if (response != null && response.ContentType != null) {
                                if (response.ContentType.StartsWith("image")) {
                                        HTTPResponse cachedResponse = response;
                                        try {
                                                response = DegradeImage(response); /*DISABLE DEGRADE*/
                                        } catch (Exception ex) {
                                                Console.Error.WriteLine("*** Unable to degrade image. Using original ***\n\n{0}", ex);
                                                response = cachedResponse;
                                        }
                                } else if (response.ContentType.StartsWith("text/html") && (response.Body != null)) {
                                        BeginParseAndPush(request, response);/*DISABLE PARSE n PUSH*/
                                }
                        }
                        return response;
                }

                private HTTPResponse DegradeImage(HTTPResponse response) {
                        if (!response.ContentType.StartsWith("image/jpeg")) {
                                Console.WriteLine("Only degrading of JPEG images is currently supported by Windows GDI+");
                        } else {
                                Console.WriteLine("Recompressing JPEG image to 10% using Windows GDI+");

                                MemoryStream imgStream = new MemoryStream(response.Body.data);
                                Bitmap bitmap = new Bitmap(imgStream);
                                MemoryStream degradedImageStream = new MemoryStream();
                                ImageCodecInfo[] codecInfo = ImageCodecInfo.GetImageEncoders();
                                ImageCodecInfo encoderCodecInfo = null;
                                foreach(ImageCodecInfo icInfo in codecInfo) {
                                        if (icInfo.MimeType.Equals(response.ContentType)) {
                                                encoderCodecInfo = icInfo;
                                                break;
                                        }
                                }
                                System.Drawing.Imaging.Encoder qualityEncoder = System.Drawing.Imaging.Encoder.Quality;
                                EncoderParameters myEncoderParameters = new EncoderParameters(1);
                                myEncoderParameters.Param[0] = new EncoderParameter(qualityEncoder, 10L);
                                bitmap.Save(degradedImageStream, encoderCodecInfo, myEncoderParameters);
                                response.Body.data = new byte[degradedImageStream.Length];
                                degradedImageStream.Seek(0, SeekOrigin.Begin);
                                degradedImageStream.Read(response.Body.data, 0, response.Body.data.Length);
                                response.ContentLength = response.Body.data.Length.ToString();
                        }
                        return response;
                }



                private void BeginParseAndPush(HTTPRequestQueueObject originalRequest, HTTPResponse htmlResponse) {
                        HTTPRequest[] httpRequests = ImageUriParser.GenerateImageRequests(new MessageLogger(Console.Out), originalRequest, htmlResponse);
                        HTTPRequestQueueObject[] imageRequests = new HTTPRequestQueueObject[httpRequests.Length];
                        for (int i = 0; i < httpRequests.Length; i++) {
                                if (httpRequests[i] != null) {
                                        imageRequests[i] = new HTTPRequestQueueObject(httpRequests[i]);
                                        imageRequests[i].sourceDeviceID = originalRequest.sourceDeviceID;
                                } else {
                                        imageRequests[i] = null; // explictyly set image request to null if we generated a null http request earlier. Will be skipped over later, and probably optimised away.
                                }
                        }
                        Console.WriteLine("- Parse phase generated {0} new requests", imageRequests.Length);
                        foreach (HTTPRequestQueueObject rqo in imageRequests) {
                                if (rqo != null) {
                                        backgroundFetcher.AddToFetchQueue(rqo); 
                                }
                        }
                }


                private void SendMessage(Message msg, bool isCacheUpdate) {
                        // selecting output queue is done in protocol stack
                        msg.isLowPriority = isCacheUpdate;
                        messageOutputQ.EnqueueBlocking(msg);

                }

                public void UpdateChkList(ushort clientID, CacheIndex index) {
                        lock (chkLists.SyncRoot) {
                                chkLists.Add(clientID, index);
                                msgLog.LogReceive("CACHE INDEX received");
                                Monitor.PulseAll(chkLists.SyncRoot);
                        }
                }

                public void SendResponse(HTTPResponse response, HTTPRequestQueueObject reqQObj, bool isCacheUpdate) {
                        bool isMessageToSend = true;
                        Message msg = null;
                        try {
                                if (response != null)  { // so long as it didn't screw up...
                                        lock (chkLists.SyncRoot) {
                                                CacheIndex clientChkList = chkLists[reqQObj.sourceDeviceID];
                                                bool indexRequestSent = false;
                                                while (clientChkList == null) { // wait for a client check list to get here. Assumes only one client, as far as I can tell
                                                        if (!indexRequestSent) {
                                                                msg = new CacheIndexRequestMessage(reqQObj.sourceDeviceID);
                                                                SendMessage(msg, false);
                                                                indexRequestSent = true;
                                                                msgLog.Log("Cache Index Requested. Sleeping now");
                                                        }
                                                        Monitor.Wait(chkLists.SyncRoot);
                                                        clientChkList = chkLists[reqQObj.sourceDeviceID];
                                                }
                                                Monitor.PulseAll(chkLists.SyncRoot);
                                                if (response.Body != null) { // response has a body
                                                        byte[] respCHK = response.GetCHK();
                                                        // check client CHK list for contents. 
/*Comment to DISABLECACHE*/     if (clientChkList.Contains(respCHK)) { // if we think client cache already has this...
/*Comment to DISABLECACHE*/             if (isCacheUpdate) { 
/*Comment to DISABLECACHE*/                     msg = new CacheUpdateNoChangeMsg(reqQObj.URI, respCHK, response.Headers);
/*Comment to DISABLECACHE*/             } else {
/*Comment to DISABLECACHE*/                     msg = new NoChangeMessage(respCHK, reqQObj.callbackReceipt, response.Headers);
/*Comment to DISABLECACHE*/             }
/*Comment to DISABLECACHE*/             UpdateChkListEntries(ref clientChkList, respCHK, response.Body);
/*Comment to DISABLECACHE*/             msgLog.LogSend("\"No Change\" message sent for {0}", reqQObj.URI);
                                                        } else { /*DISABLE CACHE*/
                                                                HTTPBody responseBody = new HTTPBody(response.Body.data);
                                                                EncodedHTTPResponse encodedResponse = new EncodedHTTPResponse(response, reqQObj.originalChk, cacheManager);
                                                                if (isCacheUpdate) {
                                                                        CacheUpdateHTTPResponseMsg cacheUpdateMsg = new CacheUpdateHTTPResponseMsg(reqQObj.URI, encodedResponse);
                                                                        msg = cacheUpdateMsg;
                                                                } else {
                                                                        HTTPResponseMessage responseMsg = new HTTPResponseMessage(encodedResponse, reqQObj.callbackReceipt);
                                                                        msg = responseMsg;
                                                                }
/*Comment to DISABLECACHE*/             UpdateChkListEntries(ref clientChkList, respCHK, responseBody);
                                                                msgLog.LogSend("\"HTTP Response\" message sent for {0}", reqQObj.URI);
/*Comment to DISABLECACHE*/     }
                                                } else { // response with no body
                                                        /* 
                                                         * We have a change here from 1.0 - previously we didn't send a cache update if there was no body. 
                                                         * In order for the pending requests on the client to function correctly, we need to send pretty much
                                                         * everything
                                                         */
                                                        EncodedHTTPResponse encodedResponse = new EncodedHTTPResponse(response);
                                                        if (!isCacheUpdate) { // not cache update, so do regular response with no body. Hope it doesn't crash with null ref!
                                                                msg = new HTTPResponseMessage(encodedResponse, reqQObj.callbackReceipt);
                                                        } else { // is cache update, do cache update response with no body.
                                                                msg = new CacheUpdateHTTPResponseMsg(reqQObj.URI, encodedResponse);
                                                        }
                                                        msgLog.LogSend("{0} message (no body) to service {1}", msg.GetType().Name, reqQObj.URI);
                                                }
                                        } // end lock on chkList
                                } else { // response == null
                                        isMessageToSend = false;
                                }
                        } catch (CacheNotFoundException ex) {
                                Console.WriteLine("*** Cache Entry not found: {0} ***", ex.ToString());
                                isMessageToSend = false;
                        }
                        if (isMessageToSend) {
                                msg.Destination = reqQObj.sourceDeviceID;
                                SendMessage(msg, isCacheUpdate);
                        }
                }

                public void UpdateChkListEntries(ref CacheIndex index, byte[] chk, HTTPBody body) {
                        if (index.Contains(chk)) {
                                ((CacheIndexEntry)index[chk]).lastUsed = DateTime.Now;
                                Console.WriteLine("- Updated CHK list entry to current time");
                        } else { // we have to add
                                // check size and see if we have to purge
                                bool flag = true;
                                int size = CacheEntry.SizeOfSerialised(body);
                                while (index.GetSpaceRemaining() < size) {
                                        if (flag) { Console.WriteLine("- Purging CHK list"); flag = false; }
                                        index.Remove(index.LeastRecentlyUsed().chk);
                                }
                                Console.WriteLine("- Added new CHK List Entry");
                                index.Add(new CacheIndexEntry(chk, Cache.StringFromChk(chk), size, DateTime.Now)); 
                        }
                }

        }

        
 
        public class ClientChkLists : ListDictionary {
                class MyComparer: IComparer {
                        public int Compare(object x, object y) {
                                ushort a = (ushort)x;
                                ushort b = (ushort)y;
                                return a-b;
                        }
                }

                public ClientChkLists() : base(new MyComparer()) {}

                public void Add(ushort deviceID, CacheIndex chkList) {
                        base[deviceID] = chkList;
                }

                public CacheIndex this[ushort index] {
                        get { return (CacheIndex)base[index]; }
                        set { base[index] = value; }
                }
        }
}

---