let routing_db = node_dir.join(ROUTING_DB_FILE);

        let tracking_db = node_dir.join(TRACKING_DB_FILE);

        let addresses = address::Book::open(address_db)?;

        let routing = routing::Table::open(routing_db)?;

        let tracking = tracking::Config::open(tracking_db)?;

        let service = service::Service::new(

            config,

            clock,

            local_addrs.push(local_addr);

            wire.listen(listener);

        }

        let reactor = Reactor::named(wire, popol::Poller::new(), id.to_human())?;

        let handle = Handle::new(home.clone(), reactor.controller());

        let listener = match UnixListener::bind(&node_sock) {

            Ok(sock) => sock,

    }

    pub fn run(self) -> Result<(), Error> {

        self.pool.run().unwrap();

        self.reactor.join().unwrap();

        fs::remove_file(self.home.socket()).ok();

        Ok(())

    }

    listener: UnixListener,

    mut handle: H,

) -> Result<(), Error> {

    for incoming in listener.incoming() {

        match incoming {

            Ok(mut stream) => {

                if let Err(e) = drain(&stream, &mut handle) {

                    if let DrainError::Shutdown = e {

                        // Channel might already be disconnected if shutdown

                        // came from somewhere else. Ignore errors.

                        handle.shutdown().ok();

                    stream.shutdown(net::Shutdown::Both).ok();

                }

            }

        }

    }

    Ok(())

}

    fn log(&self, record: &Record) {

        if self.enabled(record.metadata()) {

            if record.level() == Level::Error {

            } else {

            }

                let message = match record.level() {

                    Level::Error => message.red(),

                    Level::Warn => message.yellow(),

                    Level::Debug => message.dimmed(),

                    Level::Trace => message.white().dimmed(),

                };

            }

        }

    }

    }

}

    logger::init(log::Level::Debug)?;

    let options = Options::from_env()?;

    Ok(())

}

    }

    pub fn initialize(&mut self, time: LocalTime) -> Result<(), Error> {

        self.start_time = time;

        trace!("Wake +{}", now - self.start_time);

        if now - self.last_idle >= IDLE_INTERVAL {

            self.keep_alive(&now);

            self.disconnect_unresponsive_peers(&now);

            self.last_idle = now;

        }

        if now - self.last_sync >= SYNC_INTERVAL {

            // TODO: What do we do here?

            self.reactor.wakeup(SYNC_INTERVAL);

            self.last_announce = now;

        }

        if now - self.last_prune >= PRUNE_INTERVAL {

            if let Err(err) = self.prune_routing_entries(&now) {

                error!("Error pruning routing entries: {}", err);

    }

    pub fn command(&mut self, cmd: Command) {

        match cmd {

            Command::Connect(id, addr) => self.reactor.connect(id, addr),

                        .filter(|node| *node != self.node_id())

                        .collect(),

                    Err(err) => {

                        resp.send(FetchLookup::NotFound).ok();

                        return;

                };

                let Some(seeds) = NonEmpty::from_vec(seeds) else {

                    resp.send(FetchLookup::NotFound).ok();

                    return;

                };

                let (results_send, results) = chan::bounded(seeds.len());

                resp.send(FetchLookup::Found {

        let seed = session.id;

        if let Some(fetch) = session.fetch(rid) {

            reactor.write(session.id, fetch);

        } else {

            // TODO: If we can't fetch, it's because we're already fetching from

            // this peer. So we need to queue the request, or find another peer.

                "Unable to fetch {rid} from peer {seed} that is already being fetched from"

            );

        }

    }

    pub fn attempted(&mut self, id: NodeId, addr: &Address) {

        let persistent = self.config.is_persistent(&id);

        self.sessions

    }

    pub fn connected(&mut self, remote: NodeId, link: Link) {

        // For outbound connections, we are the first to say "Hello".

        // For inbound connections, we wait for the remote to say "Hello" first.

    pub fn disconnected(&mut self, remote: NodeId, reason: &DisconnectReason) {

        let since = self.local_time();

        if let Some(session) = self.sessions.get_mut(&remote) {

            session.to_disconnected(since);

                    }

                    // TODO: Eventually we want a delay before attempting a reconnection,

                    // with exponential back-off.

                        "Reconnecting to {} (attempts={})...",

                        remote,

                        session.attempts()

                // Discard inventory messages we've already seen, otherwise update

                // out last seen time.

                if !peer.inventory_announced(timestamp) {

                    return Ok(false);

                }

                    // Discard inventory messages we've already seen, otherwise update

                    // out last seen time.

                    if !peer.refs_announced(message.id, timestamp) {

                        return Ok(false);

                    }

                    // TODO: Check refs to see if we should try to fetch or not.

                    return Ok(true);

                } else {

                        "Ignoring refs announcement from {announcer}: repository {} isn't tracked",

                        message.id

                    );

                // Discard node messages we've already seen, otherwise update

                // our last seen time.

                if !peer.node_announced(timestamp) {

                    return Ok(false);

                }

                if !ann.validate() {

                    return Ok(false);

                }

                let alias = match str::from_utf8(alias) {

                    Ok(s) => s,

                    Err(e) => {

                        return Ok(false);

                    }

                };

                    Ok(updated) => {

                        // Only relay if we received new information.

                        if updated {

                                "Address store entry for node {announcer} updated at {timestamp}"

                            );

                            return Ok(relay);

        };

        peer.last_active = self.clock;

        match (&mut peer.state, message) {

            (

            ) => {

                // This should never happen if the service is properly configured, since all

                // incoming data is sent directly to the Git worker.

                return Err(session::Error::Misbehavior);

            }

                // Already initialized!

                if *initialized {

                    debug!(

                        "Disconnecting peer {} for initializing already initialized session",

                        peer.id

                    );

                }

            }

            (session::State::Connected { protocol, .. }, Message::Fetch { rid }) => {

                // TODO: Check that we have the repo first?

                    );

                    return Err(session::Error::Misbehavior);

                }

                *protocol = Protocol::Fetch;

                // Instruct the transport to handover the socket to the worker.

                error!("Received {:?} from connecting peer {}", msg, peer.id);

            }

            (session::State::Disconnected { .. }, msg) => {

            }

        }

        Ok(())

        for proj_id in inventory {

            included.insert(proj_id);

            if self.routing.insert(*proj_id, from, *timestamp)? {

                if self

                    .tracking

        let timestamp = self.clock.as_secs();

        if remote.refs.len() > Refs::max() {

                "refs announcement limit ({}) exceeded, other nodes will see only some of your project references",

                Refs::max(),

            );

    fn maintain_connections(&mut self) {

        let addrs = self.choose_addresses();

        if addrs.is_empty() {

        }

        for (id, addr) in addrs {

            self.reactor.connect(id, addr.clone());

        type Inventory = BoundedVec<Id, INVENTORY_LIMIT>;

        if inventory.len() > Inventory::max() {

                "inventory announcement limit ({}) exceeded, other nodes will see only some of your projects",

                inventory.len()

            );