version

Reviewed-on: #4

.vscode/launch.json

@@ -4,13 +4,30 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
-
         {
-            "name": "Launch Package",
+            "name": "web",
             "type": "go",
             "request": "launch",
             "mode": "auto",
-            "args": ["run"],
+            "args": ["-config", "${workspaceFolder}/env/config.json"],
+            "console": "integratedTerminal",
+            "program": "${workspaceFolder}/cmd/web"
+        },
+        {
+            "name": "server",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "args": ["-document-root", "${workspaceFolder}/env"],
+            "console": "integratedTerminal",
+            "program": "${workspaceFolder}/cmd/server"
+        },
+        {
+            "name": "cli",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "args": ["sync"],
             "console": "integratedTerminal",
             "program": "${workspaceFolder}/cmd/cli"
         }

README.md

@@ -21,6 +21,8 @@ e.g.:
 test:$2y$10$uULsuyROe3LVdTzFoBH7HO0zhvyKp6CX2FDNl7quXMFYqzitU0kc.
 ```
 
+To generate bcrypt password, I recommand [hash_utils](https://git.thelilfrog.com/thelilfrog/hash_utils), which is offline and secure
+
 The default path to this directory is `/var/lib/cloudsave`, this can be changed with the `-document-root` argument
 
 ### Client
@@ -45,7 +47,7 @@ Run this command to start the scan, if needed, the tool will create a new archiv
 ```bash
 cloudsave scan
 ```
-#### Send everythings on the server
+#### Send everything on the server
 
 This will pull and push data to the server.
 

build.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 
 MAKE_PACKAGE=false
-VERSION=0.0.3
+VERSION=0.0.4
 
 usage() {
  echo "Usage: $0 [OPTIONS]"
@@ -47,11 +47,11 @@ for platform in "${platforms[@]}"; do
     fi
 
     if [ "$MAKE_PACKAGE" == "true" ]; then
-        CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} go build -o build/cloudsave_server$EXT -a ./cmd/server
+        CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} GORISCV64=rva22u64 GOAMD64=v3 GOARM64=v8.2 go build -o build/cloudsave_server$EXT -a ./cmd/server
         tar -czf build/server_${platform_split[0]}_${platform_split[1]}.tar.gz build/cloudsave_server$EXT
         rm build/cloudsave_server$EXT
     else
-      CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} go build -o build/cloudsave_server_${platform_split[0]}_${platform_split[1]}$EXT -a ./cmd/server
+      CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} GORISCV64=rva22u64 GOAMD64=v3 GOARM64=v8.2 go build -o build/cloudsave_server_${platform_split[0]}_${platform_split[1]}$EXT -a ./cmd/server
     fi
 done
 

cmd/cli/commands/add/add.go

@@ -1,22 +1,21 @@
 package add
 
 import (
-	"cloudsave/pkg/remote"
+	"cloudsave/pkg/data"
-	"cloudsave/pkg/repository"
 	"context"
 	"flag"
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 
 	"github.com/google/subcommands"
 )
 
 type (
 	AddCmd struct {
-		name   string
+		Service *data.Service
-		remote string
+		name    string
+		remote  string
 	}
 )
 
@@ -51,17 +50,16 @@ func (p *AddCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) s
 		p.name = filepath.Base(path)
 	}
 
-	m, err := repository.Add(p.name, path)
+	gameID, err := p.Service.Add(p.name, path, p.remote)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "error: failed to add game reference:", err)
+		fmt.Fprintln(os.Stderr, "error: failed to add this gamesave to the datastore:", err)
 		return subcommands.ExitFailure
 	}
 
-	if len(strings.TrimSpace(p.remote)) > 0 {
+	if _, err := p.Service.Scan(gameID); err != nil {
-		remote.Set(m.ID, p.remote)
+		fmt.Fprintln(os.Stderr, "error: failed to scan:", err)
+		return subcommands.ExitFailure
 	}
 
-	fmt.Println(m.ID)
-
 	return subcommands.ExitSuccess
 }

cmd/cli/commands/apply/apply.go

@@ -1,36 +1,35 @@
 package apply
 
 import (
-	"cloudsave/pkg/repository"
+	"cloudsave/pkg/data"
-	"cloudsave/pkg/tools/archive"
 	"context"
 	"flag"
 	"fmt"
 	"os"
-	"path/filepath"
 
 	"github.com/google/subcommands"
 )
 
 type (
-	ListCmd struct {
+	ApplyCmd struct {
+		Service *data.Service
 	}
 )
 
-func (*ListCmd) Name() string     { return "apply" }
+func (*ApplyCmd) Name() string     { return "apply" }
-func (*ListCmd) Synopsis() string { return "apply a backup" }
+func (*ApplyCmd) Synopsis() string { return "apply a backup" }
-func (*ListCmd) Usage() string {
+func (*ApplyCmd) Usage() string {
-	return `Usage: cloudsave apply <GAME_ID> <BACKUP_ID>
+	return `Usage: cloudsave apply <GAME_ID> [BACKUP_ID]
 
 Apply a backup
 `
 }
 
