服务器代理地图数据

2026-06-06 12:01:46 +08:00
parent 9d3f007cb8
commit 563d609121
10 changed files with 618 additions and 49 deletions
@@ -0,0 +1,200 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+const (
+	mapTileCacheControl = "public, max-age=86400"
+	maxMapTileBytes     = 10 << 20
+)
+
+type mapTileProxy struct {
+	store    *store
+	cacheDir string
+	client   *http.Client
+}
+
+func registerMapTileProxyRoutes(r gin.IRouter, store *store, cacheDir string) {
+	proxy := &mapTileProxy{
+		store:    store,
+		cacheDir: cacheDir,
+		client:   &http.Client{Timeout: 15 * time.Second},
+	}
+	r.GET("/map/:sourceHash", proxy.handle)
+}
+
+func (p *mapTileProxy) handle(c *gin.Context) {
+	sourceHash := strings.ToLower(c.Param("sourceHash"))
+	if !isMapTileSourceHash(sourceHash) {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid map source hash"})
+		return
+	}
+
+	row, err := p.store.GetEnabledMapTileSourceByHash(sourceHash)
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		c.JSON(http.StatusNotFound, gin.H{"error": "map source not found"})
+		return
+	}
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	tile, ok := parseMapTileCoordinates(c, row.MaxZoom)
+	if !ok {
+		return
+	}
+
+	cachePath := mapTileCachePath(p.cacheDir, sourceHash, tile)
+	if data, err := os.ReadFile(cachePath); err == nil {
+		writeMapTile(c, data)
+		return
+	} else if !os.IsNotExist(err) {
+		// Fall through to upstream fetch. A broken cache file should not prevent map rendering.
+	}
+
+	data, status, err := p.fetchRemoteTile(c.Request, row.URLTemplate, tile)
+	if err != nil {
+		c.JSON(status, gin.H{"error": err.Error()})
+		return
+	}
+	_ = writeMapTileCacheFile(cachePath, data)
+	writeMapTile(c, data)
+}
+
+func (p *mapTileProxy) fetchRemoteTile(req *http.Request, template string, tile mapTileCoordinates) ([]byte, int, error) {
+	remoteURL := expandMapTileURLTemplate(template, tile)
+	upstreamReq, err := http.NewRequestWithContext(req.Context(), http.MethodGet, remoteURL, nil)
+	if err != nil {
+		return nil, http.StatusBadGateway, fmt.Errorf("build upstream map tile request: %w", err)
+	}
+	upstreamReq.Header.Set("User-Agent", "mesh_mqtt_go map tile cache")
+
+	resp, err := p.client.Do(upstreamReq)
+	if err != nil {
+		return nil, http.StatusBadGateway, fmt.Errorf("fetch upstream map tile: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusNotFound {
+		return nil, http.StatusNotFound, fmt.Errorf("upstream map tile not found")
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, http.StatusBadGateway, fmt.Errorf("upstream map tile returned status %d", resp.StatusCode)
+	}
+
+	data, err := io.ReadAll(io.LimitReader(resp.Body, maxMapTileBytes+1))
+	if err != nil {
+		return nil, http.StatusBadGateway, fmt.Errorf("read upstream map tile: %w", err)
+	}
+	if len(data) > maxMapTileBytes {
+		return nil, http.StatusBadGateway, fmt.Errorf("upstream map tile is too large")
+	}
+	return data, http.StatusOK, nil
+}
+
+type mapTileCoordinates struct {
+	x int64
+	y int64
+	z int64
+}
+
+func parseMapTileCoordinates(c *gin.Context, maxZoom int) (mapTileCoordinates, bool) {
+	x, ok := parseMapTileCoordinate(c, "x")
+	if !ok {
+		return mapTileCoordinates{}, false
+	}
+	y, ok := parseMapTileCoordinate(c, "y")
+	if !ok {
+		return mapTileCoordinates{}, false
+	}
+	z, ok := parseMapTileCoordinate(c, "z")
+	if !ok {
+		return mapTileCoordinates{}, false
+	}
+	if z > int64(maxZoom) {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "map tile z exceeds max zoom"})
+		return mapTileCoordinates{}, false
+	}
+	limit := int64(1) << z
+	if x >= limit || y >= limit {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "map tile coordinates out of range"})
+		return mapTileCoordinates{}, false
+	}
+	return mapTileCoordinates{x: x, y: y, z: z}, true
+}
+
+func parseMapTileCoordinate(c *gin.Context, name string) (int64, bool) {
+	value := c.Query(name)
+	if value == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "missing map tile " + name})
+		return 0, false
+	}
+	parsed, err := strconv.ParseInt(value, 10, 64)
+	if err != nil || parsed < 0 || parsed > 30_000_000_000 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid map tile " + name})
+		return 0, false
+	}
+	return parsed, true
+}
+
+func isMapTileSourceHash(value string) bool {
+	if len(value) != 64 {
+		return false
+	}
+	for _, r := range value {
+		if (r < '0' || r > '9') && (r < 'a' || r > 'f') {
+			return false
+		}
+	}
+	return true
+}
+
+func expandMapTileURLTemplate(template string, tile mapTileCoordinates) string {
+	result := strings.ReplaceAll(template, "{x}", strconv.FormatInt(tile.x, 10))
+	result = strings.ReplaceAll(result, "{y}", strconv.FormatInt(tile.y, 10))
+	result = strings.ReplaceAll(result, "{z}", strconv.FormatInt(tile.z, 10))
+	return result
+}
+
+func mapTileCachePath(cacheDir, sourceHash string, tile mapTileCoordinates) string {
+	return filepath.Join(cacheDir, sourceHash, strconv.FormatInt(tile.z, 10), strconv.FormatInt(tile.x, 10), strconv.FormatInt(tile.y, 10)+".tile")
+}
+
+func writeMapTileCacheFile(path string, data []byte) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		return err
+	}
+	tmp, err := os.CreateTemp(filepath.Dir(path), filepath.Base(path)+".*.tmp")
+	if err != nil {
+		return err
+	}
+	tmpPath := tmp.Name()
+	defer os.Remove(tmpPath)
+	if _, err := tmp.Write(data); err != nil {
+		tmp.Close()
+		return err
+	}
+	if err := tmp.Close(); err != nil {
+		return err
+	}
+	return os.Rename(tmpPath, path)
+}
+
+func writeMapTile(c *gin.Context, data []byte) {
+	contentType := http.DetectContentType(data)
+	c.Header("Cache-Control", mapTileCacheControl)
+	c.Data(http.StatusOK, contentType, data)
+}