PendingRequests.cs

using System;
using System.Collections;
using System.Threading;
using Common;


namespace Client {
        public class PendingRequest     {

                class WaitingRequest {
                        public Message messageToSend;
                        public IResponseHandler responseHandler;
                        public DateTime timeRequested;

                        public WaitingRequest(Message messageToSend, IResponseHandler responseHandler) {
                                this.messageToSend = messageToSend;
                                this.responseHandler = responseHandler;
                                this.timeRequested = DateTime.MinValue;
                        }

                        public bool HasExpired {
                                // TODO: Change Timeout to work from registry settings
                                get { return (timeRequested == DateTime.MinValue) ? false :  (DateTime.Now - timeRequested) >= TimeSpan.FromSeconds(90); }
                        }
                }

                
                protected Uri requestUri; // uri of pending request
                private ArrayList waitingList; // list of requests waiting
                PendingRequestManager manager;
                protected Timer expiryTimer;

                public PendingRequest(Uri uri, PendingRequestManager manager) {
                        this.requestUri = uri;
                        this.manager = manager;
                        waitingList = new ArrayList();
                        expiryTimer = new Timer(new TimerCallback(CheckForExpiry), null, 5 * 1000, 5* 1000); // timer starts after 5 seconds thru 3rd parameter
                }

                public PendingRequest(Uri uri, PendingRequestManager manager, Message messageToSend, IResponseHandler handler) : this(uri, manager) {
                        AddRequestToWaitingList(messageToSend, handler);
                }

                public void AddRequestToWaitingList(Message messageToSend, IResponseHandler responseHandler) {
                        lock (this) {
                                ArrayList.Synchronized(waitingList).Add(new WaitingRequest(messageToSend, responseHandler));
                        }
                }

                public void ProcessWaitingList(Message response) {
                        lock (this) {
                                try {
                                        foreach (object o in ArrayList.Synchronized(waitingList)) {
                                                WaitingRequest waitingRequest = (WaitingRequest)o;
                                                waitingRequest.responseHandler.Handle(response);
                                        }
                                        waitingList.Clear();
                                } catch (InvalidOperationException invOpEx) {
                                        manager.msgLog.LogError("{0}\r\nClearing Waiting list to recover..", invOpEx);
                                        waitingList.Clear();
                                } // end try .. catch
                        } // end while
                }

                protected void CheckForExpiry(object obj) {
                        bool done = false;
                        lock (this) {
                                while (!done) {
                                        try {
                                                foreach (object o in waitingList) {
                                                        WaitingRequest waitingRequest = (WaitingRequest)o;
                                                        if (waitingRequest.HasExpired) {
                                                                manager.msgLog.Log("Request Timeout: Have been waiting over 90 seconds for {0}", requestUri);
                                                                // TODO: We may want to send 'request timed out' after all messages tried rather than remove an entry on failure.
                                                                // RemoveTopRequest();
                                                                SendNextRequest();
                                                        }
                                                }
                                                done = true;
                        
                                        } catch (InvalidOperationException invOpEx) {
                                                manager.msgLog.LogError("{0}", invOpEx);
                                                done = false;
                                        } // end try .. catch
                                } // end while
                        }
                }

                private PendingRequest.WaitingRequest GetNextWaiting() {
                        return (WaitingRequest)waitingList[0];
                }

                public void RemoveTopRequest(){
                        lock (this) {
                                if (waitingList.Count > 0) {
                                        waitingList.RemoveAt(0);
                                        manager.msgLog.Log("Removed top request for {0}, {1} remaining", requestUri, Count);
                                } else {
                                        manager.msgLog.Log("No complete requests to remove top of pending request {0}", requestUri);
                                }
                        }
                }

                public int Count {
                        get { return waitingList.Count; }

                }
                public void SendNextRequest() {
                        lock (this) {
                                if (Count > 0) {
                                        WaitingRequest wr = GetNextWaiting();
                                        wr.timeRequested = DateTime.Now;
                                        manager.msgLog.LogSend("{0} for {1} sent to server", wr.messageToSend.GetType().Name, requestUri);
                                        // TODO: Alter message so it is flagged as resend
                                        manager.clientControl.serverStub.toServerMsgQ.EnqueueBlocking(wr.messageToSend);
                                } else {
                                        manager.msgLog.Log("No more requests for {0} pending", requestUri);
                                        RemoveSelf();
                                }
                        }
                }
                

