New

core/cmd/dragontcp-client/main.go

@@ -377,10 +377,12 @@ func main() {
 		chunkPollers        = flag.Int("chunk-pollers", 1, "reserved compatibility setting; binary transport uses one download worker")
 		chunkConcurrency    = flag.Int("chunk-concurrency", 1, "maximum download records per request (1-256)")
 		chunkConcurrencyMin = flag.Int("chunk-concurrency-min", 1, "minimum download records per request (1-256); equal to --chunk-concurrency pins the depth")
-		chunkReconnect      = flag.Int("chunk-reconnect-every", 0, "force reconnect after N logical requests; 0 = persistent/automatic")
+		chunkReconnect      = flag.Int("chunk-reconnect-every", 0, "connection reuse: 0 persistent, 1 auto-learn, N rotate after N requests")
 		chunkPollDelay      = flag.Duration("chunk-poll-delay", 2*time.Millisecond, "delay after an empty chunk poll")
-		chunkTimeout        = flag.Duration("chunk-timeout", 2*time.Second, "per-record transaction timeout before adaptive shrink")
-		wireMode            = flag.String("wire", "auto", "wire mode: b, x, or auto (probe and pick)")
+		chunkTimeout        = flag.Duration("chunk-timeout", 5*time.Second, "per-record transaction timeout before adaptive shrink")
+		wireMode            = flag.String("wire", "auto", "wire mode: b, bp, x, or auto (probe and pick)")
+		wireProbeDelay      = flag.Duration("wire-probe-delay", time.Second, "minimum delay between wire profile probe starts (200ms-30s)")
+		wireProbeThreads    = flag.Int("wire-probe-threads", 1, "maximum concurrent wire profile probes (1-16)")
 	)
 	flag.Parse()
 
@@ -430,19 +432,29 @@ func main() {
 	}
 	*wireMode = strings.ToLower(strings.TrimSpace(*wireMode))
 	switch *wireMode {
-	case WireBinary, WireXOR, WireAuto:
+	case WireBinary, WireBP, WireXOR, WireAuto:
 	case "binary":
 		*wireMode = WireBinary
+	case "bh", "h":
+		*wireMode = WireBP
 	case "xor":
 		*wireMode = WireXOR
 	default:
-		fmt.Fprintln(os.Stderr, "--wire must be b, x or auto")
+		fmt.Fprintln(os.Stderr, "--wire must be b, bp, x or auto")
 		os.Exit(2)
 	}
 	if *chunkReconnect < 0 {
 		fmt.Fprintln(os.Stderr, "--chunk-reconnect-every must be 0 or greater")
 		os.Exit(2)
 	}
+	if *wireProbeDelay < 200*time.Millisecond || *wireProbeDelay > 30*time.Second {
+		fmt.Fprintln(os.Stderr, "--wire-probe-delay must be between 200ms and 30s")
+		os.Exit(2)
+	}
+	if *wireProbeThreads < 1 || *wireProbeThreads > 16 {
+		fmt.Fprintln(os.Stderr, "--wire-probe-threads must be between 1 and 16")
+		os.Exit(2)
+	}
 	chunkOpts := chunkClientOptions{
 		startSize:      *chunkStart,
 		minSize:        *chunkMin,
@@ -498,15 +510,11 @@ func main() {
 		)
 	}
 
-	wires := newWireSelector(*wireMode, serverAddr, *token, chunkOpts, xorOpts)
-	if *wireMode == WireAuto {
-		fmt.Printf("wire=auto probing %s\n", probeHost)
-		// Resolve in the background so startup is not blocked; a connection that
-		// arrives first simply waits for the same result.
-		go wires.mode()
-	} else {
-		fmt.Printf("wire=%s (manual)\n", *wireMode)
-	}
+	wires := newWireSelector(*wireMode, serverAddr, *token, chunkOpts, xorOpts, *wireProbeDelay, *wireProbeThreads)
+	fmt.Printf("wire=%s discovering fixed header profile via http://%s/ probe_delay=%s probe_threads=%d\n", *wireMode, probeHost, wireProbeDelay.String(), *wireProbeThreads)
+	// Discover in the background so the local listener starts immediately. A
+	// connection arriving first waits on the same selector lock and result.
+	go wires.mode()
 
 	slots := make(chan struct{}, *maxConnections)