def main():
args = setup_main("cli_srv_ext_test")
if args.run_server:
dst = SCIONAddr.from_values(ISD_AS(args.dst_ia),
haddr_parse_interface(args.server))
ExtServer(args.data.encode('utf-8'), dst, port=int(args.port)).run()
else:
src = SCIONAddr.from_values(ISD_AS(args.src_ia),
haddr_parse_interface(args.client))
dst = SCIONAddr.from_values(ISD_AS(args.dst_ia),
haddr_parse_interface(args.server))
ExtClient(args.data.encode('utf-8'),
src,
dst,
dport=int(args.port),
retries=args.retries).run()
def test_v4(self, parse):
parse.side_effect = iter([SCIONParseError, "v4 parsed"])
# Call
ntools.eq_(haddr_parse_interface("v4 addr"), "v4 parsed")
# Tests
assert_these_calls(parse, [
call(AddrType.IPV6, "v4 addr"),
call(AddrType.IPV4, "v4 addr"),
])
def _parse_addrs(self, value):
if not value:
return []
addrs = []
if not isinstance(value, (list, tuple)):
value = [value]
for val in value:
addrs.append((haddr_parse_interface(val['Addr']), val['L4Port']))
return addrs
def __init__(self,
client,
server,
sources,
destinations,
local=True,
max_runs=None,
retries=0):
assert self.NAME
t = threading.current_thread()
t.name = self.NAME
self.client_ip = haddr_parse_interface(client)
self.server_ip = haddr_parse_interface(server)
self.src_ias = sources
self.dst_ias = destinations
self.local = local
self.max_runs = max_runs
self.retries = retries
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-l',
'--loglevel',
default="INFO",
help='Console logging level (Default: %(default)s)')
parser.add_argument('-c',
'--count',
default=1,
type=int,
help='Number of packets to send. 0 means unlimited.')
parser.add_argument(
'-s',
'--size',
default=0,
type=int,
help='Size of packets to send. 0 means use the MTU of the path.')
parser.add_argument(
'-w',
'--wait',
default=0,
type=int,
help='Wait time in milliseconds after a packet has been sent.')
parser.add_argument('src_ia', help='Src ISD-AS')
parser.add_argument('src_addr', help='Src IP')
parser.add_argument('dst_ia', help='Dst ISD-AS')
parser.add_argument('dst_addr', help='Dst IP')
args = parser.parse_args()
init_logging("logs/pktgen", console_level=args.loglevel)
src = SCIONAddr.from_values(ISD_AS(args.src_ia),
haddr_parse_interface(args.src_addr))
dst = SCIONAddr.from_values(ISD_AS(args.dst_ia),
haddr_parse_interface(args.dst_addr))
gen = PktGen(b"data", "finished", src, dst, 3000, size=args.size)
start = time.time()
try:
gen.run(args.count, args.wait)
except KeyboardInterrupt:
pass
total = time.time() - start
logging.info("Sent %d %dB packets in %.3fs (%d pps, %d bps)", gen.sent,
gen.size, total, gen.sent / total,
(gen.sent * gen.size * 8) / total)
def __init__(self, addr=None, name=None):
"""
:param str addr: (addr_type, address) of the element's Host address.
:param str name: element name or id
"""
self.addr = None
if addr:
self.addr = haddr_parse_interface(addr)
self.name = None
if name is not None:
self.name = str(name)
def main():
args = setup_main("scmp_error_test")
src = SCIONAddr.from_values(ISD_AS(args.src_ia),
haddr_parse_interface(args.client))
dst = SCIONAddr.from_values(ISD_AS(args.dst_ia),
haddr_parse_interface(args.server))
data = ("%s<->%s" % (src, dst)).encode("UTF-8")
success = True
for cls_ in GEN_LIST:
logging.info("===========> Testing: %s", cls_.DESC)
client = cls_(copy.deepcopy(data),
copy.deepcopy(src),
copy.deepcopy(dst),
0,
api=True)
if not client.run():
success = False
if not success:
sys.exit(1)
def __init__(self, interface_dict, name=None):
"""
:param dict interface_dict: contains information about the interface.
"""
super().__init__(interface_dict['Addr'], name)
self.if_id = interface_dict['IFID']
self.isd_as = ISD_AS(interface_dict['ISD_AS'])
self.link_type = interface_dict['LinkType']
self.to_udp_port = interface_dict['ToUdpPort']
self.udp_port = interface_dict['UdpPort']
self.bandwidth = interface_dict['Bandwidth']
self.mtu = interface_dict['MTU']
to_addr = interface_dict['ToAddr']
self.to_addr = None
if to_addr:
self.to_addr = haddr_parse_interface(to_addr)
self.to_if_id = 0 # Filled in later by IFID packets
def send(self, data, dst=None):
"""
Send data through the socket.
:param bytes data: Data to send.
"""
if dst:
dst_addr, dst_port = dst
if isinstance(dst_addr, str):
dst_addr = haddr_parse_interface(dst_addr)
addr_len = struct.pack("B", len(dst_addr))
packed_dst = dst_addr.pack() + struct.pack("H", dst_port)
else:
addr_len = struct.pack("B", 0)
packed_dst = b""
data_len = struct.pack("I", len(data))
data = b"".join([self.COOKIE, addr_len, data_len, packed_dst, data])
try:
self.sock.sendall(data)
except OSError as e:
logging.error("error sending to dispatcher: %s", e)
def send(self, data, dst=None):
"""
Send data through the socket.
:param bytes data: Data to send.
"""
if dst:
dst_addr, dst_port = dst
if isinstance(dst_addr, str):
dst_addr = haddr_parse_interface(dst_addr)
addr_type = struct.pack("B", dst_addr.TYPE)
packed_dst = dst_addr.pack() + struct.pack("H", dst_port)
else:
addr_type = struct.pack("B", AddrType.NONE)
packed_dst = b""
data_len = struct.pack("I", len(data))
data = b"".join([self.COOKIE, addr_type, data_len, packed_dst, data])
try:
self.sock.sendall(data)
return True
except OSError as e:
logging.error("error in send: %s", e)
return False
def test_v6(self, parse):
ntools.eq_(haddr_parse_interface("v6 addr"), parse.return_value)
# Tests
parse.assert_called_once_with(AddrType.IPV6, "v6 addr")
def _parse_zk_dicts(self, topology):
for zk in topology['Zookeepers'].values():
haddr = haddr_parse_interface(zk['Addr'])
zk_host = "[%s]:%s" % (haddr, zk['Port'])
self.zookeepers.append(zk_host)
def _parse_addrs(self, value):
if not value:
return None
return (haddr_parse_interface(value['Addr']), value['L4Port'])
def _parse_zk_dicts(self, topology):
for zk in topology.get('ZookeeperService', {}).values():
haddr = haddr_parse_interface(zk['Addr'])
zk_host = "[%s]:%s" % (haddr, zk['L4Port'])
self.zookeepers.append(zk_host)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-l',
'--loglevel',
default="INFO",
help='Console logging level (Default: %(default)s)')
parser.add_argument('-c',
'--count',
default=1,
type=int,
help='Number of packets to send. 0 means unlimited.')
parser.add_argument(
'-s',
'--size',
default=0,
type=int,
help='Size of packets to send. 0 means use the MTU of the path.')
parser.add_argument(
'-w',
'--wait',
default=0,
type=int,
help='Wait time in milliseconds after a packet has been sent.')
parser.add_argument('-r',
'--random',
action='store_true',
help='Run with randomized wait time and packet size')
parser.add_argument(
'-la',
'--lambd',
default=50,
type=int,
help='Number of packets that are sent in average per second. '
'0 means that as many packets as possible are sent.'
' Only used with -r flag')
parser.add_argument(
'-n',
'--number',
default=1000,
type=int,
help='Number of random sized packets to be used. Only used with -r flag.'
'(Default: %(default)s)')
parser.add_argument('src_ia', help='Src ISD-AS')
parser.add_argument('src_addr', help='Src IP')
parser.add_argument('dst_ia', help='Dst ISD-AS')
parser.add_argument('dst_addr', help='Dst IP')
args = parser.parse_args()
init_logging("logs/pktgen", console_level=args.loglevel)
src = SCIONAddr.from_values(ISD_AS(args.src_ia),
haddr_parse_interface(args.src_addr))
dst = SCIONAddr.from_values(ISD_AS(args.dst_ia),
haddr_parse_interface(args.dst_addr))
gen = PktGen(b"data", "finished", src, dst, 3000, size=args.size)
if args.random and (args.wait or args.size):
logging.warning(
"Flags -w and -s are not used in random mode. See -h for help.")
elif not args.random and (args.lambd != 50 or args.number != 1000):
logging.warning(
"Flags -la and -n are not used in performance mode. See -h for help."
)
try:
if args.random:
gen.random_run(args.count, args.lambd, args.number)
else:
gen.run(args.count, args.wait)
except KeyboardInterrupt:
pass
total = time.time() - gen.start
if args.random:
logging.info("Sent %d bytes in %d packets in %.3fs (%d pps, %d bps)",
gen.bytes_sent, gen.sent, total, gen.sent / total,
(gen.bytes_sent * 8) / total)
else:
logging.info("Sent %d %dB packets in %.3fs (%d pps, %d bps)", gen.sent,
gen.size, total, gen.sent / total,
(gen.sent * gen.size * 8) / total)