                void RemoveSelf() {
                        manager.msgLog.Log("Self-Removing {0} from pending requests list", requestUri);
                        lock (manager.pendingRequests.SyncRoot) {
                                Hashtable.Synchronized(manager.pendingRequests).Remove(requestUri);
                        }
                }

        }

        
        public class PendingRequestManager {
                internal Hashtable pendingRequests;
                public ClientControl clientControl;
                public MessageLogger msgLog;
                
                public PendingRequestManager(ClientControl clientControl) {
                        pendingRequests = new Hashtable();
                        this.clientControl = clientControl;
                        this.msgLog = clientControl.msgLog;
                }

                bool RequestIsPending(Uri uri) {
                                return pendingRequests.Contains(uri);
                }

                public void ServiceRequest(Uri uri, Message messageToSend, IResponseHandler handler) {
                        if (clientControl.settings.PendingRequestsEnabled) {
                                lock (pendingRequests.SyncRoot) {
                                        // TODO: Check for Pragma: no-cache
                                        if (RequestIsPending(uri)) {
                                                msgLog.Log("Request for {0} is pending, adding to waiting list", uri);
                                                AddToPendingRequest(uri, messageToSend, handler);
                                        } else { 
                                                msgLog.Log("Request for {0} is not pending, creating pending request and sending to server", uri);
                                                CreatePendingRequest(uri, messageToSend, handler); 
                                                // send on the request here
                                                ((PendingRequest)pendingRequests[uri]).SendNextRequest();
                                        }
                                }
                        } else { // pending request not enabled
                                clientControl.serverStub.toServerMsgQ.EnqueueBlocking(messageToSend);
                        }
                }

                void CreatePendingRequest(Uri uri) {
                        lock (pendingRequests.SyncRoot) {
                                pendingRequests.Add(uri, new PendingRequest(uri, this));
                        }
                }

                void CreatePendingRequest(Uri uri, Message messageToSend, IResponseHandler handler) {
                        lock (pendingRequests.SyncRoot) {
                                pendingRequests.Add(uri, new PendingRequest(uri, this, messageToSend, handler));
                        }
                }

                void AddToPendingRequest(Uri uri, Message messageToSend, IResponseHandler handler) {
                        PendingRequest myPendingRequest = (PendingRequest)pendingRequests[uri];
                        lock (myPendingRequest) {
                                myPendingRequest.AddRequestToWaitingList(messageToSend, handler);
                        }
                }

                public void HandleRemainingRequests(Uri uri, Message responseMsg, bool haveJustHandledRequestInQueue) {
                        if (clientControl.settings.PendingRequestsEnabled) {
                                lock (pendingRequests.SyncRoot) {
                                        if (pendingRequests.Contains(uri)) {
                                                // remove the top item that should have been handled pre-call.
                                                PendingRequest myPendingRequest = (PendingRequest)pendingRequests[uri];
                                                lock (myPendingRequest) {
                                                        // TODO: Figure out if we want that next line or not: enumerate conditions of arrival / pending.
                                                        if (haveJustHandledRequestInQueue) {
                                                                myPendingRequest.RemoveTopRequest();
                                                        }
                                                        myPendingRequest.ProcessWaitingList(responseMsg);
                                                        if (myPendingRequest.Count == 0) {
                                                                pendingRequests.Remove(uri);
                                                                msgLog.Log("Removed pending request holder for {0}", uri);
                                                        } else {
                                                                msgLog.LogError("Expected {0} pending requests to be empty. It has {1} entries. Cannot delete", uri, ((PendingRequest)pendingRequests[uri]).Count);
                                                        }
                                                }
                                        } else {
                                                msgLog.Log("No pending request holder for {0}, nothing to do", uri);
                                        }
                                }
                        } else { // pending requests not enabled
                                /* do nothing */
                        }
                }
        

                public void AddPlaceholders(Uri[] requestUris) {
                        lock (pendingRequests.SyncRoot) {
                                foreach (Uri currentUri in requestUris) {
                                        if (currentUri != null) {
                                                if (RequestIsPending(currentUri)) {
                                                        // no-op, we just wait until it arrives
                                                        msgLog.Log("We already have a pending request for the placeholder for {0}", currentUri);
                                                } else {
                                                        CreatePendingRequest(currentUri);
                                                }
                                        }
                                }
                                msgLog.Log("Pending requests have been entered for {0} pushed URIs", requestUris.Length);
                        }
                }
        }
}

---