Ignore response with empty provider_peers when handling GetProvidersRes?

[clovas]

Currently, an Event::OutboundQueryProgressed will be push even if provider_peers is empty.

rust-libp2p/protocols/kad/src/behaviour.rs

Lines 2365 to 2400 in 784c789

	HandlerEvent::GetProvidersRes {
	closer_peers,
	provider_peers,
	query_id,
	} => {
	let peers = closer_peers.iter().chain(provider_peers.iter());
	self.discovered(&query_id, &source, peers);
	if let Some(query) = self.queries.get_mut(&query_id) {
	let stats = *query.stats();
	if let QueryInfo::GetProviders {
	ref key,
	ref mut providers_found,
	ref mut step,
	..
	} = query.info
	{
	*providers_found += provider_peers.len();
	let providers = provider_peers.iter().map(|p| p.node_id).collect();
	self.queued_events.push_back(ToSwarm::GenerateEvent(
	Event::OutboundQueryProgressed {
	id: query_id,
	result: QueryResult::GetProviders(Ok(
	GetProvidersOk::FoundProviders {
	key: key.clone(),
	providers,
	},
	)),
	step: *step,
	stats,
	},
	));
	*step = step.next();
	}
	}
	}

I think this is noise.

Since we ignore empty responses in the two places below, there seems to be no reason not to do the same when handling GetProvidersRes.

rust-libp2p/protocols/kad/src/behaviour.rs

Lines 2461 to 2510 in 784c789

	HandlerEvent::GetRecordRes {
	record,
	closer_peers,
	query_id,
	} => {
	if let Some(query) = self.queries.get_mut(&query_id) {
	let stats = *query.stats();
	if let QueryInfo::GetRecord {
	key,
	step,
	found_a_record,
	cache_candidates,
	} = &mut query.info
	{
	if let Some(record) = record {
	*found_a_record = true;
	let record = PeerRecord {
	peer: Some(source),
	record,
	};
	self.queued_events.push_back(ToSwarm::GenerateEvent(
	Event::OutboundQueryProgressed {
	id: query_id,
	result: QueryResult::GetRecord(Ok(GetRecordOk::FoundRecord(
	record,
	))),
	step: *step,
	stats,
	},
	));
	*step = step.next();
	} else {
	tracing::trace!(record=?key, %source, "Record not found at source");
	if let Caching::Enabled { max_peers } = self.caching {
	let source_key = kbucket::Key::from(source);
	let target_key = kbucket::Key::from(key.clone());
	let distance = source_key.distance(&target_key);
	cache_candidates.insert(distance, source);
	if cache_candidates.len() > max_peers as usize {
	cache_candidates.pop_last();
	}
	}
	}
	}
	}
	self.discovered(&query_id, &source, closer_peers.iter());
	}

rust-libp2p/protocols/kad/src/behaviour.rs

Lines 1060 to 1108 in 784c789

	pub fn get_providers(&mut self, key: record::Key) -> QueryId {
	let providers: HashSet<_> = self
	.store
	.providers(&key)
	.into_iter()
	.filter(|p| {
	if p.is_expired(Instant::now()) {
	self.store.remove_provider(&key, &p.provider);
	false
	} else {
	true
	}
	})
	.map(|p| p.provider)
	.collect();
	let step = ProgressStep::first();
	let info = QueryInfo::GetProviders {
	key: key.clone(),
	providers_found: providers.len(),
	step: if providers.is_empty() {
	step
	} else {
	step.next()
	},
	};
	let target = kbucket::Key::new(key.clone());
	let peers = self.kbuckets.closest_keys(&target);
	let id = self.queries.add_iter_closest(target.clone(), peers, info);
	// No queries were actually done for the results yet.
	let stats = QueryStats::empty();
	if !providers.is_empty() {
	self.queued_events
	.push_back(ToSwarm::GenerateEvent(Event::OutboundQueryProgressed {
	id,
	result: QueryResult::GetProviders(Ok(GetProvidersOk::FoundProviders {
	key,
	providers,
	})),
	step,
	stats,
	}));
	}
	id
	}