load remote configuration from flags and setup the fuse fs

creativeprojects · creativeprojects · commit d4194446a70b · 2024-07-04T16:34:13.000+01:00
diff --git a/commands.go b/commands.go
@@ -165,6 +165,7 @@ func getOwnCommands() []ownCommand {
 			needConfiguration: true,
 			noProfile:         true,
 			hide:              true,
+			experimental:      true,
 		},
 		{
 			name:              "serve",
@@ -173,14 +174,7 @@ func getOwnCommands() []ownCommand {
 			needConfiguration: true,
 			noProfile:         true,
 			hide:              true,
-		},
-		{
-			name:              "mount-config",
-			description:       "mount virtual filesystem from remote configuration files",
-			action:            mountConfigCommand,
-			needConfiguration: false,
-			noProfile:         true,
-			hide:              true,
+			experimental:      true,
 		},
 	}
 }
diff --git a/constants/exit_code.go b/constants/exit_code.go
@@ -0,0 +1,10 @@
+package constants
+
+const (
+	ExitSuccess = iota
+	ExitGeneralError
+	ExitErrorInvalidFlags
+	ExitRunningOnBattery
+	ExitCannotSetupRemoteConfiguration
+	ExitErrorChildHasNoParentPort = 10
+)
diff --git a/examples/linux.yaml b/examples/linux.yaml
@@ -79,11 +79,14 @@ self:
     backup:
         extended-status: true
         source: ./
+        exclude-file:
+            - root-excludes
+            - excludes
     copy:
         initialize: true
         schedule-permission: user
         schedule:
-          - "*:45"
+            - "*:45"
 
 src:
     inherit: default
@@ -92,18 +95,18 @@ src:
     backup:
         check-before: true
         exclude:
-        - /**/.git
+            - /**/.git
         exclude-caches: true
         one-file-system: false
         run-after: echo All Done!
         run-before:
-        - echo Starting!
-        - ls -al ~/go
+            - echo Starting!
+            - ls -al ~/go
         source:
-        - ~/go
+            - ~/go
         tag:
-        - test
-        - dev
+            - test
+            - dev
     retention:
         after-backup: true
         before-backup: false
@@ -112,8 +115,8 @@ src:
         prune: true
     snapshots:
         tag:
-        - test
-        - dev
+            - test
+            - dev
         
 stdin:
     inherit: default
diff --git a/fuse/memfs.go b/fuse/memfs.go
@@ -1,7 +1,6 @@
 //go:build !windows
 
-// Simple implementation of a read-only filesystem in memory from a TAR file.
-// We don't want any file from the TAR to be saved on the disk
+// Simple implementation of a read-only filesystem in memory.
 //
 // Based on the examples at https://pkg.go.dev/github.com/hanwen/go-fuse/v2/fs#pkg-examples
 package fuse
diff --git a/fuse/memfs_test.go b/fuse/memfs_test.go
@@ -10,8 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/hanwen/go-fuse/v2/fs"
-	"github.com/hanwen/go-fuse/v2/fuse"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -50,20 +48,13 @@ func TestMemFS(t *testing.T) {
 		})
 	}
 
-	memFS := newMemFS(files)
-
 	mnt := t.TempDir()
-	opts := &fs.Options{
-		MountOptions: fuse.MountOptions{
-			Debug: false, // generates a LOT of logs
-		},
-	}
-	server, err := fs.Mount(mnt, memFS, opts)
+	closeMount, err := MountFS(mnt, files)
 	if err != nil && strings.Contains(err.Error(), "no FUSE mount utility found") {
 		t.Skip("no FUSE mount utility found")
 	}
 	require.NoError(t, err, "cannot mount FS")
