ResponseHandlers.cs

using System;
using Common;

namespace Client {
        /*************************************************************************/
        public interface IResponseHandler {
                void Handle(Message responseMsg);
        }

        /*************************************************************************/
        public class HTTPResponseHandler : IResponseHandler {
                Connection client;
                ClientControl clientControl;
                HTTPRequest originalRequest;










                public HTTPResponseHandler(HTTPRequest originalRequest, Connection client, ClientControl clientControl) {
                        this.originalRequest = originalRequest;
                        this.client = client;
                        this.clientControl = clientControl;
                }

                public void Handle(Message msg) {
                        HTTPResponse response;
                        if (msg.Type == MessageType.HTTPResponse) {
                                HTTPResponseMessage rspMsg = (HTTPResponseMessage)msg;
                                // decode the message
                                try {
                                        response = rspMsg.encodedResponse.Decode(clientControl.clientCacheManager);
                                        // add it to the cache
                                        clientControl.clientCacheManager.UpdateCache(response, client.Request.URI); /*DISABLE CACHE*/
                                        if (clientControl.settings.PendingRequestsEnabled) {
                                                if (response != null && response.ContentType != null && response.ContentType.StartsWith("text/html")) {
                                                        if (response.Body != null) {
                                                                clientControl.serverStub.pendingRequestManager.AddPlaceholders(ImageUriParser.GetImageUris(clientControl.msgLog, client.Request.URI, response.Body.data));
                                                        }
                                                }
                                        }
                                        client.SendResponse(response);
                                } catch (CacheNotFoundException ex) {
                                        Console.WriteLine("***" + ex.Message + "***");
                                        Console.WriteLine("* Re-issuing index message and original request");
                                        clientControl.serverStub.SendCacheIndexMessage(clientControl.clientCacheManager.GetCacheIndexMessage()); /*DISABLE CACHE*/
                                        clientControl.serverStub.ServiceReq(originalRequest, client);
                                }
                        } else if (msg.Type == MessageType.NoChange) {
                                NoChangeMessage noChangeMsg = (NoChangeMessage)msg;
                                // test to see if we still have it in the cache
                                if (noChangeMsg.chk != null && clientControl.clientCacheManager.CacheContains(noChangeMsg.chk)) {
                                        // null check to see if we're not forcing an update. chk == null imples update request
                                        // we still have it in the cache, so update the UriMapper with latest headers.
                                        clientControl.clientCacheManager.UpdateURIMapping(originalRequest.URI, noChangeMsg.chk, noChangeMsg.responseHeaders.rawString);
                                        // obtain response from cache
                                        response = clientControl.clientCacheManager.Get(originalRequest);
                                        // send to client
                                        client.SendResponse(response);
                                } else { // it's not in the cache. So the server has it wrong. So update the server with the cache situation.
                                        // null may have meant request update
                                        clientControl.serverStub.SendCacheIndexMessage(clientControl.clientCacheManager.GetCacheIndexMessage());
                                        if (noChangeMsg.chk != null) {
                                                clientControl.serverStub.ServiceReq(originalRequest, client);
                                        }
                                }
                        } else if (msg.Type == MessageType.CacheUpdateHTTPResponse || msg.Type == MessageType.CacheUpdateNoChange) {
                                /* by the time it's arrived here, the response message will have been handled and the document *should* be in the cache
                                 * there's a slight chance that it mught have been removed, but we can probably service this request from the cache */
                                clientControl.msgLog.Log("Handling previously pending request for {0}", originalRequest.URI);
                                clientControl.clientCacheManager.ServiceReq(originalRequest, client);
                        } else { // unknown message
                                throw new ApplicationException(String.Format("Unkown message type {0} in HTTPResponseHandler.Handle", msg.Type.ToString()));
                        }
                }

                public Uri RequestUri {
                        get { return originalRequest.URI; }
                }
        }
        
}

---