def _handle_request(self, spkt):
if spkt.get_payload() != PayloadRaw(self.data):
logging.error("Payload verification failed:\n%s", spkt)
return False
logging.debug('SRV: request received, sending response.')
spkt.reverse()
spkt.set_payload(PayloadRaw(b"response"))
self._send_pkt(spkt)
self.success = True
self.finished.set()
return True
def from_values(cls, cmn_hdr, addr_hdr, path_hdr, payload=None):
inst = cls()
inst._inner_from_values(cmn_hdr, addr_hdr, path_hdr)
if payload is None:
payload = PayloadRaw()
inst.set_payload(payload)
inst.update()
return inst
def _handle_request(self, spkt):
logging.debug("Received:\n%s", spkt)
spkt.reverse()
pld = PayloadRaw(("pong %d" % self.count).encode("ascii"))
spkt.set_payload(pld)
self._send_pkt(spkt)
self.count += 1
self.success = True
return True
def test(self):
inst = SCIONBasePacket()
inst.path = "path"
inst.cmn_hdr = create_mock(["validate"])
inst.addrs = create_mock(["validate"])
inst._validate_of_idxes = create_mock()
inst._payload = PayloadRaw()
# Call
inst.validate("pkt len")
# Tests
inst.cmn_hdr.validate.assert_called_once_with("pkt len", 4)
inst.addrs.validate.assert_called_once_with()
inst._validate_of_idxes.assert_called_once_with()
def _build_packet(self, dst_host=None, path=None, ext_hdrs=(),
dst_ia=None, payload=None, dst_port=0):
if dst_host is None:
dst_host = HostAddrNone()
if dst_ia is None:
dst_ia = self.addr.isd_as
if path is None:
path = SCIONPath()
if payload is None:
payload = PayloadRaw()
dst_addr = SCIONAddr.from_values(dst_ia, dst_host)
cmn_hdr, addr_hdr = build_base_hdrs(dst_addr, self.addr)
udp_hdr = SCIONUDPHeader.from_values(
self.addr, self._port, dst_addr, dst_port)
return SCIONL4Packet.from_values(
cmn_hdr, addr_hdr, path, ext_hdrs, udp_hdr, payload)
def test(self):
"""
Bandwidth test method. Obtains a path to (2, 26) and sends PACKETS_NO
packets (each with PAYLOAD_SIZE long payload) to a host in (2, 26).
"""
addr = haddr_parse("IPV4", "127.1.19.254")
conf_dir = "%s/ISD1/AD19/endhost" % GEN_PATH
sender = SCIONDaemon.start(conf_dir, addr)
paths = sender.get_paths(2, 26)
self.assertTrue(paths)
rcv_sock = UDPSocket(bind=("127.2.26.254", 0, "Bw test receiver"),
addr_type=AddrType.IPV4)
logging.info("Starting the receiver.")
recv_t = threading.Thread(
target=thread_safety_net, args=(self.receiver, rcv_sock),
name="BwT.receiver")
recv_t.start()
payload = PayloadRaw(b"A" * PAYLOAD_SIZE)
spkt = sender._build_packet(
haddr_parse("IPV4", "127.2.26.254"), dst_isd=2, dst_ad=26,
dst_port=rcv_sock.port, payload=payload, path=paths[0])
(next_hop, port) = sender.get_first_hop(spkt)
assert next_hop is not None
logging.info("Sending %d payload bytes (%d packets x %d bytes )" %
(PACKETS_NO * PAYLOAD_SIZE, PACKETS_NO, PAYLOAD_SIZE))
for _ in range(PACKETS_NO):
sender.send(spkt, next_hop, port)
time.sleep(SLEEP)
logging.info("Sending finished")
recv_t.join()
if self.rate < 10.0:
sys.exit(0)
else:
sys.exit(int(self.rate))
def _parse(self, raw):
data = Raw(raw, self.NAME, self.MIN_LEN, min_=True)
self._inner_parse(data)
self.set_payload(PayloadRaw(data.get()))
def _create_payload(self, spkt):
return PayloadRaw(self.data)
def _gen_max_pld(self, data, pld_len):
padding = pld_len - len(data)
return PayloadRaw(data + bytes(padding))
def _create_payload(self, spkt):
old_pld = spkt.get_payload()
data = b"pong " + self.data
padding = len(old_pld) - len(data)
return PayloadRaw(data + bytes(padding))