Rename components directory to resources under .dapr directory

README.md

@@ -86,7 +86,7 @@ Output should look like so:
 
 ```
 ⌛  Making the jump to hyperspace...
-✅  Downloaded binaries and completed components set up.
+✅  Downloaded binaries and completed resources set up.
 ℹ️  daprd binary has been installed to  $HOME/.dapr/bin.
 ℹ️  dapr_placement container is running.
 ℹ️  dapr_redis container is running.
@@ -99,10 +99,12 @@ Output should look like so:
 
 This step creates the following defaults:
 
-1. components folder which is later used during `dapr run` unless the `--resources-path` (`--components-path` is deprecated and will be removed in future releases) option is provided. For Linux/MacOS, the default components folder path is `$HOME/.dapr/components` and for Windows it is `%USERPROFILE%\.dapr\components`.
-2. component files in the components folder called `pubsub.yaml` and `statestore.yaml`.
+1. resources folder which is later used during `dapr run` unless the `--resources-path` (`--components-path` is deprecated and will be removed in future releases) option is provided. For Linux/MacOS, the default resources folder path is `$HOME/.dapr/resources` and for Windows it is `%USERPROFILE%\.dapr\resources`.
+2. resoources files in the resources folder called `pubsub.yaml` and `statestore.yaml`.
 3. default config file `$HOME/.dapr/config.yaml` for Linux/MacOS or for Windows at `%USERPROFILE%\.dapr\config.yaml` to enable tracing on `dapr init` call. Can be overridden with the `--config` flag on `dapr run`.
 
+> Note: If there is a `components` directory present in the default dapr installation path `$HOME/.dapr/resources` (for Linux/MacOS) or `%USERPROFILE%\.dapr\resources` (for windows) then `dapr init` will copy the `resources` from the `components` to `resources` directory. This is to ensure safe migration from using `components` to `resources` directory.
+
 #### Slim Init
 
 Alternatively to the above, to have the CLI not install any default configuration files or run Docker containers, use the `--slim` flag with the init command. Only Dapr binaries will be installed.
@@ -115,13 +117,15 @@ Output should look like so:
 
 ```bash
 ⌛  Making the jump to hyperspace...
-✅  Downloaded binaries and completed components set up.
+✅  Downloaded binaries and completed resources set up.
 ℹ️  daprd binary has been installed to $HOME/.dapr/bin.
 ℹ️  placement binary has been installed.
 ✅  Success! Dapr is up and running. To get started, go here: https://aka.ms/dapr-getting-started
 ```
 
->Note: When initializing Dapr with the `--slim` flag only the Dapr runtime binary and the placement service binary are installed. An empty default components folder is created with no default configuration files. During `dapr run` user should use `--resources-path` (`--components-path` is deprecated and will be removed in future releases) to point to a components directory with custom configurations files or alternatively place these files in the default directory. For Linux/MacOS, the default components directory path is `$HOME/.dapr/components` and for Windows it is `%USERPROFILE%\.dapr\components`.
+>Note: When initializing Dapr with the `--slim` flag only the Dapr runtime binary and the placement service binary are installed. An empty default `resources` folder is created with no default configuration files. During `dapr run` user should use `--resources-path` (`--components-path` is deprecated and will be removed in future releases) to point to a `resources` directory with custom configurations files or alternatively place these files in the default directory. For Linux/MacOS, the default `resources` directory path is `$HOME/.dapr/resources` and for Windows it is `%USERPROFILE%\.dapr\resources`.
+
+> Note: If there is a `components` directory present in the default dapr installation path `$HOME/.dapr/resources` (for Linux/MacOS) or `%USERPROFILE%\.dapr\resources` (for windows) then `dapr init` will copy the `resources` from the `components` to `resources` directory. This is to ensure safe migration from using `components` to `resources` directory.
 
 #### Install a specific runtime version
 
@@ -444,7 +448,7 @@ Launch Dapr and your app:
 dapr run --app-id nodeapp --app-port 3000 node app.js
 ```
 
