basic server

* basic untested implementation of server * updating data not implemented yet
2025-02-24 08:27:17 +00:00 · 2022-01-28 00:29:06 +01:00
commit 38318ca654
11 changed files with 1458 additions and 0 deletions
@@ -0,0 +1,13 @@
+package server
+
+type ConstError string
+
+func (e ConstError) Error() string {
+	return string(e)
+}
+
+const (
+	ErrUserNotExists       = ConstError("user does not exist")
+	ErrUserAlreadyExists   = ConstError("user already exists")
+	ErrAttemptedSystemUser = ConstError("attepted to associate with system user")
+)
@@ -0,0 +1,162 @@
+package server
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"net/http"
+	"os"
+	"time"
+
+	"cernobor.cz/oko-server/models"
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func internalError(gc *gin.Context, err error) {
+	gc.String(http.StatusInternalServerError, "%v", err)
+}
+
+func (s *Server) setupRouter() *gin.Engine {
+	router := gin.New()
+	router.Use(gin.Recovery())
+
+	// logging
+	ginLogger := logrus.New()
+	hostname, err := os.Hostname()
+	if err != nil {
+		hostname = "unknown"
+	}
+	router.Use(func(gc *gin.Context) {
+		path := gc.Request.URL.Path
+		start := time.Now()
+		gc.Next()
+		stop := time.Since(start)
+		latency := int(math.Ceil(float64(stop.Nanoseconds()) / 1_000_000.0))
+		statusCode := gc.Writer.Status()
+		clientIP := gc.ClientIP()
+		clientUserAgent := gc.Request.UserAgent()
+		referer := gc.Request.Referer()
+		dataLength := gc.Writer.Size()
+		if dataLength < 0 {
+			dataLength = 0
+		}
+		entry := ginLogger.WithFields(logrus.Fields{
+			"hostname":   hostname,
+			"statusCode": statusCode,
+			"latency":    latency,
+			"clientIP":   clientIP,
+			"method":     gc.Request.Method,
+			"path":       path,
+			"referer":    referer,
+			"dataLength": dataLength,
+			"userAgent":  clientUserAgent,
+		})
+
+		if len(gc.Errors) > 0 {
+			entry.Error(gc.Errors.ByType(gin.ErrorTypePrivate).String())
+		} else {
+			msg := fmt.Sprintf(
+				"%s - %s [%s] \"%s %s\" %d %d \"%s\" \"%s\" (%dms)",
+				clientIP, hostname, time.Now().Format(time.RFC3339), gc.Request.Method, path, statusCode, dataLength, referer, clientUserAgent, latency,
+			)
+			if statusCode >= 500 {
+				entry.Error(msg)
+			} else if statusCode >= 400 {
+				entry.Warn(msg)
+			} else {
+				entry.Info(msg)
+			}
+		}
+	})
+
+	// utility/debug paths
+	router.GET(URIPing, func(gc *gin.Context) {
+		gc.Status(http.StatusNoContent)
+	})
+	router.GET(URIHardFail, func(gc *gin.Context) {
+		gc.Status(http.StatusNotImplemented)
+	})
+	router.GET(URISoftFail, func(gc *gin.Context) {
+		gc.JSON(http.StatusOK, map[string]string{"error": "artificial fail"})
+	})
+
+	// resources
+	router.GET(URITilepack, s.handleGETTilepack)
+
+	// API
+	router.POST(URIHandshake, s.handlePOSTHandshake)
+	router.GET(URIData, s.handleGETData)
+	router.POST(URIData, s.handlePOSTData)
+	router.GET(URIDataPeople, s.handleGETDataPeople)
+	router.GET(URIDataFeatures, s.handleGETDataFeatures)
+
+	// tileserver
+	router.GET(URITileserver, gin.WrapH(s.tileserverSvSet.Handler()))
+
+	return router
+}
+
+func (s *Server) handleGETTilepack(gc *gin.Context) {
+	gc.File(s.config.TilepackPath)
+}
+
+func (s *Server) handlePOSTHandshake(gc *gin.Context) {
+	var hs models.HandshakeChallenge
+	err := gc.ShouldBindJSON(&hs)
+	if err != nil {
+		gc.String(http.StatusBadRequest, "malformed handshake challenge")
+		return
+	}
+
+	id, err := s.handshake(hs)
+	if err != nil {
+		if errors.Is(err, ErrUserAlreadyExists) {
+			gc.Status(http.StatusConflict)
+		} else if errors.Is(err, ErrUserNotExists) {
+			gc.Status(http.StatusNotFound)
+		} else if errors.Is(err, ErrAttemptedSystemUser) {
+			gc.Status(http.StatusForbidden)
+		} else {
+			internalError(gc, err)
+		}
+		return
+	}
+
+	gc.JSON(http.StatusOK, models.HandshakeResponse{
+		ID:           id,
+		Name:         hs.Name,
+		TilePackPath: URITilepack,
+	})
+}
+
+func (s *Server) handleGETData(gc *gin.Context) {
+	data, err := s.getData()
+	if err != nil {
+		internalError(gc, err)
+		return
+	}
+	gc.JSON(http.StatusOK, data)
+}
+
+func (s *Server) handlePOSTData(gc *gin.Context) {
+	panic("not implemented")
+}
+
+func (s *Server) handleGETDataPeople(gc *gin.Context) {
+	people, err := s.getPeople(nil)
+	if err != nil {
+		internalError(gc, err)
+		return
+	}
+	gc.JSON(http.StatusOK, people)
+}
+
+func (s *Server) handleGETDataFeatures(gc *gin.Context) {
+	pois, err := s.getFeatures(nil)
+	if err != nil {
+		internalError(gc, err)
+		return
+	}
+	gc.JSON(http.StatusOK, pois)
+}
@@ -0,0 +1,16 @@
+DROP TABLE IF EXISTS users CASCADE;
+CREATE TABLE IF NOT EXISTS users (
+  id integer PRIMARY KEY AUTOINCREMENT,
+  name text NOT NULL UNIQUE
+);
+INSERT INTO users(id, name) VALUES(0, 'system');
+
+DROP TABLE IF EXISTS features;
+CREATE TABLE IF NOT EXISTS features (
+  id integer PRIMARY KEY AUTOINCREMENT,
+  owner_id integer REFERENCES users(id) ON DELETE CASCADE,
+  name text NOT NULL,
+  description text,
+  category text,
+  geom text NOT NULL
+);
@@ -0,0 +1,253 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+
+	_ "embed"
+
+	"cernobor.cz/oko-server/models"
+	"crawshaw.io/sqlite"
+	"crawshaw.io/sqlite/sqlitex"
+	mbsh "github.com/consbio/mbtileserver/handlers"
+	geojson "github.com/paulmach/go.geojson"
+	"github.com/sirupsen/logrus"
+)
+
+//go:embed initdb.sql
+var initDB string
+
+type Server struct {
+	config          ServerConfig
+	dbpool          *sqlitex.Pool
+	log             *logrus.Logger
+	ctx             context.Context
+	tileserverSvSet *mbsh.ServiceSet
+}
+
+type ServerConfig struct {
+	DbPath       string
+	TilepackPath string
+	ApkPath      string
+}
+
+func New(dbPath, tilepackPath, apkPath string) *Server {
+	return &Server{
+		config: ServerConfig{
+			DbPath:       dbPath,
+			TilepackPath: tilepackPath,
+			ApkPath:      apkPath,
+		},
+	}
+}
+
+func (s *Server) Run(ctx context.Context) {
+	s.log = logrus.New()
+	s.log.SetLevel(logrus.DebugLevel)
+
+	s.ctx = ctx
+	s.setupDB(true)
+	s.setupTiles()
+
+	router := s.setupRouter()
+
+	server := &http.Server{
+		Addr:    fmt.Sprintf(":%d", 8080),
+		Handler: router,
+	}
+	go func() {
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			s.log.Infof("listen: %s\n", err)
+		}
+	}()
+
+	<-s.ctx.Done()
+	s.log.Info("Shutting down server...")
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+	if err := server.Shutdown(ctx); err != nil {
+		s.log.WithError(err).Fatal("Server forced to shutdown.")
+	}
+	s.dbpool.Close()
+
+	s.log.Info("Server exitting.")
+}
+
+func (s *Server) setupDB(reinit bool) {
+	dbpool, err := sqlitex.Open(fmt.Sprintf("file:%s", s.config.DbPath), 0, 10)
+	if err != nil {
+		s.log.WithError(err).Fatal("Failed to open/create DB.")
+	}
+	s.dbpool = dbpool
+
+	if reinit {
+		conn := s.dbpool.Get(s.ctx)
+		defer s.dbpool.Put(conn)
+
+		err = sqlitex.ExecScript(conn, initDB)
+		if err != nil {
+			s.log.WithError(err).Fatal("init DB transaction failed")
+		}
+	}
+}
+
+func (s *Server) setupTiles() {
+	tsRootURL, err := url.Parse("/tileserver")
+	if err != nil {
+		s.log.WithError(err).Fatal("Failed to parse tileserver root URL.")
+	}
+	svs, err := mbsh.New(&mbsh.ServiceSetConfig{
+		EnableServiceList: true,
+		EnableTileJSON:    true,
+		EnablePreview:     false,
+		EnableArcGIS:      false,
+		RootURL:           tsRootURL,
+	})
+	if err != nil {
+		s.log.WithError(err).Fatal("Failed to create tileserver service set.")
+	}
+	err = svs.AddTileset(s.config.TilepackPath, "main")
+	if err != nil {
+		s.log.WithError(err).Fatal("Failed to register main tileset.")
+	}
+	s.tileserverSvSet = svs
+}
+
+func (s *Server) handshake(hc models.HandshakeChallenge) (models.UserID, error) {
+	conn := s.dbpool.Get(s.ctx)
+	defer s.dbpool.Put(conn)
+
+	userID, err := func() (uid int, err error) {
+		defer sqlitex.Save(conn)(&err)
+
+		var id *int
+		if hc.Exists {
+			err = sqlitex.Exec(conn, "select id from users where name = ?", func(stmt *sqlite.Stmt) error {
+				id = ptrInt(stmt.ColumnInt(0))
+				return nil
+			}, hc.Name)
+			if sqlite.ErrCode(err) != sqlite.SQLITE_OK {
+				return 0, err
+			}
+			if id == nil {
+				return 0, ErrUserNotExists
+			}
+			if *id == 0 {
+				return 0, ErrAttemptedSystemUser
+			}
+		} else {
+			err = sqlitex.Exec(conn, "insert into users(name) values(?) returning id", func(stmt *sqlite.Stmt) error {
+				id = ptrInt(stmt.ColumnInt(0))
+				return nil
+			}, hc.Name)
+			if sqlite.ErrCode(err) == sqlite.SQLITE_CONSTRAINT_UNIQUE {
+				return 0, ErrUserAlreadyExists
+			}
+			if sqlite.ErrCode(err) != sqlite.SQLITE_OK {
+				return 0, err
+			}
+		}
+		return *id, nil
+	}()
+
+	if err != nil {
+		return 0, fmt.Errorf("failed to insert/retrieve user from db: %w", err)
+	}
+	return models.UserID(userID), nil
+}
+
+func (s *Server) getData() (models.Data, error) {
+	conn := s.dbpool.Get(s.ctx)
+	defer s.dbpool.Put(conn)
+
+	return func() (data models.Data, err error) {
+		defer sqlitex.Save(conn)(&err)
+
+		people, err := s.getPeople(conn)
+		if err != nil {
+			return models.Data{}, fmt.Errorf("failed to retreive people: %w", err)
+		}
+		features, err := s.getFeatures(conn)
+		if err != nil {
+			return models.Data{}, fmt.Errorf("failed to retreive features: %w", err)
+		}
+
+		return models.Data{
+			Users:    people,
+			Features: features,
+		}, nil
+	}()
+}
+
+func (s *Server) getPeople(conn *sqlite.Conn) ([]models.User, error) {
+	if conn == nil {
+		conn = s.dbpool.Get(s.ctx)
+		defer s.dbpool.Put(conn)
+	}
+
+	users := make([]models.User, 0, 50)
+	err := sqlitex.Exec(conn, "select id, name from users", func(stmt *sqlite.Stmt) error {
+		users = append(users, models.User{
+			ID:   models.UserID(stmt.ColumnInt(0)),
+			Name: stmt.ColumnText(1),
+		})
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to get users from db: %w", err)
+	}
+	return users, nil
+}
+
+func (s *Server) getFeatures(conn *sqlite.Conn) ([]models.Feature, error) {
+	if conn == nil {
+		conn = s.dbpool.Get(s.ctx)
+		defer s.dbpool.Put(conn)
+	}
+
+	features := make([]models.Feature, 0, 100)
+	err := sqlitex.Exec(conn, "select id, owner_id, name, description, category, geom from features", func(stmt *sqlite.Stmt) error {
+		id := stmt.ColumnInt(0)
+		var ownerID *int
+		if stmt.ColumnType(1) != sqlite.SQLITE_NULL {
+			ownerID = ptrInt(stmt.ColumnInt(1))
+		}
+		name := stmt.ColumnText(2)
+		var description *string
+		if stmt.ColumnType(3) != sqlite.SQLITE_NULL {
+			description = ptrString(stmt.ColumnText(3))
+		}
+		var category *string
+		if stmt.ColumnType(4) != sqlite.SQLITE_NULL {
+			category = ptrString(stmt.ColumnText(4))
+		}
+		geomRaw := stmt.ColumnText(5)
+
+		var geom geojson.Geometry
+		err := json.Unmarshal([]byte(geomRaw), &geom)
+		if err != nil {
+			return fmt.Errorf("failed to parse geometry for point id=%d: %w", id, err)
+		}
+
+		feature := models.Feature{
+			ID:          id,
+			OwnerID:     (*models.UserID)(ownerID),
+			Name:        name,
+			Description: description,
+			Category:    category,
+			Geometry:    geom,
+		}
+
+		features = append(features, feature)
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to get users from db: %w", err)
+	}
+	return features, nil
+}
@@ -0,0 +1,14 @@
+package server
+
+const (
+	URIPing         = "/ping"
+	URIHardFail     = "/hard-fail"
+	URISoftFail     = "/soft-fail"
+	URITilepack     = "/tilepack"
+	URIHandshake    = "/handshake"
+	URIData         = "/data"
+	URIDataPeople   = "/data/people"
+	URIDataExtra    = "/data/extra"
+	URIDataFeatures = "/data/features"
+	URITileserver   = "/tileserver/*x"
+)
@@ -0,0 +1,9 @@
+package server
+
+func ptrInt(x int) *int {
+	return &x
+}
+
+func ptrString(x string) *string {
+	return &x
+}