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()