-Note: To choose a non-default components folder, use the --resources-path(--components-path is deprecated) option.
+Note: To choose a non-default resources folder, use the --resources-path option (--components-path is deprecated, see https://github.com/dapr/cli/issues/953 for more information).
 
 Invoke your app:
 
@@ -562,8 +566,8 @@ To use a custom path for component definitions
 
 ```bash
 dapr run --resources-path [custom path]
-> Note: --components-path flag is deprecated. It will continue to work until it is removed completely.
 ```
+> Note: --components-path flag is deprecated. It will continue to work until it is removed completely. See https://github.com/dapr/cli/issues/953 for more information.
 
 
 ### List Configurations

cmd/run.go

@@ -116,7 +116,7 @@ dapr run --app-id myapp --dapr-path /usr/local/dapr
 
 		// Fallback to default components directory if not specified.
 		if componentsPath == "" {
-			componentsPath = standalone.GetDaprComponentsPath(daprDirPath)
+			componentsPath = standalone.GetResourcesDir(daprDirPath)
 		}
 
 		if unixDomainSocket != "" {

pkg/standalone/common.go

@@ -14,16 +14,19 @@ limitations under the License.
 package standalone
 
 import (
+	"fmt"
 	"os"
 	path_filepath "path/filepath"
 	"runtime"
+
+	"github.com/dapr/cli/pkg/print"
+	"github.com/dapr/cli/utils"
 )
 
 const (
-	defaultDaprDirName       = ".dapr"
-	defaultDaprBinDirName    = "bin"
-	defaultComponentsDirName = "components"
-	defaultConfigFileName    = "config.yaml"
+	defaultDaprDirName    = ".dapr"
+	defaultDaprBinDirName = "bin"
+	defaultConfigFileName = "config.yaml"
 )
 
 // GetDaprPath returns the dapr installation path.
@@ -71,9 +74,77 @@ func lookupBinaryFilePath(inputInstallPath string, binaryFilePrefix string) (str
 }
 
 func GetDaprComponentsPath(daprDir string) string {
-	return path_filepath.Join(daprDir, defaultComponentsDirName)
+	return path_filepath.Join(daprDir, utils.DefaultComponentsDirName)
+}
+
+func GetDaprResourcesPath(daprDir string) string {
+	return path_filepath.Join(daprDir, utils.DefaultResourcesDirName)
 }
 
 func GetDaprConfigPath(daprDir string) string {
 	return path_filepath.Join(daprDir, defaultConfigFileName)
 }
+
+// GetResourcesDir returns the path to the resources directory if it exists, otherwise it returns the path of components directory.
+// TODO: Remove this function and replace all its usage with above defined `DefaultResourcesDirPath` when `--components-path` flag is removed.
+func GetResourcesDir(daprDir string) string {
+	defaultResourcesDirPath := GetDaprResourcesPath(daprDir)
+	if _, err := os.Stat(defaultResourcesDirPath); os.IsNotExist(err) {
+		return GetDaprComponentsPath(daprDir)
+	}
+	return defaultResourcesDirPath
+}
+
+// moveDir moves files from src to dest. If there are files in src, it deletes the existing files in dest before copying from src and then deletes the src directory.
+func moveDir(src, dest string) error {
+	destFiles, err := os.ReadDir(dest)
+	if err != nil {
+		return fmt.Errorf("error reading files from %s: %w", dest, err)
+	}
+	srcFiles, err := os.ReadDir(src)
+	if err != nil {
+		return fmt.Errorf("error reading files from %s: %w", src, err)
+	}
+	if len(srcFiles) > 0 {
+		// delete the existing files in dest before copying from src if there are files in src.
+		for _, file := range destFiles {
+			err = os.Remove(path_filepath.Join(dest, file.Name()))
+			if err != nil {
+				return fmt.Errorf("error removing file %s: %w", file.Name(), err)
+			}
+		}
+		print.InfoStatusEvent(os.Stdout, "Moving files from %q to %q", src, dest)
+		var content []byte
+		for _, file := range srcFiles {
+			content, err = os.ReadFile(path_filepath.Join(src, file.Name()))
+			if err != nil {
+				return fmt.Errorf("error reading file %s: %w", file.Name(), err)
+			}
+			// #nosec G306
+			err = os.WriteFile(path_filepath.Join(dest, file.Name()), content, 0o644)
+			if err != nil {
+				return fmt.Errorf("error writing file %s: %w", file.Name(), err)
+			}
+		}
+	}
+	err = os.RemoveAll(src)
+	if err != nil {
+		return fmt.Errorf("error removing directory %s: %w", src, err)
+	}
+	return nil
+}
+
+// createSymLink creates a symlink from dirName to symLink.
+func createSymLink(dirName, symLink string) error {
+	if _, err := os.Stat(dirName); err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("directory %s does not exist", dirName)
+		}
+		return fmt.Errorf("error reading directory %s: %w", dirName, err)
+	}
+	err := os.Symlink(dirName, symLink)
+	if err != nil {
+		return fmt.Errorf("error creating symlink from %s to %s: %w", dirName, symLink, err)
+	}
+	return nil
+}

