add gosec

Reviewed-on: #4

.gitignore

@@ -1,4 +1,7 @@
 /cli
 /server
+/web
 /env/
 /build/
+*.exe
+/config.json

.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"
         }

LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Aurélie DELHAIE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,58 @@
+# CloudSave
+
+The software is still in alpha.
+
+A client/server that allows unsynchronized games (such as emulators, old games, etc.) to be kept up to date on multiple computers.
+
+## Build
+
+You need go1.24
+
+After downloading the go toolchain, just run the script `./build.sh`
+
+## Usage
+
+### Server
+
+The server needs an empty directory. After creating this directory, you need to make a file that contains your credential. The format is "username:password". The server only understand bcrypt password hash for now.
+
+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
+
+#### Register a game
+
+You can register a game with the verb `add`
+```bash
+cloudsave add /home/user/gamedata
+```
+
+You can also change the name of the registration and add a remote
+```bash
+cloudsave add -name "My Game" -remote "http://localhost:8080" /home/user/gamedata
+```
+
+#### Make an archive of the current state
+
+This is a command line tool, it cannot auto detect changes.
+Run this command to start the scan, if needed, the tool will create a new archive
+
+```bash
+cloudsave scan
+```
+#### Send everything on the server
+
+This will pull and push data to the server.
+
+Note: If multiple computers are pushing to this server, a conflict may be generated. If so, the tool will ask for the version to keep
+
+```bash
+cloudsave sync
+```

build.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 
 MAKE_PACKAGE=false
-VERSION=0.0.2
+VERSION=0.0.4
 
 usage() {
  echo "Usage: $0 [OPTIONS]"
@@ -35,7 +35,7 @@ fi
 
 ## SERVER
 
-platforms=("linux/amd64" "linux/arm64" "linux/riscv64" "linux/ppc64le")
+platforms=("linux/amd64" "linux/arm64" "linux/riscv64" "linux/ppc64le", "windows/amd64")
 
 for platform in "${platforms[@]}"; do
     echo "* Compiling server for $platform..."
@@ -47,11 +47,33 @@ 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
+
+# WEB
+
+platforms=("linux/amd64" "linux/arm64" "linux/riscv64" "linux/ppc64le")
+
+for platform in "${platforms[@]}"; do
+    echo "* Compiling web server for $platform..."
+    platform_split=(${platform//\// })
+
+    EXT=""
+    if [ "${platform_split[0]}" == "windows" ]; then
+      EXT=.exe
+    fi
+
+    if [ "$MAKE_PACKAGE" == "true" ]; then
+        CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} go build -o build/cloudsave_web$EXT -a ./cmd/web
+        tar -czf build/web_${platform_split[0]}_${platform_split[1]}.tar.gz build/cloudsave_web$EXT
+        rm build/cloudsave_web$EXT
+    else
+      CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} go build -o build/cloudsave_web_${platform_split[0]}_${platform_split[1]}$EXT -a ./cmd/web
     fi
 done
 

cmd/cli/commands/add/add.go

@@ -1,7 +1,7 @@
 package add
 
 import (
-	"cloudsave/pkg/repository"
+	"cloudsave/pkg/data"
 	"context"
 	"flag"
 	"fmt"
@@ -13,20 +13,26 @@ import (
 
 type (
 	AddCmd struct {
-		name string
+		Service *data.Service
+		name    string
+		remote  string
 	}
 )
 
 func (*AddCmd) Name() string     { return "add" }
-func (*AddCmd) Synopsis() string { return "Add a folder to the sync list" }
+func (*AddCmd) Synopsis() string { return "add a folder to the sync list" }
 func (*AddCmd) Usage() string {
-	return `add:
+	return `Usage: cloudsave add [-name] [-remote] <PATH>
-  Add a folder to the sync list
+
+Add a folder to the track list
+	
+Options:
 `
 }
 
 func (p *AddCmd) SetFlags(f *flag.FlagSet) {
 	f.StringVar(&p.name, "name", "", "Override the name of the game")
+	f.StringVar(&p.remote, "remote", "", "Defines a remote server to sync with")
 }
 
 func (p *AddCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
@@ -44,13 +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
 	}
 
-	fmt.Println(m.ID)
+	if _, err := p.Service.Scan(gameID); err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to scan:", err)
+		return subcommands.ExitFailure
+	}
 
 	return subcommands.ExitSuccess
 }

cmd/cli/commands/apply/apply.go

@@ -1,35 +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 `apply:
+	return `Usage: cloudsave apply <GAME_ID> [BACKUP_ID]
-  Apply a backup
+
+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
 	}
@@ -37,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,16 +14,20 @@ import (
 
 type (
 	ListCmd struct {
-		remote bool
+		Service *data.Service
-		backup bool
+		remote  bool
+		backup  bool
 	}
 )
 
 func (*ListCmd) Name() string     { return "list" }
 func (*ListCmd) Synopsis() string { return "list all game registered" }
 func (*ListCmd) Usage() string {
-	return `list:
+	return `Usage: cloudsave list [-include-backup] [-a]
-  List all game registered
+
+List all game registered
+
+Options:
 `
 }
 
@@ -39,27 +43,27 @@ func (p *ListCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 			return subcommands.ExitUsageError
 		}
 
-		username, password, err := credentials.Read()
+		username, password, err := credentials.Read(f.Arg(0))
 		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)
 	}
@@ -67,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)
 			}
