SmartDeviceClient/SmartProtocolStack/RemoteHost/ACKManager.cs

using System;
using System.Threading;
using System.Collections;
using System.Collections.Specialized;
using GPRSWeb.SmartDeviceClient.Common;

namespace GPRSWeb.SmartDeviceClient.SmartProtocolStack.RemoteHost
{

        public class ACKManager {
                public static int INTER_ACKABLE_TIME;
                public static int FIRST_ACKABLE_TIME;
                public static int ACK_ARRIVAL_TIMEOUT;

                private AckQueue ackQueue;
                private ReplyTracker replyTracker;
                private AckTimerList ackTimerList;
                private AckableGenerator ackableGenerator;
                private RemoteHostComms thisRemoteHost;

                public ACKManager(RemoteHostComms thisRemoteHost) {                     
                        this.thisRemoteHost = thisRemoteHost;
                        Init();
                        ackQueue = new AckQueue();
                        replyTracker = new ReplyTracker();
                        ackTimerList = new AckTimerList(replyTracker, thisRemoteHost.thisStack.connectionReset);
                        ackableGenerator = new AckableGenerator(thisRemoteHost);
                }

                public void Init() {
                        INTER_ACKABLE_TIME = thisRemoteHost.thisStack.settings.InterAckableTime; // seconds
                        FIRST_ACKABLE_TIME = thisRemoteHost.thisStack.settings.FirstAckableTime; // seconds
                        ACK_ARRIVAL_TIMEOUT = thisRemoteHost.thisStack.settings.AckArrivalTimeout; // seconds
                }

                public void ResetConnection() {
                        StopAckableGenerator();
            ackQueue.Clear();
                        ackTimerList.ResetConnection();
                        replyTracker.ResetConnection();
                        StartAckableGenerator();
                }

                public bool IsAckableWaiting() {
                        /* if we are due to send an ackable packet, this will return true. Else it will not.
                         * should maintain a count of ackable packets waiting (semaphore style?) */
                        return ackableGenerator.IsAckableWaiting;
                }

                public void StartAckableGenerator() {
                        ackableGenerator.Start();
                }

                public void StopAckableGenerator() {
                        ackableGenerator.Stop();
                }
                
                public AckInfo GetNextAck() {
                        /* returns details of the next acknowledgement that needs to be sent, 
                         * or null if no acknowledgement needs sending */
                        if (ackQueue.IsEmpty) { return null; } 
                        else return ackQueue.Dequeue(); 
                }

                public void SentAckableSegment(uint sequenceNumber) {
                        ackableGenerator.DecAckablesWaiting();
                        if (thisRemoteHost.readyToSendUserData) {
                                ackTimerList.AddTimer(sequenceNumber);
                        } else {
                                Console.WriteLine("    Did not set timer for return of ACK, since not ready to send");
                        }
                        //Console.WriteLine("ACK Manager: Ackable Segment #" + sequenceNumber +" just Sent");
                }

                public void ProcessReceivedSegmentHeaders(ref SegmentHeaders headers) {
                        /* if segment is an ACK, call SegmentAcknowledged(seqNum) 
                         * if segment is ACKable, call IssueACK(seqNum) 
                         * otherwise noop*/
                        if (headers.IsAck) { this.SegmentAcknowledged(headers.ACKdSequenceNumber); }
                        if (headers.IsAckable) { this.IssueACK(headers.SequenceNumber); }
                }

                private void SegmentAcknowledged(uint ackdSequenceNumber) {
                        /* If a timer for the segment has not yet expired: 
                         * - clear the timer
                         * - reset the 'Number of Acks missed in a row' counter
                         * else 
                         * - do nothing */
                        if (thisRemoteHost.readyToSendUserData) {
                                if (ackTimerList.Contains(ackdSequenceNumber)) {
                                        ackTimerList.RemoveTimer(ackdSequenceNumber);
                                        replyTracker.ACKReceived();
                                        //Console.WriteLine("ACK Manager: ACK received for segment#" + ackdSequenceNumber);
                                }
                        } else {
                                thisRemoteHost.readyToSendUserData = true;
                                Console.WriteLine("### First ACK received. Now READY TO SEND USER DATA ###");
                        }
                        
                }

