wip

cmd/cli/commands/sync/sync.go

@@ -9,9 +9,8 @@ import (
 	"flag"
 	"fmt"
 	"log/slog"
-	"net/http"
-	"net/url"
 	"os"
+	"path/filepath"
 
 	"github.com/google/subcommands"
 )
@@ -39,6 +38,11 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 		return subcommands.ExitFailure
 	}
 
+	if len(remotes) == 0 {
+		fmt.Println("nothing to do: no remote found")
+		return subcommands.ExitSuccess
+	}
+
 	username, password, err := credentials.Read()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to read std output:", err)
@@ -46,13 +50,19 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 	}
 
 	for _, r := range remotes {
-		if !ping(r.URL, username, password) {
-			slog.Warn("remote is unavailable", "url", r.URL)
-			continue
+		m, err := game.One(r.GameID)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "error: cannot get metadata for this game: %w", err)
+			return subcommands.ExitFailure
 		}
 
 		client := client.New(r.URL, username, password)
 
+		if !client.Ping() {
+			slog.Warn("remote is unavailable", "url", r.URL)
+			continue
+		}
+
 		hlocal, err := game.Hash(r.GameID)
 		if err != nil {
 			slog.Error(err.Error())
@@ -75,12 +85,18 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 		}
 
 		if vremote == 0 {
-			fmt.Println("push")
+			if err := push(r.GameID, m, client); err != nil {
+				fmt.Fprintln(os.Stderr, "failed to push:", err)
+				return subcommands.ExitFailure
+			}
 			continue
 		}
 
 		if vlocal > vremote {
-			fmt.Println("push")
+			if err := push(r.GameID, m, client); err != nil {
+				fmt.Fprintln(os.Stderr, "failed to push:", err)
+				return subcommands.ExitFailure
+			}
 			continue
 		}
 
@@ -98,34 +114,8 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 	return subcommands.ExitSuccess
 }
 
-func ping(remote, username, password string) bool {
-	cli := http.Client{}
+func push(gameID string, m game.Metadata, cli *client.Client) error {
+	archivePath := filepath.Join(game.DatastorePath(), gameID, "data.tar.gz")
 
-	hburl, err := url.JoinPath(remote, "heartbeat")
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "cannot connect to remote:", err)
-		return false
-	}
-
-	req, err := http.NewRequest("GET", hburl, nil)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "cannot connect to remote:", err)
-		return false
-	}
-
-	req.SetBasicAuth(username, password)
-
-	res, err := cli.Do(req)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "cannot connect to remote:", err)
-		return false
-	}
-
-	if res.StatusCode != http.StatusOK {
-		fmt.Fprintln(os.Stderr, "cannot connect to remote: server return code", res.StatusCode)
-		return false
-	}
-
-	return true
+	return cli.Push(gameID, archivePath, m)
 }
-

cmd/server/api/api.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"cloudsave/cmd/server/data"
 	"cloudsave/pkg/game"
 	"crypto/md5"
 	"encoding/json"
@@ -140,20 +141,30 @@ func (s HTTPServer) download(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s HTTPServer) upload(w http.ResponseWriter, r *http.Request) {
-	id := chi.URLParam(r, "id")
-	path := filepath.Clean(filepath.Join(s.documentRoot, "data", id, "data.tar.gz"))
+	const (
+		sizeLimit int64 = 500 << 20 // 500 MB
+	)
 
-	// Limit max upload size (e.g., 500 MB)
-	r.Body = http.MaxBytesReader(w, r.Body, 500<<20)
+	id := chi.URLParam(r, "id")
+
+	// Limit max upload size
+	r.Body = http.MaxBytesReader(w, r.Body, sizeLimit)
 
 	// Parse multipart form
-	err := r.ParseMultipartForm(500 << 20) // 500 MB
+	err := r.ParseMultipartForm(sizeLimit)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to load payload:", err)
 		badRequest("bad payload", w, r)
 		return
 	}
 
+	m, err := parseFormMetadata(id, r.MultipartForm.Value)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "error: cannot find metadata in the form:", err)
+		badRequest("metadata not found", w, r)
+		return
+	}
+
 	// Retrieve file
 	file, _, err := r.FormFile("payload")
 	if err != nil {
@@ -163,18 +174,15 @@ func (s HTTPServer) upload(w http.ResponseWriter, r *http.Request) {
 	}
 	defer file.Close()
 
-	// Create destination file
-	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0640)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "error: failed to open file:", err)
+	//TODO make a transaction
+	if err := data.UpdateMetadata(id, s.documentRoot, m); err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to write metadata to disk:", err)
 		internalServerError(w, r)
 		return
 	}
-	defer f.Close()
 
-	// Copy the uploaded content to the file
-	if _, err := io.Copy(f, file); err != nil {
-		fmt.Fprintln(os.Stderr, "error: an error occured while downloading data:", err)
+	if err := data.Write(id, s.documentRoot, file); err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to write file to disk:", err)
 		internalServerError(w, r)
 		return
 	}
@@ -257,3 +265,34 @@ func (s HTTPServer) version(w http.ResponseWriter, r *http.Request) {
 
 	ok(metadata.Version, w, r)
 }
+
+func parseFormMetadata(gameID string, values map[string][]string) (game.Metadata, error) {
+	var name string
+	if v, ok := values["name"]; ok {
+		if len(v) != 0 {
+			return game.Metadata{}, fmt.Errorf("error: corrupted metadata")
+
+		}
+		name = v[0]
+	} else {
+		return game.Metadata{}, fmt.Errorf("error: cannot find metadata in the form")
+	}
+
+	var version int
+	if v, ok := values["version"]; ok {
+		if len(v) != 0 {
+			return game.Metadata{}, fmt.Errorf("error: corrupted metadata")
+		}
+		if v, err := strconv.Atoi(v[0]); err == nil {
+			version = v
+		}
+	} else {
+		return game.Metadata{}, fmt.Errorf("error: cannot find metadata in the form")
+	}
+
+	return game.Metadata{
+		ID:      gameID,
+		Version: version,
+		Name:    name,
+	}, nil
+}

cmd/server/data/data.go

@@ -0,0 +1,53 @@
+package data
+
+import (
+	"cloudsave/pkg/game"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+func Write(gameID, documentRoot string, r io.Reader) error {
+	dataFolderPath := filepath.Join(documentRoot, "data", gameID)
+	partPath := filepath.Join(dataFolderPath, "data.tar.gz.part")
+	finalFilePath := filepath.Join(dataFolderPath, "data.tar.gz")
+
+	if err := os.MkdirAll(dataFolderPath, 0740); err != nil {
+		return err
+	}
+
+	f, err := os.OpenFile(partPath, os.O_CREATE|os.O_WRONLY, 0740)
+	if err != nil {
+		return err
+	}
+
+	if _, err := io.Copy(f, r); err != nil {
+		f.Close()
+		if err := os.Remove(partPath); err != nil {
+			return fmt.Errorf("failed to write the file and cannot clean the folder: %w", err)
+		}
+		return fmt.Errorf("failed to write the file: %w", err)
+	}
+	f.Close()
+
+	if err := os.Rename(partPath, finalFilePath); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func UpdateMetadata(gameID, documentRoot string, m game.Metadata) error {
+	path := filepath.Join(documentRoot, "data", gameID, "metadata.json")
+
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0740)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	e := json.NewEncoder(f)
+	return e.Encode(m)
+}