pkg/standalone/common_test.go

@@ -0,0 +1,134 @@
+/*
+Copyright 2022 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package standalone
+
+import (
+	"os"
+	path_filepath "path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCreateSymLink(t *testing.T) {
+	// create a temp dir to hold the symlink and actual directory.
+	tempDir := createTempDir(t, "dapr-test", "")
+	defer cleanupTempDir(t, tempDir)
+	originalDir := createTempDir(t, "original_dir", tempDir)
+	existingSymLinkDir := createTempDir(t, "new_name_exist", tempDir)
+	tests := []struct {
+		name          string
+		actualDirName string
+		symLinkName   string
+		expectedError bool
+	}{
+		{
+			name:          "create symlink for resources directory",
+			actualDirName: originalDir,
+			symLinkName:   path_filepath.Join(tempDir, "new_name"),
+			expectedError: false,
+		},
+		{
+			name:          "create symlink when resources directory does not exist",
+			actualDirName: "invalid-dir",
+			symLinkName:   "new_name",
+			expectedError: true,
+		},
+		{
+			name:          "create symlink when symlink named directory already exists",
+			actualDirName: originalDir,
+			symLinkName:   existingSymLinkDir,
+			expectedError: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := createSymLink(tt.actualDirName, tt.symLinkName)
+			assert.Equal(t, tt.expectedError, err != nil)
+		})
+	}
+}
+
+func TestMoveDir(t *testing.T) {
+	// create a temp dir to hold the source and destination directory.
+	tempDir := createTempDir(t, "dapr-test", "")
+	defer cleanupTempDir(t, tempDir)
+	// create a file in the source and destination directory.
+	src1 := createTempDir(t, "src1", tempDir)
+	dest2 := createTempDir(t, "dest2", tempDir)
+	srcFile := createTempFile(t, src1, "pubsub.yaml")
+	destFile := createTempFile(t, dest2, "pubsub-dest.yaml")
+	tests := []struct {
+		name            string
+		srcDirName      string
+		destDirName     string
+		expectedError   bool
+		presentFileName string
+	}{
+		{
+			name:            "move directory when source directory contains files",
+			srcDirName:      src1,
+			destDirName:     createTempDir(t, "dest1", tempDir),
+			expectedError:   false,
+			presentFileName: path_filepath.Base(srcFile),
+		},
+		{
+			name:            "move directory when source directory does not contain files",
+			srcDirName:      createTempDir(t, "src2", tempDir),
+			destDirName:     dest2,
+			expectedError:   false,
+			presentFileName: path_filepath.Base(destFile),
+		},
+		{
+			name:          "move directory when source directory does not exists",
+			srcDirName:    path_filepath.Join(tempDir, "non-existent-source-dir"),
+			destDirName:   createTempDir(t, "dest3", tempDir),
+			expectedError: true,
+		},
+		{
+			name:          "move directory when destination directory does not exists",
+			srcDirName:    createTempDir(t, "src4", tempDir),
+			destDirName:   path_filepath.Join(tempDir, "non-existent-dir-dir"),
+			expectedError: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := moveDir(tt.srcDirName, tt.destDirName)
+			assert.Equal(t, tt.expectedError, err != nil)
+			if tt.presentFileName != "" {
+				// check if the files are moved correctly.
+				assert.FileExists(t, path_filepath.Join(tt.destDirName, tt.presentFileName))
+			}
+		})
+	}
+}
+
+func createTempDir(t *testing.T, tempDirName, containerDir string) string {
+	dirName, err := os.MkdirTemp(containerDir, tempDirName)
+	assert.NoError(t, err)
+	return dirName
+}
+
+func createTempFile(t *testing.T, tempDirName, fileName string) string {
+	file, err := os.CreateTemp(tempDirName, fileName)
+	assert.NoError(t, err)
+	defer file.Close()
+	return file.Name()
+}
+
+func cleanupTempDir(t *testing.T, dirName string) {
+	err := os.RemoveAll(dirName)
+	assert.NoError(t, err)
+}

pkg/standalone/run_test.go

@@ -75,10 +75,10 @@ func setupRun(t *testing.T) {
 	myDaprPath, err := GetDaprPath("")
 	assert.NoError(t, err)
 
-	componentsDir := GetDaprComponentsPath(myDaprPath)
+	resourcesDir := GetDaprResourcesPath(myDaprPath)
 	configFile := GetDaprConfigPath(myDaprPath)
-	err = os.MkdirAll(componentsDir, 0o700)
-	assert.Equal(t, nil, err, "Unable to setup components dir before running test")
+	err = os.MkdirAll(resourcesDir, 0o700)
+	assert.Equal(t, nil, err, "Unable to setup resources dir before running test")
 	file, err := os.Create(configFile)
 	file.Close()
 	assert.Equal(t, nil, err, "Unable to create config file before running test")
@@ -88,11 +88,11 @@ func tearDownRun(t *testing.T) {
 	myDaprPath, err := GetDaprPath("")
 	assert.NoError(t, err)
 
-	componentsDir := GetDaprComponentsPath(myDaprPath)
+	componentsDir := GetDaprResourcesPath(myDaprPath)
 	configFile := GetDaprConfigPath(myDaprPath)
 
 	err = os.RemoveAll(componentsDir)
-	assert.Equal(t, nil, err, "Unable to delete default components dir after running test")
+	assert.Equal(t, nil, err, "Unable to delete default resources dir after running test")
 	err = os.Remove(configFile)
 	assert.Equal(t, nil, err, "Unable to delete default config file after running test")
 }
@@ -115,7 +115,7 @@ func assertCommonArgs(t *testing.T, basicConfig *RunConfig, output *RunOutput) {
 	assertArgumentEqual(t, "app-max-concurrency", "-1", output.DaprCMD.Args)
 	assertArgumentEqual(t, "app-protocol", "http", output.DaprCMD.Args)
 	assertArgumentEqual(t, "app-port", "3000", output.DaprCMD.Args)
-	assertArgumentEqual(t, "components-path", GetDaprComponentsPath(daprPath), output.DaprCMD.Args)
+	assertArgumentEqual(t, "components-path", GetDaprResourcesPath(daprPath), output.DaprCMD.Args)
 	assertArgumentEqual(t, "app-ssl", "", output.DaprCMD.Args)
 	assertArgumentEqual(t, "metrics-port", "9001", output.DaprCMD.Args)
 	assertArgumentEqual(t, "dapr-http-max-request-size", "-1", output.DaprCMD.Args)
@@ -169,14 +169,14 @@ func TestRun(t *testing.T) {
 	myDaprPath, err := GetDaprPath("")
 	assert.NoError(t, err)
 
-	componentsDir := GetDaprComponentsPath(myDaprPath)
+	resourcesDir := GetDaprResourcesPath(myDaprPath)
 	configFile := GetDaprConfigPath(myDaprPath)
 
 	sharedRunConfig := &SharedRunConfig{
 		LogLevel:           "WARN",
 		EnableProfiling:    false,
 		AppProtocol:        "http",
-		ComponentsPath:     componentsDir,
+		ComponentsPath:     resourcesDir,
 		AppSSL:             true,
 		MaxRequestBodySize: -1,
 		HTTPReadBufferSize: -1,
@@ -188,8 +188,8 @@ func TestRun(t *testing.T) {
 		AppPort:          3000,
 		HTTPPort:         8000,
 		GRPCPort:         50001,
-		Command:          []string{"MyCommand", "--my-arg"},
 		ProfilePort:      9090,
+		Command:          []string{"MyCommand", "--my-arg"},
 		MetricsPort:      9001,
 		InternalGRPCPort: 5050,
 		SharedRunConfig:  *sharedRunConfig,