nostr/gossip
1
0
Fork 0
mirror of https://github.com/mikedilger/gossip.git synced 2024-09-29 08:21:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update calls into relay functions

Browse Source
This commit is contained in:
Mike Dilger 2024-08-01 10:13:20 +12:00
parent 0319bcdb00
commit 218392c21d
6 changed files with 49 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gossip-bin/src/ui/wizard/follow_people.rs
View File

@ -7,7 +7,7 @@ use eframe::egui;
use egui::{Context, RichText, Ui}; use egui::{Context, RichText, Ui};
use gossip_lib::comms::ToOverlordMessage; use gossip_lib::comms::ToOverlordMessage;
use gossip_lib::{relay, PersonList, PersonTable, Private, Table, GLOBALS}; use gossip_lib::{relay, PersonList, PersonTable, Private, Table, GLOBALS};
use nostr_types::{Profile, PublicKey, RelayUsage}; use nostr_types::{Profile, PublicKey};
pub(super) fn update(app: &mut GossipUi, ctx: &Context, _frame: &mut eframe::Frame, ui: &mut Ui) { pub(super) fn update(app: &mut GossipUi, ctx: &Context, _frame: &mut eframe::Frame, ui: &mut Ui) {
if app.wizard_state.pubkey.is_none() && !app.wizard_state.follow_only { if app.wizard_state.pubkey.is_none() && !app.wizard_state.follow_only {
@ -87,11 +87,9 @@ pub(super) fn update(app: &mut GossipUi, ctx: &Context, _frame: &mut eframe::Fra
if person.borrow().metadata().is_none() { if person.borrow().metadata().is_none() {
// We don't have metadata // We don't have metadata
if let Ok(outboxes) = relay::get_best_relays_min( if let Ok(outboxes) =
pubkey, relay::get_some_pubkey_outboxes(pubkey)
RelayUsage::Outbox, {
0,
) {
if !outboxes.is_empty() { if !outboxes.is_empty() {
// But we have their outboxes // But we have their outboxes
if !app if !app

6
gossip-bin/src/ui/wizard/read_nostr_config.rs
View File

@ -3,9 +3,9 @@ use crate::ui::{GossipUi, Page};
use eframe::egui; use eframe::egui;
use egui::{Color32, Context, RichText, Ui}; use egui::{Color32, Context, RichText, Ui};
use gossip_lib::comms::ToOverlordMessage; use gossip_lib::comms::ToOverlordMessage;
use gossip_lib::Relay;
use gossip_lib::GLOBALS; use gossip_lib::GLOBALS;
use gossip_lib::{relay, Relay}; use nostr_types::RelayUrl;
use nostr_types::{RelayUrl, RelayUsage};
use super::continue_control; use super::continue_control;
@ -82,7 +82,7 @@ pub(super) fn update(app: &mut GossipUi, ctx: &Context, _frame: &mut eframe::Fra
let mut found = false; let mut found = false;
// If we have write relays, show those // If we have write relays, show those
if let Ok(urls) = relay::get_best_relays_min(pubkey, RelayUsage::Outbox, 0) { if let Ok(urls) = Relay::choose_relay_urls(Relay::WRITE, |_| true) {
if !urls.is_empty() { if !urls.is_empty() {
app.vert_scroll_area() app.vert_scroll_area()
.max_width(f32::INFINITY) .max_width(f32::INFINITY)

54
gossip-lib/src/overlord/mod.rs
View File

@ -24,7 +24,7 @@ use minion::{Minion, MinionExitReason};
use nostr_types::{ use nostr_types::{
EncryptedPrivateKey, Event, EventKind, EventReference, Filter, Id, IdHex, Metadata, EncryptedPrivateKey, Event, EventKind, EventReference, Filter, Id, IdHex, Metadata,
MilliSatoshi, NAddr, NostrBech32, PayRequestData, PreEvent, PrivateKey, Profile, PublicKey, MilliSatoshi, NAddr, NostrBech32, PayRequestData, PreEvent, PrivateKey, Profile, PublicKey,
RelayUrl, RelayUsage, Tag, UncheckedUrl, Unixtime, RelayUrl, Tag, UncheckedUrl, Unixtime,
}; };
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::atomic::Ordering; use std::sync::atomic::Ordering;
@ -1271,7 +1271,7 @@ impl Overlord {
let mut relay_urls: Vec<RelayUrl> = Vec::new(); let mut relay_urls: Vec<RelayUrl> = Vec::new();
{ {
// Get all of the relays that we write to // Get all of the relays that we write to
let write_relays = Relay::choose_relay_urls(Relay::WRITE, |_| true)?; let write_relays = relay::relays_to_post_to(&event)?;
relay_urls.extend(write_relays); relay_urls.extend(write_relays);
// Get all of the relays this events were seen on // Get all of the relays this events were seen on
@ -1349,7 +1349,7 @@ impl Overlord {
let mut relay_urls: Vec<RelayUrl> = Vec::new(); let mut relay_urls: Vec<RelayUrl> = Vec::new();
{ {
// Get all of the relays that we write to // Get all of the relays that we write to
let write_relays = Relay::choose_relay_urls(Relay::WRITE, |_| true)?; let write_relays = relay::relays_to_post_to(&event)?;
relay_urls.extend(write_relays); relay_urls.extend(write_relays);
// Get all of the relays this event was seen on // Get all of the relays this event was seen on
@ -1656,15 +1656,14 @@ impl Overlord {
} }
}; };
let relays: Vec<Relay> = Relay::choose_relays(Relay::WRITE, |_| true)?; let relays: Vec<RelayUrl> = relay::relays_to_post_to(&event)?;
// FIXME - post it to relays we have seen it on.
for relay in relays { for relay in relays {
// Send it the event to post // Send it the event to post
tracing::debug!("Asking {} to post", &relay.url); tracing::debug!("Asking {} to post", &relay);
self.engage_minion( self.engage_minion(
relay.url.clone(), relay.clone(),
vec![RelayJob { vec![RelayJob {
reason: RelayConnectionReason::PostLike, reason: RelayConnectionReason::PostLike,
payload: ToMinionPayload { payload: ToMinionPayload {
@ -1721,8 +1720,7 @@ impl Overlord {
} }
FeedKind::Person(pubkey) => { FeedKind::Person(pubkey) => {
// Get write relays for the person // Get write relays for the person
let relays: Vec<RelayUrl> = let relays: Vec<RelayUrl> = relay::get_some_pubkey_outboxes(pubkey)?;
relay::get_best_relays_fixed(pubkey, RelayUsage::Outbox)?;
// Subscribe on each of those write relays // Subscribe on each of those write relays
for relay in relays.iter() { for relay in relays.iter() {
// Subscribe // Subscribe
@ -2069,7 +2067,7 @@ impl Overlord {
// Sort the people into the relays we will find their metadata at // Sort the people into the relays we will find their metadata at
for pubkey in &pubkeys { for pubkey in &pubkeys {
for relay in relay::get_best_relays_fixed(*pubkey, RelayUsage::Outbox)?.drain(..) { for relay in relay::get_some_pubkey_outboxes(*pubkey)?.drain(..) {
map.entry(relay) map.entry(relay)
.and_modify(|e| e.push(*pubkey)) .and_modify(|e| e.push(*pubkey))
.or_insert_with(|| vec![*pubkey]); .or_insert_with(|| vec![*pubkey]);
@ -2187,7 +2185,7 @@ impl Overlord {
let mut relay_urls: Vec<RelayUrl> = Vec::new(); let mut relay_urls: Vec<RelayUrl> = Vec::new();
{ {
// Get all of the relays that we write to // Get all of the relays that we write to
let write_relay_urls: Vec<RelayUrl> = Relay::choose_relay_urls(Relay::WRITE, |_| true)?; let write_relay_urls: Vec<RelayUrl> = relay::relays_to_post_to(&event)?;
relay_urls.extend(write_relay_urls); relay_urls.extend(write_relay_urls);
relay_urls.sort(); relay_urls.sort();
relay_urls.dedup(); relay_urls.dedup();
@ -2373,7 +2371,7 @@ impl Overlord {
} }
async fn set_person_feed(&mut self, pubkey: PublicKey, anchor: Unixtime) -> Result<(), Error> { async fn set_person_feed(&mut self, pubkey: PublicKey, anchor: Unixtime) -> Result<(), Error> {
let relays: Vec<RelayUrl> = relay::get_best_relays_fixed(pubkey, RelayUsage::Outbox)?; let relays: Vec<RelayUrl> = relay::get_some_pubkey_outboxes(pubkey)?;
for relay in relays.iter() { for relay in relays.iter() {
// Subscribe // Subscribe
@ -2451,7 +2449,7 @@ impl Overlord {
bonus_relays.push(url); bonus_relays.push(url);
} else { } else {
let tagged_person_relays: Vec<RelayUrl> = let tagged_person_relays: Vec<RelayUrl> =
relay::get_best_relays_fixed(pk, RelayUsage::Outbox)?; relay::get_some_pubkey_outboxes(pk)?;
bonus_relays.extend(tagged_person_relays); bonus_relays.extend(tagged_person_relays);
} }
} }
@ -2483,8 +2481,7 @@ impl Overlord {
// Include the relays of the author of the referencing event // Include the relays of the author of the referencing event
if let Some(pk) = author { if let Some(pk) = author {
let author_relays: Vec<RelayUrl> = let author_relays: Vec<RelayUrl> = relay::get_some_pubkey_outboxes(pk)?;
relay::get_best_relays_fixed(pk, RelayUsage::Outbox)?;
bonus_relays.extend(author_relays); bonus_relays.extend(author_relays);
} }
} }
@ -2558,21 +2555,7 @@ impl Overlord {
let mut bonus_relays: Vec<RelayUrl> = Vec::new(); let mut bonus_relays: Vec<RelayUrl> = Vec::new();
if let Some(event) = GLOBALS.storage.read_event(id)? { if let Some(event) = GLOBALS.storage.read_event(id)? {
// Include all the INBOX relays of the author of the event bonus_relays.extend(relay::relays_for_seeking_replies(&event)?);
bonus_relays.extend(relay::get_best_relays_min(
event.pubkey,
RelayUsage::Inbox,
0,
)?);
// Include all the relays where the event was seen
bonus_relays.extend(
GLOBALS
.storage
.get_event_seen_on_relay(id)?
.drain(..)
.map(|(url, _time)| url),
);
} else { } else {
// We don't have the event itself yet. // We don't have the event itself yet.
@ -2588,8 +2571,7 @@ impl Overlord {
// Include the inbox relays of the author of the referencing event // Include the inbox relays of the author of the referencing event
if let Some(pk) = author { if let Some(pk) = author {
let author_relays: Vec<RelayUrl> = let author_relays: Vec<RelayUrl> = relay::get_some_pubkey_outboxes(pk)?;
relay::get_best_relays_min(pk, RelayUsage::Inbox, 0)?;
bonus_relays.extend(author_relays); bonus_relays.extend(author_relays);
} }
} }
@ -2825,7 +2807,7 @@ impl Overlord {
// for it's retry logic // for it's retry logic
GLOBALS.people.metadata_fetch_initiated(&[pubkey]); GLOBALS.people.metadata_fetch_initiated(&[pubkey]);
let best_relays = relay::get_best_relays_fixed(pubkey, RelayUsage::Outbox)?; let best_relays = relay::get_some_pubkey_outboxes(pubkey)?;
// we do 1 more than num_relays_per_person, which is really for main posts, // we do 1 more than num_relays_per_person, which is really for main posts,
// since metadata is more important and I didn't want to bother with // since metadata is more important and I didn't want to bother with
@ -2862,7 +2844,7 @@ impl Overlord {
let mut map: HashMap<RelayUrl, Vec<PublicKey>> = HashMap::new(); let mut map: HashMap<RelayUrl, Vec<PublicKey>> = HashMap::new();
for pubkey in pubkeys.drain(..) { for pubkey in pubkeys.drain(..) {
let best_relays = relay::get_best_relays_fixed(pubkey, RelayUsage::Outbox)?; let best_relays = relay::get_some_pubkey_outboxes(pubkey)?;
for relay_url in best_relays.iter() { for relay_url in best_relays.iter() {
map.entry(relay_url.to_owned()) map.entry(relay_url.to_owned())
.and_modify(|entry| entry.push(pubkey)) .and_modify(|entry| entry.push(pubkey))
@ -3370,8 +3352,7 @@ impl Overlord {
.collect(); .collect();
// Add the read relays of the target person // Add the read relays of the target person
let target_read_relays: Vec<RelayUrl> = let target_read_relays: Vec<RelayUrl> = relay::get_all_pubkey_inboxes(target_pubkey)?;
relay::get_best_relays_min(target_pubkey, RelayUsage::Inbox, 0)?;
relays.extend(target_read_relays); relays.extend(target_read_relays);
// Add all my write relays // Add all my write relays
@ -3411,6 +3392,7 @@ impl Overlord {
}; };
let event = GLOBALS.identity.sign_event(pre_event)?; let event = GLOBALS.identity.sign_event(pre_event)?;
let serialized_event = serde_json::to_string(&event)?; let serialized_event = serde_json::to_string(&event)?;
let client = reqwest::Client::builder() let client = reqwest::Client::builder()

8
gossip-lib/src/people.rs
View File

@ -7,8 +7,8 @@ use crate::storage::{PersonTable, Table};
use dashmap::{DashMap, DashSet}; use dashmap::{DashMap, DashSet};
use image::RgbaImage; use image::RgbaImage;
use nostr_types::{ use nostr_types::{
ContentEncryptionAlgorithm, Event, EventKind, Metadata, PreEvent, PublicKey, RelayUrl, ContentEncryptionAlgorithm, Event, EventKind, Metadata, PreEvent, PublicKey, RelayUrl, Tag,
RelayUsage, Tag, UncheckedUrl, Unixtime, Url, UncheckedUrl, Unixtime, Url,
}; };
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::collections::BTreeMap; use std::collections::BTreeMap;
@ -667,7 +667,7 @@ impl People {
// Only include recommended relay urls in public entries, and not in the mute list // Only include recommended relay urls in public entries, and not in the mute list
let recommended_relay_url = { let recommended_relay_url = {
if kind != EventKind::MuteList && !private.0 { if kind != EventKind::MuteList && !private.0 {
let relays = relay::get_best_relays_min(*pubkey, RelayUsage::Outbox, 1)?; let relays = relay::get_some_pubkey_outboxes(*pubkey)?;
relays.first().map(|u| u.to_unchecked_url()) relays.first().map(|u| u.to_unchecked_url())
} else { } else {
None None
@ -878,7 +878,7 @@ impl People {
*self.active_person.write().await = Some(pubkey); *self.active_person.write().await = Some(pubkey);
// Load their relays // Load their relays
let best_relays = relay::get_best_relays_min(pubkey, RelayUsage::Outbox, 1)?; let best_relays = relay::get_all_pubkey_outboxes(pubkey)?;
*self.active_persons_write_relays.write().await = best_relays; *self.active_persons_write_relays.write().await = best_relays;
// Load their DM relays // Load their DM relays

47
gossip-lib/src/relay_picker.rs
View File

@ -1,6 +1,6 @@
use crate::error::{Error, ErrorKind}; use crate::error::{Error, ErrorKind};
use crate::globals::GLOBALS; use crate::globals::GLOBALS;
use crate::relay; use crate::relay::{self, ScoreFactors};
use dashmap::DashMap; use dashmap::DashMap;
pub use nostr_types::{PublicKey, RelayUrl, RelayUsage, Unixtime}; pub use nostr_types::{PublicKey, RelayUrl, RelayUsage, Unixtime};
@ -35,7 +35,7 @@ impl RelayAssignment {
#[derive(Debug, Default)] #[derive(Debug, Default)]
pub struct RelayPicker { pub struct RelayPicker {
/// A ranking of relays per person. /// A ranking of relays per person.
person_relay_scores: DashMap<PublicKey, Vec<(RelayUrl, u64)>>, person_relay_scores: DashMap<PublicKey, Vec<(RelayUrl, f32)>>,
/// All of the relays currently connected, with their assignment. /// All of the relays currently connected, with their assignment.
relay_assignments: DashMap<RelayUrl, RelayAssignment>, relay_assignments: DashMap<RelayUrl, RelayAssignment>,
@ -171,8 +171,11 @@ impl RelayPicker {
// Compute scores for each person_relay pairing // Compute scores for each person_relay pairing
for pubkey in pubkeys.iter() { for pubkey in pubkeys.iter() {
let best_relays: Vec<(RelayUrl, u64)> = let best_relays: Vec<(RelayUrl, f32)> = relay::get_best_relays_with_score2(
relay::get_best_relays_with_score(*pubkey, RelayUsage::Outbox, 0)?; *pubkey,
RelayUsage::Outbox,
ScoreFactors::RelayScorePlusConnected,
)?;
self.person_relay_scores.insert(*pubkey, best_relays); self.person_relay_scores.insert(*pubkey, best_relays);
@ -241,9 +244,9 @@ impl RelayPicker {
return Err(ErrorKind::NoRelays.into()); return Err(ErrorKind::NoRelays.into());
} }
// Keep score for each relay, start at 0 // Keep score for each relay, start at 0.0
let scoreboard: DashMap<RelayUrl, u64> = let scoreboard: DashMap<RelayUrl, f32> =
all_relays.iter().map(|x| (x.to_owned(), 0)).collect(); all_relays.iter().map(|x| (x.to_owned(), 0.0)).collect();
// Assign scores to relays from each pubkey // Assign scores to relays from each pubkey
for elem in self.person_relay_scores.iter() { for elem in self.person_relay_scores.iter() {
@ -286,35 +289,14 @@ impl RelayPicker {
} }
} }
// Adjust all scores based on relay rank and relay success rate
// (gossip code elided due to complex data tracking required)
// TBD to add this kind of feature back.
for mut score_entry in scoreboard.iter_mut() {
let url = score_entry.key().to_owned();
let score = score_entry.value_mut();
// adjust score
*score = match GLOBALS.storage.read_relay(&url, None) {
Err(_) => 0,
Ok(Some(relay)) => {
if relay.should_avoid() {
0
} else {
*score * (relay.score() * 10.0) as u64
}
}
Ok(None) => *score,
}
}
let winner = scoreboard let winner = scoreboard
.iter() .iter()
.max_by(|x, y| x.value().cmp(y.value())) .max_by(|x, y| x.value().partial_cmp(y.value()).unwrap())
.unwrap(); .unwrap();
let winning_url: RelayUrl = winner.key().to_owned(); let winning_url: RelayUrl = winner.key().to_owned();
let winning_score: u64 = *winner.value(); let winning_score: f32 = *winner.value();
if winning_score == 0 { if winning_score < 0.000000000001 {
return Err(ErrorKind::NoProgress.into()); return Err(ErrorKind::NoProgress.into());
} }
@ -346,7 +328,8 @@ impl RelayPicker {
if *relay == winning_url { if *relay == winning_url {
// Do not assign to this relay if it's not one of their top // Do not assign to this relay if it's not one of their top
// three relays and its score has dropped to 5 or lower. // three relays and its score has dropped to 5 or lower.
if *score <= 5 && i >= 3 { // ******FIXME GINA 5.0 is probably the wrong level now ******
if *score <= 5.0 && i >= 3 {
// in this case we can skip the rest which have lower // in this case we can skip the rest which have lower
// scores and are further down the list // scores and are further down the list
break; break;

13
gossip-lib/src/seeker.rs
View File

@ -6,7 +6,7 @@ use crate::people::People;
use crate::relay; use crate::relay;
use crate::relay::Relay; use crate::relay::Relay;
use dashmap::DashMap; use dashmap::DashMap;
use nostr_types::{Event, EventReference, Id, PublicKey, RelayUrl, RelayUsage, Unixtime}; use nostr_types::{Event, EventReference, Id, PublicKey, RelayUrl, Unixtime};
use std::time::Duration; use std::time::Duration;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
@ -134,13 +134,12 @@ impl Seeker {
// Seek the relay list because it is stale, but don't let that hold us up // Seek the relay list because it is stale, but don't let that hold us up
// using the stale data // using the stale data
Self::minion_seek_relay_list(author); Self::minion_seek_relay_list(author);
let relays = relay::get_some_pubkey_outboxes(author)?;
let relays = relay::get_best_relays_fixed(author, RelayUsage::Outbox)?;
Self::minion_seek_event_at_relays(id, relays); Self::minion_seek_event_at_relays(id, relays);
self.events.insert(id, SeekData::new_event(climb)); self.events.insert(id, SeekData::new_event(climb));
} }
Freshness::Fresh => { Freshness::Fresh => {
let relays = relay::get_best_relays_fixed(author, RelayUsage::Outbox)?; let relays = relay::get_some_pubkey_outboxes(author)?;
Self::minion_seek_event_at_relays(id, relays); Self::minion_seek_event_at_relays(id, relays);
self.events.insert(id, SeekData::new_event(climb)); self.events.insert(id, SeekData::new_event(climb));
} }
@ -171,7 +170,7 @@ impl Seeker {
if let SeekState::WaitingRelayList(author) = data.state { if let SeekState::WaitingRelayList(author) = data.state {
if author == pubkey { if author == pubkey {
let id = *refmutmulti.key(); let id = *refmutmulti.key();
if let Ok(relays) = relay::get_best_relays_fixed(author, RelayUsage::Outbox) { if let Ok(relays) = relay::get_some_pubkey_outboxes(author) {
Self::minion_seek_event_at_relays(id, relays); Self::minion_seek_event_at_relays(id, relays);
updates.push((id, SeekData::new_event(data.climb))); updates.push((id, SeekData::new_event(data.climb)));
} }
@ -236,9 +235,7 @@ impl Seeker {
// Check if we have their relays yet // Check if we have their relays yet
match People::person_needs_relay_list(author) { match People::person_needs_relay_list(author) {
Freshness::Fresh | Freshness::Stale => { Freshness::Fresh | Freshness::Stale => {
if let Ok(relays) = if let Ok(relays) = relay::get_some_pubkey_outboxes(author) {
relay::get_best_relays_fixed(author, RelayUsage::Outbox)
{
Self::minion_seek_event_at_relays(id, relays); Self::minion_seek_event_at_relays(id, relays);
updates.push((id, Some(SeekData::new_event(data.climb)))); updates.push((id, Some(SeekData::new_event(data.climb))));
continue; continue;