-func (p *ListCmd) SetFlags(f *flag.FlagSet) {
+func (p *ApplyCmd) SetFlags(f *flag.FlagSet) {
 }
 
-func (p *ListCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
+func (p *ApplyCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
-	if f.NArg() != 2 {
+	if f.NArg() < 1 {
 		fmt.Fprintln(os.Stderr, "error: missing game ID and/or backup uuid")
 		return subcommands.ExitUsageError
 	}
@@ -38,31 +37,16 @@ func (p *ListCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 	gameID := f.Arg(0)
 	uuid := f.Arg(1)
 
-	g, err := repository.One(gameID)
+	if len(uuid) == 0 {
-	if err != nil {
+		if err := p.Service.ApplyCurrent(gameID); err != nil {
-		fmt.Fprintf(os.Stderr, "error: failed to open game metadata: %s\n", err)
+			fmt.Fprintf(os.Stderr, "error: failed to apply: %s", err)
-		return subcommands.ExitFailure
+			return subcommands.ExitFailure
+		}
+		return subcommands.ExitSuccess
 	}
 
-	if err := repository.RestoreArchive(gameID, uuid); err != nil {
+	if err := p.Service.ApplyBackup(gameID, uuid); err != nil {
-		fmt.Fprintf(os.Stderr, "error: failed to restore backup: %s\n", err)
+		fmt.Fprintf(os.Stderr, "error: failed to apply: %s", err)
-		return subcommands.ExitFailure
-	}
-
-	if err := os.RemoveAll(g.Path); err != nil {
-		fmt.Fprintf(os.Stderr, "error: failed to remove old data: %s\n", err)
-		return subcommands.ExitFailure
-	}
-
-	file, err := os.OpenFile(filepath.Join(repository.DatastorePath(), gameID, "data.tar.gz"), os.O_RDONLY, 0)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "error: failed to open archive: %s\n", err)
-		return subcommands.ExitFailure
-	}
-	defer file.Close()
-
-	if err := archive.Untar(file, g.Path); err != nil {
-		fmt.Fprintf(os.Stderr, "error: failed to extract archive: %s\n", err)
 		return subcommands.ExitFailure
 	}
 

cmd/cli/commands/list/list.go

@@ -2,8 +2,8 @@ package list
 
 import (
 	"cloudsave/cmd/cli/tools/prompt/credentials"
+	"cloudsave/pkg/data"
 	"cloudsave/pkg/remote/client"
-	"cloudsave/pkg/repository"
 	"context"
 	"flag"
 	"fmt"
@@ -14,8 +14,9 @@ import (
 
 type (
 	ListCmd struct {
-		remote bool
+		Service *data.Service
-		backup bool
+		remote  bool
+		backup  bool
 	}
 )
 
@@ -44,25 +45,25 @@ func (p *ListCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 
 		username, password, err := credentials.Read()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "failed to read std output: %s", err)
+			fmt.Fprintf(os.Stderr, "error: failed to read std output: %s", err)
 			return subcommands.ExitFailure
 		}
 
-		if err := remote(f.Arg(0), username, password, p.backup); err != nil {
+		if err := p.server(f.Arg(0), username, password, p.backup); err != nil {
 			fmt.Fprintln(os.Stderr, "error:", err)
 			return subcommands.ExitFailure
 		}
 		return subcommands.ExitSuccess
 	}
-	if err := local(p.backup); err != nil {
+	if err := p.local(p.backup); err != nil {
 		fmt.Fprintln(os.Stderr, "error:", err)
 		return subcommands.ExitFailure
 	}
 	return subcommands.ExitSuccess
 }
 
-func local(includeBackup bool) error {
+func (p *ListCmd) local(includeBackup bool) error {
-	games, err := repository.All()
+	games, err := p.Service.AllGames()
 	if err != nil {
 		return fmt.Errorf("failed to load datastore: %w", err)
 	}
@@ -70,9 +71,11 @@ func local(includeBackup bool) error {
 	for _, g := range games {
 		fmt.Println("ID:", g.ID)
 		fmt.Println("Name:", g.Name)
-		fmt.Println("Last Version:", g.Date, "( Version Number", g.Version, ")")
+		fmt.Println("Last Version:", g.Date)
+		fmt.Println("Version:", g.Version)
+		fmt.Println("MD5:", g.MD5)
 		if includeBackup {
-			bk, err := repository.Archives(g.ID)
+			bk, err := p.Service.AllBackups(g.ID)
 			if err != nil {
 				return fmt.Errorf("failed to list backup files: %w", err)
 			}
@@ -89,7 +92,7 @@ func local(includeBackup bool) error {
 	return nil
 }
 
-func remote(url, username, password string, includeBackup bool) error {
+func (p *ListCmd) server(url, username, password string, includeBackup bool) error {
 	cli := client.New(url, username, password)
 
 	if err := cli.Ping(); err != nil {
@@ -107,7 +110,9 @@ func remote(url, username, password string, includeBackup bool) error {
 	for _, g := range games {
 		fmt.Println("ID:", g.ID)
 		fmt.Println("Name:", g.Name)
-		fmt.Println("Last Version:", g.Date, "( Version Number", g.Version, ")")
+		fmt.Println("Last Version:", g.Date)
+		fmt.Println("Version:", g.Version)
+		fmt.Println("MD5:", g.MD5)
 		if includeBackup {
 			bk, err := cli.ListArchives(g.ID)
 			if err != nil {

cmd/cli/commands/pull/pull.go

@@ -2,20 +2,19 @@ package pull
 
 import (
 	"cloudsave/cmd/cli/tools/prompt/credentials"
+	"cloudsave/pkg/data"
 	"cloudsave/pkg/remote/client"
-	"cloudsave/pkg/repository"
-	"cloudsave/pkg/tools/archive"
 	"context"
 	"flag"
 	"fmt"
 	"os"
-	"path/filepath"
 
 	"github.com/google/subcommands"
 )
 
 type (
 	PullCmd struct {
+		Service *data.Service
 	}
 )
 
@@ -44,45 +43,33 @@ func (p *PullCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 
 	username, password, err := credentials.Read()
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to read std output: %s", err)
+		fmt.Fprintf(os.Stderr, "error: failed to read std output: %s", err)
 		return subcommands.ExitFailure
 	}
 
 	cli := client.New(url, username, password)
 
 	if err := cli.Ping(); err != nil {
-		fmt.Fprintf(os.Stderr, "failed to connect to the remote: %s", err)
+		fmt.Fprintf(os.Stderr, "error: failed to connect to the remote: %s", err)
 		return subcommands.ExitFailure
 	}
 
-	archivePath := filepath.Join(repository.DatastorePath(), gameID, "data.tar.gz")
+	if err := p.Service.PullCurrent(gameID, path, cli); err != nil {
+		fmt.Fprintf(os.Stderr, "error: failed to pull current archive: %s", err)
+		return subcommands.ExitFailure
+	}
 
-	m, err := cli.Metadata(gameID)
+	ids, err := cli.ListArchives(gameID)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to get metadata: %s", err)
+		fmt.Fprintf(os.Stderr, "error: failed to list backup archive: %s", err)
 		return subcommands.ExitFailure
 	}
 
-	err = repository.Register(m, path)
+	for _, id := range ids {
-	if err != nil {
+		if err := p.Service.PullBackup(gameID, id, cli); err != nil {
-		fmt.Fprintf(os.Stderr, "failed to register local metadata: %s", err)
+			fmt.Fprintf(os.Stderr, "error: failed to pull backup archive %s: %s", id, err)
-		return subcommands.ExitFailure
+			return subcommands.ExitFailure
-	}
+		}
-
-	if err := cli.Pull(gameID, archivePath); err != nil {
-		fmt.Fprintf(os.Stderr, "failed to pull from the remote: %s", err)
-		return subcommands.ExitFailure
-	}
-
-	fi, err := os.OpenFile(archivePath, os.O_RDONLY, 0)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to open archive: %s", err)
-		return subcommands.ExitFailure
-	}
-
-	if err := archive.Untar(fi, path); err != nil {
-		fmt.Fprintf(os.Stderr, "failed to unarchive file: %s", err)
-		return subcommands.ExitFailure
 	}
 
 	return subcommands.ExitSuccess

cmd/cli/commands/remote/remote.go

@@ -1,9 +1,9 @@
 package remote
 
 import (
+	"cloudsave/pkg/data"
 	"cloudsave/pkg/remote"
 	"cloudsave/pkg/remote/client"
-	"cloudsave/pkg/repository"
 	"context"
 	"flag"
 	"fmt"
@@ -14,8 +14,9 @@ import (
 
 type (
 	RemoteCmd struct {
-		set  bool
+		Service *data.Service
-		list bool
+		set     bool
+		list    bool
 	}
 )
 
@@ -43,7 +44,7 @@ func (p *RemoteCmd) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface
 	switch {
 	case p.list:
 		{
-			if err := list(); err != nil {
+			if err := p.print(); err != nil {
 				fmt.Fprintln(os.Stderr, "error:", err)
 				return subcommands.ExitFailure
 			}
@@ -68,8 +69,8 @@ func (p *RemoteCmd) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface
 	return subcommands.ExitSuccess
 }
 
-func list() error {
+func (p *RemoteCmd) print() error {
-	games, err := repository.All()
+	games, err := p.Service.AllGames()
 	if err != nil {
 		return fmt.Errorf("failed to load datastore: %w", err)
 	}
@@ -77,7 +78,7 @@ func list() error {
 	for _, g := range games {
 		r, err := remote.One(g.ID)
 		if err != nil {
-			return fmt.Errorf("failed to load datastore: %w", err)
+			continue
 		}
 
 		cli := client.New(r.URL, "", "")

cmd/cli/commands/remove/remove.go

@@ -1,7 +1,7 @@
 package remove
 
 import (
-	"cloudsave/pkg/repository"
+	"cloudsave/pkg/data"
 	"context"
 	"flag"
 	"fmt"
@@ -11,7 +11,9 @@ import (
 )
 
 type (
-	RemoveCmd struct{}
+	RemoveCmd struct {
+		Service *data.Service
+	}
 )
 
 func (*RemoveCmd) Name() string     { return "remove" }
@@ -33,7 +35,7 @@ func (p *RemoveCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}
 		return subcommands.ExitUsageError
 	}
 
-	err := repository.Remove(f.Arg(0))
+	err := p.Service.RemoveGame(f.Arg(0))
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to unregister the game:", err)
 		return subcommands.ExitFailure

cmd/cli/commands/run/run.go

@@ -1,22 +1,18 @@
 package run
 
 import (
-	"cloudsave/pkg/repository"
+	"cloudsave/pkg/data"
-	"cloudsave/pkg/tools/archive"
 	"context"
 	"flag"
 	"fmt"
-	"io"
 	"os"
-	"path/filepath"
-	"time"
 
 	"github.com/google/subcommands"
-	"github.com/schollz/progressbar/v3"
 )
 
 type (
 	RunCmd struct {
+		Service *data.Service
 	}
 )
 
@@ -34,106 +30,25 @@ and a new archive is created with a new version number.
 func (p *RunCmd) SetFlags(f *flag.FlagSet) {}
 
 func (p *RunCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
-	datastore, err := repository.All()
+	datastore, err := p.Service.AllGames()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to load datastore:", err)
 		return subcommands.ExitFailure
 	}
 
 	for _, metadata := range datastore {
-		metadataPath := filepath.Join(repository.DatastorePath(), metadata.ID)
+		changed, err := p.Service.Scan(metadata.ID)
-		//todo transaction
-		err := archiveIfChanged(metadata.ID, metadata.Path, filepath.Join(metadataPath, "data.tar.gz"), filepath.Join(metadataPath, ".last_run"))
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "error: cannot process the data of %s: %s\n", metadata.ID, err)
+			fmt.Println("❌", metadata.Name, ":", err.Error())
-			return subcommands.ExitFailure
+			continue
 		}
-		if err := repository.SetVersion(metadata.ID, metadata.Version+1); err != nil {
+		if changed {
-			fmt.Fprintf(os.Stderr, "error: cannot process the data of %s: %s\n", metadata.ID, err)
+			fmt.Println("✅", metadata.Name, ": backed up")
-			return subcommands.ExitFailure
+		} else {
+			fmt.Println("🆗", metadata.Name, ": up to date")
 		}
-		if err := repository.SetDate(metadata.ID, time.Now()); err != nil {
-			fmt.Fprintf(os.Stderr, "error: cannot process the data of %s: %s\n", metadata.ID, err)
-			return subcommands.ExitFailure
-		}
-		fmt.Println("✅", metadata.Name)
 	}
 
 	fmt.Println("done.")
 	return subcommands.ExitSuccess
 }
-
-// archiveIfChanged will archive srcDir into destTarGz only if any file
-// in srcDir has a modification time > the last run time stored in stateFile.
-// After archiving, it updates stateFile to the current time.
-func archiveIfChanged(gameID, srcDir, destTarGz, stateFile string) error {
-	pg := progressbar.New(-1)
-	destroyPg := func() {
-		pg.Finish()
-		pg.Clear()
-		pg.Close()
-
-	}
-	defer destroyPg()
-
-	pg.Describe("Scanning " + gameID + "...")
-
-	// load last run time
-	var lastRun time.Time
-	data, err := os.ReadFile(stateFile)
-	if err != nil && !os.IsNotExist(err) {
-		return fmt.Errorf("failed to reading state file: %w", err)
-	}
-	if err == nil {
-		lastRun, err = time.Parse(time.RFC3339, string(data))
-		if err != nil {
-			return fmt.Errorf("parsing state file timestamp: %w", err)
-		}
-	}
-
-	// check for changes
-	changed := false
-	err = filepath.Walk(srcDir, func(path string, info os.FileInfo, walkErr error) error {
-		if walkErr != nil {
-			return walkErr
-		}
-		if info.ModTime().After(lastRun) {
-			changed = true
-			return io.EOF // early exit
-		}
-		return nil
-	})
-	if err != nil && err != io.EOF {
-		return fmt.Errorf("failed to scanning source directory: %w", err)
-	}
-
-	if !changed {
-		pg.Finish()
-		return nil
-	}
-
-	// make a backup
-	pg.Describe("Backup current data...")
-	if err := repository.MakeArchive(gameID); err != nil {
-		return fmt.Errorf("failed to archive data: %w", err)
-	}
-
-	// create archive
-	pg.Describe("Archiving new data...")
-	f, err := os.Create(destTarGz)
-	if err != nil {
-		return fmt.Errorf("failed to creating archive file: %w", err)
-	}
-	defer f.Close()
-
-	if err := archive.Tar(f, srcDir); err != nil {
-		return fmt.Errorf("failed archiving files: %w", err)
-	}
-
-	now := time.Now().UTC().Format(time.RFC3339)
-	if err := os.WriteFile(stateFile, []byte(now), 0644); err != nil {
-		return fmt.Errorf("updating state file: %w", err)
-	}
-
-	return nil
-}

cmd/cli/commands/show/show.go

@@ -0,0 +1,51 @@
+package show
+
+import (
+	"cloudsave/pkg/data"
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/google/subcommands"
+)
+
+type (
+	ShowCmd struct {
+		Service *data.Service
+	}
+)
+
+func (*ShowCmd) Name() string     { return "show" }
+func (*ShowCmd) Synopsis() string { return "show metadata about game" }
+func (*ShowCmd) Usage() string {
+	return `Usage: cloudsave show <GAME_ID>
+
+Show metdata about a game
+`
+}
+
+func (p *ShowCmd) SetFlags(f *flag.FlagSet) {
+}
+
+func (p *ShowCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
+	if f.NArg() != 1 {
+		fmt.Fprintln(os.Stderr, "error: missing game ID")
+		return subcommands.ExitUsageError
+	}
+
+	gameID := f.Arg(0)
+	g, err := p.Service.One(gameID)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: failed to apply: %s", err)
+		return subcommands.ExitFailure
+	}
+
+	fmt.Println(g.Name)
+	fmt.Println("------")
+	fmt.Println("Version: ", g.Version)
+	fmt.Println("Path: ", g.Path)
+	fmt.Println("MD5: ", g.MD5)
+
+	return subcommands.ExitSuccess
+}

cmd/cli/commands/sync/sync.go

@@ -3,6 +3,7 @@ package sync
 import (
 	"cloudsave/cmd/cli/tools/prompt"
 	"cloudsave/cmd/cli/tools/prompt/credentials"
+	"cloudsave/pkg/data"
 	"cloudsave/pkg/remote"
 	"cloudsave/pkg/remote/client"
 	"cloudsave/pkg/repository"
@@ -12,7 +13,6 @@ import (
 	"fmt"
 	"log/slog"
 	"os"
-	"path/filepath"
 	"time"
 
 	"github.com/google/subcommands"
@@ -21,6 +21,7 @@ import (
 
 type (
 	SyncCmd struct {
+		Service *data.Service
 	}
 )
 
@@ -37,7 +38,7 @@ func (p *SyncCmd) SetFlags(f *flag.FlagSet) {
 }
 
 func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
-	games, err := repository.All()
+	games, err := p.Service.AllGames()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to load datastore:", err)
 		return subcommands.ExitFailure
@@ -48,7 +49,7 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 		r, err := remote.One(g.ID)
 		if err != nil {
 			if errors.Is(err, remote.ErrNoRemote) {
-				fmt.Println(g.Name + ": no remote configured")
+				fmt.Println("⬛", g.Name+": no remote configured")
 				continue
 			}
 			fmt.Fprintln(os.Stderr, "error: failed to load datastore:", err)
@@ -65,7 +66,6 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 			pg.Finish()
 			pg.Clear()
 			pg.Close()
-
 		}
 
 		pg.Describe(fmt.Sprintf("[%s] Checking status...", g.Name))
@@ -77,41 +77,22 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 
 		if !exists {
 			pg.Describe(fmt.Sprintf("[%s] Pushing data...", g.Name))
-			if err := push(g, cli); err != nil {
+			if err := p.push(g, cli); err != nil {
 				destroyPg()
 				fmt.Fprintln(os.Stderr, "failed to push:", err)
 				return subcommands.ExitFailure
 			}
 			pg.Describe(fmt.Sprintf("[%s] Pushing backup...", g.Name))
-			if err := pushBackup(g, cli); err != nil {
+			if err := p.pushBackup(g, cli); err != nil {
 				destroyPg()
 				slog.Warn("failed to push backup files", "err", err)
 			}
-			fmt.Println(g.Name + ": pushed")
+			destroyPg()
+			fmt.Println("⬆️", g.Name+": pushed")
 			continue
 		}
 
 		pg.Describe(fmt.Sprintf("[%s] Fetching metadata...", g.Name))
-		hlocal, err := repository.Hash(r.GameID)
-		if err != nil {
-			destroyPg()
-			slog.Error(err.Error())
-			continue
-		}
-
-		hremote, err := cli.Hash(r.GameID)
-		if err != nil {
-			destroyPg()
-			fmt.Fprintln(os.Stderr, "error: failed to get the file hash from the remote:", err)
-			continue
-		}
-
-		vlocal, err := repository.Version(r.GameID)
-		if err != nil {
-			destroyPg()
-			slog.Error(err.Error())
-			continue
-		}
 
 		remoteMetadata, err := cli.Metadata(r.GameID)
 		if err != nil {
@@ -121,65 +102,64 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 		}
 
 		pg.Describe(fmt.Sprintf("[%s] Pulling backup...", g.Name))
-		if err := pullBackup(g, cli); err != nil {
+		if err := p.pullBackup(g, cli); err != nil {
 			slog.Warn("failed to pull backup files", "err", err)
 		}
 
 		pg.Describe(fmt.Sprintf("[%s] Pushing backup...", g.Name))
-		if err := pushBackup(g, cli); err != nil {
+		if err := p.pushBackup(g, cli); err != nil {
 			slog.Warn("failed to push backup files", "err", err)
 		}
 
-		if hlocal == hremote {
+		if g.MD5 == remoteMetadata.MD5 {
 			destroyPg()
-			if vlocal != remoteMetadata.Version {
+			if g.Version != remoteMetadata.Version {
 				slog.Debug("version is not the same, but the hash is equal. Updating local database")
-				if err := repository.SetVersion(r.GameID, remoteMetadata.Version); err != nil {
+				if err := p.Service.SetVersion(r.GameID, remoteMetadata.Version); err != nil {
 					fmt.Fprintln(os.Stderr, "error: failed to synchronize version number:", err)
 					continue
 				}
 			}
-			fmt.Println(g.Name + ": already up-to-date")
+			fmt.Println("🆗", g.Name+": already up-to-date")
 			continue
 		}
 
-		if vlocal > remoteMetadata.Version {
+		if g.Version > remoteMetadata.Version {
 			pg.Describe(fmt.Sprintf("[%s] Pushing data...", g.Name))
-			if err := push(g, cli); err != nil {
+			if err := p.push(g, cli); err != nil {
 				destroyPg()
 				fmt.Fprintln(os.Stderr, "failed to push:", err)
 				return subcommands.ExitFailure
 			}
 			destroyPg()
-			fmt.Println(g.Name + ": pushed")
+			fmt.Println("⬆️", g.Name+": pushed")
 			continue
 		}
 
-		if vlocal < remoteMetadata.Version {
+		if g.Version < remoteMetadata.Version {
 			destroyPg()
-			if err := pull(r.GameID, cli); err != nil {
+			if err := p.pull(g, cli); err != nil {
 				destroyPg()
 				fmt.Fprintln(os.Stderr, "failed to push:", err)
 				return subcommands.ExitFailure
 			}
-			if err := repository.SetVersion(r.GameID, remoteMetadata.Version); err != nil {
+
+			g.Version = remoteMetadata.Version
+			g.Date = remoteMetadata.Date
+
+			if err := p.Service.UpdateMetadata(g.ID, g); err != nil {
 				destroyPg()
-				fmt.Fprintln(os.Stderr, "error: failed to synchronize version number:", err)
+				fmt.Fprintln(os.Stderr, "failed to push:", err)
-				continue
+				return subcommands.ExitFailure
 			}
-			if err := repository.SetDate(r.GameID, remoteMetadata.Date); err != nil {
+			fmt.Println("⬇️", g.Name+": pulled")
-				destroyPg()
-				fmt.Fprintln(os.Stderr, "error: failed to synchronize date:", err)
-				continue
-			}
-			fmt.Println(g.Name + ": pulled")
 			continue
 		}
 
 		destroyPg()
 
-		if vlocal == remoteMetadata.Version {
+		if g.Version == remoteMetadata.Version {
-			if err := conflict(r.GameID, g, remoteMetadata, cli); err != nil {
+			if err := p.conflict(r.GameID, g, remoteMetadata, cli); err != nil {
 				fmt.Fprintln(os.Stderr, "error: failed to resolve conflict:", err)
 				continue
 			}
@@ -191,15 +171,15 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 	return subcommands.ExitSuccess
 }
 
-func conflict(gameID string, m, remoteMetadata repository.Metadata, cli *client.Client) error {
+func (p *SyncCmd) conflict(gameID string, m, remoteMetadata repository.Metadata, cli *client.Client) error {
-	g, err := repository.One(gameID)
+	g, err := p.Service.One(gameID)
 	if err != nil {
 		slog.Warn("a conflict was found but the game is not found in the database")
 		slog.Debug("debug info", "gameID", gameID)
 		return nil
 	}
 	fmt.Println()
-	fmt.Println("--- /!\\ CONFLICT ---")
+	fmt.Println("--- ⚠️ CONFLICT ---")
 	fmt.Println(g.Name, "(", g.Path, ")")
 	fmt.Println("----")
 	fmt.Println("Your version:", g.Date.Format(time.RFC1123))
@@ -211,35 +191,33 @@ func conflict(gameID string, m, remoteMetadata repository.Metadata, cli *client.
 	switch res {
 	case prompt.My:
 		{
-			if err := push(m, cli); err != nil {
+			if err := p.push(m, cli); err != nil {
 				return fmt.Errorf("failed to push: %w", err)
 			}
 		}
 
 	case prompt.Their:
 		{
-			if err := pull(gameID, cli); err != nil {
+			if err := p.pull(g, cli); err != nil {
 				return fmt.Errorf("failed to push: %w", err)
 			}
-			if err := repository.SetVersion(gameID, remoteMetadata.Version); err != nil {
+			g.Version = remoteMetadata.Version
-				return fmt.Errorf("failed to synchronize version number: %w", err)
+			g.Date = remoteMetadata.Date
-			}
+
-			if err := repository.SetDate(gameID, remoteMetadata.Date); err != nil {
+			if err := p.Service.UpdateMetadata(g.ID, g); err != nil {
-				return fmt.Errorf("failed to synchronize date: %w", err)
+				return fmt.Errorf("failed to push: %w", err)
 			}
 		}
 	}
 	return nil
 }
 
-func push(m repository.Metadata, cli *client.Client) error {
+func (p *SyncCmd) push(m repository.Metadata, cli *client.Client) error {
-	archivePath := filepath.Join(repository.DatastorePath(), m.ID, "data.tar.gz")
+	return p.Service.PushArchive(m.ID, "", cli)
-
-	return cli.PushSave(archivePath, m)
 }
 
-func pushBackup(m repository.Metadata, cli *client.Client) error {
+func (p *SyncCmd) pushBackup(m repository.Metadata, cli *client.Client) error {
-	bs, err := repository.Archives(m.ID)
+	bs, err := p.Service.AllBackups(m.ID)
 	if err != nil {
 		return err
 	}
@@ -262,7 +240,7 @@ func pushBackup(m repository.Metadata, cli *client.Client) error {
 	return nil
 }
 
-func pullBackup(m repository.Metadata, cli *client.Client) error {
+func (p *SyncCmd) pullBackup(m repository.Metadata, cli *client.Client) error {
 	bs, err := cli.ListArchives(m.ID)
 	if err != nil {
 		return err
@@ -274,20 +252,13 @@ func pullBackup(m repository.Metadata, cli *client.Client) error {
 			return err
 		}
 
-		linfo, err := repository.Archive(m.ID, uuid)
+		linfo, err := p.Service.Backup(m.ID, uuid)
 		if err != nil {
-			if !errors.Is(err, os.ErrNotExist) {
-				return err
-			}
-		}
-
-		path := filepath.Join(repository.DatastorePath(), m.ID, "hist", uuid)
-		if err := os.MkdirAll(path, 0740); err != nil {
 			return err
 		}
 
-		if rinfo.MD5 != linfo.MD5 {
+		if linfo.MD5 != rinfo.MD5 {
-			if err := cli.PullBackup(m.ID, uuid, filepath.Join(path, "data.tar.gz")); err != nil {
+			if err := p.Service.PullBackup(m.ID, uuid, cli); err != nil {
 				return err
 			}
 		}
@@ -295,10 +266,11 @@ func pullBackup(m repository.Metadata, cli *client.Client) error {
 	return nil
 }
 
-func pull(gameID string, cli *client.Client) error {
+func (p *SyncCmd) pull(g repository.Metadata, cli *client.Client) error {
-	archivePath := filepath.Join(repository.DatastorePath(), gameID, "data.tar.gz")
+	if err := p.Service.PullArchive(g.ID, "", cli); err != nil {
-
+		return err
-	return cli.Pull(gameID, archivePath)
+	}
+	return p.Service.ApplyCurrent(g.ID)
 }
 
 func connect(remoteCred map[string]map[string]string, r remote.Remote) (*client.Client, error) {
@@ -309,6 +281,9 @@ func connect(remoteCred map[string]map[string]string, r remote.Remote) (*client.
 		return cli, nil
 	}
 
+	fmt.Println()
+	fmt.Println("Connexion to", r.URL)
+	fmt.Println("============")
 	username, password, err := credentials.Read()
 	if err != nil {
 		return nil, fmt.Errorf("failed to read std output: %w", err)

cmd/cli/main.go

@@ -2,34 +2,60 @@ package main
 
 import (
 	"cloudsave/cmd/cli/commands/add"
+	"cloudsave/cmd/cli/commands/apply"
 	"cloudsave/cmd/cli/commands/list"
 	"cloudsave/cmd/cli/commands/pull"
 	"cloudsave/cmd/cli/commands/remote"
 	"cloudsave/cmd/cli/commands/remove"
 	"cloudsave/cmd/cli/commands/run"
+	"cloudsave/cmd/cli/commands/show"
 	"cloudsave/cmd/cli/commands/sync"
 	"cloudsave/cmd/cli/commands/version"
+	"cloudsave/pkg/data"
+	"cloudsave/pkg/repository"
 	"context"
 	"flag"
 	"os"
+	"path/filepath"
 
 	"github.com/google/subcommands"
 )
 
 func main() {
+	roaming, err := os.UserConfigDir()
+	if err != nil {
+		panic("failed to get user config path: " + err.Error())
+	}
+
+	datastorepath := filepath.Join(roaming, "cloudsave", "data")
+	err = os.MkdirAll(datastorepath, 0740)
+	if err != nil {
+		panic("cannot make the datastore:" + err.Error())
+	}
+
+	repo, err := repository.NewLazyRepository(datastorepath)
+	if err != nil {
+		panic("cannot make the datastore:" + err.Error())
+	}
+
+	s := data.NewService(repo)
+
 	subcommands.Register(subcommands.HelpCommand(), "help")
 	subcommands.Register(subcommands.FlagsCommand(), "help")
 	subcommands.Register(subcommands.CommandsCommand(), "help")
 	subcommands.Register(&version.VersionCmd{}, "help")
 
-	subcommands.Register(&add.AddCmd{}, "management")
+	subcommands.Register(&add.AddCmd{Service: s}, "management")
-	subcommands.Register(&run.RunCmd{}, "management")
+	subcommands.Register(&run.RunCmd{Service: s}, "management")
-	subcommands.Register(&list.ListCmd{}, "management")
+	subcommands.Register(&list.ListCmd{Service: s}, "management")
-	subcommands.Register(&remove.RemoveCmd{}, "management")
+	subcommands.Register(&remove.RemoveCmd{Service: s}, "management")
+	subcommands.Register(&show.ShowCmd{Service: s}, "management")
 
-	subcommands.Register(&remote.RemoteCmd{}, "remote")
+	subcommands.Register(&apply.ApplyCmd{Service: s}, "restore")
-	subcommands.Register(&sync.SyncCmd{}, "remote")
+
-	subcommands.Register(&pull.PullCmd{}, "remote")
+	subcommands.Register(&remote.RemoteCmd{Service: s}, "remote")
+	subcommands.Register(&sync.SyncCmd{Service: s}, "remote")
+	subcommands.Register(&pull.PullCmd{Service: s}, "remote")
 
 	flag.Parse()
 	ctx := context.Background()

cmd/server/api/api.go

@@ -1,14 +1,10 @@
 package api
 
 import (
-	"cloudsave/cmd/server/data"
+	"cloudsave/pkg/data"
 	"cloudsave/pkg/repository"
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
 	"log/slog"
 	"net/http"
 	"os"
@@ -23,21 +19,23 @@ import (
 type (
 	HTTPServer struct {
 		Server       *http.Server
+		Service      *data.Service
 		documentRoot string
 	}
 )
 
 // NewServer start the http server
-func NewServer(documentRoot string, creds map[string]string, port int) *HTTPServer {
+func NewServer(documentRoot string, srv *data.Service, creds map[string]string, port int) *HTTPServer {
 	if !filepath.IsAbs(documentRoot) {
 		panic("the document root is not an absolute path")
 	}
 	s := &HTTPServer{
+		Service:      srv,
 		documentRoot: documentRoot,
 	}
 	router := chi.NewRouter()
 	router.NotFound(func(writer http.ResponseWriter, request *http.Request) {
-		notFound("This route does not exist", writer, request)
+		notFound("id not found", writer, request)
 	})
 	router.MethodNotAllowed(func(writer http.ResponseWriter, request *http.Request) {
 		methodNotAllowed(writer, request)
@@ -62,7 +60,6 @@ func NewServer(documentRoot string, creds map[string]string, port int) *HTTPServ
 					gamesRouter.Group(func(saveRouter chi.Router) {
 						saveRouter.Post("/{id}/data", s.upload)
 						saveRouter.Get("/{id}/data", s.download)
-						saveRouter.Get("/{id}/hash", s.hash)
 						saveRouter.Get("/{id}/metadata", s.metadata)
 
 						saveRouter.Get("/{id}/hist", s.allHist)
@@ -82,43 +79,13 @@ func NewServer(documentRoot string, creds map[string]string, port int) *HTTPServ
 }
 
 func (s HTTPServer) all(w http.ResponseWriter, r *http.Request) {
-	path := filepath.Join(s.documentRoot, "data")
+	datastore, err := s.Service.AllGames()
-	datastore := make([]repository.Metadata, 0)
-
-	if _, err := os.Stat(path); err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			ok(datastore, w, r)
-			return
-		}
-		fmt.Fprintln(os.Stderr, "failed to open datastore (", s.documentRoot, "):", err)
-		internalServerError(w, r)
-		return
-	}
-
-	ds, err := os.ReadDir(path)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "failed to open datastore (", s.documentRoot, "):", err)
+		slog.Error(err.Error())
 		internalServerError(w, r)
 		return
 	}
 
-	for _, d := range ds {
-		content, err := os.ReadFile(filepath.Join(path, d.Name(), "metadata.json"))
-		if err != nil {
-			slog.Error("error: failed to load metadata.json", "err", err)
-			continue
-		}
-
-		var m repository.Metadata
-		err = json.Unmarshal(content, &m)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "corrupted datastore: failed to parse %s/metadata.json: %s", d.Name(), err)
-			internalServerError(w, r)
-		}
-
-		datastore = append(datastore, m)
-	}
-
 	ok(datastore, w, r)
 }
 
@@ -126,32 +93,19 @@ func (s HTTPServer) download(w http.ResponseWriter, r *http.Request) {
 	id := chi.URLParam(r, "id")
 	path := filepath.Clean(filepath.Join(s.documentRoot, "data", id))
 
-	sdir, err := os.Stat(path)
+	fi, err := os.Stat(filepath.Join(path, "data.tar.gz"))
 	if err != nil {
 		notFound("id not found", w, r)
 		return
 	}
 
-	if !sdir.IsDir() {
+	f, err := s.Service.Repository().ReadBlob(repository.NewGameIdentifier(id))
-		notFound("id not found", w, r)
-		return
-	}
-
-	path = filepath.Join(path, "data.tar.gz")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
 	if err != nil {
-		notFound("id not found", w, r)
+		slog.Error(err.Error())
-		return
-	}
-	defer f.Close()
-
-	// Get file info to set headers
-	fi, err := f.Stat()
-	if err != nil || fi.IsDir() {
 		internalServerError(w, r)
 		return
 	}
+	defer f.Close()
 
 	// Set headers
 	w.Header().Set("Content-Disposition", "attachment; filename=\"data.tar.gz\"")
@@ -198,14 +152,20 @@ func (s HTTPServer) upload(w http.ResponseWriter, r *http.Request) {
 	defer file.Close()
 
 	//TODO make a transaction
-	if err := data.UpdateMetadata(id, s.documentRoot, m); err != nil {
+	if err := s.Service.UpdateMetadata(id, m); err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to write metadata to disk:", err)
 		internalServerError(w, r)
 		return
 	}
 
-	if err := data.Write(id, s.documentRoot, file); err != nil {
+	if err := s.Service.Copy(id, file); err != nil {
-		fmt.Fprintln(os.Stderr, "error: failed to write file to disk:", err)
+		fmt.Fprintln(os.Stderr, "error: failed to write data to disk:", err)
+		internalServerError(w, r)
+		return
+	}
+
+	if err := s.Service.ReloadCache(id); err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to reload data from the disk:", err)
 		internalServerError(w, r)
 		return
 	}
@@ -216,20 +176,9 @@ func (s HTTPServer) upload(w http.ResponseWriter, r *http.Request) {
 
 func (s HTTPServer) allHist(w http.ResponseWriter, r *http.Request) {
 	gameID := chi.URLParam(r, "id")
-	path := filepath.Join(s.documentRoot, "data", gameID, "hist")
 	datastore := make([]string, 0)
 
-	if _, err := os.Stat(path); err != nil {
+	ds, err := s.Service.AllBackups(gameID)
-		if errors.Is(err, os.ErrNotExist) {
-			ok(datastore, w, r)
-			return
-		}
-		fmt.Fprintln(os.Stderr, "failed to open datastore (", s.documentRoot, "):", err)
-		internalServerError(w, r)
-		return
-	}
-
-	ds, err := os.ReadDir(path)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "failed to open datastore (", s.documentRoot, "):", err)
 		internalServerError(w, r)
@@ -237,7 +186,7 @@ func (s HTTPServer) allHist(w http.ResponseWriter, r *http.Request) {
 	}
 
 	for _, d := range ds {
-		datastore = append(datastore, d.Name())
+		datastore = append(datastore, d.UUID)
 	}
 
 	ok(datastore, w, r)
@@ -271,8 +220,14 @@ func (s HTTPServer) histUpload(w http.ResponseWriter, r *http.Request) {
 	}
 	defer file.Close()
 
-	if err := data.WriteHist(gameID, s.documentRoot, uuid, file); err != nil {
+	if err := s.Service.CopyBackup(gameID, uuid, file); err != nil {
-		fmt.Fprintln(os.Stderr, "error: failed to write file to disk:", err)
+		fmt.Fprintln(os.Stderr, "error: failed to write data to the disk:", err)
+		internalServerError(w, r)
+		return
+	}
+
+	if err := s.Service.ReloadCache(gameID); err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to reload data from the disk:", err)
 		internalServerError(w, r)
 		return
 	}
@@ -286,32 +241,19 @@ func (s HTTPServer) histDownload(w http.ResponseWriter, r *http.Request) {
 	uuid := chi.URLParam(r, "uuid")
 	path := filepath.Clean(filepath.Join(s.documentRoot, "data", id, "hist", uuid))
 
-	sdir, err := os.Stat(path)
+	fi, err := os.Stat(filepath.Join(path, "data.tar.gz"))
 	if err != nil {
 		notFound("id not found", w, r)
 		return
 	}
 
-	if !sdir.IsDir() {
+	f, err := s.Service.Repository().ReadBlob(repository.NewBackupIdentifier(id, uuid))
-		notFound("id not found", w, r)
-		return
-	}
-
-	path = filepath.Join(path, "data.tar.gz")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
 	if err != nil {
-		notFound("id not found", w, r)
+		slog.Error(err.Error())
-		return
-	}
-	defer f.Close()
-
-	// Get file info to set headers
-	fi, err := f.Stat()
-	if err != nil || fi.IsDir() {
 		internalServerError(w, r)
 		return
 	}
+	defer f.Close()
 
 	// Set headers
 	w.Header().Set("Content-Disposition", "attachment; filename=\"data.tar.gz\"")
@@ -327,10 +269,10 @@ func (s HTTPServer) histExists(w http.ResponseWriter, r *http.Request) {
 	gameID := chi.URLParam(r, "id")
 	uuid := chi.URLParam(r, "uuid")
 
-	finfo, err := data.ArchiveInfo(gameID, s.documentRoot, uuid)
+	finfo, err := s.Service.Backup(gameID, uuid)
 	if err != nil {
-		if errors.Is(err, data.ErrBackupNotExists) {
+		if errors.Is(err, repository.ErrNotFound) {
-			notFound("backup not found", w, r)
+			notFound("not found", w, r)
 			return
 		}
 		fmt.Fprintln(os.Stderr, "error: failed to read data:", err)
@@ -341,78 +283,18 @@ func (s HTTPServer) histExists(w http.ResponseWriter, r *http.Request) {
 	ok(finfo, w, r)
 }
 
-func (s HTTPServer) hash(w http.ResponseWriter, r *http.Request) {
-	id := chi.URLParam(r, "id")
-	path := filepath.Clean(filepath.Join(s.documentRoot, "data", id))
-
-	sdir, err := os.Stat(path)
-	if err != nil {
-		notFound("id not found", w, r)
-		return
-	}
-
-	if !sdir.IsDir() {
-		notFound("id not found", w, r)
-		return
-	}
-
-	path = filepath.Join(path, "data.tar.gz")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		notFound("id not found", w, r)
-		return
-	}
-	defer f.Close()
-
-	// Create MD5 hasher
-	hasher := md5.New()
-
-	// Copy file content into hasher
-	if _, err := io.Copy(hasher, f); err != nil {
-		fmt.Fprintln(os.Stderr, "error: an error occured while reading data:", err)
-		internalServerError(w, r)
-		return
-	}
-
-	// Get checksum result
-	sum := hasher.Sum(nil)
-	ok(hex.EncodeToString(sum), w, r)
-}
-
 func (s HTTPServer) metadata(w http.ResponseWriter, r *http.Request) {
 	id := chi.URLParam(r, "id")
-	path := filepath.Clean(filepath.Join(s.documentRoot, "data", id))
+	metadata, err := s.Service.One(id)
-
-	sdir, err := os.Stat(path)
 	if err != nil {
-		notFound("id not found", w, r)
+		if errors.Is(err, repository.ErrNotFound) {
-		return
+			notFound("id not found", w, r)
-	}
+			return
-
+		}
-	if !sdir.IsDir() {
+		slog.Error(err.Error())
-		notFound("id not found", w, r)
-		return
-	}
-
-	path = filepath.Join(path, "metadata.json")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		notFound("id not found", w, r)
-		return
-	}
-	defer f.Close()
-
-	var metadata repository.Metadata
-	d := json.NewDecoder(f)
-	err = d.Decode(&metadata)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "error: an error occured while reading data:", err)
 		internalServerError(w, r)
 		return
 	}
-
 	ok(metadata, w, r)
 }
 

cmd/server/api/responses.go

@@ -3,13 +3,13 @@ package api
 import (
 	"cloudsave/pkg/remote/obj"
 	"encoding/json"
-	"log"
+	"log/slog"
 	"net/http"
 	"time"
 )
 
 func internalServerError(w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusInternalServerError,
 			Path:      r.RequestURI,
@@ -19,20 +19,16 @@ func internalServerError(w http.ResponseWriter, r *http.Request) {
 		Message: "The server encountered an unexpected condition that prevented it from fulfilling the request.",
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.WriteHeader(http.StatusInternalServerError)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func notFound(message string, w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusNotFound,
 			Path:      r.RequestURI,
@@ -42,20 +38,16 @@ func notFound(message string, w http.ResponseWriter, r *http.Request) {
 		Message: message,
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.WriteHeader(http.StatusNotFound)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func methodNotAllowed(w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusMethodNotAllowed,
 			Path:      r.RequestURI,
@@ -65,20 +57,16 @@ func methodNotAllowed(w http.ResponseWriter, r *http.Request) {
 		Message: "The server knows the request method, but the target resource doesn't support this method",
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.WriteHeader(http.StatusMethodNotAllowed)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func unauthorized(w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusUnauthorized,
 			Path:      r.RequestURI,
@@ -88,21 +76,17 @@ func unauthorized(w http.ResponseWriter, r *http.Request) {
 		Message: "The request has not been completed because it lacks valid authentication credentials for the requested resource.",
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.Header().Add("WWW-Authenticate", "Custom realm=\"loginUserHandler via /api/login\"")
 	w.WriteHeader(http.StatusUnauthorized)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func ok(o interface{}, w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPObject{
+	payload := obj.HTTPObject{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusOK,
 			Path:      r.RequestURI,
@@ -110,20 +94,15 @@ func ok(o interface{}, w http.ResponseWriter, r *http.Request) {
 		},
 		Data: o,
 	}
-
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func badRequest(message string, w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusBadRequest,
 			Path:      r.RequestURI,
@@ -133,14 +112,10 @@ func badRequest(message string, w http.ResponseWriter, r *http.Request) {
 		Message: message,
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.WriteHeader(http.StatusBadRequest)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }

cmd/server/data/data.go

@@ -1,239 +0,0 @@
-package data
-
-import (
-	"cloudsave/pkg/repository"
-	"cloudsave/pkg/tools/hash"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"sync"
-)
-
-type (
-	cache map[string]cachedInfo
-
-	cachedInfo struct {
-		MD5     string
-		Version int
-	}
-)
-
-var (
-	ErrBackupNotExists error = errors.New("backup not found")
-
-	// singleton
-	hashCacheMu sync.RWMutex
-	hashCache   cache = make(map[string]cachedInfo)
-)
-
-func (c cache) Get(gameID string) (cachedInfo, bool) {
-	hashCacheMu.RLock()
-	defer hashCacheMu.RUnlock()
-
-	if v, ok := c[gameID]; ok {
-		return v, true
-	}
-	return cachedInfo{}, false
-}
-
-func (c cache) Register(gameID string, v cachedInfo) {
-	hashCacheMu.Lock()
-	defer hashCacheMu.Unlock()
-
-	c[gameID] = v
-}
-
-func (c cache) Remove(gameID string) {
-	hashCacheMu.Lock()
-	defer hashCacheMu.Unlock()
-
-	delete(c, gameID)
-}
-
-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 := makeDataFolder(gameID, documentRoot); 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
-	}
-
-	hashCache.Remove(gameID)
-	return nil
-}
-
-func WriteHist(gameID, documentRoot, uuid string, r io.Reader) error {
-	dataFolderPath := filepath.Join(documentRoot, "data", gameID, "hist", uuid)
-	partPath := filepath.Join(dataFolderPath, "data.tar.gz.part")
-	finalFilePath := filepath.Join(dataFolderPath, "data.tar.gz")
-
-	if err := makeDataFolder(gameID, documentRoot); err != nil {
-		return err
-	}
-
-	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 repository.Metadata) error {
-	if err := makeDataFolder(gameID, documentRoot); err != nil {
-		return err
-	}
-	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)
-}
-
-func ArchiveInfo(gameID, documentRoot, uuid string) (repository.Backup, error) {
-	dataFolderPath := filepath.Join(documentRoot, "data", gameID, "hist", uuid, "data.tar.gz")
-	cacheID := gameID + ":" + uuid
-
-	finfo, err := os.Stat(dataFolderPath)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return repository.Backup{}, ErrBackupNotExists
-		}
-		return repository.Backup{}, err
-	}
-
-	if m, ok := hashCache.Get(cacheID); ok {
-		return repository.Backup{
-			CreatedAt: finfo.ModTime(),
-			UUID:      uuid,
-			MD5:       m.MD5,
-		}, nil
-	}
-
-	h, err := hash.FileMD5(dataFolderPath)
-	if err != nil {
-		return repository.Backup{}, fmt.Errorf("failed to calculate file md5: %w", err)
-	}
-
-	hashCache.Register(cacheID, cachedInfo{
-		MD5: h,
-	})
-
-	return repository.Backup{
-		CreatedAt: finfo.ModTime(),
-		UUID:      uuid,
-		MD5:       h,
-	}, nil
-}
-
-func Hash(gameID, documentRoot string) (string, error) {
-	path := filepath.Clean(filepath.Join(documentRoot, "data", gameID))
-
-	sdir, err := os.Stat(path)
-	if err != nil {
-		return "", err
-	}
-
-	if !sdir.IsDir() {
-		return "", err
-	}
-
-	v, err := getVersion(gameID, documentRoot)
-	if err != nil {
-		return "", fmt.Errorf("failed to read game metadata: %w", err)
-	}
-
-	if m, ok := hashCache.Get(gameID); ok {
-		if v == m.Version {
-			return m.MD5, nil
-		}
-	}
-
-	path = filepath.Join(path, "data.tar.gz")
-
-	h, err := hash.FileMD5(path)
-	if err != nil {
-		return "", err
-	}
-
-	hashCache.Register(gameID, cachedInfo{
-		Version: v,
-		MD5:     h,
-	})
-
-	return h, nil
-}
-
-func getVersion(gameID, documentRoot string) (int, error) {
-	path := filepath.Join(documentRoot, "data", gameID, "metadata.json")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		return 0, err
-	}
-	defer f.Close()
-
-	d := json.NewDecoder(f)
-	var m repository.Metadata
-	if err := d.Decode(&m); err != nil {
-		return 0, err
-	}
-
-	return m.Version, nil
-}
-
-func makeDataFolder(gameID, documentRoot string) error {
-	if err := os.MkdirAll(filepath.Join(documentRoot, "data", gameID), 0740); err != nil {
-		return err
-	}
-
-	if err := os.MkdirAll(filepath.Join(documentRoot, "data", gameID, "hist"), 0740); err != nil {
-		return err
-	}
-
-	return nil
-}

cmd/server/main_windows.go

@@ -2,12 +2,19 @@ package main
 
 import (
 	"cloudsave/pkg/tools/windows"
+	_ "embed"
 	"os"
+
+	"github.com/getlantern/systray"
 )
 
-const defaultDocumentRoot string = "C:/ProgramData/CloudSave"
+const defaultDocumentRoot string = "C:\\ProgramData\\CloudSave"
+
+//go:embed res/icon.ico
+var icon []byte
 
 func main() {
+	go systray.Run(onReady, onExit)
 	run()
 }
 
@@ -15,3 +22,20 @@ func fatal(message string, exitCode int) {
 	windows.MessageBox(windows.NULL, message, "CloudSave", windows.MB_OK)
 	os.Exit(exitCode)
 }
+
+func onReady() {
+	systray.SetTitle("CloudSave")
+	systray.SetTooltip("CloudSave")
+	systray.SetIcon(icon)
+
+	mQuit := systray.AddMenuItem("Quit", "Quit")
+
+	go func() {
+		<-mQuit.ClickedCh
+		os.Exit(0)
+	}()
+}
+
+func onExit() {
+	// clean up here
+}

cmd/server/runner.go

@@ -4,8 +4,11 @@ import (
 	"cloudsave/cmd/server/api"
 	"cloudsave/cmd/server/security/htpasswd"
 	"cloudsave/pkg/constants"
+	"cloudsave/pkg/data"
+	"cloudsave/pkg/repository"
 	"flag"
 	"fmt"
+	"log/slog"
 	"path/filepath"
 	"runtime"
 	"strconv"
@@ -16,18 +19,49 @@ func run() {
 
 	var documentRoot string
 	var port int
+	var noCache, verbose bool
 	flag.StringVar(&documentRoot, "document-root", defaultDocumentRoot, "Define the path to the document root")
 	flag.IntVar(&port, "port", 8080, "Define the port of the server")
+	flag.BoolVar(&noCache, "no-cache", false, "Disable the cache")
+	flag.BoolVar(&verbose, "verbose", false, "Show more logs")
 	flag.Parse()
 
+	if verbose {
+		slog.SetLogLoggerLevel(slog.LevelDebug)
+	}
+
+	slog.Info("loading .htpasswd")
 	h, err := htpasswd.Open(filepath.Join(documentRoot, ".htpasswd"))
 	if err != nil {
 		fatal("failed to load .htpasswd: "+err.Error(), 1)
 	}
+	slog.Info("users loaded: " + strconv.Itoa(len(h.Content())) + " user(s) loaded")
 
-	server := api.NewServer(documentRoot, h.Content(), port)
+	var repo repository.Repository
+	if !noCache {
+		slog.Info("loading eager repository...")
+		r, err := repository.NewEagerRepository(filepath.Join(documentRoot, "data"))
+		if err != nil {
+			fatal("failed to load datastore: "+err.Error(), 1)
+		}
+		if err := r.Preload(); err != nil {
+			fatal("failed to load datastore: "+err.Error(), 1)
+		}
+		repo = r
+	} else {
+		slog.Info("loading lazy repository...")
+		repo, err = repository.NewLazyRepository(filepath.Join(documentRoot, "data"))
+		if err != nil {
+			fatal("failed to load datastore: "+err.Error(), 1)
+		}
+	}
 
-	fmt.Println("starting server at :" + strconv.Itoa(port))
+	slog.Info("repository loaded")
+	s := data.NewService(repo)
+
+	server := api.NewServer(documentRoot, s, h.Content(), port)
+
+	fmt.Println("server started at :" + strconv.Itoa(port))
 	if err := server.Server.ListenAndServe(); err != nil {
 		fatal("failed to start server: "+err.Error(), 1)
 	}

cmd/web/server/server.go

@@ -12,6 +12,7 @@ import (
 	"net/http"
 	"runtime"
 	"slices"
+	"sync"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
@@ -160,41 +161,54 @@ func (s *HTTPServer) detailled(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	save, err := cli.Metadata(id)
+	var wg sync.WaitGroup
-	if err != nil {
+	var err1, err2 error
-		if errors.Is(err, client.ErrUnauthorized) {
+	var save repository.Metadata
+	var ids []string
+
+	wg.Add(1)
+	go func() {
+		save, err1 = cli.Metadata(id)
+		wg.Done()
+	}()
+
+	wg.Add(1)
+	go func() {
+		ids, err2 = cli.ListArchives(id)
+		wg.Done()
+	}()
+
+	wg.Wait()
+
+	if err1 != nil || err2 != nil {
+		if errors.Is(err1, client.ErrUnauthorized) {
 			unauthorized("Unable to access resources", w, r)
 			return
 		}
-		slog.Error("unable to connect to the remote", "err", err)
+		slog.Error("failed to get metadata: unable to connect to the remote", "err", err1)
 		return
 	}
 
-	h, err := cli.Hash(id)
+	wg = sync.WaitGroup{}
-	if err != nil {
-		slog.Error("unable to connect to the remote", "err", err)
-		return
-	}
-
-	ids, err := cli.ListArchives(id)
-	if err != nil {
-		slog.Error("unable to connect to the remote", "err", err)
-		return
-	}
 
 	var bm []repository.Backup
 	for _, i := range ids {
-		b, err := cli.ArchiveInfo(id, i)
+		wg.Add(1)
-		if err != nil {
+		go func() {
-			slog.Error("unable to connect to the remote", "err", err)
+			defer wg.Done()
-			return
+			b, err := cli.ArchiveInfo(id, i)
-		}
+			if err != nil {
-		bm = append(bm, b)
+				slog.Error("failed to get backup: unable to connect to the remote", "err", err)
+				return
+			}
+			bm = append(bm, b)
+		}()
 	}
 
+	wg.Wait()
+
 	payload := DetaillePayload{
 		Save:           save,
-		Hash:           h,
 		BackupMetadata: bm,
 		Version:        constants.Version,
 	}

cmd/web/server/templates/detailled.html

@@ -30,7 +30,7 @@
             <ul class="list-group list-group-flush">
                 <li class="list-group-item">UUID: {{.Save.ID}}</li>
                 <li class="list-group-item">Last Upload: {{.Save.Date}}</li>
-                <li class="list-group-item">Hash (MD5): {{.Hash}}</li>
+                <li class="list-group-item">Hash (MD5): {{.Save.MD5}}</li>
             </ul>
 
             <hr />

go.mod

@@ -3,6 +3,7 @@ module cloudsave
 go 1.24
 
 require (
+	github.com/getlantern/systray v1.2.2
 	github.com/go-chi/chi/v5 v5.2.1
 	github.com/google/subcommands v1.2.0
 	github.com/google/uuid v1.6.0
@@ -12,7 +13,15 @@ require (
 )
 
 require (
+	github.com/getlantern/context v0.0.0-20190109183933-c447772a6520 // indirect
+	github.com/getlantern/errors v0.0.0-20190325191628-abdb3e3e36f7 // indirect
+	github.com/getlantern/golog v0.0.0-20190830074920-4ef2e798c2d7 // indirect
+	github.com/getlantern/hex v0.0.0-20190417191902-c6586a6fe0b7 // indirect
+	github.com/getlantern/hidden v0.0.0-20190325191715-f02dbb02be55 // indirect
+	github.com/getlantern/ops v0.0.0-20190325191751-d70cb0d6f85f // indirect
+	github.com/go-stack/stack v1.8.0 // indirect
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
+	github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	golang.org/x/sys v0.33.0 // indirect
 )

go.sum

@@ -1,30 +1,57 @@
 github.com/chengxilo/virtualterm v1.0.4 h1:Z6IpERbRVlfB8WkOmtbHiDbBANU7cimRIof7mk9/PwM=
 github.com/chengxilo/virtualterm v1.0.4/go.mod h1:DyxxBZz/x1iqJjFxTFcr6/x+jSpqN0iwWCOK1q10rlY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/getlantern/context v0.0.0-20190109183933-c447772a6520 h1:NRUJuo3v3WGC/g5YiyF790gut6oQr5f3FBI88Wv0dx4=
+github.com/getlantern/context v0.0.0-20190109183933-c447772a6520/go.mod h1:L+mq6/vvYHKjCX2oez0CgEAJmbq1fbb/oNJIWQkBybY=
+github.com/getlantern/errors v0.0.0-20190325191628-abdb3e3e36f7 h1:6uJ+sZ/e03gkbqZ0kUG6mfKoqDb4XMAzMIwlajq19So=
+github.com/getlantern/errors v0.0.0-20190325191628-abdb3e3e36f7/go.mod h1:l+xpFBrCtDLpK9qNjxs+cHU6+BAdlBaxHqikB6Lku3A=
+github.com/getlantern/golog v0.0.0-20190830074920-4ef2e798c2d7 h1:guBYzEaLz0Vfc/jv0czrr2z7qyzTOGC9hiQ0VC+hKjk=
+github.com/getlantern/golog v0.0.0-20190830074920-4ef2e798c2d7/go.mod h1:zx/1xUUeYPy3Pcmet8OSXLbF47l+3y6hIPpyLWoR9oc=
+github.com/getlantern/hex v0.0.0-20190417191902-c6586a6fe0b7 h1:micT5vkcr9tOVk1FiH8SWKID8ultN44Z+yzd2y/Vyb0=
+github.com/getlantern/hex v0.0.0-20190417191902-c6586a6fe0b7/go.mod h1:dD3CgOrwlzca8ed61CsZouQS5h5jIzkK9ZWrTcf0s+o=
+github.com/getlantern/hidden v0.0.0-20190325191715-f02dbb02be55 h1:XYzSdCbkzOC0FDNrgJqGRo8PCMFOBFL9py72DRs7bmc=
+github.com/getlantern/hidden v0.0.0-20190325191715-f02dbb02be55/go.mod h1:6mmzY2kW1TOOrVy+r41Za2MxXM+hhqTtY3oBKd2AgFA=
+github.com/getlantern/ops v0.0.0-20190325191751-d70cb0d6f85f h1:wrYrQttPS8FHIRSlsrcuKazukx/xqO/PpLZzZXsF+EA=
+github.com/getlantern/ops v0.0.0-20190325191751-d70cb0d6f85f/go.mod h1:D5ao98qkA6pxftxoqzibIBBrLSUli+kYnJqrgBf9cIA=
+github.com/getlantern/systray v1.2.2 h1:dCEHtfmvkJG7HZ8lS/sLklTH4RKUcIsKrAD9sThoEBE=
+github.com/getlantern/systray v1.2.2/go.mod h1:pXFOI1wwqwYXEhLPm9ZGjS2u/vVELeIgNMY5HvhHhcE=
 github.com/go-chi/chi/v5 v5.2.1 h1:KOIHODQj58PmL80G2Eak4WdvUzjSJSm0vG72crDCqb8=
 github.com/go-chi/chi/v5 v5.2.1/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
+github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/google/subcommands v1.2.0 h1:vWQspBTo2nEqTUFita5/KeEWlUL8kQObDFbub/EN9oE=
 github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/lxn/walk v0.0.0-20210112085537-c389da54e794/go.mod h1:E23UucZGqpuUANJooIbHWCufXvOcT6E7Stq81gU+CSQ=
+github.com/lxn/win v0.0.0-20210218163916-a377121e959e/go.mod h1:KxxjdtRkfNoYDCUP5ryK7XJJNTnpC8atvtmTheChOtk=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
+github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c h1:rp5dCmg/yLR3mgFuSOe4oEnDDmGLROTvMragMUXpTQw=
+github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c/go.mod h1:X07ZCGwUbLaax7L0S3Tw4hpejzu63ZrrQiUe6W0hcy0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/schollz/progressbar/v3 v3.18.0 h1:uXdoHABRFmNIjUfte/Ex7WtuyVslrw2wVPQmCN62HpA=
 github.com/schollz/progressbar/v3 v3.18.0/go.mod h1:IsO3lpbaGuzh8zIMzgY3+J8l4C8GjO0Y9S69eFvNsec=
+github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966/go.mod h1:sUM3LWHvSMaG192sy56D9F7CNvL7jUJVXoqM1QKLnog=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
 golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/sys v0.0.0-20201018230417-eeed37f84f13/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
 golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+gopkg.in/Knetic/govaluate.v3 v3.0.0/go.mod h1:csKLBORsPbafmSCGTEh3U7Ozmsuq8ZSIlKk1bcqph0E=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

jenkinsfile

@@ -0,0 +1,11 @@
+pipeline {
+    agent any
+
+    stages {
+        stage('Build') {
+            steps {
+                sh './build.sh'
+            }
+        }
+    }
+}

pkg/constants/constants.go

@@ -1,5 +1,5 @@
 package constants
 
-const Version = "0.0.3"
+const Version = "0.0.4d"
 
 const ApiVersion = 1

pkg/data/data.go

@@ -0,0 +1,410 @@
+package data
+
+import (
+	"cloudsave/pkg/remote/client"
+	"cloudsave/pkg/repository"
+	"cloudsave/pkg/tools/archive"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type (
+	Service struct {
+		repo repository.Repository
+	}
+)
+
+func NewService(repo repository.Repository) *Service {
+	return &Service{
+		repo: repo,
+	}
+}
+
+func (s *Service) Add(name, path, remote string) (string, error) {
+	gameID := repository.NewGameIdentifier(uuid.NewString())
+
+	if err := s.repo.Mkdir(gameID); err != nil {
+		return "", fmt.Errorf("failed to add game reference: %w", err)
+	}
+
+	m := repository.Metadata{
+		ID:      gameID.Key(),
+		Name:    name,
+		Path:    path,
+		Version: 0,
+		Date:    time.Now(),
+	}
+
+	if err := s.repo.WriteMetadata(gameID, m); err != nil {
+		return "", fmt.Errorf("failed to add game reference: %w", err)
+	}
+
+	return gameID.Key(), nil
+}
+
+func (s *Service) One(gameID string) (repository.Metadata, error) {
+	id := repository.NewGameIdentifier(gameID)
+
+	m, err := s.repo.Metadata(id)
+	if err != nil {
+		return repository.Metadata{}, fmt.Errorf("failed to get metadata: %w", err)
+	}
+
+	return m, nil
+}
+
+func (s *Service) Backup(gameID, backupID string) (repository.Backup, error) {
+	id := repository.NewBackupIdentifier(gameID, backupID)
+
+	if err := s.repo.Mkdir(id); err != nil {
+		return repository.Backup{}, fmt.Errorf("failed to make game dir: %w", err)
+	}
+
+	return s.repo.Backup(id)
+}
+
+func (s *Service) UpdateMetadata(gameID string, m repository.Metadata) error {
+	id := repository.NewGameIdentifier(gameID)
+
+	if err := s.repo.Mkdir(id); err != nil {
+		return fmt.Errorf("failed to make game dir: %w", err)
+	}
+
+	if err := s.repo.WriteMetadata(id, m); err != nil {
+		return fmt.Errorf("failed to write metadate: %w", err)
+	}
+
+	return nil
+}
+
+func (s *Service) Scan(gameID string) (bool, error) {
+	id := repository.NewGameIdentifier(gameID)
+
+	lastRun, err := s.repo.LastScan(id)
+	if err != nil {
+		return false, fmt.Errorf("failed to get last scan time: %w", err)
+	}
+
+	m, err := s.repo.Metadata(id)
+	if err != nil {
+		return false, fmt.Errorf("failed to get game metadata: %w", err)
+	}
+
+	if !IsDirectoryChanged(m.Path, lastRun) {
+		return false, nil
+	}
+
+	if err := s.MakeBackup(gameID); err != nil {
+		return false, fmt.Errorf("failed to make the backup: %w", err)
+	}
+
+	f, err := s.repo.WriteBlob(id)
+	if err != nil {
+		return false, fmt.Errorf("failed to get datastore stream: %w", err)
+	}
+	if v, ok := f.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	if err := archive.Tar(f, m.Path); err != nil {
+		return false, fmt.Errorf("failed to make archive: %w", err)
+	}
+
+	if err := s.repo.ResetLastScan(id); err != nil {
+		return false, fmt.Errorf("failed to reset scan date: %w", err)
+	}
+
+	m.Date = time.Now()
+	m.Version += 1
+
+	if err := s.repo.WriteMetadata(id, m); err != nil {
+		return false, fmt.Errorf("failed to update metadata: %w", err)
+	}
+
+	return true, nil
+}
+
+func (s *Service) MakeBackup(gameID string) error {
+	var id repository.Identifier = repository.NewGameIdentifier(gameID)
+
+	src, err := s.repo.ReadBlob(id)
+	if err != nil {
+		if errors.Is(err, repository.ErrNotFound) {
+			return nil
+		}
+		return err
+	}
+	if v, ok := src.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	id = repository.NewBackupIdentifier(gameID, uuid.NewString())
+
+	if err := s.repo.Mkdir(id); err != nil {
+		return err
+	}
+
+	dst, err := s.repo.WriteBlob(id)
+	if err != nil {
+		return err
+	}
+	if v, ok := dst.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	if _, err := io.Copy(dst, src); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Service) AllGames() ([]repository.Metadata, error) {
+	ids, err := s.repo.All()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get the list of ids: %w", err)
+	}
+
+	var ms []repository.Metadata
+	for _, id := range ids {
+		m, err := s.repo.Metadata(repository.NewGameIdentifier(id))
+		if err != nil {
+			return nil, fmt.Errorf("failed to open metadata: %w", err)
+		}
+		ms = append(ms, m)
+	}
+
+	return ms, nil
+}
+
+func (s *Service) AllBackups(gameID string) ([]repository.Backup, error) {
+	ids, err := s.repo.AllHist(repository.NewGameIdentifier(gameID))
+	if err != nil {
+		return nil, fmt.Errorf("failed to get the list of ids: %w", err)
+	}
+
+	var bs []repository.Backup
+	for _, id := range ids {
+		b, err := s.repo.Backup(repository.NewBackupIdentifier(gameID, id))
+		if err != nil {
+			return nil, fmt.Errorf("failed to open metadata: %w", err)
+		}
+		bs = append(bs, b)
+	}
+
+	return bs, nil
+}
+
+func (l Service) PullArchive(gameID, backupID string, cli *client.Client) error {
+	if len(backupID) > 0 {
+		path := l.repo.DataPath(repository.NewBackupIdentifier(gameID, backupID))
+		return cli.PullBackup(gameID, backupID, filepath.Join(path, "data.tar.gz"))
+	}
+
+	path := l.repo.DataPath(repository.NewGameIdentifier(gameID))
+	return cli.Pull(gameID, filepath.Join(path, "data.tar.gz"))
+}
+
+func (l Service) PushArchive(gameID, backupID string, cli *client.Client) error {
+	m, err := l.repo.Metadata(repository.NewGameIdentifier(gameID))
+	if err != nil {
+		return err
+	}
+
+	if len(backupID) > 0 {
+		path := l.repo.DataPath(repository.NewBackupIdentifier(gameID, backupID))
+		return cli.PushSave(filepath.Join(path, "data.taz.gz"), m)
+	}
+
+	path := l.repo.DataPath(repository.NewGameIdentifier(gameID))
+	return cli.PushSave(filepath.Join(path, "data.tar.gz"), m)
+}
+
+func (l Service) PullCurrent(id, path string, cli *client.Client) error {
+	gameID := repository.NewGameIdentifier(id)
+	if err := l.repo.Mkdir(gameID); err != nil {
+		return err
+	}
+
+	m, err := cli.Metadata(id)
+	if err != nil {
+		return fmt.Errorf("failed to get metadata from the server: %w", err)
+	}
+
+	if err := l.repo.WriteMetadata(gameID, m); err != nil {
+		return fmt.Errorf("failed to write metadata: %w", err)
+	}
+
+	archivePath := filepath.Join(l.repo.DataPath(gameID), "data.tar.gz")
+
+	if err := cli.Pull(id, archivePath); err != nil {
+		return fmt.Errorf("failed to pull from the server: %w", err)
+	}
+
+	f, err := l.repo.ReadBlob(gameID)
+	if err != nil {
+		return fmt.Errorf("failed to open blob from local repository: %w", err)
+	}
+
+	if _, err := os.Stat(path); err == nil {
+		if err := os.RemoveAll(path); err != nil {
+			return fmt.Errorf("failed to clean the destination directory: %w", err)
+		}
+	}
+
+	if err := os.MkdirAll(path, 0740); err != nil {
+		return fmt.Errorf("failed to create destination directory: %w", err)
+	}
+
+	if err := archive.Untar(f, path); err != nil {
+		return fmt.Errorf("failed to untar archive: %w", err)
+	}
+
+	if err := l.repo.ResetLastScan(gameID); err != nil {
+		return fmt.Errorf("failed to create .last_run file: %w", err)
+	}
+
+	return nil
+}
+
+func (l Service) PullBackup(gameID, backupID string, cli *client.Client) error {
+	id := repository.NewBackupIdentifier(gameID, backupID)
+
+	archivePath := filepath.Join(l.repo.DataPath(id), "data.tar.gz")
+
+	if err := cli.PullBackup(gameID, backupID, archivePath); err != nil {
+		return fmt.Errorf("failed to pull backup: %w", err)
+	}
+
+	return nil
+}
+
+func (l Service) RemoveGame(gameID string) error {
+	return l.repo.Remove(repository.NewGameIdentifier(gameID))
+}
+
+func (l Service) SetVersion(gameID string, value int) error {
+	id := repository.NewGameIdentifier(gameID)
+
+	m, err := l.repo.Metadata(id)
+	if err != nil {
+		return fmt.Errorf("failed to get metadata from the server: %w", err)
+	}
+
+	m.Version = value
+
+	if err := l.repo.WriteMetadata(id, m); err != nil {
+		return fmt.Errorf("failed to write metadata: %w", err)
+	}
+
+	return nil
+}
+
+func IsDirectoryChanged(path string, lastRun time.Time) bool {
+	changed := false
+	_ = filepath.Walk(path, func(path string, info os.FileInfo, walkErr error) error {
+		if walkErr != nil {
+			return nil
+		}
+		if info.ModTime().After(lastRun) {
+			changed = true
+			return io.EOF // early exit
+		}
+		return nil
+	})
+	return changed
+}
+
+func (l Service) Copy(id string, src io.Reader) error {
+	dst, err := l.repo.WriteBlob(repository.NewGameIdentifier(id))
+	if err != nil {
+		return err
+	}
+	if v, ok := dst.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	if _, err := io.Copy(dst, src); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (l Service) CopyBackup(gameID, backupID string, src io.Reader) error {
+	id := repository.NewBackupIdentifier(gameID, backupID)
+
+	if err := l.repo.Mkdir(id); err != nil {
+		return err
+	}
+
+	dst, err := l.repo.WriteBlob(id)
+	if err != nil {
+		return err
+	}
+	if v, ok := dst.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	if _, err := io.Copy(dst, src); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (l Service) ApplyCurrent(gameID string) error {
+	id := repository.NewGameIdentifier(gameID)
+	path := l.repo.DataPath(id)
+
+	g, err := l.repo.Metadata(id)
+	if err != nil {
+		return err
+	}
+
+	return l.apply(filepath.Join(path, "data.tar.gz"), g.Path)
+}
+
+func (l Service) ApplyBackup(gameID, backupID string) error {
+	id := repository.NewGameIdentifier(gameID)
+	fullID := repository.NewBackupIdentifier(gameID, backupID)
+	path := l.repo.DataPath(fullID)
+
+	g, err := l.repo.Metadata(id)
+	if err != nil {
+		return err
+	}
+
+	return l.apply(filepath.Join(path, "data.tar.gz"), g.Path)
+}
+
+func (l Service) Repository() repository.Repository {
+	return l.repo
+}
+
+func (l Service) ReloadCache(gameID string) error {
+	if er, ok := l.repo.(*repository.EagerRepository); ok {
+		return er.ReloadMetadata(repository.NewGameIdentifier(gameID))
+	}
+	return nil
+}
+
+func (l Service) apply(src, dst string) error {
+	if err := os.RemoveAll(dst); err != nil {
+		return fmt.Errorf("failed to remove old save: %w", err)
+	}
+
+	f, err := os.OpenFile(src, os.O_RDONLY, 0)
+	if err != nil {
+		return fmt.Errorf("failed to open archive: %w", err)
+	}
+	defer f.Close()
+
+	return archive.Untar(f, dst)
+}

pkg/remote/client/client.go

@@ -49,7 +49,7 @@ func New(baseURL, username, password string) *Client {
 }
 
 func (c *Client) Exists(gameID string) (bool, error) {
-	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "hash")
+	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "metadata")
 	if err != nil {
 		return false, err
 	}
@@ -104,22 +104,13 @@ func (c *Client) Version() (Information, error) {
 	return Information{}, errors.New("invalid payload sent by the server")
 }
 
+// Deprecated: use c.Metadata instead
 func (c *Client) Hash(gameID string) (string, error) {
-	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "hash")
+	m, err := c.Metadata(gameID)
 	if err != nil {
 		return "", err
 	}
-
+	return m.MD5, nil
-	o, err := c.get(u)
-	if err != nil {
-		return "", err
-	}
-
-	if h, ok := (o.Data).(string); ok {
-		return h, nil
-	}
-
-	return "", errors.New("invalid payload sent by the server")
 }
 
 func (c *Client) Metadata(gameID string) (repository.Metadata, error) {
@@ -139,6 +130,7 @@ func (c *Client) Metadata(gameID string) (repository.Metadata, error) {
 			Name:    m["name"].(string),
 			Version: int(m["version"].(float64)),
 			Date:    customtime.MustParse(time.RFC3339, m["date"].(string)),
+			MD5:     m["md5"].(string),
 		}
 		return gm, nil
 	}
@@ -175,6 +167,10 @@ func (c *Client) ListArchives(gameID string) ([]string, error) {
 		return nil, err
 	}
 
+	if o.Data == nil {
+		return nil, nil
+	}
+
 	if m, ok := (o.Data).([]any); ok {
 		var res []string
 		for _, uuid := range m {
@@ -228,6 +224,11 @@ func (c *Client) Pull(gameID, archivePath string) error {
 	if err != nil {
 		return fmt.Errorf("failed to open file: %w", err)
 	}
+	defer func() {
+		if err := os.Rename(archivePath+".part", archivePath); err != nil {
+			panic(err)
+		}
+	}()
 	defer f.Close()
 
 	res, err := cli.Do(req)
@@ -250,8 +251,10 @@ func (c *Client) Pull(gameID, archivePath string) error {
 		return fmt.Errorf("an error occured while copying the file from the remote: %w", err)
 	}
 
-	if err := os.Rename(archivePath+".part", archivePath); err != nil {
+	if err := os.Remove(archivePath); err != nil {
-		return fmt.Errorf("failed to move temporary data: %w", err)
+		if !errors.Is(err, os.ErrNotExist) {
+			return fmt.Errorf("failed to remove the old version of the archive: %w", err)
+		}
 	}
 
 	return nil
@@ -276,15 +279,16 @@ func (c *Client) PullBackup(gameID, uuid, archivePath string) error {
 	if err != nil {
 		return fmt.Errorf("failed to open file: %w", err)
 	}
-	defer f.Close()
 
 	res, err := cli.Do(req)
 	if err != nil {
+		f.Close()
 		return fmt.Errorf("cannot connect to remote: %w", err)
 	}
 	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusOK {
+		f.Close()
 		return fmt.Errorf("cannot connect to remote: server return code: %s", res.Status)
 	}
 
@@ -295,8 +299,10 @@ func (c *Client) PullBackup(gameID, uuid, archivePath string) error {
 	defer bar.Close()
 
 	if _, err := io.Copy(io.MultiWriter(f, bar), res.Body); err != nil {
+		f.Close()
 		return fmt.Errorf("an error occured while copying the file from the remote: %w", err)
 	}
+	f.Close()
 
 	if err := os.Rename(archivePath+".part", archivePath); err != nil {
 		return fmt.Errorf("failed to move temporary data: %w", err)
@@ -343,6 +349,10 @@ func (c *Client) All() ([]repository.Metadata, error) {
 		return nil, err
 	}
 
+	if o.Data == nil {
+		return nil, nil
+	}
+
 	if games, ok := (o.Data).([]any); ok {
 		var res []repository.Metadata
 		for _, g := range games {
@@ -352,6 +362,7 @@ func (c *Client) All() ([]repository.Metadata, error) {
 					Name:    v["name"].(string),
 					Version: int(v["version"].(float64)),
 					Date:    customtime.MustParse(time.RFC3339, v["date"].(string)),
+					MD5:     v["md5"].(string),
 				}
 				res = append(res, gm)
 			}

pkg/repository/repository.go

@@ -2,16 +2,15 @@ package repository
 
 import (
 	"cloudsave/pkg/tools/hash"
-	"cloudsave/pkg/tools/id"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"os"
 	"path/filepath"
+	"sync"
 	"time"
-
-	"github.com/google/uuid"
 )
 
 type (
@@ -21,6 +20,12 @@ type (
 		Path    string    `json:"path"`
 		Version int       `json:"version"`
 		Date    time.Time `json:"date"`
+		MD5     string    `json:"md5,omitempty"`
+	}
+
+	Remote struct {
+		URL    string `json:"url"`
+		GameID string `json:"-"`
 	}
 
 	Backup struct {
@@ -29,353 +34,540 @@ type (
 		UUID        string    `json:"uuid"`
 		ArchivePath string    `json:"-"`
 	}
+
+	Data struct {
+		Metadata Metadata
+		Remote   *Remote
+		DataPath string
+		Backup   map[string]Backup
+	}
+
+	GameIdentifier struct {
+		gameID string
+	}
+
+	BackupIdentifier struct {
+		gameID   string
+		backupID string
+	}
+
+	Identifier interface {
+		Key() string
+	}
+
+	LazyRepository struct {
+		dataRoot string
+	}
+
+	EagerRepository struct {
+		Repository
+
+		mu   sync.RWMutex
+		data map[string]Data
+	}
+
+	Repository interface {
+		Mkdir(id Identifier) error
+
+		All() ([]string, error)
+		AllHist(gameID GameIdentifier) ([]string, error)
+
+		WriteBlob(ID Identifier) (io.Writer, error)
+		      WriteMetadata(gameID GameIdentifier, m Metadata) error
+
+		Metadata(gameID GameIdentifier) (Metadata, error)
+		LastScan(gameID GameIdentifier) (time.Time, error)
+		ReadBlob(gameID Identifier) (io.ReadSeekCloser, error)
+		Backup(id BackupIdentifier) (Backup, error)
+		Remote(id GameIdentifier) (*Remote, error)
+
+		SetRemote(gameID GameIdentifier, url string) error
+		ResetLastScan(id GameIdentifier) error
+
+		DataPath(id Identifier) string
+
+		Remove(gameID GameIdentifier) error
+	}
 )
 
 var (
-	roaming       string
+	ErrNotFound error = errors.New("not found")
-	datastorepath string
 )
 
-func init() {
+func NewGameIdentifier(gameID string) GameIdentifier {
-	var err error
+	return GameIdentifier{
-	roaming, err = os.UserConfigDir()
+		gameID: gameID,
-	if err != nil {
-		panic("failed to get user config path: " + err.Error())
 	}
+}
+func (bi GameIdentifier) Key() string {
+	return bi.gameID
+}
 
-	datastorepath = filepath.Join(roaming, "cloudsave", "data")
+func NewBackupIdentifier(gameID, backupID string) BackupIdentifier {
-	err = os.MkdirAll(datastorepath, 0740)
+	return BackupIdentifier{
-	if err != nil {
+		gameID:   gameID,
-		panic("cannot make the datastore:" + err.Error())
+		backupID: backupID,
 	}
 }
 
-func Add(name, path string) (Metadata, error) {
+func (bi BackupIdentifier) Key() string {
-	m := Metadata{
+	return bi.gameID + ":" + bi.backupID
-		ID:   id.New(),
-		Name: name,
-		Path: path,
-	}
-
-	err := os.MkdirAll(filepath.Join(datastorepath, m.ID), 0740)
-	if err != nil {
-		panic("cannot make directory for the game:" + err.Error())
-	}
-
-	f, err := os.OpenFile(filepath.Join(datastorepath, m.ID, "metadata.json"), os.O_CREATE|os.O_WRONLY, 0740)
-	if err != nil {
-		return Metadata{}, fmt.Errorf("cannot open the metadata file in the datastore: %w", err)
-	}
-	defer f.Close()
-
-	e := json.NewEncoder(f)
-	err = e.Encode(m)
-	if err != nil {
-		return Metadata{}, fmt.Errorf("cannot write into the metadata file in the datastore: %w", err)
-	}
-
-	return m, nil
 }
 
-func Register(m Metadata, path string) error {
+func NewLazyRepository(dataRootPath string) (*LazyRepository, error) {
-	m.Path = path
+	if m, err := os.Stat(dataRootPath); err != nil {
-
+		if errors.Is(err, os.ErrNotExist) {
-	err := os.MkdirAll(filepath.Join(datastorepath, m.ID), 0740)
+			if err := os.MkdirAll(dataRootPath, 0740); err != nil {
-	if err != nil {
+				return nil, fmt.Errorf("failed to make the directory: %w", err)
-		panic("cannot make directory for the game:" + err.Error())
+			}
+		} else {
+			return nil, fmt.Errorf("failed to open datastore: %w", err)
+		}
+	} else {
+		if !m.IsDir() {
+			return nil, fmt.Errorf("failed to open datastore: not a directory")
+		}
 	}
 
-	f, err := os.OpenFile(filepath.Join(datastorepath, m.ID, "metadata.json"), os.O_CREATE|os.O_WRONLY, 0740)
+	return &LazyRepository{
-	if err != nil {
+		dataRoot: dataRootPath,
-		return fmt.Errorf("cannot open the metadata file in the datastore: %w", err)
+	}, nil
-	}
+}
-	defer f.Close()
 
-	e := json.NewEncoder(f)
+func (l *LazyRepository) Mkdir(id Identifier) error {
-	err = e.Encode(m)
+	path := l.DataPath(id)
+	if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {
+		slog.Debug("making directory", "path", path, "id", id, "perm", "0740")
+		return os.MkdirAll(path, 0740)
+	}
+	return nil
+}
+
+func (l *LazyRepository) All() ([]string, error) {
+	slog.Debug("loading all current data...")
+	dir, err := os.ReadDir(l.dataRoot)
 	if err != nil {
-		return fmt.Errorf("cannot write into the metadata file in the datastore: %w", err)
+		return nil, fmt.Errorf("failed to open directory: %w", err)
+	}
+
+	var res []string
+	for _, d := range dir {
+		res = append(res, d.Name())
+	}
+
+	return res, nil
+}
+
+func (l *LazyRepository) AllHist(id GameIdentifier) ([]string, error) {
+	path := l.DataPath(id)
+
+	slog.Debug("loading hist data...", "id", id)
+	dir, err := os.ReadDir(filepath.Join(path, "hist"))
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to open directory: %w", err)
+	}
+
+	var res []string
+	for _, d := range dir {
+		res = append(res, d.Name())
+	}
+
+	return res, nil
+}
+
+func (l *LazyRepository) WriteBlob(ID Identifier) (io.Writer, error) {
+	path := l.DataPath(ID)
+
+	slog.Debug("loading write buffer...", "id", ID)
+	dst, err := os.OpenFile(filepath.Join(path, "data.tar.gz"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open destination file: %w", err)
+	}
+
+	return dst, nil
+}
+
+func (l *LazyRepository) WriteMetadata(id GameIdentifier, m Metadata) error {
+	m.MD5 = ""
+	path := l.DataPath(id)
+
+	slog.Debug("writing metadata", "id", id, "metadata", m)
+	dst, err := os.OpenFile(filepath.Join(path, "metadata.json"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	if err != nil {
+		return fmt.Errorf("failed to open destination file: %w", err)
+	}
+	defer dst.Close()
+
+	e := json.NewEncoder(dst)
+	if err := e.Encode(m); err != nil {
+		return fmt.Errorf("failed to encode data: %w", err)
 	}
 
 	return nil
 }
 
-func All() ([]Metadata, error) {
+func (l *LazyRepository) Metadata(id GameIdentifier) (Metadata, error) {
-	ds, err := os.ReadDir(datastorepath)
+	path := l.DataPath(id)
-	if err != nil {
-		return nil, fmt.Errorf("cannot open the datastore: %w", err)
-	}
 
-	var datastore []Metadata
+	slog.Debug("loading metadata", "id", id)
-	for _, d := range ds {
+	src, err := os.OpenFile(filepath.Join(path, "metadata.json"), os.O_RDONLY, 0)
-		content, err := os.ReadFile(filepath.Join(datastorepath, d.Name(), "metadata.json"))
+	if err != nil {
-		if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
-			continue
+			return Metadata{}, ErrNotFound
 		}
-
+		return Metadata{}, fmt.Errorf("corrupted datastore: failed to open metadata: %w", err)
-		var m Metadata
-		err = json.Unmarshal(content, &m)
-		if err != nil {
-			return nil, fmt.Errorf("corrupted datastore: failed to parse %s/metadata.json: %w", d.Name(), err)
-		}
-
-		datastore = append(datastore, m)
-	}
-	return datastore, nil
-}
-
-func One(gameID string) (Metadata, error) {
-	_, err := os.ReadDir(datastorepath)
-	if err != nil {
-		return Metadata{}, fmt.Errorf("cannot open the datastore: %w", err)
-	}
-
-	content, err := os.ReadFile(filepath.Join(datastorepath, gameID, "metadata.json"))
-	if err != nil {
-		return Metadata{}, fmt.Errorf("game not found: %w", err)
 	}
 
 	var m Metadata
-	err = json.Unmarshal(content, &m)
+	d := json.NewDecoder(src)
+	if err := d.Decode(&m); err != nil {
+		return Metadata{}, fmt.Errorf("corrupted datastore: failed to parse metadata: %w", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(path, "data.tar.gz")); err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return m, nil
+		}
+		return Metadata{}, fmt.Errorf("failed to open archive: %w", err)
+	}
+
+	slog.Debug("loading md5 hash", "id", id)
+	m.MD5, err = hash.FileMD5(filepath.Join(path, "data.tar.gz"))
 	if err != nil {
-		return Metadata{}, fmt.Errorf("corrupted datastore: failed to parse %s/metadata.json: %w", gameID, err)
+		return Metadata{}, fmt.Errorf("failed to calculate md5: %w", err)
 	}
 
 	return m, nil
 }
 
-func MakeArchive(gameID string) error {
+func (l *LazyRepository) Backup(id BackupIdentifier) (Backup, error) {
-	path := filepath.Join(datastorepath, gameID, "data.tar.gz")
+	path := l.DataPath(id)
 
-	// open old
+	slog.Debug("loading hist metadata", "id", id)
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
+	fs, err := os.Stat(filepath.Join(path, "data.tar.gz"))
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
-			return nil
+			return Backup{}, ErrNotFound
 		}
-		return fmt.Errorf("failed to open old file: %w", err)
+		return Backup{}, fmt.Errorf("corrupted datastore: failed to open metadata: %w", err)
-	}
-	defer f.Close()
-
-	histDirPath := filepath.Join(datastorepath, gameID, "hist", uuid.NewString())
-	if err := os.MkdirAll(histDirPath, 0740); err != nil {
-		return fmt.Errorf("failed to make directory: %w", err)
 	}
 
-	// open new
+	slog.Debug("loading md5 hash", "id", id)
-	nf, err := os.OpenFile(filepath.Join(histDirPath, "data.tar.gz"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	h, err := hash.FileMD5(filepath.Join(path, "data.tar.gz"))
 	if err != nil {
-		return fmt.Errorf("failed to open new file: %w", err)
+		return Backup{}, fmt.Errorf("corrupted datastore: failed to open metadata: %w", err)
-	}
-	defer nf.Close()
-
-	// copy
-	if _, err := io.Copy(nf, f); err != nil {
-		return fmt.Errorf("failed to copy data: %w", err)
 	}
 
-	return nil
+	return Backup{
-}
+		CreatedAt:   fs.ModTime(),
-
-func RestoreArchive(gameID, uuid string) error {
-	histDirPath := filepath.Join(datastorepath, gameID, "hist", uuid)
-	if err := os.MkdirAll(histDirPath, 0740); err != nil {
-		return fmt.Errorf("failed to make directory: %w", err)
-	}
-
-	// open old
-	nf, err := os.OpenFile(filepath.Join(histDirPath, "data.tar.gz"), os.O_RDONLY, 0)
-	if err != nil {
-		return fmt.Errorf("failed to open new file: %w", err)
-	}
-	defer nf.Close()
-
-	path := filepath.Join(datastorepath, gameID, "data.tar.gz")
-
-	// open new
-	f, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil
-		}
-		return fmt.Errorf("failed to open old file: %w", err)
-	}
-	defer f.Close()
-
-	// copy
-	if _, err := io.Copy(f, nf); err != nil {
-		return fmt.Errorf("failed to copy data: %w", err)
-	}
-
-	return nil
-}
-
-func Archive(gameID, uuid string) (Backup, error) {
-	histDirPath := filepath.Join(datastorepath, gameID, "hist", uuid)
-	if err := os.MkdirAll(histDirPath, 0740); err != nil {
-		return Backup{}, fmt.Errorf("failed to make 'hist' directory")
-	}
-
-	finfo, err := os.Stat(histDirPath)
-	if err != nil {
-		return Backup{}, fmt.Errorf("corrupted datastore: %w", err)
-	}
-	archivePath := filepath.Join(histDirPath, "data.tar.gz")
-
-	h, err := hash.FileMD5(archivePath)
-	if err != nil {
-		return Backup{}, fmt.Errorf("failed to calculate md5 hash: %w", err)
-	}
-
-	b := Backup{
-		CreatedAt:   finfo.ModTime(),
-		UUID:        filepath.Base(finfo.Name()),
 		MD5:         h,
-		ArchivePath: archivePath,
+		UUID:        id.backupID,
-	}
+		ArchivePath: filepath.Join(path, "data.tar.gz"),
-
+	}, nil
-	return b, nil
 }
 
-func Archives(gameID string) ([]Backup, error) {
+func (l *LazyRepository) LastScan(id GameIdentifier) (time.Time, error) {
-	histDirPath := filepath.Join(datastorepath, gameID, "hist")
+	path := l.DataPath(id)
-	if err := os.MkdirAll(histDirPath, 0740); err != nil {
-		return nil, fmt.Errorf("failed to make 'hist' directory")
-	}
 
-	d, err := os.ReadDir(histDirPath)
+	data, err := os.ReadFile(filepath.Join(path, ".last_run"))
 	if err != nil {
-		return nil, fmt.Errorf("failed to open 'hist' directory")
+		if errors.Is(err, os.ErrNotExist) {
+			return time.Time{}, nil
+		}
+		return time.Time{}, fmt.Errorf("failed to reading state file: %w", err)
 	}
 
-	var res []Backup
+	lastRun, err := time.Parse(time.RFC3339, string(data))
-	for _, f := range d {
+	if err != nil {
-		finfo, err := f.Info()
+		return time.Time{}, fmt.Errorf("parsing state file timestamp: %w", err)
+	}
+
+	return lastRun, nil
+}
+
+func (l *LazyRepository) ResetLastScan(id GameIdentifier) error {
+	path := l.DataPath(id)
+
+	slog.Debug("resetting last scan datetime for", "id", id)
+	f, err := os.OpenFile(filepath.Join(path, ".last_run"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	if err != nil {
+		return fmt.Errorf("failed to open file: %w", err)
+	}
+	defer f.Close()
+
+	data := time.Now().Format(time.RFC3339)
+
+	if _, err := f.WriteString(data); err != nil {
+		return fmt.Errorf("failed to write file: %w", err)
+	}
+
+	return nil
+}
+
+func (l *LazyRepository) ReadBlob(id Identifier) (io.ReadSeekCloser, error) {
+	path := l.DataPath(id)
+
+	slog.Debug("loading read buffer...", "id", id)
+	dst, err := os.OpenFile(filepath.Join(path, "data.tar.gz"), os.O_RDONLY, 0)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, fmt.Errorf("failed to open blob: %w", ErrNotFound)
+		}
+		return nil, fmt.Errorf("failed to open blob: %w", err)
+	}
+
+	return dst, nil
+}
+
+func (l *LazyRepository) SetRemote(id GameIdentifier, url string) error {
+	path := l.DataPath(id)
+
+	src, err := os.OpenFile(filepath.Join(path, "remote.json"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	if err != nil {
+		return fmt.Errorf("failed to open remote description: %w", err)
+	}
+	defer src.Close()
+
+	var r Remote
+	r.URL = url
+
+	e := json.NewEncoder(src)
+	if err := e.Encode(r); err != nil {
+		return fmt.Errorf("failed to marshall remote description: %w", err)
+	}
+
+	return nil
+}
+
+func (l *LazyRepository) Remote(id GameIdentifier) (*Remote, error) {
+	path := l.DataPath(id)
+
+	src, err := os.OpenFile(filepath.Join(path, "remote.json"), os.O_RDONLY, 0)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to open remote description: %w", err)
+	}
+	defer src.Close()
+
+	var r Remote
+	e := json.NewDecoder(src)
+	if err := e.Decode(&r); err != nil {
+		return nil, fmt.Errorf("failed to marshall remote description: %w", err)
+	}
+
+	return &r, nil
+}
+
+func (l *LazyRepository) Remove(id GameIdentifier) error {
+	path := l.DataPath(id)
+
+	slog.Debug("removing data", "id", id)
+	if err := os.RemoveAll(path); err != nil {
+		return fmt.Errorf("failed to remove game folder from the datastore: %w", err)
+	}
+
+	return nil
+}
+
+func (r *LazyRepository) DataPath(id Identifier) string {
+	switch identifier := id.(type) {
+	case GameIdentifier:
+		return filepath.Join(r.dataRoot, identifier.gameID)
+	case BackupIdentifier:
+		return filepath.Join(r.dataRoot, identifier.gameID, "hist", identifier.backupID)
+	}
+
+	panic("identifier type not supported")
+}
+
+func NewEagerRepository(dataRootPath string) (*EagerRepository, error) {
+	r, err := NewLazyRepository(dataRootPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return &EagerRepository{
+		Repository: r,
+		data:       make(map[string]Data),
+	}, nil
+}
+
+func (r *EagerRepository) Preload() error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	games, err := r.Repository.All()
+	if err != nil {
+		return fmt.Errorf("failed to load all data: %w", err)
+	}
+
+	for _, g := range games {
+		backup, err := r.Repository.AllHist(NewGameIdentifier(g))
 		if err != nil {
-			return nil, fmt.Errorf("corrupted datastore: %w", err)
+			return fmt.Errorf("[%s] failed to load hist data: %w", g, err)
 		}
-		path := filepath.Join(histDirPath, finfo.Name())
-		archivePath := filepath.Join(path, "data.tar.gz")
 
-		h, err := hash.FileMD5(archivePath)
+		remote, err := r.Repository.Remote(NewGameIdentifier(g))
 		if err != nil {
-			return nil, fmt.Errorf("failed to calculate md5 hash: %w", err)
+			return fmt.Errorf("[%s] failed to load remote metadata: %w", g, err)
 		}
 
-		b := Backup{
+		m, err := r.Repository.Metadata(NewGameIdentifier(g))
-			CreatedAt:   finfo.ModTime(),
+		if err != nil {
-			UUID:        filepath.Base(finfo.Name()),
+			return fmt.Errorf("[%s] failed to load metadata: %w", g, err)
-			MD5:         h,
-			ArchivePath: archivePath,
 		}
 
-		res = append(res, b)
+		backups := make(map[string]Backup)
+		for _, b := range backup {
+			info, err := r.Repository.Backup(NewBackupIdentifier(g, b))
+			if err != nil {
+				return fmt.Errorf("[%s] failed to get backup information: %w", g, err)
+			}
+
+			backups[b] = info
+		}
+
+		r.data[g] = Data{
+			Metadata: m,
+			Remote:   remote,
+			DataPath: r.DataPath(NewGameIdentifier(g)),
+			Backup:   backups,
+		}
+	}
+
+	return nil
+}
+
+func (r *EagerRepository) All() ([]string, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	var res []string
+	for _, g := range r.data {
+		res = append(res, g.Metadata.ID)
+	}
+
+	return res, nil
+}
+
+func (r *EagerRepository) AllHist(id GameIdentifier) ([]string, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	var res []string
+	if d, ok := r.data[id.gameID]; ok {
+		for _, b := range d.Backup {
+			res = append(res, b.UUID)
+		}
 	}
 	return res, nil
 }
 
-func DatastorePath() string {
+func (r *EagerRepository) WriteMetadata(id GameIdentifier, m Metadata) error {
-	return datastorepath
+	r.mu.Lock()
-}
+	defer r.mu.Unlock()
 
-func Remove(gameID string) error {
+	err := r.Repository.WriteMetadata(id, m)
-	err := os.RemoveAll(filepath.Join(datastorepath, gameID))
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func Hash(gameID string) (string, error) {
-	path := filepath.Join(datastorepath, gameID, "data.tar.gz")
-
-	return hash.FileMD5(path)
-}
-
-func Version(gameID string) (int, error) {
-	path := filepath.Join(datastorepath, gameID, "metadata.json")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		return 0, err
-	}
-	defer f.Close()
-
-	var metadata Metadata
-	d := json.NewDecoder(f)
-	err = d.Decode(&metadata)
-	if err != nil {
-		return 0, err
-	}
-
-	return metadata.Version, nil
-}
-
-func SetVersion(gameID string, version int) error {
-	path := filepath.Join(datastorepath, gameID, "metadata.json")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
 	if err != nil {
 		return err
 	}
 
-	var metadata Metadata
+	d := r.data[id.gameID]
-	d := json.NewDecoder(f)
+	d.Metadata = m
-	err = d.Decode(&metadata)
+	r.data[id.gameID] = d
-	if err != nil {
-		f.Close()
-		return err
-	}
-
-	f.Close()
-
-	metadata.Version = version
-
-	f, err = os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0740)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	e := json.NewEncoder(f)
-	err = e.Encode(metadata)
-	if err != nil {
-		return err
-	}
 
 	return nil
 }
 
-func SetDate(gameID string, dt time.Time) error {
+func (r *EagerRepository) Metadata(id GameIdentifier) (Metadata, error) {
-	path := filepath.Join(datastorepath, gameID, "metadata.json")
+	r.mu.RLock()
+	defer r.mu.RUnlock()
 
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
+	if d, ok := r.data[id.gameID]; ok {
+		return d.Metadata, nil
+	}
+	return Metadata{}, ErrNotFound
+}
+
+func (r *EagerRepository) Backup(id BackupIdentifier) (Backup, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	if d, ok := r.data[id.gameID]; ok {
+		if b, ok := d.Backup[id.backupID]; ok {
+			return b, nil
+		}
+	}
+	return Backup{}, ErrNotFound
+}
+
+func (r *EagerRepository) SetRemote(id GameIdentifier, url string) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	err := r.Repository.SetRemote(id, url)
 	if err != nil {
 		return err
 	}
 
-	var metadata Metadata
+	d := r.data[id.gameID]
-	d := json.NewDecoder(f)
+	d.Remote = &Remote{
-	err = d.Decode(&metadata)
+		URL:    url,
-	if err != nil {
+		GameID: d.Metadata.ID,
-		f.Close()
+	}
+	r.data[id.gameID] = d
+
+	return nil
+}
+
+func (r *EagerRepository) Remove(id GameIdentifier) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if err := r.Repository.Remove(id); err != nil {
 		return err
 	}
 
-	f.Close()
+	delete(r.data, id.gameID)
+	return nil
+}
 
-	metadata.Date = dt
+func (r *EagerRepository) ReloadMetadata(id GameIdentifier) error {
-
+	backup, err := r.Repository.AllHist(id)
-	f, err = os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0740)
 	if err != nil {
-		return err
+		return fmt.Errorf("[%s] failed to load hist data: %w", id, err)
 	}
-	defer f.Close()
 
-	e := json.NewEncoder(f)
+	remote, err := r.Repository.Remote(id)
-	err = e.Encode(metadata)
 	if err != nil {
-		return err
+		return fmt.Errorf("[%s] failed to load remote metadata: %w", id, err)
+	}
+
+	m, err := r.Repository.Metadata(id)
+	if err != nil {
+		return fmt.Errorf("[%s] failed to load metadata: %w", id, err)
+	}
+
+	backups := make(map[string]Backup)
+	for _, b := range backup {
+		info, err := r.Repository.Backup(NewBackupIdentifier(id.gameID, b))
+		if err != nil {
+			return fmt.Errorf("[%s] failed to get backup information: %w", id, err)
+		}
+
+		backups[b] = info
+	}
+
+	r.data[id.gameID] = Data{
+		Metadata: m,
+		Remote:   remote,
+		DataPath: r.DataPath(id),
+		Backup:   backups,
 	}
 
 	return nil