@@ -86,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 {
@@ -104,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/login/login.go

@@ -0,0 +1,60 @@
+package login
+
+import (
+	"cloudsave/cmd/cli/tools/prompt/credentials"
+	"cloudsave/pkg/remote/client"
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/google/subcommands"
+)
+
+type (
+	LoginCmd struct {
+	}
+)
+
+func (*LoginCmd) Name() string     { return "login" }
+func (*LoginCmd) Synopsis() string { return "save IN PLAIN TEXT your credentials" }
+func (*LoginCmd) Usage() string {
+	return `Usage: cloudsave login <SERVER_HOSTNAME>
+
+Warning: this command saves the login into a plain text json file
+
+Options:
+`
+}
+
+func (p *LoginCmd) SetFlags(f *flag.FlagSet) {
+}
+
+func (p *LoginCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
+	if f.NArg() != 1 {
+		fmt.Fprintf(os.Stderr, "error: this command take 1 argument")
+		return subcommands.ExitUsageError
+	}
+
+	server := f.Arg(0)
+
+	username, password, err := credentials.Read(server)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: failed to read std output: %s", err)
+		return subcommands.ExitFailure
+	}
+
+	cli := client.New(server, username, password)
+	if _, err := cli.Version(); err != nil {
+		fmt.Fprintf(os.Stderr, "error: failed to login: %s", err)
+		return subcommands.ExitFailure
+	}
+
+	if err := credentials.Login(username, password, server); err != nil {
+		fmt.Fprintf(os.Stderr, "error: failed to save login: %s", err)
+		return subcommands.ExitFailure
+	}
+
+	fmt.Println("login information saved!")
+	return subcommands.ExitSuccess
+}

cmd/cli/commands/logout/logout.go

@@ -0,0 +1,43 @@
+package logout
+
+import (
+	"cloudsave/cmd/cli/tools/prompt/credentials"
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/google/subcommands"
+)
+
+type (
+	LogoutCmd struct {
+	}
+)
+
+func (*LogoutCmd) Name() string     { return "logout" }
+func (*LogoutCmd) Synopsis() string { return "logout from a server" }
+func (*LogoutCmd) Usage() string {
+	return `Usage: cloudsave logout <SERVER_HOSTNAME>
+
+Options:
+`
+}
+
+func (p *LogoutCmd) SetFlags(f *flag.FlagSet) {
+}
+
+func (p *LogoutCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
+	if f.NArg() != 1 {
+		fmt.Fprintf(os.Stderr, "error: this command take 1 argument")
+		return subcommands.ExitUsageError
+	}
+
+	if err := credentials.Logout(f.Arg(0)); err != nil {
+		fmt.Fprintf(os.Stderr, "error: failed to logout: %s", err)
+		return subcommands.ExitFailure
+	}
+
+	fmt.Println("bye!")
+	return subcommands.ExitSuccess
+}

cmd/cli/commands/pull/pull.go

@@ -1,29 +1,29 @@
 package pull
 
 import (
-	"cloudsave/pkg/remote/client"
-	"cloudsave/pkg/repository"
-	"cloudsave/pkg/tools/archive"
 	"cloudsave/cmd/cli/tools/prompt/credentials"
+	"cloudsave/pkg/data"
+	"cloudsave/pkg/remote/client"
 	"context"
 	"flag"
 	"fmt"
 	"os"
-	"path/filepath"
 
 	"github.com/google/subcommands"
 )
 
 type (
 	PullCmd struct {
+		Service *data.Service
 	}
 )
 
 func (*PullCmd) Name() string     { return "pull" }
 func (*PullCmd) Synopsis() string { return "pull a game save from the remote" }
 func (*PullCmd) Usage() string {
-	return `list:
+	return `Usage: cloudsave pull <GAME_ID>
-  Pull a game save from the remote
+
+Pull a game save from the remote
 `
 }
 
@@ -41,47 +41,35 @@ func (p *PullCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 	gameID := f.Arg(1)
 	path := f.Arg(2)
 
-	username, password, err := credentials.Read()
+	username, password, err := credentials.Read(url)
 	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,16 +14,24 @@ import (
 
 type (
 	RemoteCmd struct {
-		set  bool
+		Service *data.Service
-		list bool
+		set     bool
+		list    bool
 	}
 )
 
 func (*RemoteCmd) Name() string     { return "remote" }
-func (*RemoteCmd) Synopsis() string { return "manage remote" }
+func (*RemoteCmd) Synopsis() string { return "add or update the remote url" }
 func (*RemoteCmd) Usage() string {
-	return `remote:
+	return `Usage: cloudsave remote <-set|-list>
-  manage remove
+
+The -list argument lists all remotes for each registered game.
+This command performs a connection test.
+
+The -set argument allow you to set (create or update) 
+the URL to the remote for a game
+
+Options
 `
 }
 
