thelilfrog/cloudsave
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases 8 Wiki Activity

wip

Browse Source
This commit is contained in:
Aurélie DELHAIE
2025-08-09 22:19:57 +02:00
parent 13adb26fba
commit 810c5ac627
13 changed files with 605 additions and 790 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
cmd/cli/commands/add/add.go
View File

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

35
cmd/cli/commands/apply/apply.go
View File

@@ -1,13 +1,10 @@
package apply
import (
"cloudsave/pkg/repository"
"cloudsave/pkg/tools/archive"
"context"
"flag"
"fmt"
"os"
"path/filepath"
"github.com/google/subcommands"
)
@@ -35,36 +32,10 @@ func (p *ListCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
return subcommands.ExitUsageError
}
gameID := f.Arg(0)
uuid := f.Arg(1)
//gameID := f.Arg(0)
//uuid := f.Arg(1)
g, err := repository.One(gameID)
if err != nil {
fmt.Fprintf(os.Stderr, "error: failed to open game metadata: %s\n", err)
return subcommands.ExitFailure
}
if err := repository.RestoreArchive(gameID, uuid); err != nil {
fmt.Fprintf(os.Stderr, "error: failed to restore backup: %s\n", 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
}
panic("not implemented")
return subcommands.ExitSuccess
}

21
cmd/cli/commands/list/list.go
View File

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

43
cmd/cli/commands/pull/pull.go
View File

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

13
cmd/cli/commands/remote/remote.go
View File

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

8
cmd/cli/commands/remove/remove.go
View File

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

100
cmd/cli/commands/run/run.go
View File

@@ -1,22 +1,18 @@
package run
import (
"cloudsave/pkg/repository"
"cloudsave/pkg/tools/archive"
"cloudsave/pkg/data"
"context"
"flag"
"fmt"
"io"
"os"
"path/filepath"
"time"
"github.com/google/subcommands"
"github.com/schollz/progressbar/v3"
)
type (
RunCmd struct {
Service *data.Service
}
)
@@ -34,26 +30,15 @@ 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)
//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)
return subcommands.ExitFailure
}
if err := repository.SetVersion(metadata.ID, metadata.Version+1); err != nil {
fmt.Fprintf(os.Stderr, "error: cannot process the data of %s: %s\n", metadata.ID, err)
return subcommands.ExitFailure
}
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)
if err := p.Service.Scan(metadata.ID); err != nil {
fmt.Fprintln(os.Stderr, "error: failed to scan:", err)
return subcommands.ExitFailure
}
fmt.Println("✅", metadata.Name)
@@ -62,78 +47,3 @@ func (p *RunCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) s
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
}

96
cmd/cli/commands/sync/sync.go
View File

@@ -3,6 +3,7 @@ package sync
import (
"cloudsave/cmd/cli/tools/prompt"
"cloudsave/cmd/cli/tools/prompt/credentials"
"cloudsave/pkg/data"
"cloudsave/pkg/remote"
"cloudsave/pkg/remote/client"
"cloudsave/pkg/repository"
@@ -12,7 +13,6 @@ import (
"fmt"
"log/slog"
"os"
"path/filepath"
"time"
"github.com/google/subcommands"
@@ -21,6 +21,7 @@ import (
type (
SyncCmd struct {
Service *data.Service
}
)
@@ -37,7 +38,7 @@ func (p *SyncCmd) SetFlags(f *flag.FlagSet) {
}
func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
games, err := repository.All()
games, err := p.Service.AllGames()
if err != nil {
fmt.Fprintln(os.Stderr, "error: failed to load datastore:", err)
return subcommands.ExitFailure
@@ -92,12 +93,6 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
}
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 {
@@ -106,13 +101,6 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
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 {
destroyPg()
@@ -130,11 +118,11 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
slog.Warn("failed to push backup files", "err", err)
}
if hlocal == hremote {
if g.MD5 == hremote {
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
}
@@ -143,7 +131,7 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
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 {
destroyPg()
@@ -155,22 +143,21 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
continue
}
if vlocal < remoteMetadata.Version {
if g.Version < remoteMetadata.Version {
destroyPg()
if err := pull(r.GameID, 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)
continue
}
if err := repository.SetDate(r.GameID, remoteMetadata.Date); err != nil {
destroyPg()
fmt.Fprintln(os.Stderr, "error: failed to synchronize date:", err)
continue
fmt.Fprintln(os.Stderr, "failed to push:", err)
return subcommands.ExitFailure
}
fmt.Println(g.Name + ": pulled")
continue
@@ -178,8 +165,8 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
destroyPg()
if vlocal == remoteMetadata.Version {
if err := conflict(r.GameID, g, remoteMetadata, cli); err != nil {
if g.Version == remoteMetadata.Version {
if err := p.conflict(r.GameID, g, remoteMetadata, cli); err != nil {
fmt.Fprintln(os.Stderr, "error: failed to resolve conflict:", err)
continue
}
@@ -191,8 +178,8 @@ 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 {
g, err := repository.One(gameID)
func (p *SyncCmd) conflict(gameID string, m, remoteMetadata repository.Metadata, cli *client.Client) error {
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)
@@ -211,35 +198,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(gameID, cli); err != nil {
return fmt.Errorf("failed to push: %w", err)
}
if err := repository.SetVersion(gameID, remoteMetadata.Version); err != nil {
return fmt.Errorf("failed to synchronize version number: %w", err)
}
if err := repository.SetDate(gameID, remoteMetadata.Date); err != nil {
return fmt.Errorf("failed to synchronize date: %w", err)
g.Version = remoteMetadata.Version
g.Date = remoteMetadata.Date
if err := p.Service.UpdateMetadata(g.ID, g); err != nil {
return fmt.Errorf("failed to push: %w", err)
}
}
}
return nil
}
func push(m repository.Metadata, cli *client.Client) error {
archivePath := filepath.Join(repository.DatastorePath(), m.ID, "data.tar.gz")
return cli.PushSave(archivePath, m)
func (p *SyncCmd) push(m repository.Metadata, cli *client.Client) error {
}
func pushBackup(m repository.Metadata, cli *client.Client) error {
bs, err := repository.Archives(m.ID)
func (p *SyncCmd) pushBackup(m repository.Metadata, cli *client.Client) error {
bs, err := p.Service.AllBackups(m.ID)
if err != nil {
return err
}
@@ -262,7 +247,7 @@ func pushBackup(m repository.Metadata, cli *client.Client) error {
return nil
}
func pullBackup(m repository.Metadata, cli *client.Client) error {
func (p *SyncCmd) pullBackup(m repository.Metadata, cli *client.Client) error {
bs, err := cli.ListArchives(m.ID)
if err != nil {
return err
@@ -274,20 +259,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 err := cli.PullBackup(m.ID, uuid, filepath.Join(path, "data.tar.gz")); err != nil {
if linfo != rinfo {
if err := p.Service.PullBackup(m.ID, uuid, cli); err != nil {
return err
}
}
@@ -295,10 +273,8 @@ func pullBackup(m repository.Metadata, cli *client.Client) error {
return nil
}
func pull(gameID string, cli *client.Client) error {
archivePath := filepath.Join(repository.DatastorePath(), gameID, "data.tar.gz")
return cli.Pull(gameID, archivePath)
func (p *SyncCmd) pull(gameID string, cli *client.Client) error {
return p.Service.PullArchive(gameID, "", cli)
}
func connect(remoteCred map[string]map[string]string, r remote.Remote) (*client.Client, error) {