change version

.vscode/launch.json

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

cmd/cli/commands/add/add.go

@@ -56,7 +56,7 @@ func (p *AddCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) s
 		return subcommands.ExitFailure
 	}
 
-	if err := p.Service.Scan(gameID); err != nil {
+	if _, err := p.Service.Scan(gameID); err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to scan:", err)
 		return subcommands.ExitFailure
 	}

cmd/cli/commands/run/run.go

@@ -37,15 +37,16 @@ func (p *RunCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) s
 	}
 
 	for _, metadata := range datastore {
-		if err := p.Service.MakeBackup(metadata.ID); err != nil {
-			fmt.Fprintln(os.Stderr, "error: failed to make backup:", err)
-			return subcommands.ExitFailure
+		changed, err := p.Service.Scan(metadata.ID)
+		if err != nil {
+			fmt.Println("❌", metadata.Name, ":", err.Error())
+			continue
 		}
-		if err := p.Service.Scan(metadata.ID); err != nil {
-			fmt.Fprintln(os.Stderr, "error: failed to scan:", err)
-			return subcommands.ExitFailure
+		if changed {
+			fmt.Println("✅", metadata.Name, ": backed up")
+		} else {
+			fmt.Println("🆗", metadata.Name, ": up to date")
 		}
-		fmt.Println("✅", metadata.Name)
 	}
 
 	fmt.Println("done.")

cmd/cli/commands/sync/sync.go

@@ -66,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))
@@ -88,19 +87,13 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 				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))
 
-		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
-		}
-
 		remoteMetadata, err := cli.Metadata(r.GameID)
 		if err != nil {
 			destroyPg()
@@ -118,7 +111,7 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 			slog.Warn("failed to push backup files", "err", err)
 		}
 
