milergeo added

internal/milergeo/milergeo.go

@@ -0,0 +1,131 @@
+// Package milergeo is the one place that reads and writes the live rider
+// positions in Redis (the `milers:locations` GEO set). Auto-assignment, the
+// customer pickup-slot check and the agent playground all search it; the rider
+// location ping and duty start write it.
+//
+// Why it exists: every caller used GEOSEARCH, which Redis only has from 6.2.
+// On an older server the writes (GEOADD) succeed but every search fails, and
+// the callers treated the failure as "no riders nearby" — so orders sat in
+// Pending with riders standing next to the pickup and nothing in the console
+// said why. Search now falls back to GEORADIUS (Redis 3.2+), which answers the
+// same question, and Probe reports at boot whether the search works at all.
+package milergeo
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"strings"
+	"sync/atomic"
+
+	"github.com/redis/go-redis/v9"
+)
+
+// Key is the GEO set holding each rider's last reported position, member =
+// the rider's userid as a decimal string.
+const Key = "milers:locations"
+
+// Client is the slice of the Redis client this package needs; *redis.Client
+// satisfies it. An interface so the fallback can be tested without a server.
+type Client interface {
+	GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd
+	GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd
+	GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd
+}
+
+// legacyOnly flips to true the first time the server rejects GEOSEARCH as an
+// unknown command, so later searches go straight to GEORADIUS instead of
+// paying for a failed round trip every time.
+var legacyOnly atomic.Bool
+
+// Search returns the riders within radiusKm of (lat, lon), nearest first, at
+// most count of them, each with Dist (km) set. It uses GEOSEARCH and falls back
+// to GEORADIUS when the server is older than Redis 6.2.
+//
+// Any other error (timeout, WRONGTYPE on the key, ...) is returned as is: the
+// caller must not mistake a broken search for an empty street.
+func Search(ctx context.Context, rdb Client, lat, lon, radiusKm float64, count int) ([]redis.GeoLocation, error) {
+	if isNil(rdb) {
+		return nil, fmt.Errorf("redis not available")
+	}
+	if !legacyOnly.Load() {
+		locs, err := rdb.GeoSearchLocation(ctx, Key, &redis.GeoSearchLocationQuery{
+			GeoSearchQuery: redis.GeoSearchQuery{
+				Longitude:  lon,
+				Latitude:   lat,
+				Radius:     radiusKm,
+				RadiusUnit: "km",
+				Sort:       "ASC",
+				Count:      count,
+			},
+			WithDist: true,
+		}).Result()
+		if err == nil {
+			return locs, nil
+		}
+		if !isUnknownCommand(err) {
+			return nil, fmt.Errorf("GEOSEARCH %s: %w", Key, err)
+		}
+		legacyOnly.Store(true)
+	}
+	locs, err := rdb.GeoRadius(ctx, Key, lon, lat, &redis.GeoRadiusQuery{
+		Radius:   radiusKm,
+		Unit:     "km",
+		WithDist: true,
+		Count:    count,
+		Sort:     "ASC",
+	}).Result()
+	if err != nil {
+		return nil, fmt.Errorf("GEORADIUS %s: %w", Key, err)
+	}
+	return locs, nil
+}
+
+// Index records a rider's position. The error is returned so callers can log
+// it — a failed write here is a rider auto-assignment can never find.
+func Index(ctx context.Context, rdb Client, milerUserID int, lat, lon float64) error {
+	if isNil(rdb) {
+		return fmt.Errorf("redis not available")
+	}
+	if err := rdb.GeoAdd(ctx, Key, &redis.GeoLocation{
+		Name:      fmt.Sprint(milerUserID),
+		Latitude:  lat,
+		Longitude: lon,
+	}).Err(); err != nil {
+		return fmt.Errorf("GEOADD %s: %w", Key, err)
+	}
+	return nil
+}
+
+// Probe runs one search to report, at boot and on /ready, whether rider
+// search works on this Redis: "ok", "ok (GEORADIUS fallback: Redis older than
+// 6.2)", or "error: ...". It never fails the caller.
+func Probe(ctx context.Context, rdb Client) string {
+	if isNil(rdb) {
+		return "error: redis not available"
+	}
+	if _, err := Search(ctx, rdb, 11.0168, 76.9558, 1, 1); err != nil {
+		return "error: " + err.Error()
+	}
+	if legacyOnly.Load() {
+		return "ok (GEORADIUS fallback: Redis older than 6.2)"
+	}
+	return "ok"
+}
+
+// isNil also catches a nil *redis.Client inside the interface (db.Rdb before
+// InitRedis), which a plain == nil does not.
+func isNil(rdb Client) bool {
+	if rdb == nil {
+		return true
+	}
+	v := reflect.ValueOf(rdb)
+	return v.Kind() == reflect.Ptr && v.IsNil()
+}
+
+// isUnknownCommand: how Redis < 6.2 (and proxies that filter commands) answer
+// a command they do not have, e.g. "ERR unknown command 'GEOSEARCH'".
+func isUnknownCommand(err error) bool {
+	msg := strings.ToLower(err.Error())
+	return strings.Contains(msg, "unknown command")
+}