feat: Added multi-platform plugin hook support

Signed-off-by: Steve Hipwell <steve.hipwell@gmail.com>

cmd/helm/plugin.go

@@ -47,19 +47,26 @@ func newPluginCmd(out io.Writer) *cobra.Command {
 
 // runHook will execute a plugin hook.
 func runHook(p *plugin.Plugin, event string) error {
-	hook := p.Metadata.Hooks[event]
-	if hook == "" {
+	var cmd string
+	var cmdArgs []string
+
+	plugin.SetupPluginEnv(settings, p.Metadata.Name, p.Dir)
+
+	command := p.Metadata.Hooks[event]
+	if command != "" {
+		cmd = "sh"
+		cmdArgs = []string{"-c", command}
+	}
+
+	main, argv, err := plugin.PrepareCommands(p.Metadata.PlatformHooks[event], cmd, cmdArgs, []string{})
+	if err != nil {
 		return nil
 	}
 
-	prog := exec.Command("sh", "-c", hook)
-	// TODO make this work on windows
-	// I think its ... ¯\_(ツ)_/¯
-	// prog := exec.Command("cmd", "/C", p.Metadata.Hooks.Install())
+	prog := exec.Command(main, argv...)
 
 	debug("running %s hook: %s", event, prog)
 
-	plugin.SetupPluginEnv(settings, p.Metadata.Name, p.Dir)
 	prog.Stdout, prog.Stderr = os.Stdout, os.Stderr
 	if err := prog.Run(); err != nil {
 		if eerr, ok := err.(*exec.ExitError); ok {

pkg/plugin/hooks.go

@@ -25,5 +25,8 @@ const (
 	Update = "update"
 )
 
+// PlatformHooks is a map of events to a command for a particular operating system and architecture.
+type PlatformHooks map[string][]PlatformCommand
+
 // Hooks is a map of events to commands.
 type Hooks map[string]string

pkg/plugin/plugin.go

@@ -44,9 +44,10 @@ type Downloaders struct {
 
 // PlatformCommand represents a command for a particular operating system and architecture
 type PlatformCommand struct {
-	OperatingSystem string `json:"os"`
-	Architecture    string `json:"arch"`
-	Command         string `json:"command"`
+	OperatingSystem string   `json:"os"`
+	Architecture    string   `json:"arch"`
+	Command         string   `json:"command"`
+	Args            []string `json:"args"`
 }
 
 // Metadata describes a plugin.
@@ -91,7 +92,8 @@ type Metadata struct {
 	IgnoreFlags bool `json:"ignoreFlags"`
 
 	// Hooks are commands that will run on events.
-	Hooks Hooks
+	PlatformHooks PlatformHooks `json:"platformHooks"`
+	Hooks         Hooks
 
 	// Downloaders field is used if the plugin supply downloader mechanism
 	// for special protocols.
@@ -116,21 +118,29 @@ type Plugin struct {
 // - If both OS and Arch match the current platform, search will stop and the command will be prepared for execution
 // - If OS matches and there is no more specific match, the command will be prepared for execution
 // - If no OS/Arch match is found, return nil
-func getPlatformCommand(cmds []PlatformCommand) []string {
-	var command []string
+func getPlatformCommand(cmds []PlatformCommand) ([]string, []string) {
+	var command, args []string
+
 	eq := strings.EqualFold
 	for _, c := range cmds {
+		if len(c.Architecture) > 0 && !eq(c.Architecture, runtime.GOARCH) {
+			continue
+		}
+
 		if eq(c.OperatingSystem, runtime.GOOS) {
 			command = strings.Split(c.Command, " ")
+			args = c.Args
 		}
+
 		if eq(c.OperatingSystem, runtime.GOOS) && eq(c.Architecture, runtime.GOARCH) {
-			return strings.Split(c.Command, " ")
+			return strings.Split(c.Command, " "), c.Args
 		}
 	}
-	return command
+
+	return command, args
 }
 
-// PrepareCommand takes a Plugin.PlatformCommand.Command, a Plugin.Command and will applying the following processing:
+// PrepareCommands takes a []Plugin.PlatformCommand, a Plugin.Command and will applying the following processing:
 // - If platformCommand is present, it will be searched first
 // - If both OS and Arch match the current platform, search will stop and the command will be prepared for execution
 // - If OS matches and there is no more specific match, the command will be prepared for execution
@@ -141,33 +151,63 @@ func getPlatformCommand(cmds []PlatformCommand) []string {
 // returns the name of the command and an args array.
 //
 // The result is suitable to pass to exec.Command.
-func (p *Plugin) PrepareCommand(extraArgs []string) (string, []string, error) {
-	var parts []string
-	platCmdLen := len(p.Metadata.PlatformCommand)
-	if platCmdLen > 0 {
-		parts = getPlatformCommand(p.Metadata.PlatformCommand)
+func PrepareCommands(cmds []PlatformCommand, command string, commandArgs []string, extraArgs []string) (string, []string, error) {
+	var cmdParts, args []string
+
+	cmdsLen := len(cmds)
+	if cmdsLen > 0 {
+		cmdParts, args = getPlatformCommand(cmds)
 	}
-	if platCmdLen == 0 || parts == nil {
-		parts = strings.Split(p.Metadata.Command, " ")
+	if cmdsLen == 0 || cmdParts == nil {
+		cmdParts = strings.Split(command, " ")
+		args = commandArgs
 	}
-	if len(parts) == 0 || parts[0] == "" {
+	if len(cmdParts) == 0 || cmdParts[0] == "" {
 		return "", nil, fmt.Errorf("no plugin command is applicable")
 	}
 
-	main := os.ExpandEnv(parts[0])
+	main := os.ExpandEnv(cmdParts[0])
 	baseArgs := []string{}
-	if len(parts) > 1 {
-		for _, cmdpart := range parts[1:] {
-			cmdexp := os.ExpandEnv(cmdpart)
-			baseArgs = append(baseArgs, cmdexp)
+	if len(cmdParts) > 1 {
+		for _, cmdPart := range cmdParts[1:] {
+			cmdExp := os.ExpandEnv(cmdPart)
+			baseArgs = append(baseArgs, cmdExp)
 		}
 	}
-	if !p.Metadata.IgnoreFlags {
+
+	for _, arg := range args {
+		argExp := os.ExpandEnv(arg)
+		baseArgs = append(baseArgs, argExp)
+	}
+
+	if len(extraArgs) > 0 {
 		baseArgs = append(baseArgs, extraArgs...)
 	}
+
 	return main, baseArgs, nil
 }
 
+// PrepareCommand takes a Plugin.PlatformCommand.Command, a Plugin.Command and will applying the following processing:
+// - If platformCommand is present, it will be searched first
+// - If both OS and Arch match the current platform, search will stop and the command will be prepared for execution
+// - If OS matches and there is no more specific match, the command will be prepared for execution
+// - If no OS/Arch match is found, the default command will be prepared for execution
+// - If no command is present and no matches are found in platformCommand, will exit with an error
+//
+// It merges extraArgs into any arguments supplied in the plugin. It
+// returns the name of the command and an args array.
+//
+// The result is suitable to pass to exec.Command.
+func (p *Plugin) PrepareCommand(extraArgs []string) (string, []string, error) {
+	var extraArgsIn []string
+
+	if !p.Metadata.IgnoreFlags {
+		extraArgsIn = extraArgs
+	}
+
+	return PrepareCommands(p.Metadata.PlatformCommand, p.Metadata.Command, []string{}, extraArgsIn)
+}
+
 // validPluginName is a regular expression that validates plugin names.
 //
 // Plugin names can only contain the ASCII characters a-z, A-Z, 0-9, ​_​ and ​-.

pkg/plugin/plugin_test.go

@@ -26,7 +26,7 @@ import (
 	"helm.sh/helm/v3/pkg/cli"
 )
 
-func checkCommand(p *Plugin, extraArgs []string, osStrCmp string, t *testing.T) {
+func checkPlatformCommand(p *Plugin, extraArgs []string, osStrCmp string, t *testing.T) {
 	cmd, args, err := p.PrepareCommand(extraArgs)
 	if err != nil {
 		t.Fatal(err)
@@ -76,7 +76,7 @@ func TestPrepareCommand(t *testing.T) {
 	}
 	argv := []string{"--debug", "--foo", "bar"}
 
-	checkCommand(p, argv, "foo", t)
+	checkPlatformCommand(p, argv, "foo", t)
 }
 
 func TestPlatformPrepareCommand(t *testing.T) {
@@ -118,7 +118,7 @@ func TestPlatformPrepareCommand(t *testing.T) {
 	}
 
 	argv := []string{"--debug", "--foo", "bar"}
-	checkCommand(p, argv, osStrCmp, t)
+	checkPlatformCommand(p, argv, osStrCmp, t)
 }
 
 func TestPartialPlatformPrepareCommand(t *testing.T) {
@@ -145,7 +145,7 @@ func TestPartialPlatformPrepareCommand(t *testing.T) {
 	}
 
 	argv := []string{"--debug", "--foo", "bar"}
-	checkCommand(p, argv, osStrCmp, t)
+	checkPlatformCommand(p, argv, osStrCmp, t)
 }
 
 func TestNoPrepareCommand(t *testing.T) {
@@ -180,6 +180,93 @@ func TestNoMatchPrepareCommand(t *testing.T) {
 	}
 }
 
+func TestPrepareCommands(t *testing.T) {
+	cmds := []PlatformCommand{
+		{OperatingSystem: "no-os", Architecture: "no-arch", Command: "pwsh", Args: []string{"-c", "echo \"error\""}},
+		{OperatingSystem: runtime.GOOS, Architecture: runtime.GOARCH, Command: "sh", Args: []string{"-c", "echo \"test\""}},
+		{OperatingSystem: runtime.GOOS, Architecture: "no-arch", Command: "pwsh", Args: []string{"-c", "echo \"error\""}},
+		{OperatingSystem: runtime.GOOS, Architecture: "", Command: "pwsh", Args: []string{"-c", "echo \"error\""}},
+	}
+	extraArgs := []string{"--debug", "--foo", "bar"}
+
+	expectedIndex := 1
+	resultArgs := append(cmds[expectedIndex].Args, extraArgs...)
+
+	cmd, args, err := PrepareCommands(cmds, "pwsh", []string{"-c", "echo \"error\""}, extraArgs)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cmd != cmds[expectedIndex].Command {
+		t.Fatalf("Expected %q, got %q", cmds[expectedIndex].Command, cmd)
+	}
+	if !reflect.DeepEqual(args, resultArgs) {
+		t.Fatalf("Expected %v, got %v", resultArgs, args)
+	}
+}
+
+func TestPrepareCommandsNoArch(t *testing.T) {
+	cmds := []PlatformCommand{
+		{OperatingSystem: "no-os", Architecture: "no-arch", Command: "pwsh", Args: []string{"-c", "echo \"error\""}},
+		{OperatingSystem: runtime.GOOS, Architecture: "", Command: "sh", Args: []string{"-c", "echo \"test\""}},
+		{OperatingSystem: runtime.GOOS, Architecture: "no-arch", Command: "pwsh", Args: []string{"-c", "echo \"error\""}},
+	}
+
+	expectedIndex := 1
+
+	cmd, args, err := PrepareCommands(cmds, "pwsh", []string{"-c", "echo \"error\""}, []string{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cmd != cmds[expectedIndex].Command {
+		t.Fatalf("Expected %q, got %q", cmds[expectedIndex].Command, cmd)
+	}
+	if !reflect.DeepEqual(args, cmds[expectedIndex].Args) {
+		t.Fatalf("Expected %v, got %v", cmds[expectedIndex].Args, args)
+	}
+}
+
+func TestPrepareCommandsFallback(t *testing.T) {
+	cmds := []PlatformCommand{
+		{OperatingSystem: "no-os", Architecture: "no-arch", Command: "sh", Args: []string{"-c", "echo \"test\""}},
+		{OperatingSystem: runtime.GOOS, Architecture: "no-arch", Command: "sh", Args: []string{"-c", "echo \"test\""}},
+		{OperatingSystem: "no-os", Architecture: runtime.GOARCH, Command: "sh", Args: []string{"-c", "echo \"test\""}},
+	}
+
+	command := "sh"
+	commandArgs := []string{"-c", "echo \"test\""}
+
+	cmd, args, err := PrepareCommands(cmds, command, commandArgs, []string{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cmd != command {
+		t.Fatalf("Expected %q, got %q", command, cmd)
+	}
+	if !reflect.DeepEqual(args, commandArgs) {
+		t.Fatalf("Expected %v, got %v", commandArgs, args)
+	}
+}
+
+func TestPrepareCommandsNoMatch(t *testing.T) {
+	cmds := []PlatformCommand{
+		{OperatingSystem: "no-os", Architecture: "no-arch", Command: "sh", Args: []string{"-c", "echo \"test\""}},
+		{OperatingSystem: runtime.GOOS, Architecture: "no-arch", Command: "sh", Args: []string{"-c", "echo \"test\""}},
+		{OperatingSystem: "no-os", Architecture: runtime.GOARCH, Command: "sh", Args: []string{"-c", "echo \"test\""}},
+	}
+
+	if _, _, err := PrepareCommands(cmds, "", []string{}, []string{}); err == nil {
+		t.Fatalf("Expected error to be returned")
+	}
+}
+
+func TestPrepareCommandsNoCommands(t *testing.T) {
+	cmds := []PlatformCommand{}
+
+	if _, _, err := PrepareCommands(cmds, "", []string{}, []string{}); err == nil {
+		t.Fatalf("Expected error to be returned")
+	}
+}
+
 func TestLoadDir(t *testing.T) {
 	dirname := "testdata/plugdir/good/hello"
 	plug, err := LoadDir(dirname)
@@ -196,8 +283,18 @@ func TestLoadDir(t *testing.T) {
 		Version:     "0.1.0",
 		Usage:       "usage",
 		Description: "description",
-		Command:     "$HELM_PLUGIN_DIR/hello.sh",
+		PlatformCommand: []PlatformCommand{
+			{OperatingSystem: "linux", Architecture: "", Command: "sh", Args: []string{"-c", "${HELM_PLUGIN_DIR}/hello.sh"}},
+			{OperatingSystem: "windows", Architecture: "", Command: "pwsh", Args: []string{"-c", "${HELM_PLUGIN_DIR}/hello.ps1"}},
+		},
+		Command:     "${HELM_PLUGIN_DIR}/hello.sh",
 		IgnoreFlags: true,
+		PlatformHooks: map[string][]PlatformCommand{
+			Install: {
+				{OperatingSystem: "linux", Architecture: "", Command: "sh", Args: []string{"-c", "echo \"installing...\""}},
+				{OperatingSystem: "windows", Architecture: "", Command: "pwsh", Args: []string{"-c", "echo \"installing...\""}},
+			},
+		},
 		Hooks: map[string]string{
 			Install: "echo installing...",
 		},

pkg/plugin/testdata/plugdir/good/hello/hello.ps1

@@ -0,0 +1,3 @@
+#!/usr/bin/env pwsh
+
+Write-Host "Hello, world!"

pkg/plugin/testdata/plugdir/good/hello/plugin.yaml

@@ -3,7 +3,26 @@ version: "0.1.0"
 usage: "usage"
 description: |-
   description
-command: "$HELM_PLUGIN_DIR/hello.sh"
+platformCommand:
+  - os: linux
+    arch:
+    command: "sh"
+    args: ["-c", "${HELM_PLUGIN_DIR}/hello.sh"]
+  - os: windows
+    arch:
+    command: "pwsh"
+    args: ["-c", "${HELM_PLUGIN_DIR}/hello.ps1"]
+command: "${HELM_PLUGIN_DIR}/hello.sh"
 ignoreFlags: true
+PlatformHooks:
+  install:
+    - os: linux
+      arch:
+      command: "sh"
+      args: ["-c", 'echo "installing..."']
+    - os: windows
+      arch:
+      command: "pwsh"
+      args: ["-c", 'echo "installing..."']
 hooks:
   install: "echo installing..."