365 lines
9.7 KiB
Go
365 lines
9.7 KiB
Go
package basemap
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"database/sql"
|
|
"encoding/base32"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
_ "modernc.org/sqlite"
|
|
)
|
|
|
|
const (
|
|
defaultScanSourceCode = "local-basemaps"
|
|
defaultManifestName = "manifest.json"
|
|
readPermission = "read"
|
|
defaultVectorSourceCode = "local-vectors"
|
|
)
|
|
|
|
type StoreConfig struct {
|
|
SQLitePath string
|
|
ScanRoot string
|
|
VectorScanRoot string
|
|
APIBaseURL string
|
|
TileBaseURL string
|
|
VectorBaseURL string
|
|
AutoScanOnStart bool
|
|
}
|
|
|
|
type Store struct {
|
|
db *sql.DB
|
|
cfg StoreConfig
|
|
httpClient *http.Client
|
|
}
|
|
|
|
type CreatedToken struct {
|
|
Meta ServiceToken `json:"meta"`
|
|
Token string `json:"token"`
|
|
}
|
|
|
|
type TileDescriptor struct {
|
|
FilePath string
|
|
ContentType string
|
|
Basemap Basemap
|
|
Version BasemapVersion
|
|
Token ServiceToken
|
|
RelativePath string
|
|
}
|
|
|
|
func OpenStore(cfg StoreConfig) (*Store, error) {
|
|
if strings.TrimSpace(cfg.SQLitePath) == "" {
|
|
return nil, errors.New("sqlite path is required")
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(cfg.SQLitePath), 0o755); err != nil {
|
|
return nil, fmt.Errorf("create sqlite dir: %w", err)
|
|
}
|
|
|
|
db, err := sql.Open("sqlite", cfg.SQLitePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("open sqlite: %w", err)
|
|
}
|
|
db.SetConnMaxLifetime(10 * time.Minute)
|
|
db.SetMaxOpenConns(1)
|
|
db.SetMaxIdleConns(1)
|
|
|
|
store := &Store{
|
|
db: db,
|
|
cfg: cfg,
|
|
httpClient: &http.Client{
|
|
Timeout: 15 * time.Second,
|
|
},
|
|
}
|
|
if err := store.bootstrap(context.Background()); err != nil {
|
|
_ = db.Close()
|
|
return nil, err
|
|
}
|
|
if strings.TrimSpace(cfg.ScanRoot) != "" {
|
|
if _, err := store.EnsureScanSource(context.Background(), CreateScanSourceInput{
|
|
Code: defaultScanSourceCode,
|
|
Name: "Local Basemaps",
|
|
RootPath: cfg.ScanRoot,
|
|
ManifestName: defaultManifestName,
|
|
}); err != nil {
|
|
_ = db.Close()
|
|
return nil, err
|
|
}
|
|
}
|
|
if strings.TrimSpace(cfg.VectorScanRoot) != "" {
|
|
if err := os.MkdirAll(cfg.VectorScanRoot, 0o755); err != nil {
|
|
_ = db.Close()
|
|
return nil, fmt.Errorf("create vector scan root: %w", err)
|
|
}
|
|
}
|
|
return store, nil
|
|
}
|
|
|
|
func (s *Store) Close() error {
|
|
if s == nil || s.db == nil {
|
|
return nil
|
|
}
|
|
return s.db.Close()
|
|
}
|
|
|
|
func (s *Store) bootstrap(ctx context.Context) error {
|
|
statements := []string{
|
|
`PRAGMA foreign_keys = ON;`,
|
|
`CREATE TABLE IF NOT EXISTS basemaps (
|
|
id TEXT PRIMARY KEY,
|
|
code TEXT NOT NULL UNIQUE,
|
|
name TEXT NOT NULL,
|
|
type TEXT NOT NULL,
|
|
status TEXT NOT NULL,
|
|
description TEXT NOT NULL DEFAULT '',
|
|
created_at TEXT NOT NULL,
|
|
updated_at TEXT NOT NULL
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS basemap_versions (
|
|
id TEXT PRIMARY KEY,
|
|
basemap_id TEXT NOT NULL,
|
|
scan_source_id TEXT,
|
|
version TEXT NOT NULL,
|
|
status TEXT NOT NULL,
|
|
is_default INTEGER NOT NULL DEFAULT 0,
|
|
manifest_path TEXT NOT NULL DEFAULT '',
|
|
tile_root_path TEXT NOT NULL,
|
|
url_template TEXT NOT NULL,
|
|
tile_format TEXT NOT NULL,
|
|
tile_scheme TEXT NOT NULL,
|
|
min_zoom INTEGER NOT NULL DEFAULT 0,
|
|
max_zoom INTEGER NOT NULL DEFAULT 0,
|
|
bbox_json TEXT NOT NULL DEFAULT '',
|
|
attribution TEXT NOT NULL DEFAULT '',
|
|
metadata_json TEXT NOT NULL DEFAULT '',
|
|
created_at TEXT NOT NULL,
|
|
updated_at TEXT NOT NULL,
|
|
UNIQUE(basemap_id, version),
|
|
FOREIGN KEY (basemap_id) REFERENCES basemaps(id) ON DELETE CASCADE,
|
|
FOREIGN KEY (scan_source_id) REFERENCES scan_sources(id) ON DELETE SET NULL
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS scan_sources (
|
|
id TEXT PRIMARY KEY,
|
|
code TEXT NOT NULL UNIQUE,
|
|
name TEXT NOT NULL,
|
|
root_path TEXT NOT NULL,
|
|
manifest_name TEXT NOT NULL,
|
|
enabled INTEGER NOT NULL DEFAULT 1,
|
|
metadata_json TEXT NOT NULL DEFAULT '',
|
|
created_at TEXT NOT NULL,
|
|
updated_at TEXT NOT NULL
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS scan_runs (
|
|
id TEXT PRIMARY KEY,
|
|
scan_source_id TEXT NOT NULL,
|
|
status TEXT NOT NULL,
|
|
scanned_count INTEGER NOT NULL DEFAULT 0,
|
|
added_count INTEGER NOT NULL DEFAULT 0,
|
|
updated_count INTEGER NOT NULL DEFAULT 0,
|
|
removed_count INTEGER NOT NULL DEFAULT 0,
|
|
summary_json TEXT NOT NULL DEFAULT '',
|
|
started_at TEXT NOT NULL,
|
|
finished_at TEXT NOT NULL,
|
|
FOREIGN KEY (scan_source_id) REFERENCES scan_sources(id) ON DELETE CASCADE
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS target_systems (
|
|
id TEXT PRIMARY KEY,
|
|
code TEXT NOT NULL UNIQUE,
|
|
name TEXT NOT NULL,
|
|
callback_url TEXT NOT NULL,
|
|
callback_method TEXT NOT NULL,
|
|
callback_headers_json TEXT NOT NULL DEFAULT '',
|
|
enabled INTEGER NOT NULL DEFAULT 1,
|
|
created_at TEXT NOT NULL,
|
|
updated_at TEXT NOT NULL
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS service_tokens (
|
|
id TEXT PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
token_hash TEXT NOT NULL UNIQUE,
|
|
token_prefix TEXT NOT NULL,
|
|
status TEXT NOT NULL,
|
|
expires_at TEXT,
|
|
last_used_at TEXT,
|
|
created_at TEXT NOT NULL
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS token_grants (
|
|
id TEXT PRIMARY KEY,
|
|
token_id TEXT NOT NULL,
|
|
basemap_id TEXT NOT NULL,
|
|
basemap_version_id TEXT,
|
|
permission TEXT NOT NULL,
|
|
created_at TEXT NOT NULL,
|
|
FOREIGN KEY (token_id) REFERENCES service_tokens(id) ON DELETE CASCADE,
|
|
FOREIGN KEY (basemap_id) REFERENCES basemaps(id) ON DELETE CASCADE,
|
|
FOREIGN KEY (basemap_version_id) REFERENCES basemap_versions(id) ON DELETE CASCADE
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS push_records (
|
|
id TEXT PRIMARY KEY,
|
|
target_system_id TEXT NOT NULL,
|
|
basemap_version_id TEXT NOT NULL,
|
|
status TEXT NOT NULL,
|
|
request_json TEXT NOT NULL DEFAULT '',
|
|
response_status INTEGER,
|
|
response_body TEXT NOT NULL DEFAULT '',
|
|
error_message TEXT NOT NULL DEFAULT '',
|
|
pushed_at TEXT NOT NULL,
|
|
finished_at TEXT,
|
|
FOREIGN KEY (target_system_id) REFERENCES target_systems(id) ON DELETE CASCADE,
|
|
FOREIGN KEY (basemap_version_id) REFERENCES basemap_versions(id) ON DELETE CASCADE
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS vector_assets (
|
|
id TEXT PRIMARY KEY,
|
|
code TEXT NOT NULL UNIQUE,
|
|
name TEXT NOT NULL,
|
|
format TEXT NOT NULL,
|
|
status TEXT NOT NULL,
|
|
description TEXT NOT NULL DEFAULT '',
|
|
file_path TEXT NOT NULL,
|
|
file_name TEXT NOT NULL,
|
|
file_size INTEGER NOT NULL DEFAULT 0,
|
|
checksum TEXT NOT NULL DEFAULT '',
|
|
download_url TEXT NOT NULL,
|
|
metadata_json TEXT NOT NULL DEFAULT '',
|
|
created_at TEXT NOT NULL,
|
|
updated_at TEXT NOT NULL
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS vector_token_grants (
|
|
id TEXT PRIMARY KEY,
|
|
token_id TEXT NOT NULL,
|
|
vector_asset_id TEXT NOT NULL,
|
|
permission TEXT NOT NULL,
|
|
created_at TEXT NOT NULL,
|
|
FOREIGN KEY (token_id) REFERENCES service_tokens(id) ON DELETE CASCADE,
|
|
FOREIGN KEY (vector_asset_id) REFERENCES vector_assets(id) ON DELETE CASCADE
|
|
);`,
|
|
`CREATE TABLE IF NOT EXISTS vector_push_records (
|
|
id TEXT PRIMARY KEY,
|
|
target_system_id TEXT NOT NULL,
|
|
vector_asset_id TEXT NOT NULL,
|
|
status TEXT NOT NULL,
|
|
request_json TEXT NOT NULL DEFAULT '',
|
|
response_status INTEGER,
|
|
response_body TEXT NOT NULL DEFAULT '',
|
|
error_message TEXT NOT NULL DEFAULT '',
|
|
pushed_at TEXT NOT NULL,
|
|
finished_at TEXT,
|
|
FOREIGN KEY (target_system_id) REFERENCES target_systems(id) ON DELETE CASCADE,
|
|
FOREIGN KEY (vector_asset_id) REFERENCES vector_assets(id) ON DELETE CASCADE
|
|
);`,
|
|
`CREATE INDEX IF NOT EXISTS idx_versions_basemap ON basemap_versions(basemap_id);`,
|
|
`CREATE INDEX IF NOT EXISTS idx_versions_source ON basemap_versions(scan_source_id);`,
|
|
`CREATE INDEX IF NOT EXISTS idx_grants_token ON token_grants(token_id);`,
|
|
`CREATE INDEX IF NOT EXISTS idx_push_target ON push_records(target_system_id);`,
|
|
`CREATE INDEX IF NOT EXISTS idx_vector_grants_token ON vector_token_grants(token_id);`,
|
|
`CREATE INDEX IF NOT EXISTS idx_vector_push_target ON vector_push_records(target_system_id);`,
|
|
}
|
|
|
|
for _, statement := range statements {
|
|
if _, err := s.db.ExecContext(ctx, statement); err != nil {
|
|
return fmt.Errorf("bootstrap sqlite: %w", err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) AutoScanEnabled() bool {
|
|
return s.cfg.AutoScanOnStart
|
|
}
|
|
|
|
func (s *Store) ScanRoot() string {
|
|
return s.cfg.ScanRoot
|
|
}
|
|
|
|
func (s *Store) VectorScanRoot() string {
|
|
return s.cfg.VectorScanRoot
|
|
}
|
|
|
|
func (s *Store) generateTokenSecret() (string, string, error) {
|
|
var raw [32]byte
|
|
if _, err := rand.Read(raw[:]); err != nil {
|
|
return "", "", err
|
|
}
|
|
|
|
encoder := base32.StdEncoding.WithPadding(base32.NoPadding)
|
|
secret := strings.ToLower(encoder.EncodeToString(raw[:]))
|
|
token := "bmp_" + secret
|
|
sum := sha256.Sum256([]byte(token))
|
|
return token, hex.EncodeToString(sum[:]), nil
|
|
}
|
|
|
|
func normalizeBasemapCode(value string) string {
|
|
return normalizeCode(value)
|
|
}
|
|
|
|
func nowUTC() time.Time {
|
|
return time.Now().UTC().Round(time.Second)
|
|
}
|
|
|
|
func toRFC3339(t time.Time) string {
|
|
return t.UTC().Format(time.RFC3339)
|
|
}
|
|
|
|
func nullableTime(t *time.Time) any {
|
|
if t == nil || t.IsZero() {
|
|
return nil
|
|
}
|
|
return toRFC3339(*t)
|
|
}
|
|
|
|
func scanNullString(value string) sql.NullString {
|
|
if strings.TrimSpace(value) == "" {
|
|
return sql.NullString{}
|
|
}
|
|
return sql.NullString{String: value, Valid: true}
|
|
}
|
|
|
|
func readMaybeJSON[T any](value string, target *T) error {
|
|
if strings.TrimSpace(value) == "" {
|
|
return nil
|
|
}
|
|
return json.Unmarshal([]byte(value), target)
|
|
}
|
|
|
|
func writeJSON(value any) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
encoded, err := json.Marshal(value)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return string(encoded)
|
|
}
|
|
|
|
func sortedKeys(values map[string]struct{}) []string {
|
|
keys := make([]string, 0, len(values))
|
|
for key := range values {
|
|
keys = append(keys, key)
|
|
}
|
|
sort.Strings(keys)
|
|
return keys
|
|
}
|
|
|
|
func trimURL(value string) string {
|
|
return strings.TrimRight(strings.TrimSpace(value), "/")
|
|
}
|
|
|
|
func limitedReadAll(body io.Reader, limit int64) string {
|
|
content, err := io.ReadAll(io.LimitReader(body, limit))
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return string(content)
|
|
}
|