wip (apply)

cmd/server/api/api.go

@@ -1,8 +1,12 @@
 package api
 
 import (
+	"encoding/json"
 	"fmt"
+	"log/slog"
+	"mirror-sync/cmd/server/core/storage"
 	"mirror-sync/pkg/constants"
+	"mirror-sync/pkg/project"
 	"mirror-sync/pkg/remote/obj"
 	"net/http"
 	"runtime"
@@ -14,11 +18,14 @@ import (
 type (
 	HTTPServer struct {
 		Server *http.Server
+		data   *storage.Repository
 	}
 )
 
-func NewServer(port int) *HTTPServer {
-	s := &HTTPServer{}
+func NewServer(data *storage.Repository, port int) *HTTPServer {
+	s := &HTTPServer{
+		data: data,
+	}
 	router := chi.NewRouter()
 	router.NotFound(func(writer http.ResponseWriter, request *http.Request) {
 		notFound("id not found", writer, request)
@@ -35,8 +42,10 @@ func NewServer(port int) *HTTPServer {
 		routerAPI.Route("/v1", func(r chi.Router) {
 			// Get information about the server
 			r.Get("/version", s.Information)
-			r.Route("/sync", func(r chi.Router) {
-				
+			r.Route("/projects", func(r chi.Router) {
+				r.Get("/{name}", func(w http.ResponseWriter, r *http.Request) {})
+				r.Post("/{name}", s.ProjectPostHandler)
+				r.Delete("/{name}", func(w http.ResponseWriter, r *http.Request) {})
 			})
 		})
 	})
@@ -57,3 +66,28 @@ func (s *HTTPServer) Information(w http.ResponseWriter, r *http.Request) {
 	}
 	ok(info, w, r)
 }
+
+func (s *HTTPServer) ProjectPostHandler(w http.ResponseWriter, r *http.Request) {
+	name := chi.URLParam(r, "name")
+
+	if len(name) == 0 {
+		badRequest("project name cannot be empty", w, r)
+		return
+	}
+
+	var pr project.Project
+	d := json.NewDecoder(r.Body)
+	if err := d.Decode(&pr); err != nil {
+		slog.Error("failed to parse project description", "err", err)
+		internalServerError(err, w, r)
+		return
+	}
+
+	if err := s.data.Save(pr); err != nil {
+		slog.Error("failed to save project to the database", "err", err)
+		internalServerError(err, w, r)
+		return
+	}
+
+	w.WriteHeader(201)
+}

cmd/server/api/middlewares.go

@@ -7,7 +7,7 @@ func recoverMiddleware(next http.Handler) http.Handler {
 		defer func() {
 			err := recover()
 			if err != nil {
-				internalServerError(w, r)
+				internalServerError(err, w, r)
 			}
 		}()
 		next.ServeHTTP(w, r)

cmd/server/api/responses.go

@@ -2,13 +2,14 @@ package api
 
 import (
 	"encoding/json"
+	"fmt"
 	"log/slog"
 	"mirror-sync/pkg/remote/obj"
 	"net/http"
 	"time"
 )
 
-func internalServerError(w http.ResponseWriter, r *http.Request) {
+func internalServerError(err any, w http.ResponseWriter, r *http.Request) {
 	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusInternalServerError,
@@ -16,7 +17,7 @@ func internalServerError(w http.ResponseWriter, r *http.Request) {
 			Timestamp: time.Now(),
 		},
 		Error:   "Internal Server Error",
-		Message: "The server encountered an unexpected condition that prevented it from fulfilling the request.",
+		Message: fmt.Sprintf("%v", err),
 	}
 
 	w.Header().Add("Content-Type", "application/json")

cmd/server/core/storage/migration.go

@@ -0,0 +1,25 @@
+package storage
+
+import (
+	"embed"
+	"fmt"
+
+	"github.com/pressly/goose/v3"
+)
+
+//go:embed migrations/*.sql
+var embedMigrations embed.FS
+
+func (r *Repository) Migrate() error {
+	goose.SetBaseFS(embedMigrations)
+
+	if err := goose.SetDialect("sqlite3"); err != nil {
+		panic(err)
+	}
+
+	if err := goose.Up(r.db, "migrations"); err != nil {
+		return fmt.Errorf("failed to migrate the database: %s", err)
+	}
+
+	return nil
+}

cmd/server/core/storage/migrations/001_first_schema.sql

@@ -0,0 +1,18 @@
+-- +goose Up
+CREATE TABLE Projects (
+	id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+	name TEXT NOT NULL
+);
+
+CREATE TABLE Repositories (
+	id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+	name TEXT NOT NULL,
+	schedule TEXT NOT NULL,
+	"source" TEXT NOT NULL,
+	destination TEXT NOT NULL,
+    project INTEGER NOT NULL
+);
+
+
+-- +goose Down
+DROP TABLE Projects;

cmd/server/core/storage/storage.go

@@ -0,0 +1,73 @@
+package storage
+
+import (
+	"database/sql"
+	"fmt"
+	"mirror-sync/pkg/project"
+
+	_ "github.com/glebarez/go-sqlite"
+)
+
+type (
+	Repository struct {
+		db *sql.DB
+	}
+)
+
+func OpenDB(path string) (*Repository, error) {
+	// connect
+	db, err := sql.Open("sqlite", path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open database: %s", err)
+	}
+
+	return &Repository{
+		db: db,
+	}, nil
+}
+
+func (r *Repository) Save(pr project.Project) (err error) {
+	tx, err := r.db.Begin()
+	if err != nil {
+		return fmt.Errorf("failed to create transaction: %s", err)
+	}
+	defer func() {
+		if err != nil {
+			tx.Rollback()
+			return
+		}
+		tx.Commit()
+	}()
+
+	stmt, err := tx.Prepare("INSERT INTO Projects (name) VALUES (?)")
+	if err != nil {
+		return fmt.Errorf("failed to create statement: %s", err)
+	}
+	if _, err := stmt.Exec(pr.Name); err != nil {
+		return fmt.Errorf("failed to execute sql query: %s", err)
+	}
+
+	rows, err := tx.Query("SELECT id FROM Projects WHERE name = ?", pr.Name)
+	if err != nil {
+		return fmt.Errorf("failed to query project id: %s", err)
+	}
+	defer rows.Close()
+
+	var id int
+	rows.Next()
+	if err := rows.Scan(&id); err != nil {
+		return fmt.Errorf("failed to query project id: %s", err)
+	}
+
+	for _, repo := range pr.Repositories {
+		stmt, err := tx.Prepare("INSERT INTO Repositories (name, source, destination, schedule, project) VALUES (?, ?, ?, ?, ?)")
+		if err != nil {
+			return fmt.Errorf("failed to create statement: %s", err)
+		}
+		if _, err := stmt.Exec(repo.Name, repo.Source, repo.Destination, repo.Schedule, id); err != nil {
+			return fmt.Errorf("failed to execute sql query: %s", err)
+		}
+	}
+
+	return nil
+}

cmd/server/main.go

@@ -1,19 +1,37 @@
 package main
 
 import (
+	"flag"
 	"fmt"
+	"log/slog"
 	"mirror-sync/cmd/server/api"
+	"mirror-sync/cmd/server/core/storage"
 	"mirror-sync/pkg/constants"
 	"os"
 	"runtime"
 )
 
 func main() {
+	var dbPath string
+	flag.StringVar(&dbPath, "db-path", "/var/lib/mirror-sync/data.db", "path to the sqlite database")
+	flag.Parse()
+
 	fmt.Printf("mirror-sync daemon -- v%s.%s.%s\n\n", constants.Version, runtime.GOOS, runtime.GOARCH)
 
-	s := api.NewServer(8080)
+	data, err := storage.OpenDB(dbPath)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "failed to start server:", err.Error())
+		os.Exit(1)
+	}
 
-	fmt.Println("daemon listening to :8080")
+	if err := data.Migrate(); err != nil {
+		fmt.Fprintln(os.Stderr, "failed to start server:", err.Error())
+		os.Exit(1)
+	}
+
+	s := api.NewServer(data, 8080)
+
+	slog.Info("daemon listening to :8080")
 	if err := s.Server.ListenAndServe(); err != nil {
 		fmt.Fprintln(os.Stderr, "failed to start server:", err.Error())
 		os.Exit(1)