                private void IssueACK(uint sequenceNumberToACK) {
                        //Console.WriteLine("ACK Manager: Ackable received. Need to ACK #" + sequenceNumberToACK);
                        lock(thisRemoteHost.TxQueue.SyncRoot) {
                                if (thisRemoteHost.TxQueue.IsEmpty) {
                                        /* create no-op message */
                                        Message noopMsg = new EmptyMessage();
                                        noopMsg.Destination = thisRemoteHost.RemoteDeviceID;
                                        /* segmentise */
                                        TransmissionQueueEntry[] buffer = TransmissionQueueEntry.FromMessage(noopMsg);
                                        /* place results in segment queue */
                                        // make sure this all happens in a monitor, so we get them all together
                                        thisRemoteHost.TxQueue.EnqueueUnprotected(buffer, false);
                                }
                                ackQueue.Enqueue(new AckInfo(sequenceNumberToACK));
                                //Console.WriteLine("ACK Manager: ACK Issued for #" + sequenceNumberToACK);
                                Monitor.PulseAll(thisRemoteHost.TxQueue.SyncRoot);
                        }
                        
                }
        }

        public class AckableGenerator {
                private int ackablesWaitingCount;
                private Timer ackableGenerateTimer;
                private RemoteHostComms thisRemoteHost;
                private TransmissionQueue txQueue;
                
                public AckableGenerator(RemoteHostComms thisRemoteHost) {
                        this.thisRemoteHost = thisRemoteHost;
                        this.txQueue = thisRemoteHost.TxQueue;
                        ackablesWaitingCount = 0;
                        ackableGenerateTimer = new Timer(new TimerCallback(this.GeneratorTimerCallback), null, Timeout.Infinite, Timeout.Infinite);
                }

                public void GeneratorTimerCallback(object o) {
                        lock(txQueue.SyncRoot) {
                                if (txQueue.IsEmpty) {
                                        /* create no-op message */
                                        Message noopMsg = new EmptyMessage();
                                        noopMsg.Destination = thisRemoteHost.RemoteDeviceID;
                                        /* segmentise */
                                        TransmissionQueueEntry[] buffer = TransmissionQueueEntry.FromMessage(noopMsg);
                                        /* place results in segment queue */
                                        // make sure this all happens in a monitor, so we get them all together
                                        txQueue.EnqueueUnprotected(buffer, false);
                                }
                                IncAckablesWaiting();
                                lock (thisRemoteHost.AckManager) {
                                        Monitor.PulseAll(thisRemoteHost.AckManager);
                                }
                                Monitor.PulseAll(txQueue.SyncRoot);
                        }
                }

                public void IncAckablesWaiting() {
                        lock(this) {
                                ackablesWaitingCount++;
                        }
                }
                public void DecAckablesWaiting() {
                        lock(this) {
                                if (ackablesWaitingCount > 0) { ackablesWaitingCount--; }
                        }
                }

                public void ResetConnection() {
                        lock(this) {
                                ackablesWaitingCount = 0;
                        }
                }

                public void Start() {
                        ackableGenerateTimer.Change(ACKManager.FIRST_ACKABLE_TIME * 1000, ACKManager.INTER_ACKABLE_TIME * 1000);
                }

                public void Stop() {
                        ackableGenerateTimer.Change(Timeout.Infinite, Timeout.Infinite);
                }

                public bool IsAckableWaiting {
                        get {
                                bool result;
                                lock(this) {
                                        result = (ackablesWaitingCount != 0);
                                }
                                return result;
                        }
                }

        }

        public class AckInfo {
                uint sequenceNumber; // seq # of the segment that needs acking

