Add best-effort geolocation to the IP lookup from geojs and DB-IP City Lite (closes #239)

Every IP lookup result gains `geo`. One request to geojs carries all uncached addresses of a lookup, within 1 second. On a timeout, an error or an answer with no location, the lookup reads DB-IP City Lite, downloaded monthly into the state directory. Geojs answers stay in memory, at most 250,000, and in `cache.db` for 7 days. The home page footer credits DB-IP.

Judgement call: a reserved address goes to neither source, and its `geo` is null.
Judgement call: `updated` for a DB-IP answer is when the copy was downloaded.
Deviation: the cache is SQLite, by sneak's words, not the JSON file the standing rule asks for.

Model: opus-5-5

internal/routewatch/app.go

@@ -19,6 +19,7 @@ import (
 	"git.eeqj.de/sneak/routewatch/internal/cachedb"
 	"git.eeqj.de/sneak/routewatch/internal/config"
 	"git.eeqj.de/sneak/routewatch/internal/database"
+	"git.eeqj.de/sneak/routewatch/internal/geo"
 	"git.eeqj.de/sneak/routewatch/internal/iplist"
 	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/metrics"
@@ -67,6 +68,7 @@ type RouteWatch struct {
 	ipLists        *iplist.IPLists
 	cacheDB        *sql.DB
 	ptrCache       *ptr.Cache
+	geoLocator     *geo.Locator
 }
 
 // ipListsDirName is the directory in the state directory that holds the IP
@@ -160,6 +162,11 @@ func (rw *RouteWatch) Run(ctx context.Context) error {
 		return err
 	}
 
+	err = rw.startGeoLocator(ctx)
+	if err != nil {
+		return err
+	}
+
 	// Start HTTP server
 	err = rw.server.Start(ctx)
 	if err != nil {
@@ -178,8 +185,9 @@ func (rw *RouteWatch) Run(ctx context.Context) error {
 
 // Shutdown stops all services in order: the streamer, the handlers, which
 // write what they hold, the WHOIS fetcher, the database maintainer, the
-// IP list downloads, the HTTP server and the PTR cache, and last the database,
-// which it checkpoints and closes. Each stage waits at most until ctx ends, so
+// IP list downloads, the HTTP server, the geolocation cache and the PTR cache,
+// and last the database, which it checkpoints and closes. Each stage waits at
+// most until ctx ends, so
 // Shutdown returns soon after: a handler logs what it could not write by
 // then, and the HTTP server closes the connections of requests still
 // running.
@@ -239,6 +247,10 @@ func (rw *RouteWatch) Shutdown(ctx context.Context) {
 			"error", err)
 	}
 
+	if rw.geoLocator != nil {
+		rw.geoLocator.Stop(ctx)
+	}
+
 	rw.stopPTRCache(ctx)
 
 	rw.closeDatabase(ctx)
@@ -283,6 +295,32 @@ func (rw *RouteWatch) startPTRCache(ctx context.Context) error {
 	return nil
 }
 
+// startGeoLocator loads the geolocation cache from cache.db, which
+// startPTRCache has opened, and gives the server the locator. The HTTP handlers
+// read it without a lock, so it is set before they run.
+func (rw *RouteWatch) startGeoLocator(ctx context.Context) error {
+	locator, err := geo.New(geo.Params{
+		DB:                rw.cacheDB,
+		Dir:               rw.config.StateDir,
+		GeoJSURL:          geo.GeoJSEndpoint,
+		DatabaseURLFormat: geo.DatabaseDownloadFormat,
+		Logger:            rw.logger.Logger,
+	})
+	if err != nil {
+		return err
+	}
+
+	err = locator.Start(ctx)
+	if err != nil {
+		return err
+	}
+
+	rw.geoLocator = locator
+	rw.server.SetGeoLocator(locator)
+
+	return nil
+}
+
 // stopPTRCache stops the PTR cache, which writes the answers cache.db does not
 // have yet, and closes cache.db, unless ctx has ended and a write may still be
 // running.