Method handle_request

ipld/resolver/src/service.rs:426–471

Handle an internal request coming from a [`Client`].

(&mut self, request: Request<V>)

    /// Handle an internal request coming from a [`Client`].
    fn handle_request(&mut self, request: Request<V>) {
        match request {
            Request::SetProvidedSubnets(ids) => {
                if let Err(e) = self.membership_mut().set_provided_subnets(ids) {
                    warn!("failed to publish set provided subnets: {e}")
                }
            }
            Request::AddProvidedSubnet(id) => {
                if let Err(e) = self.membership_mut().add_provided_subnet(id) {
                    warn!("failed to publish added provided subnet: {e}")
                }
            }
            Request::RemoveProvidedSubnet(id) => {
                if let Err(e) = self.membership_mut().remove_provided_subnet(id) {
                    warn!("failed to publish removed provided subnet: {e}")
                }
            }
            Request::PublishVote(vote) => {
                if let Err(e) = self.membership_mut().publish_vote(*vote) {
                    warn!("failed to publish vote: {e}")
                }
            }
            Request::PublishPreemptive(subnet_id, data) => {
                if let Err(e) = self.membership_mut().publish_preemptive(subnet_id, data) {
                    warn!("failed to publish pre-emptive data: {e}")
                }
            }
            Request::PinSubnet(id) => {
                if let Err(e) = self.membership_mut().pin_subnet(id) {
                    warn!("error pinning subnet: {e}")
                }
            }
            Request::UnpinSubnet(id) => {
                if let Err(e) = self.membership_mut().unpin_subnet(&id) {
                    warn!("error unpinning subnet: {e}")
                }
            }
            Request::Resolve(cid, subnet_id, response_channel) => {
                self.start_query(cid, subnet_id, response_channel)
            }
            Request::RateLimitUsed(peer_id, bytes) => {
                self.content_mut().rate_limit_used(peer_id, bytes)
            }
            Request::UpdateRateLimit(bytes) => self.content_mut().update_rate_limit(bytes),
        }
    }

    /// Start a CID resolution.
    fn start_query(&mut self, cid: Cid, subnet_id: SubnetID, response_channel: ResponseChannel) {