                public AckInfo(uint sequenceNumber) {
                        this.sequenceNumber = sequenceNumber;
                }

                public uint SequenceNumber { get { return sequenceNumber; } }
        }

        class AckQueue : Queue {
                public AckQueue() : base() {}

                public void Enqueue(AckInfo ackInfo) {
                        lock (this.SyncRoot) {
                                base.Enqueue(ackInfo);                  
                                Monitor.PulseAll(this.SyncRoot);
                        } 
                }

                public new AckInfo Dequeue() {
                        AckInfo result;
                        lock (this.SyncRoot) {
                                result = (AckInfo)base.Dequeue();
                        }
                        return result;
                }


                public bool IsEmpty {
                        get {
                                bool result;
                                lock (this.SyncRoot) {
                                        result = (this.Count == 0);
                                }
                                return result;
                        }
                }

        }

        class AckTimer {
                private Timer t;

                public AckTimer(TimerInfo timerInfo, TimerCallback callback) {
                        t = new Timer(callback, timerInfo, Timeout.Infinite, Timeout.Infinite);
                }

                public void StopTheClock() {
                        t.Change(Timeout.Infinite, Timeout.Infinite);
                        //t.Dispose();
                        //t = null; // cause garbage collecter to free some memory.
                        //Console.WriteLine("Clock Stopped");
                }

                public void StartTheClock(uint countdown) {
                        t.Change(countdown, Timeout.Infinite);
                        //Console.WriteLine("Clock Started");
                }
        }

        class ReplyTracker {
                private int noReplyCount;
                public ReplyTracker() {
                        Init();
                }

                private void Init() {
                        noReplyCount = 0;
                }

                public void ResetConnection() {
                        Init();
                }

                public void ACKMissed() {
                        noReplyCount++;
                        if (noReplyCount == 3) {
                                throw new ConnectionReset();
                        }
                }

                public void ACKReceived() {
                        noReplyCount = 0;
                }
        }

        class AckTimerList : ListDictionary {
                private ReplyTracker replyTracker;
                private ConnectionResetDelegate connectionReset;

                public AckTimerList(ReplyTracker replyTracker, ConnectionResetDelegate connectionReset) : base() {
                        this.replyTracker = replyTracker;
                        this.connectionReset = connectionReset;
                }

                public void AddTimer(uint sequenceNumber) {
                        TimerInfo info = new TimerInfo(sequenceNumber, replyTracker);
                        AckTimer timerObj = new AckTimer(info, new TimerCallback(this.TimerExpires));
                        base.Add(sequenceNumber, timerObj);
                        timerObj.StartTheClock((uint)ACKManager.ACK_ARRIVAL_TIMEOUT * 1000);
                }

                public void TimerExpires(object obj){
                        try {
                                TimerInfo ti = (TimerInfo)obj;
                                lock(ti.tracker) {
                                        ti.tracker.ACKMissed();
                                }
                                this.RemoveTimer(ti.segmentNumber); 
                        } catch (ConnectionReset) {
                                Console.WriteLine("*** No traffic on connection for last 90 seconds. Connection Reset ***\n*** Calling Connection Reset Handler ***");
                                connectionReset();
                        }
                }

                public void RemoveTimer(uint sequenceNumber) {
                        AckTimer workingTimer = (AckTimer)base[sequenceNumber];
                        if (workingTimer != null) {
                                workingTimer.StopTheClock();
                        }
                        base.Remove(sequenceNumber);
                }

                public void ResetConnection() {
                        foreach (DictionaryEntry de in this) {
                                AckTimer timer = (AckTimer)de.Value;
                                timer.StopTheClock();
                        }
                        Clear();
                }
        }

        class TimerInfo {
                public uint segmentNumber;
                public ReplyTracker tracker;

                public TimerInfo(uint segmentNumber, ReplyTracker tracker) {
                        this.segmentNumber = segmentNumber;
                        this.tracker = tracker;
                }
        }
}

---