class Link:
"""
Builder for Link instances.
"""
_STATIC = 1
_DYNAMIC = 1
_WINDOW = 4000
def __init__(self):
"""
Creates a Link instance.
"""
self._tracker = LinkTracker()
def __repr__(self):
"""
Defines the string representation for a Link instance.
"""
return ('Link['
'dest=%s'
']') % (self.dest().source())
def getTracker(self):
'''
return the linkTracker instance
'''
return self._tracker
def record_packet_entry(self, packet, time):
self._tracker.record_packet_entry(packet, time)
def update_queueing_delay(self, packet, time):
"""
Updates the queuing delay of the link.
"""
self._tracker.update_queueing_delay(packet, time)
def record_sent(self, time, size):
"""
Records the time when a packet is sent.
"""
self._tracker.record_sent(time, size)
#print str(time) + " " + str(size)
def record_packet_loss(self, time):
"""
Records the time when a packet is lost.
"""
self._tracker.record_packet_loss(time)
def record_buffer_size(self, time, size):
"""
Records the buffer size at a certain time.
"""
self._tracker.record_buffer_size(time, size)
def record_round_trip(self, time, rtt):
"""
Records the round trip time at a certain time.
"""
self._tracker.record_round_trip(time, rtt)
def record_link_rate(self, time, rate):
'''
record the link rate at a certain time
'''
self._tracker.record_link_rate(time, rate)
def throughput(self, since, until):
"""
Returns the throughput of the link within the given time range.
"""
occupancy = self._tracker.occupancy(since, until, self.delay())
if (until - since) == 0:
return 0
else:
return (float(occupancy) / float(until - since))
def rtt(self, since=-1):
"""
Returns the average round trip time of the link.
"""
mean_rtt = self._tracker.mean_rtt(since)
if mean_rtt == -1:
return 3 * self.delay()
return mean_rtt
def timeout(self, since=-1):
"""
Returns the timeout length of the link.
"""
return (self.rtt(since) + 4 * sqrt(self._tracker.variance_rtt(since)))
def delay(self, delay=None):
"""
delay() -> returns the delay
delay(delay) -> sets the delay as the specified value and
returns this instance
"""
if delay is None:
return self._delay
# Checks that delay is a float
if not isinstance(delay, float):
raise TypeError, 'delay must be a float'
self._delay = delay
self._tracker.set_delay(delay)
return self
def mean_queuing_delay(self, since):
"""
Returns the average queuing delay since the specified time.
"""
return self._tracker.get_average_queueing_delay(since)
def cost(self, time):
"""
Returns the static component of the cost.
"""
static_cost = Link._STATIC * self.delay()
since = time - Link._WINDOW
dynamic_cost = Link._DYNAMIC * self.mean_queuing_delay(since)
return (static_cost + dynamic_cost)
def rate(self, rate=None):
"""
rate() -> returns the rate
rate(rate) -> sets the rate as the specified value and returns
this instance
"""
if rate is None:
return self._rate
# Checks that rate is an int
if not isinstance(rate, int):
raise TypeError, 'rate must be an int'
self._rate = rate
def dest(self, port=None):
"""
dest() -> returns the destination port
dest(port) -> sets the destination port as the specified value
"""
if port is None:
return self._dest_port
# Checks that port is a Port instance
if not isinstance(port, Port):
raise TypeError, 'port must be a Port instance'
self._dest_port = port
def __init__(self):
"""
Creates a Link instance.
"""
self._tracker = LinkTracker()
