Support environments with broken $HOME (#1057)

* Support environments with broken $HOME

Currently in standalone mode dapr cli will install the dapr runtime
binaries into $HOME/.dapr. However, in some environments $HOME is
readonly or os.UserHomeDir() can fail (e.g. AWS Lambda). To support
dapr in these environments this change does 2 things:

1. Allows the user to set DAPR_PATH environment variable to indicate
the location of the dapr runtime binaries.

2. Allows the user to optionally specify --dapr-path cli flag to
indicate the location of the dapr runtime binaries. When both
DAPR_PATH environment variable and --dapr-path CLI flag are present,
the cli flag has higher precedence.

When neither DAPR_PATH nor the --dapr-path CLI flag are present, we
fallback to existing behavior of defaulting to $HOME/.dapr.

Signed-off-by: Mike Brown <[email protected]>

* Address comments

Signed-off-by: Shubham Sharma <[email protected]>

* Address comments

Signed-off-by: Shubham Sharma <[email protected]>

* Address comments

Signed-off-by: Shubham Sharma <[email protected]>

* Fix unit test

Signed-off-by: Shubham Sharma <[email protected]>

* Fix e2e test

Signed-off-by: Shubham Sharma <[email protected]>

* Fix lint

Signed-off-by: Shubham Sharma <[email protected]>

Signed-off-by: Mike Brown <[email protected]>
Signed-off-by: Shubham Sharma <[email protected]>
Co-authored-by: Shubham Sharma <[email protected]>

Author: mikeb26

cmd/buildinfo.go

@@ -15,9 +15,11 @@ package cmd
 
 import (
 	"fmt"
+	"os"
 
 	"github.com/spf13/cobra"
 
+	"github.com/dapr/cli/pkg/print"
 	"github.com/dapr/cli/pkg/standalone"
 )
 
@@ -29,7 +31,12 @@ var BuildInfoCmd = &cobra.Command{
 dapr build-info
 `,
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println(standalone.GetBuildInfo(RootCmd.Version))
+		out, err := standalone.GetBuildInfo(daprPath, RootCmd.Version)
+		if err != nil {
+			print.FailureStatusEvent(os.Stderr, "Error getting build info: %s", err.Error())
+			os.Exit(1)
+		}
+		fmt.Println(out)
 	},
 }
 

cmd/dapr.go

@@ -49,16 +49,20 @@ type daprVersion struct {
 var (
 	daprVer   daprVersion
 	logAsJSON bool
+	daprPath  string
 )
 
 // Execute adds all child commands to the root command.
 func Execute(version, apiVersion string) {
 	RootCmd.Version = version
 	api.RuntimeAPIVersion = apiVersion
 
+	// err intentionally ignored since daprd may not yet be installed.
+	runtimeVer, _ := standalone.GetRuntimeVersion(daprPath)
+
 	daprVer = daprVersion{
 		CliVersion:     version,
-		RuntimeVersion: strings.ReplaceAll(standalone.GetRuntimeVersion(), "\n", ""),
+		RuntimeVersion: strings.ReplaceAll(runtimeVer, "\n", ""),
 	}
 
 	cobra.OnInitialize(initConfig)
@@ -87,5 +91,6 @@ func initConfig() {
 }
 
 func init() {
+	RootCmd.PersistentFlags().StringVarP(&daprPath, "dapr-path", "", "", "The path to the dapr installation directory")
 	RootCmd.PersistentFlags().BoolVarP(&logAsJSON, "log-as-json", "", false, "Log output in JSON format")
 }

cmd/dashboard.go

@@ -79,7 +79,13 @@ dapr dashboard -k -p 0
 `,
 	Run: func(cmd *cobra.Command, args []string) {
 		if dashboardVersionCmd {
-			fmt.Println(standalone.GetDashboardVersion())
+			dashboardVer, err := standalone.GetDashboardVersion(daprPath)
+			if err != nil {
+				print.FailureStatusEvent(os.Stderr, "Failed to get Dapr install directory: %v", err)
+				os.Exit(1)
+			}
+
+			fmt.Println(dashboardVer)
 			os.Exit(0)
 		}
 
@@ -179,9 +185,14 @@ dapr dashboard -k -p 0
 			<-portForward.GetStop()
 		} else {
 			// Standalone mode.
-			err := standalone.NewDashboardCmd(dashboardLocalPort).Run()
+			dashboardCmd, err := standalone.NewDashboardCmd(daprPath, dashboardLocalPort)
 			if err != nil {
-				print.FailureStatusEvent(os.Stderr, "Dapr dashboard not found. Is Dapr installed?")
+				print.FailureStatusEvent(os.Stderr, "Failed to get Dapr install	directory: %v", err)
+			} else {
+				err = dashboardCmd.Run()
+				if err != nil {
+					print.FailureStatusEvent(os.Stderr, "Dapr dashboard failed to run: %v", err)
+				}
 			}
 		}
 	},
@@ -199,5 +210,6 @@ func init() {
 	DashboardCmd.Flags().IntVarP(&dashboardLocalPort, "port", "p", defaultLocalPort, "The local port on which to serve Dapr dashboard")
 	DashboardCmd.Flags().StringVarP(&dashboardNamespace, "namespace", "n", daprSystemNamespace, "The namespace where Dapr dashboard is running")
 	DashboardCmd.Flags().BoolP("help", "h", false, "Print this help message")
+
 	RootCmd.AddCommand(DashboardCmd)
 }

cmd/init.go

@@ -81,6 +81,9 @@ dapr init --from-dir <path-to-directory>
 # Initialize dapr with a particular image variant. Allowed values: "mariner"
 dapr init --image-variant <variant>
 
+# Initialize Dapr to non-default install directory (default is $HOME/.dapr)
+dapr init --dapr-path <path-to-install-directory>
+
 # See more at: https://docs.dapr.io/getting-started/
 `,
 	Run: func(cmd *cobra.Command, args []string) {
@@ -92,6 +95,11 @@ dapr init --image-variant <variant>
 			imageRegistryURI := ""
 			var err error
 
+			if len(strings.TrimSpace(daprPath)) != 0 {
+				print.FailureStatusEvent(os.Stderr, "--dapr-path is only valid for self-hosted mode")
+				os.Exit(1)
+			}
+
 			if len(imageRegistryFlag) != 0 {
 				warnForPrivateRegFeat()
 				imageRegistryURI = imageRegistryFlag
@@ -137,11 +145,12 @@ dapr init --image-variant <variant>
 			if len(imageRegistryURI) != 0 {
 				warnForPrivateRegFeat()
 			}
+
 			if !utils.IsValidContainerRuntime(containerRuntime) {
 				print.FailureStatusEvent(os.Stdout, "Invalid container runtime. Supported values are docker and podman.")
 				os.Exit(1)
 			}
-			err := standalone.Init(runtimeVersion, dashboardVersion, dockerNetwork, slimMode, imageRegistryURI, fromDir, containerRuntime, imageVariant)
+			err := standalone.Init(runtimeVersion, dashboardVersion, dockerNetwork, slimMode, imageRegistryURI, fromDir, containerRuntime, imageVariant, daprPath)
 			if err != nil {
 				print.FailureStatusEvent(os.Stderr, err.Error())
 				os.Exit(1)
@@ -168,6 +177,7 @@ func init() {
 	if dashboardVersionEnv != "" {
 		defaultDashboardVersion = dashboardVersionEnv
 	}
+
 	InitCmd.Flags().BoolVarP(&kubernetesMode, "kubernetes", "k", false, "Deploy Dapr to a Kubernetes cluster")
 	InitCmd.Flags().BoolVarP(&wait, "wait", "", false, "Wait for Kubernetes initialization to complete")
 	InitCmd.Flags().UintVarP(&timeout, "timeout", "", 300, "The wait timeout for the Kubernetes installation")
@@ -184,5 +194,6 @@ func init() {
 	InitCmd.Flags().StringArrayVar(&values, "set", []string{}, "set values on the command line (can specify multiple or separate values with commas: key1=val1,key2=val2)")
 	InitCmd.Flags().String("image-registry", "", "Custom/private docker image repository URL")
 	InitCmd.Flags().StringVarP(&containerRuntime, "container-runtime", "", "docker", "The container runtime to use. Supported values are docker (default) and podman")
+
 	RootCmd.AddCommand(InitCmd)
 }

cmd/run.go

@@ -84,6 +84,9 @@ dapr run --app-id myapp
 
 # Run a gRPC application written in Go (listening on port 3000)
 dapr run --app-id myapp --app-port 3000 --app-protocol grpc -- go run main.go
+
+# Run sidecar only specifying dapr runtime installation directory
+dapr run --app-id myapp --dapr-path /usr/local/dapr
   `,
 	Args: cobra.MinimumNArgs(0),
 	PreRun: func(cmd *cobra.Command, args []string) {
@@ -94,6 +97,22 @@ dapr run --app-id myapp --app-port 3000 --app-protocol grpc -- go run main.go
 			fmt.Println(print.WhiteBold("WARNING: no application command found."))
 		}
 
+		daprDirPath, err := standalone.GetDaprPath(daprPath)
+		if err != nil {
+			print.FailureStatusEvent(os.Stderr, "Failed to get Dapr install directory: %v", err)
+			os.Exit(1)
+		}
+
+		// Fallback to default config file if not specified.
+		if configFile == "" {
+			configFile = standalone.GetDaprConfigPath(daprDirPath)
+		}
+
+		// Fallback to default components directory if not specified.
+		if componentsPath == "" {
+			componentsPath = standalone.GetDaprComponentsPath(daprDirPath)
+		}
+
 		if unixDomainSocket != "" {
 			// TODO(@daixiang0): add Windows support.
 			if runtime.GOOS == "windows" {
@@ -134,6 +153,7 @@ dapr run --app-id myapp --app-port 3000 --app-protocol grpc -- go run main.go
 			AppHealthThreshold: appHealthThreshold,
 			EnableAPILogging:   enableAPILogging,
 			InternalGRPCPort:   internalGRPCPort,
+			DaprPathCmdFlag:    daprPath,
 			APIListenAddresses: apiListenAddresses,
 		})
 		if err != nil {
@@ -368,7 +388,7 @@ dapr run --app-id myapp --app-port 3000 --app-protocol grpc -- go run main.go
 func init() {
 	RunCmd.Flags().IntVarP(&appPort, "app-port", "p", -1, "The port your application is listening on")
 	RunCmd.Flags().StringVarP(&appID, "app-id", "a", "", "The id for your application, used for service discovery")
-	RunCmd.Flags().StringVarP(&configFile, "config", "c", standalone.DefaultConfigFilePath(), "Dapr configuration file")
+	RunCmd.Flags().StringVarP(&configFile, "config", "c", "", "Dapr configuration file")
 	RunCmd.Flags().IntVarP(&port, "dapr-http-port", "H", -1, "The HTTP port for Dapr to listen on")
 	RunCmd.Flags().IntVarP(&grpcPort, "dapr-grpc-port", "G", -1, "The gRPC port for Dapr to listen on")
 	RunCmd.Flags().IntVarP(&internalGRPCPort, "dapr-internal-grpc-port", "I", -1, "The gRPC port for the Dapr internal API to listen on")
@@ -377,7 +397,7 @@ func init() {
 	RunCmd.Flags().StringVarP(&logLevel, "log-level", "", "info", "The log verbosity. Valid values are: debug, info, warn, error, fatal, or panic")
 	RunCmd.Flags().IntVarP(&maxConcurrency, "app-max-concurrency", "", -1, "The concurrency level of the application, otherwise is unlimited")
 	RunCmd.Flags().StringVarP(&protocol, "app-protocol", "P", "http", "The protocol (gRPC or HTTP) Dapr uses to talk to the application")
-	RunCmd.Flags().StringVarP(&componentsPath, "components-path", "d", standalone.DefaultComponentsDirPath(), "The path for components directory")
+	RunCmd.Flags().StringVarP(&componentsPath, "components-path", "d", "", "The path for components directory")
 	RunCmd.Flags().StringVarP(&resourcesPath, "resources-path", "", "", "The path for resources directory")
 	// TODO: Remove below line once the flag is removed in the future releases.
 	// By marking this as deprecated, the flag will be hidden from the help menu, but will continue to work. It will show a warning message when used.

cmd/uninstall.go

@@ -16,6 +16,7 @@ package cmd
 import (
 	"fmt"
 	"os"
+	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -46,6 +47,9 @@ dapr uninstall --all
 
 # Uninstall from Kubernetes
 dapr uninstall -k
+
+# Uninstall Dapr from non-default install directory (default is $HOME/.dapr)
+dapr uninstall --dapr-path <path-to-install-directory>
 `,
 	PreRun: func(cmd *cobra.Command, args []string) {
 		viper.BindPFlag("network", cmd.Flags().Lookup("network"))
@@ -55,6 +59,11 @@ dapr uninstall -k
 		var err error
 
 		if uninstallKubernetes {
+			if len(strings.TrimSpace(daprPath)) != 0 {
+				print.FailureStatusEvent(os.Stderr, "--dapr-path is only valid for self-hosted mode")
+				os.Exit(1)
+			}
+
 			print.InfoStatusEvent(os.Stdout, "Removing Dapr from your cluster...")
 			err = kubernetes.Uninstall(uninstallNamespace, uninstallAll, timeout)
 		} else {
@@ -64,7 +73,7 @@ dapr uninstall -k
 			}
 			print.InfoStatusEvent(os.Stdout, "Removing Dapr from your machine...")
 			dockerNetwork := viper.GetString("network")
-			err = standalone.Uninstall(uninstallAll, dockerNetwork, uninstallContainerRuntime)
+			err = standalone.Uninstall(uninstallAll, dockerNetwork, uninstallContainerRuntime, daprPath)
 		}
 
 		if err != nil {

pkg/standalone/common.go

@@ -26,27 +26,54 @@ const (
 	defaultConfigFileName    = "config.yaml"
 )
 
-func defaultDaprDirPath() string {
-	homeDir, _ := os.UserHomeDir()
-	return path_filepath.Join(homeDir, defaultDaprDirName)
+// GetDaprPath returns the dapr installation path.
+// The order of precedence is:
+//  1. From --dapr-path command line flag
+//  2. From DAPR_PATH environment variable
+//  3. $HOME/.dapr
+func GetDaprPath(inputInstallPath string) (string, error) {
+	if inputInstallPath != "" {
+		return inputInstallPath, nil
+	}
+
+	envDaprDir := os.Getenv("DAPR_PATH")
+	if envDaprDir != "" {
+		return envDaprDir, nil
+	}
+
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+
+	return path_filepath.Join(homeDir, defaultDaprDirName), nil
 }
 
-func defaultDaprBinPath() string {
-	return path_filepath.Join(defaultDaprDirPath(), defaultDaprBinDirName)
+func getDaprBinPath(daprDir string) string {
+	return path_filepath.Join(daprDir, defaultDaprBinDirName)
 }
 
-func binaryFilePath(binaryDir string, binaryFilePrefix string) string {
+func binaryFilePathWithDir(binaryDir string, binaryFilePrefix string) string {
 	binaryPath := path_filepath.Join(binaryDir, binaryFilePrefix)
 	if runtime.GOOS == daprWindowsOS {
 		binaryPath += ".exe"
 	}
 	return binaryPath
 }
 
-func DefaultComponentsDirPath() string {
-	return path_filepath.Join(defaultDaprDirPath(), defaultComponentsDirName)
+func lookupBinaryFilePath(inputInstallPath string, binaryFilePrefix string) (string, error) {
+	daprPath, err := GetDaprPath(inputInstallPath)
+	if err != nil {
+		return "", err
+	}
+
+	return binaryFilePathWithDir(getDaprBinPath(daprPath), binaryFilePrefix), nil
+}
+
+func GetDaprComponentsPath(daprDir string) string {
+	return path_filepath.Join(daprDir, defaultComponentsDirName)
 }
 
-func DefaultConfigFilePath() string {
-	return path_filepath.Join(defaultDaprDirPath(), defaultConfigFileName)
+func GetDaprConfigPath(daprDir string) string {
+	return path_filepath.Join(daprDir, defaultConfigFileName)
 }

pkg/standalone/dashboard.go

@@ -17,24 +17,21 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"runtime"
 	"strconv"
 )
 
 // NewDashboardCmd creates the command to run dashboard.
-func NewDashboardCmd(port int) *exec.Cmd {
-	// Use the default binary install location.
-	dashboardPath := defaultDaprBinPath()
-	binaryName := "dashboard"
-	if runtime.GOOS == daprWindowsOS {
-		binaryName = "dashboard.exe"
+func NewDashboardCmd(inputInstallPath string, port int) (*exec.Cmd, error) {
+	dashboardPath, err := lookupBinaryFilePath(inputInstallPath, "dashboard")
+	if err != nil {
+		return nil, err
 	}
 
 	// Construct command to run dashboard.
 	return &exec.Cmd{
-		Path:   filepath.Join(dashboardPath, binaryName),
-		Args:   []string{binaryName, "--port", strconv.Itoa(port)},
-		Dir:    dashboardPath,
+		Path:   dashboardPath,
+		Args:   []string{filepath.Base(dashboardPath), "--port", strconv.Itoa(port)},
+		Dir:    filepath.Dir(dashboardPath),
 		Stdout: os.Stdout,
-	}
+	}, nil
 }

pkg/standalone/dashboard_test.go

@@ -21,8 +21,9 @@ import (
 
 func TestDashboardRun(t *testing.T) {
 	t.Run("build Cmd", func(t *testing.T) {
-		cmd := NewDashboardCmd(9090)
+		cmd, err := NewDashboardCmd("", 9090)
 
+		assert.NoError(t, err)
 		assert.Contains(t, cmd.Args[0], "dashboard")
 		assert.Equal(t, cmd.Args[1], "--port")
 		assert.Equal(t, cmd.Args[2], "9090")

pkg/standalone/run.go

@@ -62,6 +62,7 @@ type RunConfig struct {
 	AppHealthTimeout   int    `arg:"app-health-probe-timeout" ifneq:"0"`
 	AppHealthThreshold int    `arg:"app-health-threshold" ifneq:"0"`
 	EnableAPILogging   bool   `arg:"enable-api-logging"`
+	DaprPathCmdFlag    string
 }
 
 func (meta *DaprMeta) newAppID() string {
@@ -309,7 +310,11 @@ type RunOutput struct {
 }
 
 func getDaprCommand(config *RunConfig) (*exec.Cmd, error) {
-	daprCMD := binaryFilePath(defaultDaprBinPath(), "daprd")
+	daprCMD, err := lookupBinaryFilePath(config.DaprPathCmdFlag, "daprd")
+	if err != nil {
+		return nil, err
+	}
+
 	args := config.getArgs()
 	cmd := exec.Command(daprCMD, args...)
 	return cmd, nil