def __init__(self, local_port, remote_port, msg_handler):
util.log("Starting up `Selective Repeat` protocol ... ")
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
# receiver
self.receiver_base = 0
self.is_receiver = True
self.receiver_buffer = [
None
] * config.WINDOW_SIZE # list to store packets with sequence number higher than receiver_base
self.received_flag_list = [
False
] * config.WINDOW_SIZE # list to keep track of received status for packet
# sender
self.sender_lock = threading.Lock()
self.sender_base = 0
self.next_sequence_number = 0
self.timer_list = [
None
] * config.WINDOW_SIZE # list to store of timer thread
self.acked_flag_list = [
False
] * config.WINDOW_SIZE # list to keep track of acknowledgement status for packet
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.seq_num = 0
self.lock = threading.RLock(
) # to ensure thread-safe global var of seq_num
self.header_format = "!hhh"
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.start_time = datetime.datetime.now()
self.base = 1
self.nextseqnum = 1
# sndpkts in window
self.sndpkts = collections.deque()
# init self.ack_pkts
self.ack_pkts = []
for i in range(config.WINDOW_SIZE):
self.ack_pkts.append(None)
# the very first 0 ack:
# calculate send check sum
self.receiver_wait_for_seq_num = 1
checksum = 0
checksum += config.MSG_TYPE_ACK
checksum += (self.receiver_wait_for_seq_num - 1)
# keep checksum in range [-32767, 32767]
checksum = checksum % 32767
# build and send pkt
ack_pkt = struct.pack('!h', config.MSG_TYPE_ACK)
ack_pkt += struct.pack('!h', self.receiver_wait_for_seq_num - 1)
ack_pkt += struct.pack('!h', checksum)
self.ack_pkts[0] = ack_pkt
self.ack_pkt = ack_pkt
self.previous_ack_seq_num = 0
def __init__(self, local_ip, local_port, remote_ip, remote_port,
msg_handler):
self.network_layer = udt.NetworkLayer(local_ip, local_port, remote_ip,
remote_port, self)
self.msg_handler = msg_handler
self.state = 0
self.lock = threading.Lock()
self.event = None
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.msg_buffer = collections.deque(maxlen=8)
self.buffer_lock = threading.Lock()
self.send_seq_number = 0
self.recv_seq_number = 0
self.send_seq_number_lock = threading.Lock()
self.recv_seq_number_lock = threading.Lock()
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.lock = threading.Lock()
self.is_sender = False
self.buffer = b""
self.sequence_number = 0
self.timer = None
self.state = WAIT_FOR_CALL
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
# Logger
LOGGER_FORMAT = '%(asctime)s - %(levelname)s - %(name)s - %(message)s'
logging.basicConfig(format=LOGGER_FORMAT)
self.logger = logging.getLogger('Stop and Wait Transport Protocol')
self.logger.setLevel(logging.INFO)
self.sender_count = 0
def __init__(self, local_ip, local_port,
remote_ip, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_ip, local_port,
remote_ip, remote_port, self)
self.msg_handler = msg_handler
self.base = 1
self.nextseqnum = 1
self.expseqnum = 1
self.timer = util.PeriodicClosure(self.timer_handler, config.TIMEOUT_MSEC / 1000)
self.ls = []
def __init__(self, local_ip, local_port, remote_ip, remote_port,
msg_handler):
self.network_layer = udt.NetworkLayer(local_ip, local_port, remote_ip,
remote_port, self)
self.msg_handler = msg_handler
self.sequence = 0
self.base = 0
self.expect_receive = 0
self.dic = dict()
self.timer = util.PeriodicClosure(self.timer_handler, 2)
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.lock = threading.Lock()
self.base = 0
self.next_sequence_number = 0
self.expected_sequence_number = 0
self.timer = self.get_timer()
self.is_sender = False
self.buffer = [b'' for _ in range(WINDOW_SIZE)]
def __init__(self, local_port, remote_port, msg_handler): self.network_layer = udt.NetworkLayer(local_port, remote_port, self) self.msg_handler = msg_handler self.base = 1 self.nextseqnum = 1 self.sendpkt = [b'']*config.WINDOWN_SIZE self.expectedseqnum = 1 self.recvr_segment = util.make_segment(config.MSG_TYPE_ACK, 0, b'') # Starts the timer thread immediately upon object creating self.timer = timer.TimerThread(self.timeout_handler)
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.base = 1
self.nextseqnum = 1
self.rcver_wait_for_seq_num = 1
self.timer = None
self.timer_active = False
self.last_sent_packets = []
self.last_ack_pkt = util.make_packet(config.MSG_TYPE_ACK, 0, '')
def __init__(self, local_port, remote_port, msg_handler):
util.log("Starting up `Stop and Wait` protocol ... ")
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.sequence_number = 0
self.last_pkt_sent = b''
self.last_pkt_sent_data = None
self.sender_lock = threading.Lock()
self.sender_state = config.WAIT_FOR_APP_DATA
self.set_timer()
self.is_receiver = True
def __init__(self, local_ip, local_port, remote_ip, remote_port,
msg_handler):
self.network_layer = udt.NetworkLayer(local_ip, local_port, remote_ip,
remote_port, self)
self.msg_handler = msg_handler
self.sequence = 0
self.ack_receive = -1
self.expect_receive = 0
self.timer = util.PeriodicClosure(self.timer_handler, 0.1)
self.packet = None
self.ss_type = 1 # 1-receiver 0-sender
def __init__(self, local_port, remote_port, msg_handler): self.network_layer = udt.NetworkLayer(local_port, remote_port, self) self.msg_handler = msg_handler self.next_seq_number = 1 self.base_seq_number = 1 self.last_seq_number_to_be_sent = None self.base_seq_number_lock = threading.Lock() self.next_seq_number_lock = threading.Lock() self.last_ack_number = 0 self.last_ack_number_lock = threading.Lock() self.timer = None self.timer_lock = threading.Lock()
def __init__(self, local_port, remote_port, msg_handler):
util.log("Starting up `Selective Repeat` protocol ... ")
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.sender_base = 0
self.next_sequence_number = 0
self.window = [b''] * config.WINDOW_SIZE
self.expected_sequence_number = [range(0, config.WINDOW_SIZE)]
self.receiver_last_ack = b''
self.is_receiver = True
self.sender_lock = threading.Lock()
self.windows = {}
def __init__(self, local_ip, local_port,
remote_ip, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_ip, local_port,
remote_ip, remote_port, self)
self.msg_handler = msg_handler
self.base = 1
self.next_seq = 1
self.expect_seq = 1
self.start_time = 0.0
self.packets = [None]
self.sendpkt = util.make_pack_with_header(config.MSG_TYPE_ACK, 0)
self.time_on = False
def __init__(self, local_ip, local_port, remote_ip, remote_port,
msg_handler):
self.network_layer = udt.NetworkLayer(local_ip, local_port, remote_ip,
remote_port, self)
self.msg_handler = msg_handler
self.timer = util.PeriodicClosure(self.timer_handler, 1)
self.nextseqnum = 0
self.buffer = b''
self.recv_buffer = b''
self.expseqnum = 0
self.can_sent = True
self.can_end = False
def __init__(self, local_ip, local_port, remote_ip, remote_port,
msg_handler):
self.network_layer = udt.NetworkLayer(local_ip, local_port, remote_ip,
remote_port, self)
self.msg_handler = msg_handler
self.start_time = 0.0
self.time_on = False
self.sender_type = config.MSG_TYPE_DATA
self.sender_seq = 0
self.packet = b''
self.expect_seq = 0
self.receiver_pack = util.make_pack_with_header(config.MSG_TYPE_ACK, 1)
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
# inits all variables:
# sender side
self.start_time = datetime.datetime.now()
self.sender_send_seq_num = 0
self.ack_wait_for_seq_num = 0
self.sndpkt = b''
# receiver side
self.receiver_wait_for_seq_num = 0
self.ack_pkt = b''
def __init__(self, local_port, remote_port, msg_handler):
util.log("Starting up `Selective Repeat` protocol ... ")
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.sender_base = 0
self.next_sequence_number = 0
self.timer_list = [self.set_timer(-1)] * config.WINDOW_SIZE
self.ack_list = [False] * config.WINDOW_SIZE
self.sender_buffer = [b''] * config.WINDOW_SIZE
self.receiver_last_ack = b''
self.is_receiver = True
self.receiver_base = 0
self.rcv_list = [False] * config.WINDOW_SIZE
self.rcv_buffer = [b''] * config.WINDOW_SIZE
self.sender_lock = threading.Lock()
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
# The initial state for the sender is wait for seq 0 from above
self.send_state = State.SEQ_0
# The initial state for the receiver is wait for seq 0 from below
self.recv_state = State.SEQ_0
# Initally empty transport layer segment
self.segment = b''
# Locking of segment
self.segment_lock = Lock()
# Once through for reciver
self.oncethru = 0
# Define timer thread, creates thread immediately
self.timer = timer.TimerThread(self.handle_timeout)
def __init__(self, local_ip, local_port,
remote_ip, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_ip, local_port,
remote_ip, remote_port, self)
self.msg_handler = msg_handler
self.pipe = []
self.next_seq = 0
self.receiver_expected_seq = 0
self.base = 0
self.p = threading.Thread(target=self.timer_event, daemon=True)
self.start_timer_event = threading.Event()
self.reset_timer_event = threading.Event()
self.stop_timer_event = threading.Event()
self.sender_lock = threading.Lock()
self.terminate_event = threading.Event()
self.lock = threading.Lock()
self.queue_lock = threading.Lock()
def __init__(self, local_port, remote_port, msg_handler):
self.network_layer = udt.NetworkLayer(local_port, remote_port, self)
self.msg_handler = msg_handler
self.sender_lock = threading.Lock()
self.sender_stop_monitor = False
self.sender_packet_list = []
self.sender_timer_list = []
self.sender_sequence_list = []
self.sender_sequence_count = 0
self.sender_ack_base = -1
# Logger
LOGGER_FORMAT = '%(asctime)s - %(levelname)s - %(name)s - %(message)s'
logging.basicConfig(format=LOGGER_FORMAT)
self.logger = logging.getLogger('GoBackN Transport Protocol')
self.logger.setLevel(logging.INFO)
threading.Thread(target=self._timeout_monitor).start()
threading.Thread(target=self._base_ack_monitor).start()
def __init__(self, role, local_ip, local_port, remote_ip, remote_port,
msg_handler):
self.role = role
self.network_layer = udt.NetworkLayer(local_ip, local_port, remote_ip,
remote_port, self)
self.msg_handler = msg_handler
self.timer = util.PeriodicClosure(self.timeout_handler,
config.TIMEOUT_MSEC / 1000)
# fields for a tl sender
self.seq_pkt_delivered = -1
self.seq_pkt_to_send = 0
self.msg_to_send = None
self.pkt_to_send = None
self.lock = Lock()
self.sender_arv_lock = Lock()
# fields for a tl receiver
self.seq_pkt_received = -1
self.seq_pkt_to_receive = 0
self.recvlock = Lock()
def __init__(self, role, local_ip, local_port, remote_ip, remote_port,
msg_handler):
self.role = role
self.network_layer = udt.NetworkLayer(local_ip, local_port, remote_ip,
remote_port, self)
self.msg_handler = msg_handler
self.timer = util.PeriodicClosure(self.timeout_handler,
config.TIMEOUT_MSEC / 1000)
self.starttime = time.time()
# fields for a tl sender
self.seq_pkt_delivered = -1
self.seq_pkt_index = 0
self.seq_pkt_window_left = 0
self.seq_pkt_window_right = config.WINDOW_SIZE # not inclusive
self.buffer = deque() # buffer of packages to send
self.lock = Lock()
# fields for a tl receiver
self.seq_pkt_received = -1
self.seq_pkt_to_receive = 0
self.recvlock = Lock()
def __init__(self, local_port, remote_port, msg_handler): self.network_layer = udt.NetworkLayer(local_port, remote_port, self) self.msg_handler = msg_handler
