From deec1c0f331fd2f3468b917b17646f9cd109223b Mon Sep 17 00:00:00 2001 From: Jon Seager Date: Thu, 31 Oct 2024 15:46:11 +0000 Subject: [PATCH] refactor: move snapd client into runner --- internal/concierge/plan.go | 8 +- internal/concierge/plan_validators_test.go | 4 +- internal/juju/juju.go | 8 +- internal/juju/juju_test.go | 30 +--- internal/packages/apt.go | 11 -- internal/packages/deb_handler.go | 10 ++ internal/packages/deb_handler_test.go | 10 +- internal/packages/snap.go | 135 ------------------ internal/packages/snap_handler.go | 44 +++--- internal/packages/snap_handler_test.go | 31 ++-- internal/providers/google_test.go | 8 +- internal/providers/k8s.go | 12 +- internal/providers/k8s_test.go | 33 ++--- internal/providers/lxd.go | 8 +- internal/providers/lxd_test.go | 32 +---- internal/providers/microk8s.go | 12 +- internal/providers/microk8s_test.go | 33 ++--- internal/runner/interface.go | 8 ++ .../{runnertest => runner}/mock_runner.go | 65 +++++++-- internal/runner/runner.go | 55 +------ internal/runner/snap.go | 101 +++++++++++++ internal/{packages => runner}/snap_test.go | 16 ++- internal/runner/util.go | 62 ++++++++ internal/runnertest/mock_snap.go | 19 --- 24 files changed, 343 insertions(+), 412 deletions(-) delete mode 100644 internal/packages/apt.go delete mode 100644 internal/packages/snap.go rename internal/{runnertest => runner}/mock_runner.go (64%) create mode 100644 internal/runner/snap.go rename internal/{packages => runner}/snap_test.go (52%) create mode 100644 internal/runner/util.go delete mode 100644 internal/runnertest/mock_snap.go diff --git a/internal/concierge/plan.go b/internal/concierge/plan.go index 358931d..2c69d58 100644 --- a/internal/concierge/plan.go +++ b/internal/concierge/plan.go @@ -14,7 +14,7 @@ import ( // Plan represents a set of packages and providers that are to be prepared/restored. type Plan struct { Providers []providers.Provider - Snaps []packages.SnapPackage + Snaps []*runner.Snap Debs []*packages.Deb config *config.Config @@ -26,12 +26,12 @@ func NewPlan(config *config.Config, runner runner.CommandRunner) *Plan { plan := &Plan{config: config, runner: runner} for _, s := range append(config.Host.Snaps, config.Overrides.ExtraSnaps...) { - snap := packages.NewSnapFromString(s) + snap := runner.NewSnapFromString(s) // Check if the channel has been overridden by a CLI argument/env var - channelOverride := getSnapChannelOverride(config, snap.Name()) + channelOverride := getSnapChannelOverride(config, snap.Name) if channelOverride != "" { - snap.SetChannel(channelOverride) + snap.Channel = channelOverride } plan.Snaps = append(plan.Snaps, snap) diff --git a/internal/concierge/plan_validators_test.go b/internal/concierge/plan_validators_test.go index 6ec71f5..ae1d981 100644 --- a/internal/concierge/plan_validators_test.go +++ b/internal/concierge/plan_validators_test.go @@ -4,11 +4,11 @@ import ( "testing" "github.com/jnsgruk/concierge/internal/config" - "github.com/jnsgruk/concierge/internal/runnertest" + "github.com/jnsgruk/concierge/internal/runner" ) func TestSingleK8sValidator(t *testing.T) { - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() twoK8s := &config.Config{} twoK8s.Providers.K8s.Enable = true diff --git a/internal/juju/juju.go b/internal/juju/juju.go index 0efd59f..6262633 100644 --- a/internal/juju/juju.go +++ b/internal/juju/juju.go @@ -17,7 +17,7 @@ import ( ) // NewJujuHandler constructs a new JujuHandler instance. -func NewJujuHandler(config *config.Config, runner runner.CommandRunner, providers []providers.Provider) *JujuHandler { +func NewJujuHandler(config *config.Config, r runner.CommandRunner, providers []providers.Provider) *JujuHandler { var channel string if config.Overrides.JujuChannel != "" { channel = config.Overrides.JujuChannel @@ -30,8 +30,8 @@ func NewJujuHandler(config *config.Config, runner runner.CommandRunner, provider bootstrapConstraints: config.Juju.BootstrapConstraints, modelDefaults: config.Juju.ModelDefaults, providers: providers, - runner: runner, - snaps: []packages.SnapPackage{packages.NewSnap("juju", channel)}, + runner: r, + snaps: []*runner.Snap{{Name: "juju", Channel: channel}}, } } @@ -42,7 +42,7 @@ type JujuHandler struct { modelDefaults map[string]string providers []providers.Provider runner runner.CommandRunner - snaps []packages.SnapPackage + snaps []*runner.Snap } // Prepare bootstraps Juju on the configured providers. diff --git a/internal/juju/juju_test.go b/internal/juju/juju_test.go index 46633db..dfc3cfe 100644 --- a/internal/juju/juju_test.go +++ b/internal/juju/juju_test.go @@ -2,14 +2,12 @@ package juju import ( "fmt" - "os" "reflect" "testing" "github.com/jnsgruk/concierge/internal/config" - "github.com/jnsgruk/concierge/internal/packages" "github.com/jnsgruk/concierge/internal/providers" - "github.com/jnsgruk/concierge/internal/runnertest" + "github.com/jnsgruk/concierge/internal/runner" ) var fakeGoogleCreds = []byte(`auth-type: oauth2 @@ -22,12 +20,12 @@ private-key: | project-id: concierge `) -func setupHandlerWithPreset(preset string) (*runnertest.MockRunner, *JujuHandler, error) { +func setupHandlerWithPreset(preset string) (*runner.MockRunner, *JujuHandler, error) { var err error var cfg *config.Config var provider providers.Provider - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() runner.MockCommandReturn("sudo -u test-user juju show-controller concierge-lxd", []byte("not found"), fmt.Errorf("Test error")) runner.MockCommandReturn("sudo -u test-user juju show-controller concierge-microk8s", []byte("not found"), fmt.Errorf("Test error")) runner.MockCommandReturn("sudo -u test-user juju show-controller concierge-k8s", []byte("not found"), fmt.Errorf("Test error")) @@ -47,17 +45,17 @@ func setupHandlerWithPreset(preset string) (*runnertest.MockRunner, *JujuHandler } handler := NewJujuHandler(cfg, runner, []providers.Provider{provider}) - handler.snaps = []packages.SnapPackage{runnertest.NewTestSnap("juju", "", false, false)} + return runner, handler, nil } -func setupHandlerWithGoogleProvider() (*runnertest.MockRunner, *JujuHandler, error) { +func setupHandlerWithGoogleProvider() (*runner.MockRunner, *JujuHandler, error) { cfg := &config.Config{} cfg.Providers.Google.Enable = true cfg.Providers.Google.Bootstrap = true cfg.Providers.Google.CredentialsFile = "google.yaml" - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() runner.MockFile("google.yaml", fakeGoogleCreds) provider := providers.NewProvider("google", runner, cfg) @@ -68,15 +66,9 @@ func setupHandlerWithGoogleProvider() (*runnertest.MockRunner, *JujuHandler, err } handler := NewJujuHandler(cfg, runner, []providers.Provider{provider}) - handler.snaps = []packages.SnapPackage{runnertest.NewTestSnap("juju", "", false, false)} return runner, handler, nil } func TestJujuHandlerCommandsPresets(t *testing.T) { - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - os.Setenv("PATH", "") - defer os.Setenv("PATH", path) - type test struct { preset string expectedCommands []string @@ -171,11 +163,6 @@ func TestJujuHandlerWithCredentialedProvider(t *testing.T) { } func TestJujuRestoreNoKillController(t *testing.T) { - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - os.Setenv("PATH", "") - defer os.Setenv("PATH", path) - runner, handler, err := setupHandlerWithPreset("machine") if err != nil { t.Fatal(err.Error()) @@ -196,11 +183,6 @@ func TestJujuRestoreNoKillController(t *testing.T) { } func TestJujuRestoreKillController(t *testing.T) { - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - os.Setenv("PATH", "") - defer os.Setenv("PATH", path) - runner, handler, err := setupHandlerWithGoogleProvider() if err != nil { t.Fatal(err.Error()) diff --git a/internal/packages/apt.go b/internal/packages/apt.go deleted file mode 100644 index 0bcdecf..0000000 --- a/internal/packages/apt.go +++ /dev/null @@ -1,11 +0,0 @@ -package packages - -// NewDeb constructs a new Deb instance. -func NewDeb(name string) *Deb { - return &Deb{Name: name} -} - -// Deb is a simple representation of a package installed from the Ubuntu archive. -type Deb struct { - Name string -} diff --git a/internal/packages/deb_handler.go b/internal/packages/deb_handler.go index 7579cdb..c8b087f 100644 --- a/internal/packages/deb_handler.go +++ b/internal/packages/deb_handler.go @@ -7,6 +7,16 @@ import ( "github.com/jnsgruk/concierge/internal/runner" ) +// NewDeb constructs a new Deb instance. +func NewDeb(name string) *Deb { + return &Deb{Name: name} +} + +// Deb is a simple representation of a package installed from the Ubuntu archive. +type Deb struct { + Name string +} + // NewDebHandler constructs a new instance of a DebHandler. func NewDebHandler(runner runner.CommandRunner, debs []*Deb) *DebHandler { return &DebHandler{ diff --git a/internal/packages/deb_handler_test.go b/internal/packages/deb_handler_test.go index 1417b35..62d0136 100644 --- a/internal/packages/deb_handler_test.go +++ b/internal/packages/deb_handler_test.go @@ -1,11 +1,10 @@ package packages import ( - "os" "reflect" "testing" - "github.com/jnsgruk/concierge/internal/runnertest" + "github.com/jnsgruk/concierge/internal/runner" ) func TestDebHandlerCommands(t *testing.T) { @@ -14,11 +13,6 @@ func TestDebHandlerCommands(t *testing.T) { expected []string } - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - defer os.Setenv("PATH", path) - os.Setenv("PATH", "") - tests := []test{ { func(d *DebHandler) { d.Prepare() }, @@ -44,7 +38,7 @@ func TestDebHandlerCommands(t *testing.T) { } for _, tc := range tests { - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() tc.testFunc(NewDebHandler(runner, debs)) if !reflect.DeepEqual(tc.expected, runner.ExecutedCommands) { diff --git a/internal/packages/snap.go b/internal/packages/snap.go deleted file mode 100644 index 425c243..0000000 --- a/internal/packages/snap.go +++ /dev/null @@ -1,135 +0,0 @@ -package packages - -import ( - "context" - "fmt" - "log/slog" - "strings" - "time" - - retry "github.com/sethvargo/go-retry" - "github.com/snapcore/snapd/client" -) - -// SnapPackage is an interface with methods that can describe a snap package -type SnapPackage interface { - // Name reports the name of the snap. - Name() string - // Installed reports if the snap is currently Installed. - Installed() bool - // Classic reports whether or not the snap at the tip of the specified channel uses - // Classic confinement or not. - Classic() (bool, error) - // tracking reports which channel an installed snap is tracking. - Tracking() (string, error) - // Channel reports the snap channel. - Channel() string - // SetChannel sets the snap channel. - SetChannel(c string) -} - -// NewSnapFromString returns a constructed snap instance, where the snap is -// specified in shorthand form, i.e. `charmcraft/latest/edge`. -func NewSnapFromString(snap string) *Snap { - before, after, found := strings.Cut(snap, "/") - if found { - return NewSnap(before, after) - } else { - return NewSnap(before, "") - } -} - -// NewSnap constructs a new Snap instance. -func NewSnap(name string, channel string) *Snap { - return &Snap{name: name, channel: channel, client: client.New(nil)} -} - -// Snap represents a snap package on the system. -type Snap struct { - name string - channel string - - client *client.Client -} - -// Name reports the name of the snap. -func (s *Snap) Name() string { return s.name } - -// Channel reports the snap channel. -func (s *Snap) Channel() string { return s.channel } - -// SetChannel sets the snap channel. -func (s *Snap) SetChannel(c string) { s.channel = c } - -// Installed is a helper that reports if the snap is currently Installed. -func (s *Snap) Installed() bool { - slog.Debug("Querying snap install status", "snap", s.name) - - snap, err := s.withRetry(func(ctx context.Context) (*client.Snap, error) { - snap, _, err := s.client.Snap(s.name) - if err != nil && strings.Contains(err.Error(), "snap not installed") { - return snap, nil - } else if err != nil { - return nil, retry.RetryableError(err) - } - return snap, nil - }) - if err != nil || snap == nil { - return false - } - - return snap.Status == client.StatusActive -} - -// Classic reports whether or not the snap at the tip of the specified channel uses -// Classic confinement or not. -func (s *Snap) Classic() (bool, error) { - slog.Debug("Querying snap confinement", "snap", s.name) - - snap, err := s.withRetry(func(ctx context.Context) (*client.Snap, error) { - snap, _, err := s.client.FindOne(s.name) - if err != nil { - return nil, retry.RetryableError(err) - } - return snap, nil - }) - if err != nil { - return false, fmt.Errorf("failed to find snap: %w", err) - } - - channel, ok := snap.Channels[s.channel] - if ok { - return channel.Confinement == "classic", nil - } - - return snap.Confinement == "classic", nil -} - -// Tracking reports which channel an installed snap is tracking. -func (s *Snap) Tracking() (string, error) { - slog.Debug("Querying snap channel tracking", "snap", s.name) - - snap, err := s.withRetry(func(ctx context.Context) (*client.Snap, error) { - snap, _, err := s.client.Snap(s.name) - if err != nil { - return nil, retry.RetryableError(err) - } - return snap, nil - }) - if err != nil { - return "", fmt.Errorf("failed to find snap: %w", err) - } - - if snap.Status == client.StatusActive { - return snap.TrackingChannel, nil - } else { - return "", fmt.Errorf("snap '%s' is not installed", s.name) - } -} - -func (s *Snap) withRetry(f func(ctx context.Context) (*client.Snap, error)) (*client.Snap, error) { - backoff := retry.NewExponential(1 * time.Second) - backoff = retry.WithMaxRetries(10, backoff) - ctx := context.Background() - return retry.DoValue(ctx, backoff, f) -} diff --git a/internal/packages/snap_handler.go b/internal/packages/snap_handler.go index c6dce80..ab01c95 100644 --- a/internal/packages/snap_handler.go +++ b/internal/packages/snap_handler.go @@ -8,7 +8,7 @@ import ( ) // NewSnapHandler constructs a new instance of a SnapHandler. -func NewSnapHandler(runner runner.CommandRunner, snaps []SnapPackage) *SnapHandler { +func NewSnapHandler(runner runner.CommandRunner, snaps []*runner.Snap) *SnapHandler { return &SnapHandler{ Snaps: snaps, runner: runner, @@ -17,7 +17,7 @@ func NewSnapHandler(runner runner.CommandRunner, snaps []SnapPackage) *SnapHandl // SnapHandler can install or remove a set of snaps. type SnapHandler struct { - Snaps []SnapPackage + Snaps []*runner.Snap runner runner.CommandRunner } @@ -45,9 +45,16 @@ func (h *SnapHandler) Restore() error { // installSnap ensures that the specified snap is installed at the specified channel. // If already installed, but on the wrong channel, the snap is refreshed. -func (h *SnapHandler) installSnap(s SnapPackage) error { +func (h *SnapHandler) installSnap(s *runner.Snap) error { + slog.Debug("Installing snap", "snap", s.Name) var action, logAction string - if s.Installed() { + + snapInfo, err := h.runner.SnapInfo(s.Name, s.Channel) + if err != nil { + return fmt.Errorf("failed to lookup snap details: %w", err) + } + + if snapInfo.Installed { action = "refresh" logAction = "Refreshed" } else { @@ -55,18 +62,13 @@ func (h *SnapHandler) installSnap(s SnapPackage) error { logAction = "Installed" } - args := []string{action, s.Name()} - - if s.Channel() != "" { - args = append(args, "--channel", s.Channel()) - } + args := []string{action, s.Name} - classic, err := s.Classic() - if err != nil { - return fmt.Errorf("failed to determine if snap '%s' is classic: %w", s.Name(), err) + if s.Channel != "" { + args = append(args, "--channel", s.Channel) } - if classic { + if snapInfo.Classic { args = append(args, "--classic") } @@ -76,25 +78,21 @@ func (h *SnapHandler) installSnap(s SnapPackage) error { return fmt.Errorf("command failed: %w", err) } - trackingChannel, err := s.Tracking() - if err != nil { - return fmt.Errorf("failed to resolve which channel the '%s' snap is tracking: %w", s.Name(), err) - } - - slog.Info(fmt.Sprintf("%s snap", logAction), "snap", s.Name(), "channel", trackingChannel) + slog.Info(fmt.Sprintf("%s snap", logAction), "snap", s.Name) return nil } // Remove uninstalls the specified snap from the system, optionally purging its data. -func (h *SnapHandler) removeSnap(s SnapPackage) error { - args := []string{"remove", s.Name(), "--purge"} +func (h *SnapHandler) removeSnap(s *runner.Snap) error { + slog.Debug("Removing snap", "snap", s.Name) + args := []string{"remove", s.Name, "--purge"} cmd := runner.NewCommand("snap", args) _, err := h.runner.RunExclusive(cmd) if err != nil { - return fmt.Errorf("failed to remove snap '%s': %w", s.Name(), err) + return fmt.Errorf("failed to remove snap '%s': %w", s.Name, err) } - slog.Info("Removed snap", "snap", s.Name()) + slog.Info("Removed snap", "snap", s.Name) return nil } diff --git a/internal/packages/snap_handler_test.go b/internal/packages/snap_handler_test.go index 9f5d91c..01d0c37 100644 --- a/internal/packages/snap_handler_test.go +++ b/internal/packages/snap_handler_test.go @@ -1,11 +1,10 @@ package packages import ( - "os" "reflect" "testing" - "github.com/jnsgruk/concierge/internal/runnertest" + "github.com/jnsgruk/concierge/internal/runner" ) func TestSnapHandlerCommands(t *testing.T) { @@ -14,12 +13,6 @@ func TestSnapHandlerCommands(t *testing.T) { expected []string } - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - defer os.Setenv("PATH", path) - os.Setenv("PATH", "") - // Reset the PATH variable - tests := []test{ { func(s *SnapHandler) { s.Prepare() }, @@ -39,18 +32,20 @@ func TestSnapHandlerCommands(t *testing.T) { }, } - snaps := []SnapPackage{ - runnertest.NewTestSnap("charmcraft", "latest/stable", true, true), - runnertest.NewTestSnap("jq", "latest/stable", false, false), - runnertest.NewTestSnap("microk8s", "1.30-strict/stable", false, false), - } - for _, tc := range tests { - runner := runnertest.NewMockRunner() - tc.testFunc(NewSnapHandler(runner, snaps)) + r := runner.NewMockRunner() + r.MockSnapStoreLookup("charmcraft", "latest/stable", true, true) + + snaps := []*runner.Snap{ + r.NewSnap("charmcraft", "latest/stable"), + r.NewSnap("jq", "latest/stable"), + r.NewSnap("microk8s", "1.30-strict/stable"), + } + + tc.testFunc(NewSnapHandler(r, snaps)) - if !reflect.DeepEqual(tc.expected, runner.ExecutedCommands) { - t.Fatalf("expected: %v, got: %v", tc.expected, runner.ExecutedCommands) + if !reflect.DeepEqual(tc.expected, r.ExecutedCommands) { + t.Fatalf("expected: %v, got: %v", tc.expected, r.ExecutedCommands) } } diff --git a/internal/providers/google_test.go b/internal/providers/google_test.go index d760ca9..402572c 100644 --- a/internal/providers/google_test.go +++ b/internal/providers/google_test.go @@ -5,7 +5,7 @@ import ( "testing" "github.com/jnsgruk/concierge/internal/config" - "github.com/jnsgruk/concierge/internal/runnertest" + "github.com/jnsgruk/concierge/internal/runner" "gopkg.in/yaml.v3" ) @@ -23,7 +23,7 @@ func TestNewGoogle(t *testing.T) { overrides := &config.Config{} overrides.Overrides.GoogleCredentialFile = "/home/ubuntu/alternate-credentials.yaml" - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() tests := []test{ { @@ -63,7 +63,7 @@ func TestGooglePrepareCommands(t *testing.T) { config := &config.Config{} config.Providers.Google.CredentialsFile = "/home/ubuntu/credentials.yaml" - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() uk8s := NewGoogle(runner, config) uk8s.Prepare() @@ -80,7 +80,7 @@ func TestGoogleReadCredentials(t *testing.T) { config := &config.Config{} config.Providers.Google.CredentialsFile = "credentials.yaml" - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() creds := []byte(`auth-type: oauth2 client-email: juju-gce-1-sa@concierge.iam.gserviceaccount.com diff --git a/internal/providers/k8s.go b/internal/providers/k8s.go index 304d516..12361fb 100644 --- a/internal/providers/k8s.go +++ b/internal/providers/k8s.go @@ -15,7 +15,7 @@ import ( const defaultK8sChannel = "1.31/candidate" // NewK8s constructs a new K8s provider instance. -func NewK8s(runner runner.CommandRunner, config *config.Config) *K8s { +func NewK8s(r runner.CommandRunner, config *config.Config) *K8s { var channel string if config.Overrides.K8sChannel != "" { @@ -30,10 +30,10 @@ func NewK8s(runner runner.CommandRunner, config *config.Config) *K8s { Channel: channel, Features: config.Providers.K8s.Features, bootstrap: config.Providers.K8s.Bootstrap, - runner: runner, - snaps: []packages.SnapPackage{ - packages.NewSnap("k8s", channel), - packages.NewSnap("kubectl", "stable"), + runner: r, + snaps: []*runner.Snap{ + {Name: "k8s", Channel: channel}, + {Name: "kubectl", Channel: "stable"}, }, } } @@ -45,7 +45,7 @@ type K8s struct { bootstrap bool runner runner.CommandRunner - snaps []packages.SnapPackage + snaps []*runner.Snap } // Prepare installs and configures K8s such that it can work in testing environments. diff --git a/internal/providers/k8s_test.go b/internal/providers/k8s_test.go index 15901ca..162c49a 100644 --- a/internal/providers/k8s_test.go +++ b/internal/providers/k8s_test.go @@ -1,14 +1,12 @@ package providers import ( - "os" "reflect" "slices" "testing" "github.com/jnsgruk/concierge/internal/config" - "github.com/jnsgruk/concierge/internal/packages" - "github.com/jnsgruk/concierge/internal/runnertest" + "github.com/jnsgruk/concierge/internal/runner" ) var defaultFeatureConfig = map[string]map[string]string{ @@ -34,7 +32,7 @@ func TestNewK8s(t *testing.T) { overrides.Overrides.K8sChannel = "1.32/edge" overrides.Providers.K8s.Features = defaultFeatureConfig - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() tests := []test{ { @@ -55,8 +53,8 @@ func TestNewK8s(t *testing.T) { ck8s := NewK8s(runner, tc.config) // Check the constructed snaps are correct - if ck8s.snaps[0].Channel() != tc.expected.Channel { - t.Fatalf("expected: %v, got: %v", ck8s.snaps[0].Channel(), tc.expected.Channel) + if ck8s.snaps[0].Channel != tc.expected.Channel { + t.Fatalf("expected: %v, got: %v", ck8s.snaps[0].Channel, tc.expected.Channel) } // Remove the snaps so the rest of the object can be compared @@ -68,17 +66,13 @@ func TestNewK8s(t *testing.T) { } func TestK8sPrepareCommands(t *testing.T) { - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - defer os.Setenv("PATH", path) - os.Setenv("PATH", "") - config := &config.Config{} config.Providers.K8s.Channel = "" config.Providers.K8s.Features = defaultFeatureConfig expectedCommands := []string{ - "snap install k8s", + "snap install k8s --channel 1.31/candidate", + "snap install kubectl --channel stable", "k8s bootstrap", "k8s status --wait-ready", "k8s set load-balancer.l2-mode=true", @@ -92,14 +86,8 @@ func TestK8sPrepareCommands(t *testing.T) { ".kube/config": "", } - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() ck8s := NewK8s(runner, config) - - // Override the snaps with fake ones that don't call the snapd socket. - ck8s.snaps = []packages.SnapPackage{ - runnertest.NewTestSnap("k8s", "", false, false), - } - ck8s.Prepare() slices.Sort(expectedCommands) @@ -115,16 +103,11 @@ func TestK8sPrepareCommands(t *testing.T) { } func TestK8sRestore(t *testing.T) { - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - defer os.Setenv("PATH", path) - os.Setenv("PATH", "") - config := &config.Config{} config.Providers.K8s.Channel = "" config.Providers.K8s.Features = defaultFeatureConfig - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() ck8s := NewK8s(runner, config) ck8s.Restore() diff --git a/internal/providers/lxd.go b/internal/providers/lxd.go index 2509835..3e72be0 100644 --- a/internal/providers/lxd.go +++ b/internal/providers/lxd.go @@ -10,7 +10,7 @@ import ( ) // NewLXD constructs a new LXD provider instance. -func NewLXD(runner runner.CommandRunner, config *config.Config) *LXD { +func NewLXD(r runner.CommandRunner, config *config.Config) *LXD { var channel string if config.Overrides.LXDChannel != "" { channel = config.Overrides.LXDChannel @@ -20,9 +20,9 @@ func NewLXD(runner runner.CommandRunner, config *config.Config) *LXD { return &LXD{ Channel: channel, - runner: runner, + runner: r, bootstrap: config.Providers.LXD.Bootstrap, - snaps: []packages.SnapPackage{packages.NewSnap("lxd", channel)}, + snaps: []*runner.Snap{{Name: "lxd", Channel: channel}}, } } @@ -32,7 +32,7 @@ type LXD struct { bootstrap bool runner runner.CommandRunner - snaps []packages.SnapPackage + snaps []*runner.Snap } // Prepare installs and configures LXD such that it can work in testing environments. diff --git a/internal/providers/lxd_test.go b/internal/providers/lxd_test.go index def04ec..7532676 100644 --- a/internal/providers/lxd_test.go +++ b/internal/providers/lxd_test.go @@ -1,13 +1,11 @@ package providers import ( - "os" "reflect" "testing" "github.com/jnsgruk/concierge/internal/config" - "github.com/jnsgruk/concierge/internal/packages" - "github.com/jnsgruk/concierge/internal/runnertest" + "github.com/jnsgruk/concierge/internal/runner" ) func TestNewLXD(t *testing.T) { @@ -24,7 +22,7 @@ func TestNewLXD(t *testing.T) { overrides := &config.Config{} overrides.Overrides.LXDChannel = "5.20/stable" - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() tests := []test{ {config: noOverrides, expected: &LXD{Channel: "", runner: runner}}, @@ -36,8 +34,8 @@ func TestNewLXD(t *testing.T) { lxd := NewLXD(runner, tc.config) // Check the constructed snaps are correct - if lxd.snaps[0].Channel() != tc.expected.Channel { - t.Fatalf("expected: %v, got: %v", lxd.snaps[0].Channel(), tc.expected.Channel) + if lxd.snaps[0].Channel != tc.expected.Channel { + t.Fatalf("expected: %v, got: %v", lxd.snaps[0].Channel, tc.expected.Channel) } // Remove the snaps so the rest of the object can be compared @@ -49,15 +47,10 @@ func TestNewLXD(t *testing.T) { } func TestLXDPrepareCommands(t *testing.T) { - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - defer os.Setenv("PATH", path) - os.Setenv("PATH", "") - config := &config.Config{} expected := []string{ - "snap install lxd --channel latest/stable", + "snap install lxd", "lxd waitready", "lxd init --minimal", "lxc network set lxdbr0 ipv6.address none", @@ -67,14 +60,8 @@ func TestLXDPrepareCommands(t *testing.T) { "iptables -P FORWARD ACCEPT", } - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() lxd := NewLXD(runner, config) - - // Override the snaps with fake ones that don't call the snapd socket. - lxd.snaps = []packages.SnapPackage{ - runnertest.NewTestSnap("lxd", "latest/stable", false, false), - } - lxd.Prepare() if !reflect.DeepEqual(expected, runner.ExecutedCommands) { @@ -83,14 +70,9 @@ func TestLXDPrepareCommands(t *testing.T) { } func TestLXDRestore(t *testing.T) { - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - defer os.Setenv("PATH", path) - os.Setenv("PATH", "") - config := &config.Config{} - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() lxd := NewLXD(runner, config) lxd.Restore() diff --git a/internal/providers/microk8s.go b/internal/providers/microk8s.go index 4c7603d..d450d40 100644 --- a/internal/providers/microk8s.go +++ b/internal/providers/microk8s.go @@ -21,7 +21,7 @@ import ( const defaultMicroK8sChannel = "1.31-strict/stable" // NewMicroK8s constructs a new MicroK8s provider instance. -func NewMicroK8s(runner runner.CommandRunner, config *config.Config) *MicroK8s { +func NewMicroK8s(r runner.CommandRunner, config *config.Config) *MicroK8s { var channel string if config.Overrides.MicroK8sChannel != "" { @@ -36,10 +36,10 @@ func NewMicroK8s(runner runner.CommandRunner, config *config.Config) *MicroK8s { Channel: channel, Addons: config.Providers.MicroK8s.Addons, bootstrap: config.Providers.MicroK8s.Bootstrap, - runner: runner, - snaps: []packages.SnapPackage{ - packages.NewSnap("microk8s", channel), - packages.NewSnap("kubectl", "stable"), + runner: r, + snaps: []*runner.Snap{ + {Name: "microk8s", Channel: channel}, + {Name: "kubectl", Channel: "stable"}, }, } } @@ -51,7 +51,7 @@ type MicroK8s struct { bootstrap bool runner runner.CommandRunner - snaps []packages.SnapPackage + snaps []*runner.Snap } // Prepare installs and configures MicroK8s such that it can work in testing environments. diff --git a/internal/providers/microk8s_test.go b/internal/providers/microk8s_test.go index 507424b..ca22597 100644 --- a/internal/providers/microk8s_test.go +++ b/internal/providers/microk8s_test.go @@ -1,13 +1,11 @@ package providers import ( - "os" "reflect" "testing" "github.com/jnsgruk/concierge/internal/config" - "github.com/jnsgruk/concierge/internal/packages" - "github.com/jnsgruk/concierge/internal/runnertest" + "github.com/jnsgruk/concierge/internal/runner" ) var defaultAddons []string = []string{ @@ -32,7 +30,7 @@ func TestNewMicroK8s(t *testing.T) { overrides.Overrides.MicroK8sChannel = "1.30/edge" overrides.Providers.MicroK8s.Addons = defaultAddons - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() tests := []test{ { @@ -53,8 +51,8 @@ func TestNewMicroK8s(t *testing.T) { uk8s := NewMicroK8s(runner, tc.config) // Check the constructed snaps are correct - if uk8s.snaps[0].Channel() != tc.expected.Channel { - t.Fatalf("expected: %v, got: %v", uk8s.snaps[0].Channel(), tc.expected.Channel) + if uk8s.snaps[0].Channel != tc.expected.Channel { + t.Fatalf("expected: %v, got: %v", uk8s.snaps[0].Channel, tc.expected.Channel) } // Remove the snaps so the rest of the object can be compared @@ -79,7 +77,7 @@ func TestMicroK8sGroupName(t *testing.T) { for _, tc := range tests { config := &config.Config{} config.Providers.MicroK8s.Channel = tc.channel - uk8s := NewMicroK8s(runnertest.NewMockRunner(), config) + uk8s := NewMicroK8s(runner.NewMockRunner(), config) if !reflect.DeepEqual(tc.expected, uk8s.GroupName()) { t.Fatalf("expected: %v, got: %v", tc.expected, uk8s.GroupName()) @@ -88,17 +86,13 @@ func TestMicroK8sGroupName(t *testing.T) { } func TestMicroK8sPrepareCommands(t *testing.T) { - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - defer os.Setenv("PATH", path) - os.Setenv("PATH", "") - config := &config.Config{} config.Providers.MicroK8s.Channel = "1.31-strict/stable" config.Providers.MicroK8s.Addons = defaultAddons expectedCommands := []string{ "snap install microk8s --channel 1.31-strict/stable", + "snap install kubectl --channel stable", "microk8s status --wait-ready", "microk8s enable hostpath-storage", "microk8s enable dns", @@ -112,14 +106,8 @@ func TestMicroK8sPrepareCommands(t *testing.T) { ".kube/config": "", } - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() uk8s := NewMicroK8s(runner, config) - - // Override the snaps with fake ones that don't call the snapd socket. - uk8s.snaps = []packages.SnapPackage{ - runnertest.NewTestSnap("microk8s", "1.31-strict/stable", false, false), - } - uk8s.Prepare() if !reflect.DeepEqual(expectedCommands, runner.ExecutedCommands) { @@ -132,16 +120,11 @@ func TestMicroK8sPrepareCommands(t *testing.T) { } func TestMicroK8sRestore(t *testing.T) { - // Prevent the path of the test machine interfering with the test results. - path := os.Getenv("PATH") - defer os.Setenv("PATH", path) - os.Setenv("PATH", "") - config := &config.Config{} config.Providers.MicroK8s.Channel = "1.31-strict/stable" config.Providers.MicroK8s.Addons = defaultAddons - runner := runnertest.NewMockRunner() + runner := runner.NewMockRunner() uk8s := NewMicroK8s(runner, config) uk8s.Restore() diff --git a/internal/runner/interface.go b/internal/runner/interface.go index 4e8a485..f539ce0 100644 --- a/internal/runner/interface.go +++ b/internal/runner/interface.go @@ -33,4 +33,12 @@ type CommandRunner interface { ReadHomeDirFile(filepath string) ([]byte, error) // ReadFile reads a file with an arbitrary path from the system. ReadFile(filePath string) ([]byte, error) + // SnapInfo returns information about a given snap, looking up details in the snap + // store using the snapd client API where necessary. + SnapInfo(snap string, channel string) (*SnapInfo, error) + // NewSnap returns a new Snap package. + NewSnap(snap, channel string) *Snap + // NewSnapFromString returns a constructed snap instance, where the snap is + // specified in shorthand form, i.e. `charmcraft/latest/edge`. + NewSnapFromString(snap string) *Snap } diff --git a/internal/runnertest/mock_runner.go b/internal/runner/mock_runner.go similarity index 64% rename from internal/runnertest/mock_runner.go rename to internal/runner/mock_runner.go index 6c77585..bce6957 100644 --- a/internal/runnertest/mock_runner.go +++ b/internal/runner/mock_runner.go @@ -1,20 +1,20 @@ -package runnertest +package runner import ( "fmt" "os" "os/user" + "strings" "time" - - "github.com/jnsgruk/concierge/internal/runner" ) -// NewMockRunner constructs a new mock command runner. +// NewMockRunner constructs a new mock command func NewMockRunner() *MockRunner { return &MockRunner{ CreatedFiles: map[string]string{}, mockReturns: map[string]MockCommandReturn{}, mockFiles: map[string][]byte{}, + mockSnapInfo: map[string]*SnapInfo{}, } } @@ -31,8 +31,9 @@ type MockRunner struct { CreatedDirectories []string Deleted []string - mockReturns map[string]MockCommandReturn - mockFiles map[string][]byte + mockFiles map[string][]byte + mockReturns map[string]MockCommandReturn + mockSnapInfo map[string]*SnapInfo } // MockCommandReturn sets a static return value representing command combined output, @@ -46,6 +47,15 @@ func (r *MockRunner) MockFile(filePath string, contents []byte) { r.mockFiles[filePath] = contents } +// MockSnapStoreLookup gets a new test snap and adds a mock snap into the mock test +func (r *MockRunner) MockSnapStoreLookup(name, channel string, classic, installed bool) *Snap { + r.mockSnapInfo[name] = &SnapInfo{ + Installed: installed, + Classic: classic, + } + return &Snap{Name: name, Channel: channel} +} + // User returns the user the runner executes commands on behalf of. func (r *MockRunner) User() *user.User { return &user.User{ @@ -57,7 +67,12 @@ func (r *MockRunner) User() *user.User { } // Run executes the command, returning the stdout/stderr where appropriate. -func (r *MockRunner) Run(c *runner.Command) ([]byte, error) { +func (r *MockRunner) Run(c *Command) ([]byte, error) { + // Prevent the path of the test machine interfering with the test results. + path := os.Getenv("PATH") + defer os.Setenv("PATH", path) + os.Setenv("PATH", "") + cmd := c.CommandString() r.ExecutedCommands = append(r.ExecutedCommands, cmd) @@ -71,13 +86,13 @@ func (r *MockRunner) Run(c *runner.Command) ([]byte, error) { // RunWithRetries executes the command, retrying utilising an exponential backoff pattern, // which starts at 1 second. Retries will be attempted up to the specified maximum duration. -func (r *MockRunner) RunWithRetries(c *runner.Command, maxDuration time.Duration) ([]byte, error) { +func (r *MockRunner) RunWithRetries(c *Command, maxDuration time.Duration) ([]byte, error) { return r.Run(c) } // RunMany takes a variadic number of Command's, and runs them in a loop, returning // and error if any command fails. -func (r *MockRunner) RunMany(commands ...*runner.Command) error { +func (r *MockRunner) RunMany(commands ...*Command) error { for _, cmd := range commands { _, err := r.Run(cmd) if err != nil { @@ -89,7 +104,7 @@ func (r *MockRunner) RunMany(commands ...*runner.Command) error { // RunExclusive is a wrapper around Run that uses a mutex to ensure that only one of that // particular command can be run at a time. -func (r *MockRunner) RunExclusive(c *runner.Command) ([]byte, error) { +func (r *MockRunner) RunExclusive(c *Command) ([]byte, error) { return r.Run(c) } @@ -131,3 +146,33 @@ func (r *MockRunner) RemoveAllHome(filePath string) error { r.Deleted = append(r.Deleted, filePath) return nil } + +// SnapInfo returns information about a given snap, looking up details in the snap +// store using the snapd client API where necessary. +func (r *MockRunner) SnapInfo(snap string, channel string) (*SnapInfo, error) { + snapInfo, ok := r.mockSnapInfo[snap] + if ok { + return snapInfo, nil + } + + return &SnapInfo{ + Installed: false, + Classic: false, + }, nil +} + +// NewSnap returns a Snap object with details populated from the snap store and local system. +func (r *MockRunner) NewSnap(name, channel string) *Snap { + return &Snap{Name: name, Channel: channel} +} + +// NewSnapFromString returns a constructed snap instance, where the snap is +// specified in shorthand form, i.e. `charmcraft/latest/edge`. +func (r *MockRunner) NewSnapFromString(snap string) *Snap { + before, after, found := strings.Cut(snap, "/") + if found { + return r.NewSnap(before, after) + } else { + return r.NewSnap(before, "") + } +} diff --git a/internal/runner/runner.go b/internal/runner/runner.go index 1ceb7d3..1c0524e 100644 --- a/internal/runner/runner.go +++ b/internal/runner/runner.go @@ -16,8 +16,8 @@ import ( "sync" "time" - "github.com/fatih/color" retry "github.com/sethvargo/go-retry" + client "github.com/snapcore/snapd/client" ) // NewRunner constructs a new command runner. @@ -30,6 +30,7 @@ func NewRunner(trace bool) (*Runner, error) { trace: trace, user: realUser, cmdMutexes: map[string]*sync.Mutex{}, + snapd: *client.New(nil), }, nil } @@ -37,6 +38,7 @@ func NewRunner(trace bool) (*Runner, error) { type Runner struct { trace bool user *user.User + snapd client.Client // Map of mutexes to prevent the concurrent execution of certain commands. cmdMutexes map[string]*sync.Mutex } @@ -217,54 +219,3 @@ func (r *Runner) chownRecursively(path string, user *user.User) error { slog.Debug("Filesystem ownership changed", "user", user.Username, "group", user.Gid, "path", path) return err } - -// generateTraceMessage creates a formatted string that is written to stdout, representing -// a command and it's output when concierge is run with `--trace`. -func generateTraceMessage(cmd string, output []byte) string { - green := color.New(color.FgGreen, color.Bold, color.Underline) - bold := color.New(color.Bold) - - result := fmt.Sprintf("%s %s\n", green.Sprintf("Command:"), bold.Sprintf(cmd)) - if len(output) > 0 { - result = fmt.Sprintf("%s%s\n%s", result, green.Sprintf("Output:"), string(output)) - } - return result -} - -// getShellPath tries to find the path to the user's preferred shell, as per the `SHELL“ -// environment variable. If that cannot be found, it looks for a path to "bash", and to -// "sh" in that order. If no shell can be found, then an error is returned. -func getShellPath() (string, error) { - // If the `SHELL` var is set, return that. - shellVar := os.Getenv("SHELL") - if len(shellVar) > 0 { - return shellVar, nil - } - - // Try both the command name (to lookup in PATH), and common default paths. - for _, shell := range []string{"bash", "/bin/bash", "sh", "/bin/sh"} { - // Check if the shell path exists - if _, err := os.Stat(shell); errors.Is(err, os.ErrNotExist) { - // If the path doesn't exist, the lookup the value in the `PATH` variable - path, err := exec.LookPath(shell) - if err != nil { - continue - } - return path, nil - } - return shell, nil - } - - return "", fmt.Errorf("could not find path to a shell") -} - -// realUser returns a user struct containing details of the "real" user, which -// may differ from the current user when concierge is executed with `sudo`. -func realUser() (*user.User, error) { - realUser := os.Getenv("SUDO_USER") - if len(realUser) == 0 { - return user.Lookup("root") - } - - return user.Lookup(realUser) -} diff --git a/internal/runner/snap.go b/internal/runner/snap.go new file mode 100644 index 0000000..453c00b --- /dev/null +++ b/internal/runner/snap.go @@ -0,0 +1,101 @@ +package runner + +import ( + "context" + "fmt" + "log/slog" + "strings" + "time" + + retry "github.com/sethvargo/go-retry" + client "github.com/snapcore/snapd/client" +) + +// SnapInfo represents information about a snap fetched from the snapd API. +type SnapInfo struct { + Installed bool + Classic bool +} + +// Snap represents a given snap on a given channel. +type Snap struct { + Name string + Channel string +} + +// NewSnap returns a new Snap package. +func (r *Runner) NewSnap(name, channel string) *Snap { + return &Snap{Name: name, Channel: channel} +} + +// NewSnapFromString returns a constructed snap instance, where the snap is +// specified in shorthand form, i.e. `charmcraft/latest/edge`. +func (r *Runner) NewSnapFromString(snap string) *Snap { + before, after, found := strings.Cut(snap, "/") + if found { + return r.NewSnap(before, after) + } else { + return r.NewSnap(before, "") + } +} + +// SnapInfo returns information about a given snap, looking up details in the snap +// store using the snapd client API where necessary. +func (r *Runner) SnapInfo(snap string, channel string) (*SnapInfo, error) { + classic, err := r.snapIsClassic(snap, channel) + if err != nil { + return nil, err + } + + installed := r.snapInstalled(snap) + + slog.Debug("Queried snapd API", "snap", snap, "installed", installed, "classic", classic) + return &SnapInfo{Installed: installed, Classic: classic}, nil +} + +// snapInstalled is a helper that reports if the snap is currently Installed. +func (r *Runner) snapInstalled(name string) bool { + s, err := r.withRetry(func(ctx context.Context) (*client.Snap, error) { + snap, _, err := r.snapd.Snap(name) + if err != nil && strings.Contains(err.Error(), "snap not installed") { + return snap, nil + } else if err != nil { + return nil, retry.RetryableError(err) + } + return snap, nil + }) + if err != nil || s == nil { + return false + } + + return s.Status == client.StatusActive +} + +// snapIsClassic reports whether or not the snap at the tip of the specified channel uses +// Classic confinement or not. +func (r *Runner) snapIsClassic(name, channel string) (bool, error) { + snap, err := r.withRetry(func(ctx context.Context) (*client.Snap, error) { + snap, _, err := r.snapd.FindOne(name) + if err != nil { + return nil, retry.RetryableError(err) + } + return snap, nil + }) + if err != nil { + return false, fmt.Errorf("failed to find snap: %w", err) + } + + c, ok := snap.Channels[channel] + if ok { + return c.Confinement == "classic", nil + } + + return snap.Confinement == "classic", nil +} + +func (r *Runner) withRetry(f func(ctx context.Context) (*client.Snap, error)) (*client.Snap, error) { + backoff := retry.NewExponential(1 * time.Second) + backoff = retry.WithMaxRetries(10, backoff) + ctx := context.Background() + return retry.DoValue(ctx, backoff, f) +} diff --git a/internal/packages/snap_test.go b/internal/runner/snap_test.go similarity index 52% rename from internal/packages/snap_test.go rename to internal/runner/snap_test.go index 5017085..cce72ed 100644 --- a/internal/packages/snap_test.go +++ b/internal/runner/snap_test.go @@ -1,4 +1,4 @@ -package packages +package runner import ( "testing" @@ -11,17 +11,19 @@ func TestNewSnapFromString(t *testing.T) { } tests := []test{ - {input: "juju", expected: &Snap{name: "juju"}}, - {input: "juju/latest/edge", expected: &Snap{name: "juju", channel: "latest/edge"}}, - {input: "juju/stable", expected: &Snap{name: "juju", channel: "stable"}}, + {input: "juju", expected: &Snap{Name: "juju"}}, + {input: "juju/latest/edge", expected: &Snap{Name: "juju", Channel: "latest/edge"}}, + {input: "juju/stable", expected: &Snap{Name: "juju", Channel: "stable"}}, } for _, tc := range tests { - snap := NewSnapFromString(tc.input) - if tc.expected.channel != snap.channel { + runner := NewMockRunner() + snap := runner.NewSnapFromString(tc.input) + + if tc.expected.Channel != snap.Channel { t.Fatalf("incorrect snap channel; expected: %v, got: %v", tc.expected, snap) } - if tc.expected.name != snap.name { + if tc.expected.Name != snap.Name { t.Fatalf("incorrect snap name; expected: %v, got: %v", tc.expected, snap) } } diff --git a/internal/runner/util.go b/internal/runner/util.go new file mode 100644 index 0000000..65c5c4e --- /dev/null +++ b/internal/runner/util.go @@ -0,0 +1,62 @@ +package runner + +import ( + "errors" + "fmt" + "os" + "os/exec" + "os/user" + + "github.com/fatih/color" +) + +// generateTraceMessage creates a formatted string that is written to stdout, representing +// a command and it's output when concierge is run with `--trace`. +func generateTraceMessage(cmd string, output []byte) string { + green := color.New(color.FgGreen, color.Bold, color.Underline) + bold := color.New(color.Bold) + + result := fmt.Sprintf("%s %s\n", green.Sprintf("Command:"), bold.Sprintf(cmd)) + if len(output) > 0 { + result = fmt.Sprintf("%s%s\n%s", result, green.Sprintf("Output:"), string(output)) + } + return result +} + +// getShellPath tries to find the path to the user's preferred shell, as per the `SHELL“ +// environment variable. If that cannot be found, it looks for a path to "bash", and to +// "sh" in that order. If no shell can be found, then an error is returned. +func getShellPath() (string, error) { + // If the `SHELL` var is set, return that. + shellVar := os.Getenv("SHELL") + if len(shellVar) > 0 { + return shellVar, nil + } + + // Try both the command name (to lookup in PATH), and common default paths. + for _, shell := range []string{"bash", "/bin/bash", "sh", "/bin/sh"} { + // Check if the shell path exists + if _, err := os.Stat(shell); errors.Is(err, os.ErrNotExist) { + // If the path doesn't exist, the lookup the value in the `PATH` variable + path, err := exec.LookPath(shell) + if err != nil { + continue + } + return path, nil + } + return shell, nil + } + + return "", fmt.Errorf("could not find path to a shell") +} + +// realUser returns a user struct containing details of the "real" user, which +// may differ from the current user when concierge is executed with `sudo`. +func realUser() (*user.User, error) { + realUser := os.Getenv("SUDO_USER") + if len(realUser) == 0 { + return user.Lookup("root") + } + + return user.Lookup(realUser) +} diff --git a/internal/runnertest/mock_snap.go b/internal/runnertest/mock_snap.go deleted file mode 100644 index cba99b7..0000000 --- a/internal/runnertest/mock_snap.go +++ /dev/null @@ -1,19 +0,0 @@ -package runnertest - -func NewTestSnap(name, channel string, classic bool, installed bool) *TestSnap { - return &TestSnap{name: name, channel: channel, classic: classic, installed: installed} -} - -type TestSnap struct { - name string - channel string - classic bool - installed bool -} - -func (ts *TestSnap) Name() string { return ts.name } -func (ts *TestSnap) Classic() (bool, error) { return ts.classic, nil } -func (ts *TestSnap) Installed() bool { return ts.installed } -func (ts *TestSnap) Tracking() (string, error) { return ts.channel, nil } -func (ts *TestSnap) Channel() string { return ts.channel } -func (ts *TestSnap) SetChannel(c string) { ts.channel = c }