@@ -36,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
 			}
@@ -61,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)
 	}
@@ -70,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,14 +11,18 @@ import (
 )
 
 type (
-	RemoveCmd struct{}
+	RemoveCmd struct {
+		Service *data.Service
+	}
 )
 
 func (*RemoveCmd) Name() string     { return "remove" }
 func (*RemoveCmd) Synopsis() string { return "unregister a game" }
 func (*RemoveCmd) Usage() string {
-	return `remove:
+	return `Usage: cloudsave remove <GAME_ID>
-  Unregister a game
+
+Unregister a game
+Caution: all the backup are deleted
 `
 }
 
@@ -31,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,136 +1,54 @@
 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
 	}
 )
 
-func (*RunCmd) Name() string     { return "run" }
+func (*RunCmd) Name() string     { return "scan" }
-func (*RunCmd) Synopsis() string { return "Check and process all the folder" }
+func (*RunCmd) Synopsis() string { return "check and process all the folder" }
 func (*RunCmd) Usage() string {
-	return `run:
+	return `Usage: cloudsave scan
-  Check and process all the folder
+
+Check if the files have been modified. If so,
+the current archive is moved to the backup list
+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,14 +21,16 @@ import (
 
 type (
 	SyncCmd struct {
+		Service *data.Service
 	}
 )
 
 func (*SyncCmd) Name() string     { return "sync" }
 func (*SyncCmd) Synopsis() string { return "list all game registered" }
 func (*SyncCmd) Usage() string {
-	return `add:
+	return `Usage: cloudsave sync
-  List all game registered
+
+Synchronize the archives with the server defined for each game.
 `
 }
 
@@ -36,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
@@ -47,6 +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")
 				continue
 			}
 			fmt.Fprintln(os.Stderr, "error: failed to load datastore:", err)
@@ -63,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))
@@ -75,40 +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)
 			}
+			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 {
@@ -118,63 +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("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")
 			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 {
-				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
 			}
@@ -186,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))
@@ -206,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
 	}
@@ -257,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
@@ -269,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
 			}
 		}
@@ -290,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) {
@@ -304,7 +281,10 @@ func connect(remoteCred map[string]map[string]string, r remote.Remote) (*client.
 		return cli, nil
 	}
 
-	username, password, err := credentials.Read()
+	fmt.Println()
+	fmt.Println("Connexion to", r.URL)
+	fmt.Println("============")
+	username, password, err := credentials.Read(r.URL)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read std output: %w", err)
 	}

cmd/cli/commands/version/version.go

