def test_console(self, basic_config, console):
# Call
init_logging(console_level=logging.DEBUG)
# Tests
basic_config.assert_called_once_with(
level=logging.DEBUG, handlers=[console.return_value],
)
def test_full(self, formatter, rotate, console, basic_config):
levels = "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
file_handlers = [
create_mock(["setLevel", "setFormatter"]),
create_mock(["setLevel", "setFormatter"]),
create_mock(["setLevel", "setFormatter"]),
create_mock(["setLevel", "setFormatter"]),
create_mock(["setLevel", "setFormatter"]),
]
console_handler = console.return_value
rotate.side_effect = file_handlers
# Call
init_logging("logbase",
file_level=logging.DEBUG,
console_level=logging.CRITICAL)
# Tests
rotate_calls = []
for lvl in levels:
rotate_calls.append(
call("logbase.%s" % lvl,
maxBytes=LOG_MAX_SIZE,
backupCount=LOG_BACKUP_COUNT,
encoding="utf-8"))
assert_these_calls(rotate, rotate_calls)
for lvl, f_h in zip(levels, file_handlers):
f_h.setLevel.assert_called_once_with(logging._nameToLevel[lvl])
f_h.setFormatter.assert_called_once_with(formatter.return_value)
console_handler.setLevel.assert_called_once_with(logging.CRITICAL)
console_handler.setFormatter.assert_called_once_with(
formatter.return_value)
basic_config.assert_called_once_with(level=logging.DEBUG,
handlers=file_handlers +
[console_handler])
def test_file(self, basic_config, rotate):
# Call
init_logging("logfile", file_level=logging.CRITICAL)
# Tests
basic_config.assert_called_once_with(
level=logging.DEBUG, handlers=[rotate.return_value],
)
def main_default(type_, local_type=None, trace_=False, **kwargs):
"""
Default main() method. Parses cmdline args, setups up signal handling,
logging, creates the appropriate object and runs it.
:param type type_: Primary type to instantiate.
:param type local_type:
If not `None`, load the topology to check if this is a core or local AS.
If it's a core AS, instantiate the primary type, otherwise the local
type.
:param bool trace_: Should a periodic thread stacktrace report be created?
"""
handle_signals()
parser = argparse.ArgumentParser()
parser.add_argument('--log_dir',
default="logs/",
help='Log dir (Default: logs/)')
parser.add_argument(
'--spki_cache_dir',
default="gen-cache/",
help='Cache dir for SCION TRCs and cert chains (Default: gen-cache/)')
parser.add_argument('--prom',
type=str,
help='Address to export prometheus metrics on')
parser.add_argument('server_id', help='Server identifier')
parser.add_argument('conf_dir',
nargs='?',
default='.',
help='Configuration directory (Default: ./)')
args = parser.parse_args()
init_logging(os.path.join(args.log_dir, args.server_id))
if local_type is None:
inst = type_(args.server_id,
args.conf_dir,
prom_export=args.prom,
spki_cache_dir=args.spki_cache_dir,
**kwargs)
else:
# Load the topology to check if this is a core AD or not
topo = Topology.from_file(os.path.join(args.conf_dir, TOPO_FILE))
if topo.is_core_as:
inst = type_(args.server_id,
args.conf_dir,
prom_export=args.prom,
spki_cache_dir=args.spki_cache_dir,
**kwargs)
else:
inst = local_type(args.server_id,
args.conf_dir,
prom_export=args.prom,
spki_cache_dir=args.spki_cache_dir,
**kwargs)
if trace_:
trace(inst.id)
logging.info("Started %s", args.server_id)
inst.run()
def main():
init_logging(CLIENT_LOG_BASE,
file_level=logging.DEBUG, console_level=logging.DEBUG)
handle_signals()
res = test_list()
test_lookup(res)
test_topology_lookup()
test_locations_lookup()
test_set_ISD_whitelist()
test_clear_ISD_whitelist()
test_ISD_endpoints_lookup()
test_clear_kbase()
test_list()
def setup_main(name, parser=None):
handle_signals()
parser = parser or argparse.ArgumentParser()
parser.add_argument('-l',
'--loglevel',
default=logging.DEBUG,
help='Console logging level (Default: %(default)s)')
parser.add_argument('-c', '--client', help='Client address')
parser.add_argument('-s', '--server', help='Server address')
parser.add_argument('-m',
'--mininet',
action='store_true',
help="Running under mininet")
parser.add_argument("--retries",
type=int,
default=0,
help="Number of retries before giving up.")
parser.add_argument('--run_server',
action='store_true',
default=False,
help="Run as server")
parser.add_argument('--data',
default=None,
help="Data for client / server split run")
parser.add_argument('--port',
default=0,
help="Port for client / server split run")
parser.add_argument('src_ia', nargs='?', help='Src isd-as')
parser.add_argument('dst_ia', help='Dst isd-as')
args = parser.parse_args()
init_logging(None, file_level=logging.NOTSET, console_level=args.loglevel)
overlay = get_overlay()
if "IPv6" in overlay:
if not args.client:
args.client = DEFAULT6_CLIENT
if not args.server:
args.server = DEFAULT6_SERVER
else:
if not args.client:
args.client = "169.254.0.2" if args.mininet else "127.0.0.2"
if not args.server:
args.server = "169.254.0.3" if args.mininet else "127.0.0.3"
if not args.data:
args.data = 'data'
return args
def setup_main(name, parser=None):
handle_signals()
parser = parser or argparse.ArgumentParser()
parser.add_argument('-l',
'--loglevel',
default="INFO",
help='Console logging level (Default: %(default)s)')
parser.add_argument('-c', '--client', help='Client address')
parser.add_argument('-s', '--server', help='Server address')
parser.add_argument('-m',
'--mininet',
action='store_true',
help="Running under mininet")
parser.add_argument("-r",
"--runs",
type=int,
help="Limit the number of pairs tested")
parser.add_argument("-w",
"--wait",
type=float,
default=0.0,
help="Time in seconds to wait before running")
parser.add_argument("--retries",
type=int,
default=0,
help="Number of retries before giving up.")
parser.add_argument('src_ia', nargs='?', help='Src isd-as')
parser.add_argument('dst_ia', nargs='?', help='Dst isd-as')
args = parser.parse_args()
init_logging("logs/%s" % name, console_level=args.loglevel)
overlay = get_overlay()
if "IPv6" in overlay:
if not args.client:
args.client = DEFAULT6_CLIENT
if not args.server:
args.server = DEFAULT6_SERVER
else:
if not args.client:
args.client = "169.254.0.2" if args.mininet else "127.0.0.2"
if not args.server:
args.server = "169.254.0.3" if args.mininet else "127.0.0.3"
as_list = _load_as_list()
srcs = _parse_locs(args.src_ia, as_list)
dsts = _parse_locs(args.dst_ia, as_list)
return args, srcs, dsts
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 main():
"""
Parse the command-line arguments and start the proxy server.
"""
handle_signals()
parser = argparse.ArgumentParser()
parser.add_argument("--address",
help='IP address of the source SCION Proxy',
default='127.0.0.1')
parser.add_argument("-p",
"--port",
help='Port number to run SCION Proxy on',
type=int,
default=DEFAULT_SERVER_PORT)
parser.add_argument("-f",
"--forward",
help='Forwarding proxy mode',
action="store_true")
parser.add_argument("-s",
"--scion",
help='Use SCION multi-path socket',
action="store_true")
parser.add_argument(
"--WARNING-insecure-kbase",
dest="kbase",
action="store_true",
help='Enable SCION knowledge-base. %s' % KBASE_SECURITY_WARN,
)
parser.add_argument("-t",
"--topo",
help='Topology file SCION knowledge-base should use',
default='topology/Wide.topo')
parser.add_argument("-l",
"--loc",
help='Locations file SCION knowledge-base should use',
default='topology/Wide.locations')
parser.add_argument("--source_isd_as",
help='ISD-AS of the source SCION Proxy',
default='1-4')
parser.add_argument("--target_isd_as",
help='ISD-AS of the target SCION Proxy',
default='3-3')
parser.add_argument("--target_address",
help='IP address of the target SCION Proxy',
default='127.0.0.1')
parser.add_argument("--target_port",
help='Port of the target SCION Proxy',
type=int,
default=9090)
args = parser.parse_args()
if args.forward:
init_logging(LOG_BASE + "_forward",
file_level=logging.DEBUG,
console_level=logging.INFO)
logging.info("Operating in forwarding (bridge) mode.")
isd_as = ISD_AS(args.source_isd_as)
host = HostAddrIPv4(args.address)
else:
init_logging(LOG_BASE,
file_level=logging.DEBUG,
console_level=logging.INFO)
logging.info("Operating in normal proxy mode.")
isd_as = ISD_AS(args.target_isd_as)
host = HostAddrIPv4(args.target_address)
# start sciond
logging.info("Starting sciond for %s", isd_as)
api_addr = SCIOND_API_SOCKDIR + "%s-%s.sock" % (isd_as[0], isd_as[1])
sciond = start_sciond(host, api_addr, isd_as)
kbase = None
if args.scion:
logging.info("SCION-socket mode is on.")
if args.kbase:
if args.forward:
logging.warning(
"*** SCION-socket knowledge-base is enabled. %s ***",
KBASE_SECURITY_WARN)
kbase = SocketKnowledgeBase(args.topo, args.loc,
ISD_AS(args.source_isd_as),
ISD_AS(args.target_isd_as))
else:
logging.info("SCION-socket knowledge-base is supported "
"only in forwarding mode.")
if args.scion and not args.forward:
logging.info("Starting the server with SCION multi-path socket.")
soc = scion_server_socket((args.target_address, args.port), api_addr,
ISD_AS(args.target_isd_as))
else:
logging.info("Starting the server with UNIX socket.")
soc = unix_server_socket(args.port)
worker = threading.Thread(target=serve_forever,
args=(soc, args.forward, args.scion, kbase,
args.source_isd_as, args.target_isd_as,
args.target_address, args.target_port),
daemon=True)
worker.start()
try:
worker.join()
finally:
# Exit gracefully
logging.info("Closing the socket.")
soc.close()
logging.info("Stopping sciond.")
sciond.stop()
def main():
"""
Parse the command-line arguments and start the proxy server.
"""
handle_signals()
parser = argparse.ArgumentParser()
parser.add_argument("-p",
"--port",
help='Port number to run SCION Proxy on',
type=int,
default=DEFAULT_SERVER_PORT)
parser.add_argument("-f",
"--forward",
help='Forwarding proxy mode',
action="store_true")
parser.add_argument("-s",
"--scion",
help='Use SCION multi-path socket',
action="store_true")
parser.add_argument("-k",
"--kbase",
help='Enable SCION knowledge-base',
action="store_true")
parser.add_argument("-t",
"--topo",
help='Topology file SCION knowledge-base should use',
default='topology/Wide.topo')
parser.add_argument("-l",
"--loc",
help='Locations file SCION knowledge-base should use',
default='topology/Wide.locations')
parser.add_argument("--source_isd_as",
help='ISD-AS of the source SCION Proxy',
default='1-4')
parser.add_argument("--target_isd_as",
help='ISD-AS of the target SCION Proxy',
default='3-3')
args = parser.parse_args()
server_address = DEFAULT_SERVER_IP, args.port
if args.forward:
init_logging(LOG_BASE + "_forward",
file_level=logging.DEBUG,
console_level=logging.INFO)
logging.info("Operating in forwarding (bridge) mode.")
else:
init_logging(LOG_BASE,
file_level=logging.DEBUG,
console_level=logging.INFO)
logging.info("Operating in normal proxy mode.")
kbase = None
if args.scion:
logging.info("SCION-socket mode is on.")
if args.kbase:
if args.forward:
logging.info("SCION-socket knowledge-base is enabled.")
kbase = SocketKnowledgeBase(args.topo, args.loc,
ISD_AS(args.source_isd_as),
ISD_AS(args.target_isd_as))
else:
logging.info("SCION-socket knowledge-base is supported "
"only in forwarding mode.")
if args.scion and not args.forward:
logging.info("Starting the server with SCION multi-path socket.")
soc = scion_server_socket(server_address, args.target_isd_as)
else:
logging.info("Starting the server with UNIX socket.")
soc = unix_server_socket(server_address)
try:
serve_forever(soc, args.forward, args.scion, kbase, args.source_isd_as,
args.target_isd_as)
except KeyboardInterrupt:
logging.info("Exiting")
soc.close()
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))
if __name__ == "__main__":
init_logging("logs/bw_test", console_level=logging.DEBUG)
handle_signals()
try:
TestBandwidth().test()
except SystemExit:
logging.info("Exiting")
raise
except:
log_exception("Exception in main process:")
logging.critical("Exiting")
sys.exit(1)
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)
from lib.log import init_logging init_logging()
