SmartDeviceGUIClient/ACKManager.cs

using System;
using System.Threading;
using System.Collections;
using System.Collections.Specialized;

namespace SmartDeviceGUIClient
{
        public class ACKManager{}

//      public class ACKManager2 {
//              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 ACKManager2(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();
//              }
//
//              /// <summary>
//              /// Determines if the next segment to be sent should be 'ackable'
//              /// </summary>
//              /// <returns></returns>
//              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(); 
//              }
//
//              /// <summary>
//              /// Sets timer awaiting arrival of the acknowledgemnt for just sent ackable packet.
//              /// </summary>
//              /// <param name="sequenceNumber">sequence number we are expecting an ACK for</param>
//              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");
//              }
//
//              /// <summary>
//              /// Issues and accepts acknowledgements from a set of Segment Headers
//              /// </summary>
//              /// <param name="headers">Segment Headers to process</param>
//              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); }
//              }
//
//              /// <summary>
//              /// Processes the acknowledgement of a segment.
//              /// </summary>
//              /// <param name="ackdSequenceNumber">The segment number that has been acknowledged</param>
//              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;
//              
//              /// <summary>
//              /// Creates a new generator of Ackable segments
//              /// </summary>
//              /// <param name="txQueue">The transmission queue to output carriers on to, if need be</param>
//              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");
//              }
//
//              /// <summary>
//              /// Starts the timer. 'TimerExpired' will execute after the number of milliseconds in the argument
//              /// </summary>
//              /// <param name="countdown">Number of milliseconds before timer expires</param>
//              public void StartTheClock(uint countdown) {
//                      t.Change(countdown, Timeout.Infinite);
//                      //Console.WriteLine("Clock Started");
//              }
//      }
//
//      /// <summary>
//      /// Maintains a list of the number of ACKs that have been missed in succession.
//      /// Must be locked before use.
//      /// </summary>
//      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;
//              }
//      }
//
//      /// <summary>
//      /// List of AckTimers. Also deals with the 'three strikes and you're out' connection reset.
//      /// </summary>
//      class AckTimerList : ListDictionary {
//              private ReplyTracker replyTracker;
//              private ConnectionResetDelegate connectionReset;
//
//              public AckTimerList(ReplyTracker replyTracker, ConnectionResetDelegate connectionReset) : base() {
//                      this.replyTracker = replyTracker;
//                      this.connectionReset = connectionReset;
//              }
//
//              /// <summary>
//              /// Adds a timer to the list for a the ACK of a given sequence number.
//              /// Sets it going on a 10 second fuse
//              /// </summary>
//              /// <param name="sequenceNumber">sequence number we are timing the ACK response for</param>
//              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);
//              }
//
//              /// <summary>
//              /// Called by timer thread when a timer expires.
//              /// </summary>
//              /// <param name="obj">A TimerInfo object telling what segment number we were wating for, and where to record the count</param>
//              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();
//                      }
//              }
//
//              /// <summary>
//              /// Stops timer for given sequence number, and removes it from the list. 
//              /// </summary>
//              /// <param name="sequenceNumber"></param>
//              public void RemoveTimer(uint sequenceNumber) {
//                      AckTimer workingTimer = (AckTimer)base[sequenceNumber];
//                      if (workingTimer != null) {
//                              workingTimer.StopTheClock();
//                      }
//                      base.Remove(sequenceNumber);
//              }
//
//              /// <summary>
//              /// Stops and removes all timers
//              /// </summary>
//              public void ResetConnection() {
//                      foreach (DictionaryEntry de in this) {
//                              AckTimer timer = (AckTimer)de.Value;
//                              timer.StopTheClock();
//                      }
//                      Clear();
//              }
//      }
//
//      /// <summary>
//      /// An object passed to the timer, which in turn passes it to the timer callback on firing.
//      /// This object specifies where to find the ReplyTracker object, and what segement number we were wating for
//      /// (this allows is to delete the timer)
//      /// </summary>
//      class TimerInfo {
//              public uint segmentNumber;
//              public ReplyTracker tracker;
//
//              public TimerInfo(uint segmentNumber, ReplyTracker tracker) {
//                      this.segmentNumber = segmentNumber;
//                      this.tracker = tracker;
//              }
//      }
}

---