/// <summary>
/// Constructor: Creates a new instance with the given retransmit command
/// </summary>
/// <param name="sender">The sender associated with this instance</param>
/// <param name="cmd">The command used to retransmit a missing message</param>
/// <param name="start_seqno">The first sequence number to be received</param>
/// <param name="sched">The external scheduler to use for retransmission</param>
public NakReceiverWindow(Address sender, Retransmitter.RetransmitCommand cmd,
long start_seqno, TimeScheduler sched)
{
this.sender = sender;
this.cmd = cmd;
head = start_seqno;
tail = head;
if (cmd != null)
retransmitter = sched==null ?
new Retransmitter(sender, cmd):
new Retransmitter(sender, cmd, sched);
}
/// <summary>
/// Sets the TimeScheduler to the instance in the ProtocolSinkStack and
/// initialises the GMS implementation if possible.
/// </summary>
public override void init()
{
timer=stack != null? stack.timer : null;
if(timer == null)
throw new Exception("GMS.init(): timer is null");
if(impl != null)
impl.init();
}
/// <remarks>
/// The reason for waiting a random amount of time is that, in the worst case, all members receive a
/// STABLE_GOSSIP message from the last outstanding member at the same time and would therefore mcast the
/// STABILITY message at the same time too. To avoid this, each member waits random N msecs. If, before N
/// elapses, some other member sent the STABILITY message, we just cancel our own message. If, during
/// waiting for N msecs to send STABILITY message S1, another STABILITY message S2 is to be sent, we just
/// discard S2.
/// </remarks>
/// <summary>
/// Schedules a stability message to be mcast after a random number of milliseconds.
/// </summary>
/// <param name="tmp">Stable Digest</param>
private void sendStabilityMessage(Digest tmp)
{
long delay;
if(timer == null)
{
if(Trace.trace)
Trace.error("STABLE.sendStabilityMessage()", "timer is null, cannot schedule " + "stability message to be sent");
timer=stack != null ? stack.timer : null;
return;
}
// give other members a chance to mcast STABILITY message. if we receive STABILITY by the end of
// our random sleep, we will not send the STABILITY msg. this prevents that all mbrs mcast a
// STABILITY msg at the same time
delay=random.Next((int)stability_delay);
if(Trace.trace)
Trace.info("STABLE.sendStabilityMessage()", "stability_task=" + stability_task + ", delay is " + delay);
lock(stability_mutex)
{
if(stability_task != null && !stability_task.cancelled()) // schedule only if not yet running
return;
stability_task =new StabilitySendTask(this, tmp, delay);
timer.add(stability_task, true); // run it 1x after delay msecs. use fixed-rate scheduling
}
}
/// <summary>
/// Sets the Scheduler to the Scheduler present in the ProtocolSinkStack
/// </summary>
public override void start()
{
if(stack != null && stack.timer != null)
timer = stack.timer;
else
throw new Exception("STABLE.up(): timer cannot be retrieved from protocol stack");
}
/// <summary>
/// Uses TimeScheduler from ProtocolSinkStack.
/// </summary>
public override void start()
{
timer=stack != null ? stack.timer : null;
if(timer == null)
throw new Exception("NAKACK.up(): timer is null");
}
/// <summary>
/// Sets the Scheduler to the Scheduler present in the ProtocolSinkStack
/// </summary>
public override void start()
{
timer=stack != null ? stack.timer : null;
if(timer == null)
if(Trace.trace)
Trace.error("UNICAST.up()", "[START] timer is null");
}
/// <summary>
/// Constructor: Create a new Retransmitter associated with the given sender address
/// </summary>
/// <param name="sender">The address from which retransmissions are expected or to which retransmissions are sent</param>
/// <param name="cmd">The retransmission callback reference</param>
/// <param name="sched">The retransmissions scheduler</param>
public Retransmitter(Address sender, RetransmitCommand cmd, TimeScheduler sched)
{
init(sender, cmd, sched, false);
}
/* ------------------------------- Private Methods -------------------------------------- */
/// <summary>
/// Initialises this object
/// </summary>
/// <param name="sender">The address from which retransmissions are expected</param>
/// <param name="cmd">The retransmission callback reference</param>
/// <param name="sched">Schedular for retransmit tasks</param>
/// <param name="sched_owned">sched_owned whether the scheduler parameter is owned by this object or is externally provided</param>
private void init(Address sender, RetransmitCommand cmd, TimeScheduler sched, bool sched_owned)
{
this.sender = sender;
this.cmd = cmd;
retransmitter_owned = sched_owned;
retransmitter = sched;
}
/// <summary>
/// Sets the <c>TimeScheduler</c> to be used to the one present in the <c>ProtocolSinkStack</c>
/// </summary>
public override void init()
{
if(stack != null && stack.timer != null)
timer=stack.timer;
else
if(Trace.trace)
Trace.error("FD.up()", "[START]: timer cannot be retrieved from protocol stack");
}