-		if g.MD5 == hremote {
+		if g.MD5 == remoteMetadata.MD5 {
 			destroyPg()
 			if g.Version != remoteMetadata.Version {
 				slog.Debug("version is not the same, but the hash is equal. Updating local database")

cmd/server/api/api.go

@@ -60,7 +60,6 @@ func NewServer(documentRoot string, srv *data.Service, creds map[string]string,
 					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)
@@ -165,6 +164,12 @@ func (s HTTPServer) upload(w http.ResponseWriter, r *http.Request) {
 		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
+	}
+
 	// Respond success
 	w.WriteHeader(http.StatusCreated)
 }
@@ -216,7 +221,13 @@ func (s HTTPServer) histUpload(w http.ResponseWriter, r *http.Request) {
 	defer file.Close()
 
 	if err := s.Service.CopyBackup(gameID, uuid, file); err != nil {
-		fmt.Fprintln(os.Stderr, "error: failed to write data 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
 	}
@@ -272,23 +283,6 @@ 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")
-
-	m, err := s.Service.One(id)
-	if err != nil {
-		if errors.Is(err, repository.ErrNotFound) {
-			notFound("not found", w, r)
-			return
-		}
-		fmt.Fprintln(os.Stderr, "error: an error occured while calculating the hash:", err)
-		internalServerError(w, r)
-		return
-	}
-
-	ok(m.MD5, w, r)
-}
-
 func (s HTTPServer) metadata(w http.ResponseWriter, r *http.Request) {
 	id := chi.URLParam(r, "id")
 	metadata, err := s.Service.One(id)

cmd/web/server/server.go

@@ -162,9 +162,8 @@ func (s *HTTPServer) detailled(w http.ResponseWriter, r *http.Request) {
 	}
 
 	var wg sync.WaitGroup
-	var err1, err2, err3 error
+	var err1, err2 error
 	var save repository.Metadata
-	var h string
 	var ids []string
 
 	wg.Add(1)
@@ -175,24 +174,18 @@ func (s *HTTPServer) detailled(w http.ResponseWriter, r *http.Request) {
 
 	wg.Add(1)
 	go func() {
-		h, err2 = cli.Hash(id)
-		wg.Done()
-	}()
-
-	wg.Add(1)
-	go func() {
-		ids, err3 = cli.ListArchives(id)
+		ids, err2 = cli.ListArchives(id)
 		wg.Done()
 	}()
 
 	wg.Wait()
 
-	if err1 != nil || err2 != nil || err3 != nil {
+	if err1 != nil || err2 != nil {
 		if errors.Is(err1, client.ErrUnauthorized) {
 			unauthorized("Unable to access resources", w, r)
 			return
 		}
-		slog.Error("unable to connect to the remote", "err", err1)
+		slog.Error("failed to get metadata: unable to connect to the remote", "err", err1)
 		return
 	}
 
@@ -205,7 +198,7 @@ func (s *HTTPServer) detailled(w http.ResponseWriter, r *http.Request) {
 			defer wg.Done()
 			b, err := cli.ArchiveInfo(id, i)
 			if err != nil {
-				slog.Error("unable to connect to the remote", "err", err)
+				slog.Error("failed to get backup: unable to connect to the remote", "err", err)
 				return
 			}
 			bm = append(bm, b)
@@ -216,7 +209,6 @@ func (s *HTTPServer) detailled(w http.ResponseWriter, r *http.Request) {
 
 	payload := DetaillePayload{
 		Save:           save,
-		Hash:           h,
 		BackupMetadata: bm,
 		Version:        constants.Version,
 	}

cmd/web/server/templates/detailled.html

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

pkg/constants/constants.go

@@ -1,5 +1,5 @@
 package constants
 
-const Version = "0.0.4b"
+const Version = "0.0.4c"
 
 const ApiVersion = 1

pkg/data/data.go

@@ -4,6 +4,7 @@ import (
 	"cloudsave/pkg/remote/client"
 	"cloudsave/pkg/repository"
 	"cloudsave/pkg/tools/archive"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -82,47 +83,51 @@ func (s *Service) UpdateMetadata(gameID string, m repository.Metadata) error {
 	return nil
 }
 
-func (s *Service) Scan(gameID string) error {
+func (s *Service) Scan(gameID string) (bool, error) {
 	id := repository.NewGameIdentifier(gameID)
 
 	lastRun, err := s.repo.LastScan(id)
 	if err != nil {
-		return fmt.Errorf("failed to get last scan time: %w", err)
+		return false, fmt.Errorf("failed to get last scan time: %w", err)
 	}
 
 	m, err := s.repo.Metadata(id)
 	if err != nil {
-		return fmt.Errorf("failed to get game metadata: %w", err)
+		return false, fmt.Errorf("failed to get game metadata: %w", err)
 	}
 
 	if !IsDirectoryChanged(m.Path, lastRun) {
-		return nil
+		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 fmt.Errorf("failed to get datastore stream: %w", err)
+		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 fmt.Errorf("failed to make archive: %w", err)
+		return false, fmt.Errorf("failed to make archive: %w", err)
 	}
 
 	if err := s.repo.ResetLastScan(id); err != nil {
-		return fmt.Errorf("failed to reset scan date: %w", err)
+		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 fmt.Errorf("failed to update metadata: %w", err)
+		return false, fmt.Errorf("failed to update metadata: %w", err)
 	}
 
-	return nil
+	return true, nil
 }
 
 func (s *Service) MakeBackup(gameID string) error {
@@ -130,6 +135,9 @@ func (s *Service) MakeBackup(gameID string) error {
 
 	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 {
@@ -374,6 +382,13 @@ 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)

pkg/remote/client/client.go

@@ -49,7 +49,7 @@ func New(baseURL, username, password string) *Client {
 }
 
 func (c *Client) Exists(gameID string) (bool, error) {
-	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "hash")
+	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "metadata")
 	if err != nil {
 		return false, err
 	}
@@ -104,22 +104,13 @@ func (c *Client) Version() (Information, error) {
 	return Information{}, errors.New("invalid payload sent by the server")
 }
 
+// Deprecated: use c.Metadata instead
 func (c *Client) Hash(gameID string) (string, error) {
-	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "hash")
+	m, err := c.Metadata(gameID)
 	if err != nil {
 		return "", err
 	}
-
-	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")
+	return m.MD5, nil
 }
 
 func (c *Client) Metadata(gameID string) (repository.Metadata, error) {
@@ -139,6 +130,7 @@ func (c *Client) Metadata(gameID string) (repository.Metadata, error) {
 			Name:    m["name"].(string),
 			Version: int(m["version"].(float64)),
 			Date:    customtime.MustParse(time.RFC3339, m["date"].(string)),
+			MD5:     m["md5"].(string),
 		}
 		return gm, nil
 	}
@@ -175,6 +167,10 @@ func (c *Client) ListArchives(gameID string) ([]string, error) {
 		return nil, err
 	}
 
+	if o.Data == nil {
+		return nil, nil
+	}
+
 	if m, ok := (o.Data).([]any); ok {
 		var res []string
 		for _, uuid := range m {
@@ -346,6 +342,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 {
@@ -355,6 +355,7 @@ func (c *Client) All() ([]repository.Metadata, error) {
 					Name:    v["name"].(string),
 					Version: int(v["version"].(float64)),
 					Date:    customtime.MustParse(time.RFC3339, v["date"].(string)),
+					MD5:     v["md5"].(string),
 				}
 				res = append(res, gm)
 			}

pkg/repository/repository.go

@@ -9,6 +9,7 @@ import (
 	"log/slog"
 	"os"
 	"path/filepath"
+	"sync"
 	"time"
 )
 
@@ -19,7 +20,7 @@ type (
 		Path    string    `json:"path"`
 		Version int       `json:"version"`
 		Date    time.Time `json:"date"`
-		MD5     string    `json:"-"`
+		MD5     string    `json:"md5,omitempty"`
 	}
 
 	Remote struct {
@@ -61,6 +62,7 @@ type (
 	EagerRepository struct {
 		Repository
 
+		mu   sync.RWMutex
 		data map[string]Data
 	}
 
@@ -189,6 +191,7 @@ func (l *LazyRepository) WriteBlob(ID Identifier) (io.Writer, error) {
 }
 
 func (l *LazyRepository) WriteMetadata(id GameIdentifier, m Metadata) error {
+	m.MD5 = ""
 	path := l.DataPath(id)
 
 	slog.Debug("writing metadata", "id", id, "metadata", m)
@@ -310,6 +313,9 @@ func (l *LazyRepository) ReadBlob(id Identifier) (io.ReadSeekCloser, error) {
 	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)
 	}
 
@@ -392,6 +398,9 @@ func NewEagerRepository(dataRootPath string) (*EagerRepository, error) {
 }
 
 func (r *EagerRepository) Preload() error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
 	games, err := r.Repository.All()
 	if err != nil {
 		return fmt.Errorf("failed to load all data: %w", err)
@@ -435,6 +444,9 @@ func (r *EagerRepository) Preload() error {
 }
 
 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)
@@ -444,6 +456,9 @@ func (r *EagerRepository) All() ([]string, error) {
 }
 
 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 {
@@ -454,6 +469,9 @@ func (r *EagerRepository) AllHist(id GameIdentifier) ([]string, error) {
 }
 
 func (r *EagerRepository) WriteMetadata(id GameIdentifier, m Metadata) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
 	err := r.Repository.WriteMetadata(id, m)
 	if err != nil {
 		return err
@@ -467,6 +485,9 @@ func (r *EagerRepository) WriteMetadata(id GameIdentifier, m Metadata) error {
 }
 
 func (r *EagerRepository) Metadata(id GameIdentifier) (Metadata, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
 	if d, ok := r.data[id.gameID]; ok {
 		return d.Metadata, nil
 	}
@@ -474,6 +495,9 @@ func (r *EagerRepository) Metadata(id GameIdentifier) (Metadata, error) {
 }
 
 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
@@ -483,6 +507,9 @@ func (r *EagerRepository) Backup(id BackupIdentifier) (Backup, error) {
 }
 
 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
@@ -499,6 +526,9 @@ func (r *EagerRepository) SetRemote(id GameIdentifier, url string) error {
 }
 
 func (r *EagerRepository) Remove(id GameIdentifier) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
 	if err := r.Repository.Remove(id); err != nil {
 		return err
 	}
@@ -506,3 +536,39 @@ func (r *EagerRepository) Remove(id GameIdentifier) error {
 	delete(r.data, id.gameID)
 	return nil
 }
+
+func (r *EagerRepository) ReloadMetadata(id GameIdentifier) error {
+	backup, err := r.Repository.AllHist(id)
+	if err != nil {
+		return fmt.Errorf("[%s] failed to load hist data: %w", id, err)
+	}
+
+	remote, err := r.Repository.Remote(id)
+	if err != nil {
+		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
+}