@@ -1,9 +1,9 @@
 package version
 
 import (
+	"cloudsave/cmd/cli/tools/prompt/credentials"
 	"cloudsave/pkg/constants"
 	"cloudsave/pkg/remote/client"
-	"cloudsave/cmd/cli/tools/prompt/credentials"
 	"context"
 	"flag"
 	"fmt"
@@ -23,8 +23,11 @@ type (
 func (*VersionCmd) Name() string     { return "version" }
 func (*VersionCmd) Synopsis() string { return "show version and system information" }
 func (*VersionCmd) Usage() string {
-	return `add:
+	return `Usage: cloudsave version [-a]
-  Show version and system information
+
+Print the version of the software
+
+Options:
 `
 }
 
@@ -39,7 +42,7 @@ func (p *VersionCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{
 			return subcommands.ExitUsageError
 		}
 
-		username, password, err := credentials.Read()
+		username, password, err := credentials.Read(f.Arg(0))
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "failed to read std output: %s", err)
 			return subcommands.ExitFailure

cmd/cli/main.go

@@ -2,34 +2,64 @@ package main
 
 import (
 	"cloudsave/cmd/cli/commands/add"
+	"cloudsave/cmd/cli/commands/apply"
 	"cloudsave/cmd/cli/commands/list"
+	"cloudsave/cmd/cli/commands/login"
+	"cloudsave/cmd/cli/commands/logout"
 	"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")
+	subcommands.Register(&login.LoginCmd{}, "remote")
+	subcommands.Register(&logout.LogoutCmd{}, "remote")
 
 	flag.Parse()
 	ctx := context.Background()

cmd/cli/tools/prompt/credentials/credentials.go

@@ -2,14 +2,48 @@ package credentials
 
 import (
 	"bufio"
+	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"golang.org/x/term"
 )
 
-func Read() (string, string, error) {
+type (
+	credential struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+	}
+
+	credentialsStore struct {
+		Store map[string]credential `json:"store"`
+	}
+)
+
+var (
+	datastorePath string
+)
+
+func init() {
+	roaming, err := os.UserConfigDir()
+	if err != nil {
+		panic("failed to get user config path: " + err.Error())
+	}
+	datastorePath = filepath.Join(roaming, "cloudsave")
+}
+
+func Read(server string) (string, string, error) {
+	var err error
+	store, err := load()
+	if err == nil {
+		if c, ok := store[server]; ok {
+			return c.Username, c.Password, nil
+		}
+	}
+
 	fmt.Print("Enter username: ")
 	reader := bufio.NewReader(os.Stdin)
 	username, _ := reader.ReadString('\n')
@@ -24,3 +58,66 @@ func Read() (string, string, error) {
 
 	return username, string(password), nil
 }
+
+func Login(username, password, server string) error {
+	store, err := load()
+	if err != nil {
+		return err
+	}
+
+	store[server] = credential{
+		Username: username,
+		Password: password,
+	}
+
+	return save(store)
+}
+
+func Logout(server string) error {
+	store, err := load()
+	if err != nil {
+		return err
+	}
+
+	delete(store, server)
+
+	return save(store)
+}
+
+func save(store map[string]credential) error {
+	c := credentialsStore{
+		Store: store,
+	}
+
+	f, err := os.OpenFile(filepath.Join(datastorePath, "credential.json"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	if err != nil {
+		return fmt.Errorf("failed to open datastore: %w", err)
+	}
+	defer f.Close()
+
+	e := json.NewEncoder(f)
+	if err := e.Encode(c); err != nil {
+		return fmt.Errorf("failed to encode data: %w", err)
+	}
+
+	return nil
+}
+
+func load() (map[string]credential, error) {
+	f, err := os.OpenFile(filepath.Join(datastorePath, "credential.json"), os.O_RDONLY, 0)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return make(map[string]credential), nil
+		}
+		return nil, fmt.Errorf("failed to open datastore: %w", err)
+	}
+	defer f.Close()
+
+	var c credentialsStore
+	d := json.NewDecoder(f)
+	if err := d.Decode(&c); err != nil {
+		return nil, fmt.Errorf("failed to decode data: %w", err)
+	}
+
+	return c.Store, nil
+}

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,25 @@ import (
 type (
 	HTTPServer struct {
 		Server       *http.Server
+		Service      *data.Service
 		documentRoot string
+		creds        map[string]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,
+		creds:        creds,
 	}
 	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)
@@ -48,7 +48,7 @@ func NewServer(documentRoot string, creds map[string]string, port int) *HTTPServ
 	router.Use(middleware.Compress(5, "application/gzip"))
 	router.Use(middleware.Heartbeat("/heartbeat"))
 	router.Route("/api", func(routerAPI chi.Router) {
-		routerAPI.Use(BasicAuth("cloudsave", creds))
+		routerAPI.Use(s.BasicAuth("cloudsave"))
 		routerAPI.Route("/v1", func(r chi.Router) {
 			// Get information about the server
 			r.Get("/version", s.Information)
@@ -62,7 +62,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)
@@ -81,44 +80,18 @@ func NewServer(documentRoot string, creds map[string]string, port int) *HTTPServ
 	return s
 }
 
+func (s *HTTPServer) SetCredentials(creds map[string]string) {
+	s.creds = creds
+}
+
 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 +99,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 +158,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 +182,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 +192,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 +226,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 +247,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 +275,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 +289,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/middlewares.go

@@ -20,7 +20,7 @@ func recoverMiddleware(next http.Handler) http.Handler {
 }
 
 // BasicAuth implements a simple middleware handler for adding basic http auth to a route.
-func BasicAuth(realm string, creds map[string]string) func(next http.Handler) http.Handler {
+func (s *HTTPServer) BasicAuth(realm string) func(next http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			user, pass, ok := r.BasicAuth()
@@ -29,7 +29,7 @@ func BasicAuth(realm string, creds map[string]string) func(next http.Handler) ht
 				return
 			}
 
-			credPass := creds[user]
+			credPass := s.creds[user]
 			if err := bcrypt.CompareHashAndPassword([]byte(credPass), []byte(pass)); err != nil {
 				basicAuthFailed(w, r, realm)
 				return

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,131 +0,0 @@
-package data
-
-import (
-	"cloudsave/pkg/repository"
-	"cloudsave/pkg/tools/hash"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-var (
-	ErrBackupNotExists error = errors.New("backup not found")
-)
-
-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
-	}
-
-	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")
-
-	finfo, err := os.Stat(dataFolderPath)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return repository.Backup{}, ErrBackupNotExists
-		}
-		return repository.Backup{}, err
-	}
-
-	h, err := hash.FileMD5(dataFolderPath)
-	if err != nil {
-		return repository.Backup{}, fmt.Errorf("failed to calculate file md5: %w", err)
-	}
-
-	return repository.Backup{
-		CreatedAt: finfo.ModTime(),
-		UUID:      uuid,
-		MD5:       h,
-	}, 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.go

@@ -5,12 +5,30 @@ package main
 import (
 	"fmt"
 	"os"
+	"os/signal"
+	"syscall"
 )
 
 const defaultDocumentRoot string = "/var/lib/cloudsave"
 
+var (
+	updateChan chan struct{}
+)
+
 func main() {
-	run()
+	updateChan = make(chan struct{})
+
+	sigc := make(chan os.Signal, 1)
+	signal.Notify(sigc, syscall.SIGHUP)
+
+	go func() {
+		for {
+			<-sigc
+			updateChan <- struct{}{}
+		}
+	}()
+
+	run(updateChan)
 }
 
 func fatal(message string, exitCode int) {

cmd/server/main_windows.go

@@ -2,16 +2,54 @@ 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
+
+var (
+	updateChan chan struct{}
+)
 
 func main() {
-	run()
+	updateChan = make(chan struct{})
+	go systray.Run(onReady, onExit)
+
+	run(updateChan)
 }
 
 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)
+
+	mReload := systray.AddMenuItem("Reload", "Reload the server data")
+	mQuit := systray.AddMenuItem("Quit", "Quit the server")
+
+	go func() {
+		<-mQuit.ClickedCh
+		os.Exit(0)
+	}()
+
+	go func() {
+		for {
+			<-mReload.ClickedCh
+			updateChan <- struct{}{}
+		}
+	}()
+}
+
+func onExit() {
+	// clean up here
+}

cmd/server/runner.go

@@ -4,30 +4,80 @@ 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"
 )
 
-func run() {
+func run(updateChan <-chan struct{}) {
 	fmt.Printf("CloudSave server -- v%s.%s.%s\n\n", constants.Version, runtime.GOOS, runtime.GOARCH)
 
 	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)
+		}
 
-	fmt.Println("starting server at :" + strconv.Itoa(port))
+		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)
+		}
+	}
+
+	slog.Info("repository loaded")
+	s := data.NewService(repo)
+
+	server := api.NewServer(documentRoot, s, h.Content(), port)
+
+	go func() {
+		for {
+			<-updateChan
+			if r, ok := repo.(*repository.EagerRepository); ok {
+				r.Reload()
+			}
+			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.SetCredentials(h.Content())
+		}
+	}()
+
+	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/config.template.json

@@ -0,0 +1,8 @@
+{
+    "server": {
+        "port": 8181
+    },
+    "remote": {
+        "url": "http://localhost:8080"
+    }
+}

cmd/web/server/config/config.go

@@ -0,0 +1,40 @@
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+type (
+	Configuration struct {
+		Server ServerConfiguration `json:"server"`
+		Remote RemoteConfiguration `json:"remote"`
+	}
+
+	ServerConfiguration struct {
+		Port int `json:"port"`
+	}
+
+	RemoteConfiguration struct {
+		URL string `json:"url"`
+	}
+)
+
+func Load(path string) (Configuration, error) {
+	f, err := os.OpenFile(path, os.O_RDONLY, 0)
+	if err != nil {
+		return Configuration{}, fmt.Errorf("failed to open configuration file: %w", err)
+	}
+	defer f.Close()
+
+	d := json.NewDecoder(f)
+
+	var c Configuration
+	err = d.Decode(&c)
+	if err != nil {
+		return Configuration{}, fmt.Errorf("failed to parse configuration file (%s): %w", path, err)
+	}
+
+	return c, nil
+}

cmd/web/server/middlewares.go

@@ -0,0 +1,63 @@
+package server
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"golang.org/x/crypto/bcrypt"
+)
+
+func recoverMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			err := recover()
+			if err != nil {
+				internalServerError(w, r)
+			}
+		}()
+		next.ServeHTTP(w, r)
+	})
+}
+
+// BasicAuth implements a simple middleware handler for adding basic http auth to a route.
+func BasicAuth(realm string, creds map[string]string) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			user, pass, ok := r.BasicAuth()
+			if !ok {
+				basicAuthFailed(w, r, realm)
+				return
+			}
+
+			credPass := creds[user]
+			if err := bcrypt.CompareHashAndPassword([]byte(credPass), []byte(pass)); err != nil {
+				basicAuthFailed(w, r, realm)
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		})
+	}
+}
+
+func basicAuthFailed(w http.ResponseWriter, r *http.Request, realm string) {
+	unauthorized(realm, w, r)
+}
+
+func unauthorized(realm string, w http.ResponseWriter, r *http.Request) {
+	w.Header().Add("WWW-Authenticate", fmt.Sprintf(`Basic realm="%s"`, realm))
+	w.WriteHeader(http.StatusUnauthorized)
+	_, err := w.Write([]byte(UnauthorizedErrorHTMLPage))
+	if err != nil {
+		log.Println(err)
+	}
+}
+
+func internalServerError(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusInternalServerError)
+	_, err := w.Write([]byte(InternalServerErrorHTMLPage))
+	if err != nil {
+		log.Println(err)
+	}
+}

cmd/web/server/server.go

@@ -0,0 +1,262 @@
+package server
+
+import (
+	"cloudsave/cmd/web/server/config"
+	"cloudsave/pkg/constants"
+	"cloudsave/pkg/remote/client"
+	"cloudsave/pkg/repository"
+	"errors"
+	"fmt"
+	"html/template"
+	"log/slog"
+	"net/http"
+	"runtime"
+	"slices"
+	"sync"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+
+	_ "embed"
+)
+
+type (
+	HTTPServer struct {
+		Server    *http.Server
+		Config    config.Configuration
+		Templates Templates
+	}
+
+	Templates struct {
+		Dashboard *template.Template
+		Detailled *template.Template
+		System    *template.Template
+	}
+)
+
+type (
+	DetaillePayload struct {
+		Version        string
+		Save           repository.Metadata
+		BackupMetadata []repository.Backup
+		Hash           string
+	}
+
+	DashboardPayload struct {
+		Version string
+		Saves   []repository.Metadata
+	}
+
+	SystemPayload struct {
+		Version string
+		Client  client.Information
+		Server  client.Information
+	}
+)
+
+var (
+	//go:embed templates/500.html
+	InternalServerErrorHTMLPage string
+
+	//go:embed templates/401.html
+	UnauthorizedErrorHTMLPage string
+
+	//go:embed templates/dashboard.html
+	DashboardHTMLPage string
+
+	//go:embed templates/detailled.html
+	DetailledHTMLPage string
+
+	//go:embed templates/information.html
+	SystemHTMLPage string
+)
+
+// NewServer start the http server
+func NewServer(c config.Configuration) *HTTPServer {
+	dashboardTemplate := template.New("dashboard")
+	dashboardTemplate.Parse(DashboardHTMLPage)
+
+	detailledTemplate := template.New("detailled")
+	detailledTemplate.Parse(DetailledHTMLPage)
+
+	systemTemplate := template.New("system")
+	systemTemplate.Parse(SystemHTMLPage)
+
+	s := &HTTPServer{
+		Config: c,
+		Templates: Templates{
+			Dashboard: dashboardTemplate,
+			Detailled: detailledTemplate,
+			System:    systemTemplate,
+		},
+	}
+	router := chi.NewRouter()
+	router.Use(middleware.Logger)
+	router.Use(recoverMiddleware)
+	router.Route("/web", func(routerAPI chi.Router) {
+		routerAPI.Get("/", s.dashboard)
+		routerAPI.Get("/{id}", s.detailled)
+		routerAPI.Get("/system", s.system)
+	})
+	s.Server = &http.Server{
+		Addr:    fmt.Sprintf(":%d", c.Server.Port),
+		Handler: router,
+	}
+	return s
+}
+
+func (s *HTTPServer) dashboard(w http.ResponseWriter, r *http.Request) {
+	user, pass, ok := r.BasicAuth()
+	if !ok {
+		basicAuthFailed(w, r, "realm")
+		return
+	}
+
+	cli := client.New(s.Config.Remote.URL, user, pass)
+
+	if err := cli.Ping(); err != nil {
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	saves, err := cli.All()
+	if err != nil {
+		if errors.Is(err, client.ErrUnauthorized) {
+			unauthorized("Unable to access resources", w, r)
+			return
+		}
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	slices.SortFunc(saves, func(a, b repository.Metadata) int {
+		return a.Date.Compare(b.Date)
+	})
+
+	slices.Reverse(saves)
+
+	payload := DashboardPayload{
+		Version: constants.Version,
+		Saves:   saves,
+	}
+
+	if err := s.Templates.Dashboard.Execute(w, payload); err != nil {
+		slog.Error("failed to render the html pages", "err", err)
+		return
+	}
+}
+
+func (s *HTTPServer) detailled(w http.ResponseWriter, r *http.Request) {
+	user, pass, ok := r.BasicAuth()
+	if !ok {
+		basicAuthFailed(w, r, "realm")
+		return
+	}
+
+	id := chi.URLParam(r, "id")
+	cli := client.New(s.Config.Remote.URL, user, pass)
+
+	if err := cli.Ping(); err != nil {
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	var wg sync.WaitGroup
+	var err1, err2 error
+	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("failed to get metadata: unable to connect to the remote", "err", err1)
+		return
+	}
+
+	wg = sync.WaitGroup{}
+
+	var bm []repository.Backup
+	for _, i := range ids {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			b, err := cli.ArchiveInfo(id, i)
+			if err != nil {
+				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,
+		BackupMetadata: bm,
+		Version:        constants.Version,
+	}
+
+	if err := s.Templates.Detailled.Execute(w, payload); err != nil {
+		slog.Error("failed to render the html pages", "err", err)
+		return
+	}
+}
+
+func (s *HTTPServer) system(w http.ResponseWriter, r *http.Request) {
+	user, pass, ok := r.BasicAuth()
+	if !ok {
+		basicAuthFailed(w, r, "realm")
+		return
+	}
+	cli := client.New(s.Config.Remote.URL, user, pass)
+
+	if err := cli.Ping(); err != nil {
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	clientInfo := client.Information{
+		Version:        constants.Version,
+		APIVersion:     constants.ApiVersion,
+		GoVersion:      runtime.Version(),
+		OSName:         runtime.GOOS,
+		OSArchitecture: runtime.GOARCH,
+	}
+	serverInfo, err := cli.Version()
+	if err != nil {
+		if errors.Is(err, client.ErrUnauthorized) {
+			unauthorized("Unable to access resources", w, r)
+			return
+		}
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	payload := SystemPayload{
+		Version: constants.Version,
+		Client:  clientInfo,
+		Server:  serverInfo,
+	}
+
+	if err := s.Templates.System.Execute(w, payload); err != nil {
+		slog.Error("failed to render the html pages", "err", err)
+		return
+	}
+}

cmd/web/server/templates/401.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>You are not allowed</title>
+    </head>
+    <body>
+        <h1>401 Unauthorized</h1>
+    </body>
+</html>

cmd/web/server/templates/500.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>An error occured</title>
+    </head>
+    <body>
+        <h1>500 Internal Server Error</h1>
+    </body>
+</html>

cmd/web/server/templates/dashboard.html

@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Dashboard</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-LN+7fdVzj6u52u30Kp6M/trliBMCMKTyK833zpbD+pXdCLuTusPj697FH4R/5mcr" crossorigin="anonymous">
+</head>
+
+<body>
+    <nav class="navbar bg-body-tertiary">
+        <div class="container-fluid">
+            <span class="navbar-brand mb-0 h1">CloudSave</span>
+            <a class="muted" href="/web/system">v{{.Version}}</a>
+        </div>
+    </nav>
+    <div class="container" style="margin-top: 1rem;">
+        <div class="list-group">
+            {{range .Saves}}
+            <a href="/web/{{.ID}}" class="list-group-item list-group-item-action">
+                <div class="d-flex w-100 justify-content-between">
+                    <h5 class="mb-1">{{.Name}}</h5>
+                    <small>{{.Date}}</small>
+                </div>
+                <p class="mb-1">Version: {{.Version}}</p>
+                <small>{{.ID}}</small>
+            </a>
+            {{end}}
+        </div>
+    </div>
+</body>
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/js/bootstrap.bundle.min.js"
+    integrity="sha384-ndDqU0Gzau9qJ1lfW4pNLlhNTkCfHzAVBReH9diLvGRem5+R9g2FzA8ZGN954O5Q"
+    crossorigin="anonymous"></script>
+
+</html>

cmd/web/server/templates/detailled.html

@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>{{.Save.Name}}</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-LN+7fdVzj6u52u30Kp6M/trliBMCMKTyK833zpbD+pXdCLuTusPj697FH4R/5mcr" crossorigin="anonymous">
+</head>
+
+<body>
+    <nav class="navbar bg-body-tertiary">
+        <div class="container-fluid">
+            <span class="navbar-brand mb-0 h1">CloudSave</span>
+            <a class="muted" href="/web/system">v{{.Version}}</a>
+        </div>
+    </nav>
+    <div class="container" style="margin-top: 1rem;">
+        <nav aria-label="breadcrumb">
+            <ol class="breadcrumb">
+                <li class="breadcrumb-item"><a href="/web">Home</a></li>
+                <li class="breadcrumb-item active" aria-current="page">{{.Save.ID}}</li>
+            </ol>
+        </nav>
+        <div class="list-group">
+            <h1>{{.Save.Name}} <span class="badge text-bg-success">Version {{.Save.Version}}</span></h1>
+            <hr />
+            <h3>Details</h3>
+            <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): {{.Save.MD5}}</li>
+            </ul>
+
+            <hr />
+            <h3>Backup</h3>
+            {{ range .BackupMetadata}}
+            <div class="card" style="margin-top: 1rem;">
+                <div class="card-body">
+                    <h5 class="card-title">{{.CreatedAt}}</h5>
+                    <h6 class="card-subtitle mb-2 text-body-secondary">{{.UUID}}</h6>
+                    <p class="card-text">MD5: {{.MD5}}</p>
+                </div>
+            </div>
+            {{end}}
+        </div>
+    </div>
+</body>
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/js/bootstrap.bundle.min.js"
+    integrity="sha384-ndDqU0Gzau9qJ1lfW4pNLlhNTkCfHzAVBReH9diLvGRem5+R9g2FzA8ZGN954O5Q"
+    crossorigin="anonymous"></script>
+
+</html>

cmd/web/server/templates/information.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>System Information</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-LN+7fdVzj6u52u30Kp6M/trliBMCMKTyK833zpbD+pXdCLuTusPj697FH4R/5mcr" crossorigin="anonymous">
+</head>
+
+<body>
+    <nav class="navbar bg-body-tertiary">
+        <div class="container-fluid">
+            <span class="navbar-brand mb-0 h1">CloudSave</span>
+            <span class="muted">v{{.Version}}</span>
+        </div>
+    </nav>
+    <div class="container" style="margin-top: 1rem;">
+        <nav aria-label="breadcrumb">
+            <ol class="breadcrumb">
+                <li class="breadcrumb-item"><a href="/web">Home</a></li>
+                <li class="breadcrumb-item active" aria-current="page">System</li>
+            </ol>
+        </nav>
+        <div class="list-group">
+            <h3>Client</h3>
+            <hr />
+            <ul class="list-group list-group-flush">
+                <li class="list-group-item">Version: {{.Client.Version}}</li>
+                <li class="list-group-item">API Version: {{.Client.APIVersion}}</li>
+                <li class="list-group-item">Go Version: {{.Client.GoVersion}}</li>
+                <li class="list-group-item">OS: {{.Client.OSName}}/{{.Client.OSArchitecture}}</li>
+            </ul>
+
+            <hr />
+            <h3>Server</h3>
+            <hr />
+            <ul class="list-group list-group-flush">
+                <li class="list-group-item">Version: {{.Server.Version}}</li>
+                <li class="list-group-item">API Version: {{.Server.APIVersion}}</li>
+                <li class="list-group-item">Go Version: {{.Server.GoVersion}}</li>
+                <li class="list-group-item">OS: {{.Server.OSName}}/{{.Server.OSArchitecture}}</li>
+            </ul>
+        </div>
+    </div>
+</body>
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/js/bootstrap.bundle.min.js"
+    integrity="sha384-ndDqU0Gzau9qJ1lfW4pNLlhNTkCfHzAVBReH9diLvGRem5+R9g2FzA8ZGN954O5Q"
+    crossorigin="anonymous"></script>
+
+</html>

cmd/web/web.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"cloudsave/cmd/web/server"
+	"cloudsave/cmd/web/server/config"
+	"cloudsave/pkg/constants"
+	"flag"
+	"fmt"
+	"os"
+	"runtime"
+	"strconv"
+)
+
+func main() {
+	fmt.Printf("CloudSave web -- v%s.%s.%s\n\n", constants.Version, runtime.GOOS, runtime.GOARCH)
+
+	var configPath string
+	flag.StringVar(&configPath, "config", "/var/lib/cloudsave/config.json", "Define the path to the configuration file")
+	flag.Parse()
+
+	c, err := config.Load(configPath)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "failed to load configuration:", err)
+		os.Exit(1)
+	}
+
+	s := server.NewServer(c)
+
+	fmt.Println("starting server at :" + strconv.Itoa(c.Server.Port))
+	if err := s.Server.ListenAndServe(); err != nil {
+		fmt.Fprintln(os.Stderr, "failed to start web server:", err)
+		os.Exit(1)
+	}
+}

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,19 @@
+pipeline {
+    agent any
+
+    stages {
+        stage('Audit') {
+            steps {
+                sh '''
+                go install github.com/securego/gosec/v2/cmd/gosec@v2.22.8
+                /var/lib/jenkins/go/bin/gosec ./...
+                '''
+            }
+        }
+        stage('Build') {
+            steps {
+                sh './build.sh'
+            }
+        }
+    }
+}

pkg/constants/constants.go

@@ -1,5 +1,5 @@
 package constants
 
-const Version = "0.0.2"
+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

@@ -36,7 +36,8 @@ type (
 )
 
 var (
-	ErrNotFound error = errors.New("not found")
+	ErrNotFound     error = errors.New("not found")
+	ErrUnauthorized error = errors.New("unauthorized (HTTP Error 401)")
 )
 
 func New(baseURL, username, password string) *Client {
@@ -48,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
 	}
@@ -103,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) {
@@ -138,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
 	}
@@ -174,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 {
@@ -227,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)
@@ -249,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
@@ -275,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)
 	}
 
@@ -294,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)
@@ -342,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 {
@@ -351,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)
 			}
@@ -382,6 +394,10 @@ func (c *Client) get(url string) (obj.HTTPObject, error) {
 		return obj.HTTPObject{}, ErrNotFound
 	}
 
+	if res.StatusCode == 401 {
+		return obj.HTTPObject{}, ErrUnauthorized
+	}
+
 	if res.StatusCode != 200 {
 		return obj.HTTPObject{}, fmt.Errorf("server returns an unexpected status code: %d %s (expected 200)", res.StatusCode, res.Status)
 	}

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,556 @@ 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()
+
+	slog.Info("loading data from datastore to memory...")
+	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) ClearCache() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	slog.Info("clearing cache...")
+	for k := range r.data {
+		delete(r.data, k)
+	}
+}
+
+func (r *EagerRepository) Reload() error {
+	r.ClearCache()
+	return r.Preload()
+}
+
+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