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