-	defer server.Unmount()
+	defer closeMount()
 
 	for filename, fileContents := range memfsContents {
 		fullPath := filepath.Join(mnt, filename)
diff --git a/fuse/memfs_windows_test.go b/fuse/memfs_windows_test.go
@@ -0,0 +1,14 @@
+//go:build windows
+
+package fuse
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMountFS(t *testing.T) {
+	_, err := MountFS("mnt", []File{})
+	assert.Error(t, err)
+}
diff --git a/fuse/mount.go b/fuse/mount.go
@@ -4,23 +4,15 @@ package fuse
 
 import (
 	"fmt"
-	"math/rand"
-	"os"
-	"path/filepath"
 
 	"github.com/creativeprojects/clog"
 	"github.com/hanwen/go-fuse/v2/fs"
 	"github.com/hanwen/go-fuse/v2/fuse"
 )
 
-func MountFS(files []File) (func(), error) {
+func MountFS(mountpoint string, files []File) (func(), error) {
 	memFS := newMemFS(files)
 
-	mountpoint := filepath.Join(os.TempDir(), fmt.Sprintf("%s-%x", "resticprofile", rand.Uint32()))
-	err := os.MkdirAll(mountpoint, 0o755)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create mount directory: %w", err)
-	}
 	clog.Debugf("mounting filesystem at %s", mountpoint)
 
 	opts := &fs.Options{
@@ -36,14 +28,12 @@ func MountFS(files []File) (func(), error) {
 		return nil, fmt.Errorf("failed to mount filesystem: %w", err)
 	}
 	close := func() {
-		err := server.Unmount()
+		clog.Debug("unmounting filesystem")
+		err := server.Unmount() // don't need to call Wait after Unmount
 		if err != nil {
 			clog.Errorf("failed to unmount filesystem: %v", err)
 		}
-		err = os.Remove(mountpoint)
-		if err != nil {
-			clog.Errorf("failed to remove mountpoint: %v", err)
-		}
+
 		memFS.Close()
 	}
 	return close, nil
diff --git a/fuse/mount_windows.go b/fuse/mount_windows.go
@@ -2,6 +2,6 @@ package fuse
 
 import "errors"
 
-func MountFS(files []File) (func(), error) {
+func MountFS(_ string, _ []File) (func(), error) {
 	return nil, errors.New("not supported on Windows")
 }
diff --git a/main.go b/main.go
@@ -142,6 +142,19 @@ func main() {
 
 	banner()
 
+	if flags.remote != "" {
+		closeFS, err := setupRemoteConfiguration(flags.remote)
+		if err != nil {
+			// need to setup console logging to display the error message
+			closeLogger := setupLogging(nil)
+			defer closeLogger()
+			clog.Error(err)
+			exitCode = constants.ExitCannotSetupRemoteConfiguration
+			return
+		}
+		shutdown.AddHook(closeFS)
+	}
+
 	// resticprofile own commands (configuration file may not be loaded)
 	if len(flags.resticArgs) > 0 {
 		if ownCommands.Exists(flags.resticArgs[0], false) {
@@ -280,21 +293,22 @@ func banner() {
 func loadConfig(flags commandLineFlags, silent bool) (cfg *config.Config, global *config.Global, err error) {
 	fs := afero.NewOsFs()
 
-	if flags.remote != "" {
-		// fs = afero.NewMemMapFs()
-		// parameters, err := loadRemoteConfiguration(fs, flags.remote)
-		_, parameters, err := loadRemoteFiles(flags.remote)
-		if err != nil {
-			return nil, nil, fmt.Errorf("cannot load remote configuration: %w", err)
-		}
-		// we should probably move this to the context (and keep flags intact)
-		if flags.config == constants.DefaultConfigurationFile {
-			flags.config = parameters.ConfigurationFile
-		}
-		if flags.name == constants.DefaultProfileName {
-			flags.name = parameters.ProfileName
-		}
-	}
+	// if flags.remote != "" {
+	// 	// fs = afero.NewMemMapFs()
+	// 	// parameters, err := loadRemoteConfiguration(fs, flags.remote)
+	// 	os.Chdir()
+	// 	_, parameters, err := loadRemoteFiles(flags.remote)
+	// 	if err != nil {
+	// 		return nil, nil, fmt.Errorf("cannot load remote configuration: %w", err)
+	// 	}
+	// 	// we should probably move this to the context (and keep flags intact)
+	// 	if flags.config == constants.DefaultConfigurationFile {
+	// 		flags.config = parameters.ConfigurationFile
+	// 	}
+	// 	if flags.name == constants.DefaultProfileName {
+	// 		flags.name = parameters.ProfileName
+	// 	}
+	// }
 
 	var configFile string
 	if configFile, err = filesearch.FindConfigurationFile(fs, flags.config); err == nil {
diff --git a/mount_config.go b/mount_config.go
diff --git a/own_commands.go b/own_commands.go
@@ -5,6 +5,8 @@ import (
 	"io"
 	"os"
 	"strings"
+
+	"github.com/creativeprojects/clog"
 )
 
 // commandContext is the context for running a command.
@@ -23,6 +25,7 @@ type ownCommand struct {
 	hide              bool                                  // don't display the command in help and completion
 	hideInCompletion  bool                                  // don't display the command in completion
 	noProfile         bool                                  // true if the command doesn't need a profile name
+	experimental      bool                                  // display a warning when using this command
 	flags             map[string]string                     // own command flags should be simple enough to be handled manually for now
 }
 
@@ -61,6 +64,9 @@ func (o *OwnCommands) Run(ctx *Context) error {
 	if command == nil {
 		return fmt.Errorf("command not found: %v", ctx.request.command)
 	}
+	if command.experimental {
+		clog.Warning("this command is experimental and its behaviour may change in the future")
+	}
 	return command.action(os.Stdout, commandContext{
 		ownCommands: o,
 		Context:     *ctx,
diff --git a/remote.go b/remote.go
@@ -6,7 +6,9 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"math/rand"
 	"net/http"
+	"os"
 	"path/filepath"
 	"strings"
 
@@ -87,3 +89,37 @@ func getManifestParameters(reader io.Reader) (*remote.Manifest, error) {
 	}
 	return manifest, nil
 }
+
+// setupRemoteConfiguration downloads the configuration files from the remote endpoint and mounts the virtual FS
+func setupRemoteConfiguration(remoteEndpoint string) (func(), error) {
+	files, parameters, err := loadRemoteFiles(remoteEndpoint)
+	if err != nil {
+		return nil, err
+	}
+
+	closeMountpoint := func() {}
+	mountpoint := parameters.Mountpoint
+	if mountpoint == "" {
+		// generates a temporary directory
+		mountpoint = filepath.Join(os.TempDir(), fmt.Sprintf("%s-%x", "resticprofile", rand.Uint32()))
+		closeMountpoint = func() {
+			err = os.Remove(mountpoint)
+			if err != nil {
+				clog.Errorf("failed to remove mountpoint: %v", err)
+			}
+		}
+	}
+	err = os.MkdirAll(mountpoint, 0o755)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create mount directory: %w", err)
+	}
+
+	closeFs, err := fuse.MountFS(mountpoint, files)
+	if err != nil {
+		return closeMountpoint, err
+	}
+	return func() {
+		closeFs()
+		closeMountpoint()
+	}, nil
+}
diff --git a/serve.go b/serve.go
@@ -86,7 +86,7 @@ func serveCommand(w io.Writer, cmdCtx commandContext) error {
 	}(server, quit)
 
 	// we want to return the server error if any so we need to keep it in the main thread.
-	clog.Debugf("listening on %s", server.Addr)
+	clog.Infof("listening on %s", server.Addr)
 	err := server.ListenAndServe()
 	if err != nil && err != http.ErrServerClosed {
 		return err

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,6 @@ package fuse`
`2`	`2`
`3`	`3`	`import "errors"`
`4`	`4`
`5`		`-func MountFS(files []File) (func(), error) {`
	`5`	`+func MountFS(_ string, _ []File) (func(), error) {`
`6`	`6`	`return nil, errors.New("not supported on Windows")`
`7`	`7`	`}`