simple client/server model

Author: creativeprojects

commands.go

@@ -168,6 +168,24 @@ func getOwnCommands() []ownCommand {
 			needConfiguration: false,
 			hide:              true,
 		},
+		{
+			name:              "send",
+			description:       "send a configuration profile to a remote client and execute a command",
+			action:            sendProfileCommand,
+			needConfiguration: true,
+			noProfile:         true,
+			hide:              true,
+			experimental:      true,
+		},
+		{
+			name:              "serve",
+			description:       "serve configuration profiles to remote clients",
+			action:            serveCommand,
+			needConfiguration: true,
+			noProfile:         true,
+			hide:              true,
+			experimental:      true,
+		},
 	}
 }
 

complete.go

@@ -10,6 +10,7 @@ import (
 	"github.com/creativeprojects/clog"
 	"github.com/creativeprojects/resticprofile/config"
 	"github.com/creativeprojects/resticprofile/filesearch"
+	"github.com/spf13/afero"
 	"github.com/spf13/pflag"
 )
 
@@ -135,7 +136,7 @@ func (c *Completer) listProfileNames() (list []string) {
 		}
 
 		if file, err := filesearch.NewFinder().FindConfigurationFile(filename); err == nil {
-			if conf, err := config.LoadFile(file, format); err == nil {
+			if conf, err := config.LoadFile(afero.NewOsFs(), file, format); err == nil {
 				list = append(list, conf.GetProfileNames()...)
 				for name := range conf.GetProfileGroups() {
 					list = append(list, name)

config/checkdoc/main.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/creativeprojects/clog"
 	"github.com/creativeprojects/resticprofile/config"
+	"github.com/spf13/afero"
 	"github.com/spf13/pflag"
 )
 
@@ -174,7 +175,7 @@ func saveConfiguration(content []byte, configType string) (string, error) {
 
 // checkConfiguration returns true when the configuration is valid
 func checkConfiguration(filename, configType string, lineNum int) bool {
-	cfg, err := config.LoadFile(filename, configType)
+	cfg, err := config.LoadFile(afero.NewOsFs(), filename, configType)
 	if err != nil {
 		clog.Errorf("    %q on line %d: %s", configType, lineNum, err)
 		return false

config/config.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"io"
 	"maps"
-	"os"
 	"path/filepath"
 	"slices"
 	"sort"
@@ -21,6 +20,7 @@ import (
 	"github.com/creativeprojects/resticprofile/util/maybe"
 	"github.com/creativeprojects/resticprofile/util/templates"
 	"github.com/mitchellh/mapstructure"
+	"github.com/spf13/afero"
 	"github.com/spf13/viper"
 )
 
@@ -74,7 +74,7 @@ func formatFromExtension(configFile string) string {
 
 // LoadFile loads configuration from file
 // Leave format blank for auto-detection from the file extension
-func LoadFile(configFile, format string) (config *Config, err error) {
+func LoadFile(fs afero.Fs, configFile, format string) (config *Config, err error) {
 	if format == "" {
 		format = formatFromExtension(configFile)
 	}
@@ -84,7 +84,7 @@ func LoadFile(configFile, format string) (config *Config, err error) {
 
 	readAndAdd := func(configFile string, replace bool) error {
 		clog.Debugf("loading: %s", configFile)
-		file, fileErr := os.Open(configFile)
+		file, fileErr := fs.Open(configFile)
 		if fileErr != nil {
 			return fmt.Errorf("cannot open configuration file for reading: %w", fileErr)
 		}
@@ -716,6 +716,22 @@ func (c *Config) getProfilePath(key string) string {
 	return c.flatKey(constants.SectionConfigurationProfiles, key)
 }
 
+// HasRemote returns true if the remote exists in the configuration
+func (c *Config) HasRemote(remoteName string) bool {
+	return c.IsSet(c.flatKey(constants.SectionConfigurationRemotes, remoteName))
+}
+
+func (c *Config) GetRemote(remoteName string) (*Remote, error) {
+	// we don't need to check the file version: the remotes can be in a separate configuration file
+
+	remote := NewRemote(c, remoteName)
+	err := c.unmarshalKey(c.flatKey(constants.SectionConfigurationRemotes, remoteName), remote)
+
+	rootPath := filepath.Dir(c.GetConfigFile())
+	remote.SetRootPath(rootPath)
+	return remote, err
+}
+
 // unmarshalConfig returns the decoder config options depending on the configuration version and format
 func (c *Config) unmarshalConfig() viper.DecoderConfigOption {
 	if c.GetVersion() == Version01 {

config/config_test.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/creativeprojects/resticprofile/util/maybe"
+	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -366,67 +367,57 @@ x=0
 }
 
 func TestIncludes(t *testing.T) {
-	files := []string{}
-	cleanFiles := func() {
-		for _, file := range files {
-			os.Remove(file)
-		}
-		files = files[:0]
-	}
-	defer cleanFiles()
-
-	createFile := func(t *testing.T, suffix, content string) string {
+	createFile := func(t *testing.T, fs afero.Fs, suffix, content string) string {
 		t.Helper()
 		name := ""
-		file, err := os.CreateTemp("", "*-"+suffix)
+		file, err := afero.TempFile(fs, "", "*-"+suffix)
 		if err == nil {
 			defer file.Close()
 			_, err = file.WriteString(content)
 			name = file.Name()
-			files = append(files, name)
 		}
 		require.NoError(t, err)
 		return name
 	}
 
-	mustLoadConfig := func(t *testing.T, configFile string) *Config {
+	mustLoadConfig := func(t *testing.T, fs afero.Fs, configFile string) *Config {
 		t.Helper()
-		config, err := LoadFile(configFile, "")
+		config, err := LoadFile(fs, configFile, "")
 		require.NoError(t, err)
 		return config
 	}
 
 	testID := fmt.Sprintf("%d", time.Now().Unix())
 
 	t.Run("multiple-includes", func(t *testing.T) {
-		defer cleanFiles()
+		fs := afero.NewMemMapFs()
 		content := fmt.Sprintf(`includes=['*%[1]s.inc.toml','*%[1]s.inc.yaml','*%[1]s.inc.json']`, testID)
 
-		configFile := createFile(t, "profiles.conf", content)
-		createFile(t, "d-"+testID+".inc.toml", "[one]\nk='v'")
-		createFile(t, "o-"+testID+".inc.yaml", `two: { k: v }`)
-		createFile(t, "j-"+testID+".inc.json", `{"three":{ "k": "v" }}`)
+		configFile := createFile(t, fs, "profiles.conf", content)
+		createFile(t, fs, "d-"+testID+".inc.toml", "[one]\nk='v'")
+		createFile(t, fs, "o-"+testID+".inc.yaml", `two: { k: v }`)
+		createFile(t, fs, "j-"+testID+".inc.json", `{"three":{ "k": "v" }}`)
 
-		config := mustLoadConfig(t, configFile)
+		config := mustLoadConfig(t, fs, configFile)
 		assert.True(t, config.IsSet("includes"))
 		assert.True(t, config.HasProfile("one"))
 		assert.True(t, config.HasProfile("two"))
 		assert.True(t, config.HasProfile("three"))
 	})
 
 	t.Run("overrides", func(t *testing.T) {
-		defer cleanFiles()
+		fs := afero.NewMemMapFs()
 
-		configFile := createFile(t, "profiles.conf", `
+		configFile := createFile(t, fs, "profiles.conf", `
 includes = "*`+testID+`.inc.toml"
 [default]
 repository = "default-repo"`)
 
-		createFile(t, "override-"+testID+".inc.toml", `
+		createFile(t, fs, "override-"+testID+".inc.toml", `
 [default]
 repository = "overridden-repo"`)
 
-		config := mustLoadConfig(t, configFile)
+		config := mustLoadConfig(t, fs, configFile)
 		assert.True(t, config.HasProfile("default"))
 
 		profile, err := config.GetProfile("default")
@@ -435,26 +426,26 @@ repository = "overridden-repo"`)
 	})
 
 	t.Run("mixins", func(t *testing.T) {
-		defer cleanFiles()
+		fs := afero.NewMemMapFs()
 
-		configFile := createFile(t, "profiles.conf", `
+		configFile := createFile(t, fs, "profiles.conf", `
 version = 2
 includes = "*`+testID+`.inc.toml"
 [profiles.default]
 use = "another-run-before"
 run-before = "default-before"`)
 
-		createFile(t, "mixin-"+testID+".inc.toml", `
+		createFile(t, fs, "mixin-"+testID+".inc.toml", `
 [mixins.another-run-before]
 "run-before..." = "another-run-before"
 [mixins.another-run-before2]
 "run-before..." = "another-run-before2"`)
 
-		createFile(t, "mixin-use-"+testID+".inc.toml", `
+		createFile(t, fs, "mixin-use-"+testID+".inc.toml", `
 [profiles.default]
 use = "another-run-before2"`)
 
-		config := mustLoadConfig(t, configFile)
+		config := mustLoadConfig(t, fs, configFile)
 		assert.True(t, config.HasProfile("default"))
 
 		profile, err := config.GetProfile("default")
@@ -463,56 +454,56 @@ use = "another-run-before2"`)
 	})
 
 	t.Run("hcl-includes-only-hcl", func(t *testing.T) {
-		defer cleanFiles()
+		fs := afero.NewMemMapFs()
 
-		configFile := createFile(t, "profiles.hcl", `includes = "*`+testID+`.inc.*"`)
-		createFile(t, "pass-"+testID+".inc.hcl", `one { }`)
+		configFile := createFile(t, fs, "profiles.hcl", `includes = "*`+testID+`.inc.*"`)
+		createFile(t, fs, "pass-"+testID+".inc.hcl", `one { }`)
 
-		config := mustLoadConfig(t, configFile)
+		config := mustLoadConfig(t, fs, configFile)
 		assert.True(t, config.HasProfile("one"))
 
-		createFile(t, "fail-"+testID+".inc.toml", `[two]`)
-		_, err := LoadFile(configFile, "")
+		createFile(t, fs, "fail-"+testID+".inc.toml", `[two]`)
+		_, err := LoadFile(fs, configFile, "")
 		assert.Error(t, err)
 		assert.Regexp(t, ".+ is in hcl format, includes must use the same format", err.Error())
 	})
 
 	t.Run("non-hcl-include-no-hcl", func(t *testing.T) {
-		defer cleanFiles()
+		fs := afero.NewMemMapFs()
 
-		configFile := createFile(t, "profiles.toml", `includes = "*`+testID+`.inc.*"`)
-		createFile(t, "pass-"+testID+".inc.toml", "[one]\nk='v'")
+		configFile := createFile(t, fs, "profiles.toml", `includes = "*`+testID+`.inc.*"`)
+		createFile(t, fs, "pass-"+testID+".inc.toml", "[one]\nk='v'")
 
-		config := mustLoadConfig(t, configFile)
+		config := mustLoadConfig(t, fs, configFile)
 		assert.True(t, config.HasProfile("one"))
 
-		createFile(t, "fail-"+testID+".inc.hcl", `one { }`)
-		_, err := LoadFile(configFile, "")
+		createFile(t, fs, "fail-"+testID+".inc.hcl", `one { }`)
+		_, err := LoadFile(fs, configFile, "")
 		assert.Error(t, err)
 		assert.Regexp(t, "hcl format .+ cannot be used in includes from toml", err.Error())
 	})
 
 	t.Run("cannot-load-different-versions", func(t *testing.T) {
-		defer cleanFiles()
+		fs := afero.NewMemMapFs()
 		content := fmt.Sprintf(`includes=['*%s.inc.json']`, testID)
 
-		configFile := createFile(t, "profiles.conf", content)
-		createFile(t, "a-"+testID+".inc.json", `{"version": 2, "profiles": {"one":{}}}`)
-		createFile(t, "b-"+testID+".inc.json", `{"two":{}}`)
+		configFile := createFile(t, fs, "profiles.conf", content)
+		createFile(t, fs, "a-"+testID+".inc.json", `{"version": 2, "profiles": {"one":{}}}`)
+		createFile(t, fs, "b-"+testID+".inc.json", `{"two":{}}`)
 
-		_, err := LoadFile(configFile, "")
+		_, err := LoadFile(fs, configFile, "")
 		assert.ErrorContains(t, err, "cannot include different versions of the configuration file")
 	})
 
 	t.Run("cannot-load-different-versions", func(t *testing.T) {
-		defer cleanFiles()
+		fs := afero.NewMemMapFs()
 		content := fmt.Sprintf(`{"version": 2, "includes":["*%s.inc.json"]}`, testID)
 
-		configFile := createFile(t, "profiles.json", content)
-		createFile(t, "c-"+testID+".inc.json", `{"version": 1, "two":{}}`)
-		createFile(t, "d-"+testID+".inc.json", `{"profiles": {"one":{}}}`)
+		configFile := createFile(t, fs, "profiles.json", content)
+		createFile(t, fs, "c-"+testID+".inc.json", `{"version": 1, "two":{}}`)
+		createFile(t, fs, "d-"+testID+".inc.json", `{"profiles": {"one":{}}}`)
 
-		_, err := LoadFile(configFile, "")
+		_, err := LoadFile(fs, configFile, "")
 		assert.ErrorContains(t, err, "cannot include different versions of the configuration file")
 	})
 }

config/error.go

@@ -3,5 +3,6 @@ package config
 import "errors"
 
 var (
-	ErrNotFound = errors.New("not found")
+	ErrNotFound               = errors.New("not found")
+	ErrNotSupportedInVersion1 = errors.New("not supported in configuration version 1")
 )

config/remote.go

@@ -0,0 +1,34 @@
+package config
+
+type Remote struct {
+	name              string
+	config            *Config
+	Connection        string   `mapstructure:"connection" default:"ssh" description:"Connection type to use to connect to the remote client"`
+	Host              string   `mapstructure:"host" description:"Address of the remote client. Format: <host>:<port>"`
+	Username          string   `mapstructure:"username" description:"User to connect to the remote client"`
+	PrivateKeyPath    string   `mapstructure:"private-key" description:"Path to the private key to use for authentication"`
+	KnownHostsPath    string   `mapstructure:"known-hosts" description:"Path to the known hosts file"`
+	BinaryPath        string   `mapstructure:"binary-path" description:"Path to the resticprofile binary to use on the remote client"`
+	ConfigurationFile string   `mapstructure:"configuration-file" description:"Path to the configuration file to transfer to the remote client"`
+	ProfileName       string   `mapstructure:"profile-name" description:"Name of the profile to use on the remote client"`
+	SendFiles         []string `mapstructure:"send-files" description:"Other configuration files to transfer to the remote client"`
+}
+
+func NewRemote(config *Config, name string) *Remote {
+	remote := &Remote{
+		name:   name,
+		config: config,
+	}
+	return remote
+}
+
+// SetRootPath changes the path of all the relative paths and files in the configuration
+func (r *Remote) SetRootPath(rootPath string) {
+	r.PrivateKeyPath = fixPath(r.PrivateKeyPath, expandEnv, absolutePrefix(rootPath))
+	r.KnownHostsPath = fixPath(r.KnownHostsPath, expandEnv, absolutePrefix(rootPath))
+	r.ConfigurationFile = fixPath(r.ConfigurationFile, expandEnv, absolutePrefix(rootPath))
+
+	for i := range r.SendFiles {
+		r.SendFiles[i] = fixPath(r.SendFiles[i], expandEnv, absolutePrefix(rootPath))
+	}
+}

constants/exit_code.go

@@ -0,0 +1,10 @@
+package constants
+
+const (
+	ExitSuccess = iota
+	ExitGeneralError
+	ExitErrorInvalidFlags
+	ExitRunningOnBattery
+	ExitCannotSetupRemoteConfiguration
+	ExitErrorChildHasNoParentPort = 10
+)

constants/other.go

@@ -3,4 +3,5 @@ package constants
 const (
 	TemporaryDirMarker = "temp:"
 	JSONSchema         = "$schema"
+	ManifestFilename   = ".manifest.json"
 )

constants/section.go

@@ -13,6 +13,7 @@ const (
 	SectionConfigurationMixins      = "mixins"
 	SectionConfigurationMixinUse    = "use"
 	SectionConfigurationSchedule    = "schedule"
+	SectionConfigurationRemotes     = "remotes"
 
 	SectionDefinitionCommon = "common"
 	SectionDefinitionForget = "forget"