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)