fetch: use more outbox relays.

count.go

@@ -63,11 +63,19 @@ var count = &cli.Command{
 					hll = hyperloglog.New(offset)
 				}
 				for _, relayUrl := range relayUrls {
-					relay, err := sys.Pool.EnsureRelay(relayUrl)
-					if err != nil {
-						fmt.Fprintf(os.Stderr, "%s%s: ", strings.Repeat(" ", biggerUrlSize-len(relayUrl)), relayUrl)
-						fmt.Fprintf(os.Stderr, "error: %s\n", err)
-						continue
+					nm := nostr.NormalizeURL(relayUrl)
+					relay, ok := sys.Pool.Relays.Load(nm)
+					if !ok || relay == nil || !relay.IsConnected() {
+						ct, cancel := context.WithTimeout(context.Background(), connectTimeout)
+						var err error
+						relay, err = nostr.RelayConnect(ct, relayUrl, sys.Pool.RelayOptions)
+						cancel()
+						if err != nil {
+							fmt.Fprintf(os.Stderr, "%s%s: ", strings.Repeat(" ", biggerUrlSize-len(relayUrl)), relayUrl)
+							fmt.Fprintf(os.Stderr, "error: %s\n", err)
+							continue
+						}
+						sys.Pool.Relays.Store(nm, relay)
 					}
 
 					count, hllRegisters, err := relay.Count(ctx, filter, nostr.SubscriptionOptions{

event.go

@@ -543,9 +543,19 @@ func publishFlow(ctx context.Context, c *cli.Command, kr nostr.Signer, evt nostr
 				defer cancel()
 
 				if !relay.IsConnected() {
-					if new_, err := sys.Pool.EnsureRelay(relay.URL); err == nil {
-						relays[i] = new_
-						relay = new_
+					nm := nostr.NormalizeURL(relay.URL)
+					if r, ok := sys.Pool.Relays.Load(nm); ok && r != nil && r.IsConnected() {
+						relays[i] = r
+						relay = r
+					} else {
+						ct, cancel := context.WithTimeout(context.Background(), connectTimeout)
+						new_, err := nostr.RelayConnect(ct, relay.URL, sys.Pool.RelayOptions)
+						cancel()
+						if err == nil {
+							sys.Pool.Relays.Store(nm, new_)
+							relays[i] = new_
+							relay = new_
+						}
 					}
 				}
 

fetch.go

@@ -101,7 +101,7 @@ var fetch = &cli.Command{
 					sys.Hints.Save(authorHint, nostr.NormalizeURL(url), hints.LastInHint, nostr.Now())
 				}
 
-				for _, url := range sys.FetchOutboxRelays(ctx, authorHint, 3) {
+				for _, url := range sys.FetchOutboxRelays(ctx, authorHint, 6) {
 					relays = append(relays, url)
 				}
 			}

group.go

@@ -243,9 +243,17 @@ var group = &cli.Command{
 					return err
 				}
 
-				r, err := sys.Pool.EnsureRelay(relay)
-				if err != nil {
-					return err
+				nm := nostr.NormalizeURL(relay)
+				r, ok := sys.Pool.Relays.Load(nm)
+				if !ok || r == nil || !r.IsConnected() {
+					ct, cancel := context.WithTimeout(context.Background(), connectTimeout)
+					var err error
+					r, err = nostr.RelayConnect(ct, relay, sys.Pool.RelayOptions)
+					cancel()
+					if err != nil {
+						return err
+					}
+					sys.Pool.Relays.Store(nm, r)
 				}
 
 				sub, err := r.Subscribe(ctx, nostr.Filter{
@@ -316,11 +324,19 @@ var group = &cli.Command{
 							return fmt.Errorf("failed to sign message: %w", err)
 						}
 
-						if r, err := sys.Pool.EnsureRelay(relay); err != nil {
-							return err
-						} else {
-							return r.Publish(ctx, msg)
+						nm := nostr.NormalizeURL(relay)
+						r, ok := sys.Pool.Relays.Load(nm)
+						if !ok || r == nil || !r.IsConnected() {
+							ct, cancel := context.WithTimeout(context.Background(), connectTimeout)
+							var err error
+							r, err = nostr.RelayConnect(ct, relay, sys.Pool.RelayOptions)
+							cancel()
+							if err != nil {
+								return err
+							}
+							sys.Pool.Relays.Store(nm, r)
 						}
+						return r.Publish(ctx, msg)
 					},
 				},
 			},
@@ -474,9 +490,17 @@ write your forum post
 							return fmt.Errorf("failed to sign forum topic event: %w", err)
 						}
 
-						r, err := sys.Pool.EnsureRelay(relay)
-						if err != nil {
-							return err
+						nm := nostr.NormalizeURL(relay)
+						r, ok := sys.Pool.Relays.Load(nm)
+						if !ok || r == nil || !r.IsConnected() {
+							ct, cancel := context.WithTimeout(context.Background(), connectTimeout)
+							var err error
+							r, err = nostr.RelayConnect(ct, relay, sys.Pool.RelayOptions)
+							cancel()
+							if err != nil {
+								return err
+							}
+							sys.Pool.Relays.Store(nm, r)
 						}
 
 						return r.Publish(ctx, evt)
@@ -581,9 +605,17 @@ write your forum post
 							return fmt.Errorf("failed to sign forum comment event: %w", err)
 						}
 
-						r, err := sys.Pool.EnsureRelay(relay)
-						if err != nil {
-							return err
+						nm := nostr.NormalizeURL(relay)
+						r, ok := sys.Pool.Relays.Load(nm)
+						if !ok || r == nil || !r.IsConnected() {
+							ct, cancel := context.WithTimeout(context.Background(), connectTimeout)
+							var err error
+							r, err = nostr.RelayConnect(ct, relay, sys.Pool.RelayOptions)
+							cancel()
+							if err != nil {
+								return err
+							}
+							sys.Pool.Relays.Store(nm, r)
 						}
 
 						return r.Publish(ctx, evt)
@@ -906,9 +938,17 @@ func publishModerationEvent(ctx context.Context, c *cli.Command, kind nostr.Kind
 
 	stdout(evt.String())
 
-	r, err := sys.Pool.EnsureRelay(relay)
-	if err != nil {
-		return err
+	nm := nostr.NormalizeURL(relay)
+	r, ok := sys.Pool.Relays.Load(nm)
+	if !ok || r == nil || !r.IsConnected() {
+		ct, cancel := context.WithTimeout(context.Background(), connectTimeout)
+		var err error
+		r, err = nostr.RelayConnect(ct, relay, sys.Pool.RelayOptions)
+		cancel()
+		if err != nil {
+			return err
+		}
+		sys.Pool.Relays.Store(nm, r)
 	}
 
 	return r.Publish(ctx, evt)

helpers.go

@@ -48,6 +48,8 @@ var (
 	stdout     = func(args ...any) { fmt.Fprintln(color.Output, args...) }
 )
 
+var connectTimeout = 2 * time.Second
+
 func isPiped() bool {
 	stat, err := os.Stdin.Stat()
 	if err != nil {
@@ -268,63 +270,75 @@ func connectToSingleRelay(
 	colorizepreamble func(c func(string, ...any) string),
 	logthis func(s string, args ...any),
 ) *nostr.Relay {
-	if relay, err := sys.Pool.EnsureRelay(url); err == nil {
-		if c.Bool("force-pre-auth") {
-			if colorizepreamble != nil {
-				colorizepreamble(color.YellowString)
-			}
-			logthis("waiting for auth challenge... ")
-			time.Sleep(time.Millisecond * 200)
+	nm := nostr.NormalizeURL(url)
 
-			for range 5 {
-				if err := relay.Auth(ctx, func(ctx context.Context, authEvent *nostr.Event) error {
-					challengeTag := authEvent.Tags.Find("challenge")
-					if challengeTag == nil || len(challengeTag) < 2 || challengeTag[1] == "" {
-						return fmt.Errorf("auth not received yet *****") // what a giant hack
-					}
-					return authSigner(ctx, c, logthis, authEvent)
-				}); err == nil {
-					// auth succeeded
-					goto preauthSuccess
-				} else {
-					// auth failed
-					if strings.HasSuffix(err.Error(), "auth not received yet *****") {
-						// it failed because we didn't receive the challenge yet, so keep waiting
-						time.Sleep(time.Second)
-						continue
-					} else {
-						// it failed for some other reason, so skip this relay
-						if colorizepreamble != nil {
-							colorizepreamble(colors.errorf)
-						}
-						logthis(err.Error())
-						return nil
-					}
-				}
-			}
+	relay, ok := sys.Pool.Relays.Load(nm)
+	if !ok || relay == nil || !relay.IsConnected() {
+		connectCtx, cancel := context.WithTimeout(context.Background(), connectTimeout)
+		defer cancel()
+
+		var err error
+		if relay, err = nostr.RelayConnect(connectCtx, url, sys.Pool.RelayOptions); err != nil {
 			if colorizepreamble != nil {
 				colorizepreamble(colors.errorf)
 			}
-			logthis("failed to get an AUTH challenge in enough time.")
+			logthis(clampError(err, len(url)+12))
 			return nil
 		}
 
-	preauthSuccess:
+		sys.Pool.Relays.Store(nm, relay)
+		go func(r *nostr.Relay, relayURL string) {
+			<-r.Context().Done()
+			if current, ok := sys.Pool.Relays.Load(relayURL); ok && current == r {
+				sys.Pool.Relays.Delete(relayURL)
+			}
+		}(relay, nm)
+	}
+
+	if c.Bool("force-pre-auth") {
 		if colorizepreamble != nil {
-			colorizepreamble(colors.successf)
+			colorizepreamble(color.YellowString)
+		}
+		logthis("waiting for auth challenge... ")
+		time.Sleep(time.Millisecond * 200)
+
+		for range 5 {
+			if err := relay.Auth(ctx, func(ctx context.Context, authEvent *nostr.Event) error {
+				challengeTag := authEvent.Tags.Find("challenge")
+				if challengeTag == nil || len(challengeTag) < 2 || challengeTag[1] == "" {
+					return fmt.Errorf("auth not received yet *****") // what a giant hack
+				}
+				return authSigner(ctx, c, logthis, authEvent)
+			}); err == nil {
+				// auth succeeded
+				goto preauthSuccess
+			} else {
+				// auth failed
+				if strings.HasSuffix(err.Error(), "auth not received yet *****") {
+					time.Sleep(time.Second)
+					continue
+				} else {
+					if colorizepreamble != nil {
+						colorizepreamble(colors.errorf)
+					}
+					logthis(err.Error())
+					return nil
+				}
+			}
 		}
-		logthis("ok.")
-		return relay
-	} else {
 		if colorizepreamble != nil {
 			colorizepreamble(colors.errorf)
 		}
-
-		// if we're here that means we've failed to connect, this may be a huge message
-		// but we're likely to only be interested in the lowest level error (although we can leave space)
-		logthis(clampError(err, len(url)+12))
+		logthis("failed to get an AUTH challenge in enough time.")
 		return nil
 	}
+
+preauthSuccess:
+	if colorizepreamble != nil {
+		colorizepreamble(colors.successf)
+	}
+	logthis("ok.")
+	return relay
 }
 
 func clearLines(lineCount int) {

main.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"time"
 
 	"fiatjaf.com/nostr"
 	"fiatjaf.com/nostr/nip42"
@@ -42,6 +43,7 @@ var defaultKeyFlags = []cli.Flag{
 		Name:     "prompt-sec",
 		Usage:    "prompt the user to paste a hex or nsec with which to sign the event",
 		Category: CATEGORY_SIGNER,
+		Hidden:   true,
 	},
 	&SecretKeyFlag{
 		Name:        "connect-as",
@@ -50,6 +52,7 @@ var defaultKeyFlags = []cli.Flag{
 		Sources:     cli.EnvVars("NOSTR_CLIENT_KEY"),
 		Value:       defaultKey(),
 		DefaultText: "the default key (see `nak key default`)",
+		Hidden:      true,
 	},
 }
 
@@ -128,6 +131,7 @@ var app = &cli.Command{
 					}
 					return nil
 				},
+				Hidden: true,
 			},
 			&cli.BoolFlag{
 				Name:    "verbose",
@@ -141,6 +145,17 @@ var app = &cli.Command{
 					}
 					return nil
 				},
+				Hidden: true,
+			},
+			&cli.DurationFlag{
+				Name:  "connect-timeout",
+				Usage: "timeout for connecting to relays",
+				Value: connectTimeout,
+				Action: func(ctx context.Context, c *cli.Command, d time.Duration) error {
+					connectTimeout = d
+					return nil
+				},
+				Hidden: true,
 			},
 		},
 		defaultKeyFlags,

nostrfs_cgo/root.go

@@ -996,10 +996,13 @@ func (r *NostrRoot) publishNote(path string) {
 	}
 
 	for _, url := range relays {
-		relay, err := r.sys.Pool.EnsureRelay(url)
+		connectCtx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+		relay, err := nostr.RelayConnect(connectCtx, url, r.sys.Pool.RelayOptions)
+		cancel()
 		if err != nil {
 			continue
 		}
+		r.sys.Pool.Relays.Store(nostr.NormalizeURL(url), relay)
 		relay.Publish(ctx, *evt)
 	}