node: &mut Node,

    profile: &Profile,

) -> Result<bool, anyhow::Error> {

        Ok(updated) => Ok(updated),

        Err(e) if e.is_connection_err() => {

            let now = LocalTime::now();

            let mut db = profile.database_mut()?;

            Ok(!updates.is_empty())

        }

                let now = LocalTime::now();

                let mut db = profile.database_mut()?;

            }

            Ok(result)

        }

            let result = config.unseed(&rid)?;

            let mut db = profile.database_mut()?;

            Ok(result)

        }

        .unwrap();

    eve.db

        .routing_mut()

        .unwrap();

    eve.config.peers = node::config::PeerConfig::Static;

            )],

        )

        .unwrap();

    eve.config.peers = node::config::PeerConfig::Static;

    let eve = eve.spawn();

            }

            CommandResult::ok().to_writer(writer).ok();

        }

            Ok(result) => {

                CommandResult::updated(result).to_writer(writer)?;

            }

            .map_err(Error::from)

    }

        let (sender, receiver) = chan::bounded(1);

        receiver.recv().map_err(Error::from)

    }

    AnnounceRefs(RepoId, chan::Sender<RefsAt>),

    /// Announce local repositories to peers.

    AnnounceInventory,

    /// Connect to node with the given address.

    Connect(NodeId, Address, ConnectOptions),

    /// Disconnect from node.

        match self {

            Self::AnnounceRefs(id, _) => write!(f, "AnnounceRefs({id})"),

            Self::AnnounceInventory => write!(f, "AnnounceInventory"),

            Self::Connect(id, addr, opts) => write!(f, "Connect({id}, {addr}, {opts:?})"),

            Self::Disconnect(id) => write!(f, "Disconnect({id})"),

            Self::Config(_) => write!(f, "Config"),

            // user creates a new repository while the node is stopped.

            self.db

                .routing_mut()

            self.inventory = gossip::inventory(self.timestamp(), inventory);

        }

            Command::AnnounceInventory => {

                self.announce_inventory();

            }

                Ok(updated) => {

                    resp.send(updated).ok();

                }

    /// Add a seed to our routing table.

    fn seed_discovered(&mut self, rid: RepoId, nid: NodeId, time: Timestamp) {

            if let &[(_, InsertResult::SeedAdded)] = result.as_slice() {

                self.emitter.emit(Event::SeedDiscovered { rid, nid });

                info!(target: "service", "Routing table updated for {} with seed {nid}", rid);

        let node = self.node_id();

        let now = self.timestamp();

        if removed {

            // Update cached inventory message.

            let inventory = self.inventory()?;

            error!(target: "service", "Attempt to add non-existing inventory {rid}: repository not found in storage");

            return Ok(false);

        }

        let updated = !updates.is_empty();

        if updated {

    fn inventory(&self) -> Result<HashSet<RepoId>, Error> {

        self.db

            .routing()

            .map_err(Error::from)

    }

        let mut synced = SyncedRouting::default();

        let included = inventory.into_iter().collect::<BTreeSet<_>>();

        {

            match result {

                InsertResult::SeedAdded => {

                InsertResult::NotUpdated => {}

            }

        }

            if !included.contains(&rid) {

                    synced.removed.push(rid);

                    self.emitter.emit(Event::SeedDropped { rid, nid: from });

                }

        Ok(())

    }

        unimplemented!()

    }

        self.service

            .database()

            .routing()

            .unwrap()

    }

    // We now expect Eve to fetch Alice's project from Alice.

    // Then we expect Bob to fetch Alice's project from Eve.

    alice.elapse(LocalDuration::from_secs(1)); // Make sure our announcement is fresh.

    sim.run_while([&mut alice, &mut bob, &mut eve], |s| !s.is_settled());

            .storage_mut()

            .repos

            .insert(rid, gen::<MockRepository>(1));

        sim.run_while([&mut alice, &mut bob, &mut eve, &mut zod, &mut tom], |s| {

            s.elapsed() < LocalDuration::from_mins(3)

    AnnounceInventory,

    /// Update node's inventory.

    /// Get the current node condiguration.

    Config,

    /// Announce local inventory.

    fn announce_inventory(&mut self) -> Result<(), Self::Error>;

    /// Notify the service that our inventory was updated with the given repository.

    /// Ask the service to shutdown.

    fn shutdown(self) -> Result<(), Self::Error>;

    /// Query the peer session state.

        Ok(())

    }

        let response = lines.next().ok_or(Error::EmptyResponse)??;

        Ok(response.updated)

pub trait Store {

    /// Get the nodes seeding the given id.

    fn get(&self, id: &RepoId) -> Result<HashSet<NodeId>, Error>;

    /// Get a specific entry.

    fn entry(&self, id: &RepoId, node: &NodeId) -> Result<Option<Timestamp>, Error>;

    /// Checks if any entries are available.

        Ok(self.len()? == 0)

    }

    /// Add a new node seeding the given id.

        &mut self,

        ids: impl IntoIterator<Item = &'a RepoId>,

        node: NodeId,

        time: Timestamp,

    ) -> Result<Vec<(RepoId, InsertResult)>, Error>;

    /// Remove a node for the given id.

    /// Iterate over all entries in the routing table.

    fn entries(&self) -> Result<Box<dyn Iterator<Item = (RepoId, NodeId)>>, Error>;

    /// Get the total number of routing entries.

        Ok(nodes)

    }

        let mut stmt = self.db.prepare("SELECT repo FROM routing WHERE node = ?")?;

        stmt.bind((1, node))?;

        for row in stmt.into_iter() {

        }

    }

    fn entry(&self, id: &RepoId, node: &NodeId) -> Result<Option<Timestamp>, Error> {

        Ok(None)

    }

        &mut self,

        ids: impl IntoIterator<Item = &'a RepoId>,

        node: NodeId,

        Ok(Box::new(entries.into_iter()))

    }

        let mut stmt = self

            .db

            .prepare("DELETE FROM routing WHERE repo = ? AND node = ?")?;

        for node in &nodes {

            assert_eq!(

                ids.iter()

                    .map(|id| (*id, InsertResult::SeedAdded))

                    .collect::<Vec<_>>()

        let mut db = database(":memory:");

        for node in &nodes {

        }

        for node in &nodes {

            for id in &ids {

                assert!(projects.contains(id));

            }

        for node in &nodes {

            assert!(db

                .unwrap()

                .iter()

                .all(|(_, r)| *r == InsertResult::SeedAdded));

        let mut db = database(":memory:");

        for node in &nodes {

        }

        for id in &ids {

            for node in &nodes {

            }

        }

        for id in &ids {

        let mut db = database(":memory:");

        assert_eq!(

            vec![(id, InsertResult::SeedAdded)]

        );

        assert_eq!(

            vec![(id, InsertResult::NotUpdated)]

        );

        assert_eq!(

            vec![(id, InsertResult::NotUpdated)]

        );

    }

        let mut db = database(":memory:");

        assert_eq!(

            vec![(id, InsertResult::SeedAdded)]

        );

        assert_eq!(

                .unwrap(),

            vec![(id, InsertResult::TimeUpdated)]

        );

        let mut db = database(":memory:");

        assert_eq!(

            vec![(id1, InsertResult::SeedAdded)]

        );

        assert_eq!(

            vec![

                (id1, InsertResult::NotUpdated),

                (id2, InsertResult::SeedAdded)

            ]

        );

        assert_eq!(

                .unwrap(),

            vec![

                (id1, InsertResult::TimeUpdated),

        let mut db = database(":memory:");

        assert_eq!(

            vec![(id, InsertResult::SeedAdded)]

        );

    }

    #[test]

        let ids = arbitrary::vec::<RepoId>(10);

        let node = arbitrary::gen(1);

        assert_eq!(10, db.len().unwrap(), "correct number of rows in table");

    }

        for node in &nodes {

            let time = rng.u64(..now.as_millis());

                .unwrap();

        }

        for node in &nodes {

            let time = rng.u64(now.as_millis()..i64::MAX as u64);

                .unwrap();

        }

        let mut db = database(":memory:");

        for node in &nodes {

        }

        assert_eq!(db.count(&id).unwrap(), nodes.len());

    }