def do_tty(self, args):
node = MeshAddress.parse(args.destination)
port = args.port
if node == MeshAddress.parse("ff.ff"):
self.tty = self.transport_manager.broadcast(
partial(ShellDatagramProtocol, self.stdout, self.prompt), self.network.our_address, port)
else:
self.tty = self.transport_manager.connect(
partial(ShellDatagramProtocol, self.stdout, self.prompt), self.network.our_address, node, port)
self.tty_port = port
self.prompt = f"(tarpn {node}) "
def do_ping(self, args):
node = MeshAddress.parse(args.destination)
self.stdout.write(f"Sending ping ({len(self.network.alive_neighbors())})...\r\n")
for _ in range(args.count):
t0 = time.time_ns()
seq = self.network.ping_protocol.send_ping(node)
found = self.network.ping_protocol.wait_for_ping(node, seq, timeout_ms=args.timeout * 1000)
t1 = time.time_ns()
if found:
dt = (t1-t0) / 1000000.
self.stdout.write(f"Got response in {dt}ms\r\n")
else:
self.stdout.write(f"Timed out waiting for response\r\n")
def write(self, data: Any) -> None:
_, mtu = self.network.route_packet(MeshAddress.parse("ff.ff"))
if isinstance(data, str):
encoded_data = data.encode("utf-8")
elif isinstance(data, (bytes, bytearray)):
encoded_data = data
else:
raise ValueError(
"DatagramTransport.write only supports bytes and strings")
if len(encoded_data) <= mtu:
self.broadcast_protocol.send_broadcast(self.port, encoded_data)
else:
raise RuntimeError(f"Message too large, maximum size is {mtu}")
def broadcast(self, protocol_factory: Callable[[], DProtocol],
local_address: MeshAddress, port: int) -> DProtocol:
if port in self.connections:
if self.connections[port][0].is_closing():
del self.connections[port]
else:
raise RuntimeError(f"Connection to {port} is already open")
protocol = protocol_factory()
transport = BroadcastTransport(self.l3_protocol,
self.broadcast_protocol,
self.datagram_protocol,
port, local_address,
MeshAddress.parse("ff.ff"))
protocol.connection_made(transport)
self.connections[port] = (transport, protocol)
return protocol
def __init__(self, time: Time, config: NetworkConfig,
link_multiplexer: LinkMultiplexer, l4_handlers: L4Handlers,
scheduler: Scheduler):
LoggingMixin.__init__(self, extra_func=self.log_ident)
CloseableThreadLoop.__init__(self, name="MeshNetwork")
self.time = time
self.config = config
self.link_multiplexer = link_multiplexer
self.l4_handlers = l4_handlers
self.scheduler = scheduler
self.queue = queue.Queue()
self.our_address = MeshAddress.parse(config.get("mesh.address"))
self.host_name = config.get("host.name")
self.ping_protocol = PingProtocol(self)
# TTL cache of seen frames from each source
self.header_cache: TTLCache = TTLCache(time, 30_000)
# Our own send sequence
self.send_seq: int = 1
self.seq_lock = threading.Lock()
# Link states and neighbors
self.neighbors: Dict[MeshAddress, Neighbor] = dict()
# An epoch for our own link state changes. Any time a neighbor comes or goes, or the quality changes,
# we increment this counter. Uses a "lollipop sequence" to allow for easy detection of wrap around vs
# reset
self.our_link_state_epoch_generator = lollipop_sequence()
self.our_link_state_epoch: int = next(
self.our_link_state_epoch_generator)
# Epochs we have received from other nodes and their link states
self.link_state_epochs: Dict[MeshAddress, int] = dict()
self.host_names: Dict[MeshAddress, str] = dict()
self.link_states: Dict[MeshAddress, List[LinkStateHeader]] = dict()
self.last_hello_time = datetime.fromtimestamp(0)
self.last_advert = datetime.utcnow()
self.last_query = datetime.utcnow()
self.last_epoch_bump = datetime.utcnow()
self.scheduler.timer(1_000, partial(self.scheduler.submit, self), True)
def write_to(self, address: str, data: Any) -> None:
dest = MeshAddress.parse(address)
can_route, mtu = self.network.route_packet(dest)
if can_route:
if isinstance(data, str):
encoded_data = data.encode("utf-8")
elif isinstance(data, (bytes, bytearray)):
encoded_data = data
else:
raise ValueError(
"DatagramTransport.write only supports bytes and strings")
if len(encoded_data) <= mtu:
header = DatagramHeader(source=self.port,
destination=self.port,
length=len(encoded_data),
checksum=crc_b(encoded_data))
self.datagram_protocol.send_datagram(self.local, self.remote,
header, encoded_data)
#self.broadcast_protocol.send_broadcast(self.port, encoded_data)
else:
raise RuntimeError(f"Message too large, maximum size is {mtu}")
else:
raise RuntimeError(f"Cannot route to {dest}!")
records.append(record)
self.epochs[address] = record.epoch
return True
else:
return False
def get_link_states(self, node: MeshAddress) -> Dict[MeshAddress, int]:
states = {}
if node not in self.epochs.keys():
return states
for record in self.records[node]:
if isinstance(record, LinkRecord):
link_record = cast(LinkRecord, record)
states[link_record.source] = link_record.quality
return states
if __name__ == "__main__":
log = Log()
nodeA = MeshAddress.parse("00.aa")
nodeB = MeshAddress.parse("00.bb")
log.append(nodeA, LinkRecord(-128, nodeA, nodeB, 100))
log.append(nodeA, LinkRecord(-127, nodeA, nodeB, 99))
log.append(nodeA, LinkRecord(10, nodeA, nodeB, 98))
log.append(nodeA, LinkRecord(9, nodeA, nodeB, 97))
log.append(nodeA, LinkRecord(-128, nodeA, nodeB, 100))
print(log.get_link_states(nodeA))
print(log.get_link_states(nodeB))
print(log.records)
def run_node(args):
# Bootstrap node.ini
if not os.path.exists(args.config) and os.path.basename(
args.config) == "node.ini":
shutil.copyfile("config/node.ini.sample", args.config)
# Load settings from ini file
s = Settings(".", ["config/defaults.ini", args.config])
node_settings = s.node_config()
node_call = AX25Call.parse(node_settings.node_call())
if node_call.callsign == "N0CALL":
print("Callsign is missing from config. Please see instructions here "
"https://github.com/tarpn/tarpn-node-controller")
sys.exit(1)
else:
print(f"Loaded configuration for {node_call}")
# Setup logging
logging_config_file = node_settings.get("log.config", "not_set")
if logging_config_file != "not_set":
log_dir = node_settings.get("log.dir")
if not os.path.exists(log_dir):
os.makedirs(log_dir)
logging.config.fileConfig(logging_config_file,
defaults={"log.dir": log_dir},
disable_existing_loggers=False)
if args.verbose:
logging.getLogger("root").setLevel(logging.DEBUG)
# Create thread pool
scheduler = Scheduler()
# Initialize I/O devices and L2 protocols
l3_protocols = L3Protocols()
l3_protocols.register(NoLayer3Protocol())
l2_multi = DefaultLinkMultiplexer(L3PriorityQueue, scheduler)
# Port UDP mapping
# udp.forwarding.enabled = true
# udp.address = 192.168.0.160:10093
# udp.destinations = K4DBZ-2,NODES
# udp.mapping = KN4ORB-2:1,KA2DEW-2:2
port_queues = {}
if node_settings.get_boolean("udp.enabled", False):
udp_host, udp_port = node_settings.get("udp.address").split(":")
udp_port = int(udp_port)
udp_writer = UDPWriter(g8bpq_address=(udp_host, udp_port))
intercept_dests = {
AX25Call.parse(c)
for c in node_settings.get("udp.destinations", "").split(",")
}
interceptor = udp_writer.receive_frame
udp_mapping = {}
for mapping in node_settings.get("udp.mapping", "").split(","):
c, i = mapping.split(":")
udp_mapping[AX25Call.parse(c)] = int(i)
scheduler.submit(
UDPThread("0.0.0.0", udp_port, udp_mapping, port_queues,
udp_writer))
else:
intercept_dests = {}
interceptor = lambda frame: None
for port_config in s.port_configs():
if port_config.get_boolean("port.enabled") and port_config.get(
"port.type") == "serial":
l2_queueing = L2FIFOQueue(20, AX25Protocol.maximum_frame_size())
port_queues[port_config.port_id()] = l2_queueing
l2 = AX25Protocol(port_config, port_config.port_id(), node_call,
scheduler, l2_queueing, l2_multi, l3_protocols,
intercept_dests, interceptor)
kiss = KISSProtocol(
port_config.port_id(), l2_queueing,
port_config.get_boolean("kiss.checksum", False))
SerialDevice(kiss, port_config.get("serial.device"),
port_config.get_int("serial.speed"),
port_config.get_float("serial.timeout"), scheduler)
scheduler.submit(L2IOLoop(l2_queueing, l2))
# Register L3 protocols
routing_table = tarpn.netrom.router.NetRomRoutingTable.load(
f"nodes-{node_settings.node_call()}.json", node_settings.node_alias())
network_configs = s.network_configs()
if network_configs.get_boolean("netrom.enabled", False):
logger.info("Starting NET/ROM router")
netrom_l3 = NetRomL3(node_call, node_settings.node_alias(), scheduler,
l2_multi, routing_table)
l3_protocols.register(netrom_l3)
netrom_l4 = NetRomTransportProtocol(s.network_configs(), netrom_l3,
scheduler)
l4_handlers = L4Handlers()
if network_configs.get_boolean("mesh.enabled", False):
mesh_l3 = MeshProtocol(WallTime(), network_configs, l2_multi,
l4_handlers, scheduler)
l3_protocols.register(mesh_l3)
# Create the L4 protocols
mesh_l4 = MeshTransportManager(mesh_l3)
# Register L4 handlers
reliable = ReliableManager(mesh_l3, scheduler)
fragment_protocol = FragmentProtocol(mesh_l3, mesh_l4)
reliable_protocol = ReliableProtocol(mesh_l3, reliable, l4_handlers)
datagram_protocol = DatagramProtocol(mesh_l3, mesh_l4,
fragment_protocol,
reliable_protocol)
broadcast_protocol = BroadcastProtocol(mesh_l3, mesh_l4, reliable)
l4_handlers.register_l4(Protocol.FRAGMENT, fragment_protocol)
l4_handlers.register_l4(Protocol.RELIABLE, reliable_protocol)
l4_handlers.register_l4(Protocol.DATAGRAM, datagram_protocol)
l4_handlers.register_l4(Protocol.BROADCAST, broadcast_protocol)
# TODO fix circular dependency here
mesh_l4.broadcast_protocol = broadcast_protocol
mesh_l4.datagram_protocol = datagram_protocol
# Bind the command processor
ncp_factory = partial(NodeCommandProcessor,
config=network_configs,
link=l2_multi,
network=mesh_l3,
transport_manager=mesh_l4,
scheduler=scheduler)
mesh_l4.bind(ncp_factory, mesh_l3.our_address, 11)
# Set up applications
for app_config in s.app_configs():
# We have a single unix socket connection multiplexed to many network connections
print(app_config)
app_multiplexer = TransportMultiplexer()
app_address = MeshTransportAddress.parse(
app_config.get("app.address"))
app_protocol = ApplicationProtocol(app_config.app_name(),
app_config.app_alias(),
str(app_address.address),
mesh_l4, app_multiplexer)
scheduler.submit(
UnixServerThread(app_config.app_socket(), app_protocol))
multiplexer_protocol = partial(MultiplexingProtocol,
app_multiplexer)
# TODO bind or connect?
mesh_l4.connect(multiplexer_protocol, app_address.address,
MeshAddress.parse("00.a2"), app_address.port)
sock = node_settings.get("node.sock")
print(f"Binding node terminal to {sock}")
scheduler.submit(
UnixServerThread(sock, TarpnShellProtocol(mesh_l3, mesh_l4)))
# Start a metrics reporter
#reporter = ConsoleReporter(reporting_interval=300)
#scheduler.timer(10_000, reporter.start, True)
#scheduler.add_shutdown_hook(reporter.stop)
logger.info("Finished Startup")
try:
# Wait for all threads
scheduler.join()
except KeyboardInterrupt:
scheduler.shutdown()
def parse(cls, s: str):
uri_parts = urllib.parse.urlsplit(s)
assert uri_parts.scheme == "mesh"
address = MeshAddress.parse(uri_parts.hostname)
return cls(address=address, port=uri_parts.port)
def main():
parser = argparse.ArgumentParser(
description='Broadcast to mesh network over serial device')
parser.add_argument("device", help="Serial port to open")
parser.add_argument("baud", type=int, help="Baudrate to use")
parser.add_argument("callsign", help="Your callsign (e.g., K4DBZ-10)")
parser.add_argument("address", help="Local address, e.g., 00.1a")
parser.add_argument("port", type=int, help="Port", default=10)
parser.add_argument("--debug", action="store_true")
args = parser.parse_args()
# Configure logging
main_logger = logging.getLogger("root")
main_logger.setLevel(logging.ERROR)
main_logger.addHandler(logging.StreamHandler(sys.stdout))
if args.debug:
main_logger.setLevel(logging.DEBUG)
state_logger = logging.getLogger("ax25.state")
state_logger.setLevel(logging.DEBUG)
state_logger.addHandler(logging.StreamHandler(sys.stdout))
scheduler = Scheduler()
# Configure and initialize I/O device and L2
port_config = PortConfig.from_dict(
0, {
"port.enabled": True,
"port.type": "serial",
"serial.device": args.device,
"serial.speed": args.baud
})
# Initialize I/O device and L2
l3_protocols = L3Protocols()
l2_multi = DefaultLinkMultiplexer(L3PriorityQueue, scheduler)
l2_queueing = L2FIFOQueue(20, AX25Protocol.maximum_frame_size())
l2 = AX25Protocol(port_config, port_config.port_id(),
AX25Call.parse(args.callsign), scheduler, l2_queueing,
l2_multi, l3_protocols)
kiss = KISSProtocol(port_config.port_id(), l2_queueing,
port_config.get_boolean("kiss.checksum", False))
SerialDevice(kiss, port_config.get("serial.device"),
port_config.get_int("serial.speed"),
port_config.get_float("serial.timeout"), scheduler)
scheduler.submit(L2IOLoop(l2_queueing, l2))
addr = MeshAddress.parse(args.address)
mesh_l3 = MeshProtocol(our_address=addr,
link_multiplexer=l2_multi,
scheduler=scheduler)
l3_protocols.register(mesh_l3)
mesh_l4 = MeshTransportManager(mesh_l3)
tty = TTY()
loop = asyncio.get_event_loop()
loop.add_reader(sys.stdin, tty.handle_stdin)
loop.add_signal_handler(signal.SIGTERM, tty.handle_signal, loop, scheduler)
loop.add_signal_handler(signal.SIGINT, tty.handle_signal, loop, scheduler)
mesh_l4.connect(protocol_factory=lambda: tty,
port=args.port,
local_address=addr,
remote_address=MeshProtocol.BroadcastAddress)
try:
loop.run_forever()
finally:
loop.close()