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

@@ -377,7 +377,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", standalone.GetResourcesDir(), "The path for resources 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.

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"
 )
 
 func defaultDaprDirPath() string {
@@ -44,9 +47,104 @@ func binaryFilePath(binaryDir string, binaryFilePrefix string) string {
 }
 
 func DefaultComponentsDirPath() string {
-	return path_filepath.Join(defaultDaprDirPath(), defaultComponentsDirName)
+	return path_filepath.Join(defaultDaprDirPath(), utils.DefaultComponentsDirName)
+}
+
+func DefaultResourcesDirPath() string {
+	return path_filepath.Join(defaultDaprDirPath(), utils.DefaultResourcesDirName)
+}
+
+// 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() string {
+	defaultResourcesDirPath := DefaultResourcesDirPath()
+	if _, err := os.Stat(defaultResourcesDirPath); os.IsNotExist(err) {
+		return DefaultComponentsDirPath()
+	}
+	return defaultResourcesDirPath
 }
 
 func DefaultConfigFilePath() string {
 	return path_filepath.Join(defaultDaprDirPath(), defaultConfigFileName)
 }
+
+// copyFilesAndCreateSymlink copies files from src to dest. It deletes the existing files in dest before copying from src.
+// this method also deletes the components dir and makes it as a symlink to resources directory.
+// please see this comment for more details:https://github.com/dapr/cli/pull/1149#issuecomment-1364424345
+// TODO: Remove this function when `--components-path` flag is removed.
+func copyFilesAndCreateSymlink(src, dest string) error {
+	var err error
+	if _, err = os.Stat(src); err != nil {
+		// if the src directory does not exist, create symlink and return nil, because there is nothing to copy from.
+		if os.IsNotExist(err) {
+			err = createSymLink(dest, src)
+			if err != nil {
+				return err
+			}
+			return nil
+		}
+		return fmt.Errorf("error reading directory %s: %w", src, err)
+	}
+	if err = moveDir(src, dest); err != nil {
+		return err
+	}
+	if err = createSymLink(dest, src); err != nil {
+		return err
+	}
+	return nil
+}
+
+// moveDir moves files from src to dest. If there are files in src, it deletes the existing files in dest before copying from src.
+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 iff 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)
+			}
+		}
+	}
+	// delete the components dir and make it as a symlink to resources directory.
+	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,173 @@
+/*
+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 TestCopyFilesAndCreateSymlink(t *testing.T) {
+	// create a temp dir to hold the symlink and actual directory.
+	tempDir := createTempDir(t, "dapr-test", "")
+	defer cleanupTempDir(t, tempDir)
+	destDir := createTempDir(t, "dest", tempDir)
+	srcDir := createTempDir(t, "src", tempDir)
+	srcFile := createTempFile(t, srcDir, "pubsub.yaml")
+	tests := []struct {
+		name            string
+		destDirName     string
+		srcDirName      string
+		expectedError   bool
+		presentFileName string
+	}{
+		{
+			name:            "copy files and create symlink for destination directory when source dir exists",
+			destDirName:     destDir,
+			srcDirName:      srcDir,
+			expectedError:   false,
+			presentFileName: srcFile,
+		},
+		{
+			name:            "copy files and create symlink for destination directory when source dir does not exists",
+			destDirName:     destDir,
+			srcDirName:      path_filepath.Join(tempDir, "non-existent-source-dir"),
+			expectedError:   false,
+			presentFileName: path_filepath.Base(srcFile),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := copyFilesAndCreateSymlink(tt.srcDirName, tt.destDirName)
+			assert.Equal(t, tt.expectedError, err != nil)
+			// check if the files are copied.
+			assert.FileExists(t, path_filepath.Join(tt.srcDirName, path_filepath.Base(tt.presentFileName)))
+		})
+	}
+}
+
+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)
+}