Merge branch 'master' into upgrade_goversion

# Conflicts:
#	go.sum

.github/holopin.yml

@@ -0,0 +1,6 @@
+organization: dapr
+defaultSticker: clmjkxscc122740fl0mkmb7egi
+stickers:
+  -
+    id: clmjkxscc122740fl0mkmb7egi
+    alias: ghc2023

.github/workflows/kind_e2e.yaml

@@ -50,11 +50,11 @@ jobs:
     name: E2E tests for K8s (KinD)
     runs-on: ubuntu-latest
     env:
-      DAPR_RUNTIME_PINNED_VERSION: 1.11.0
-      DAPR_DASHBOARD_PINNED_VERSION: 0.13.0
+      DAPR_RUNTIME_PINNED_VERSION: 1.12.0
+      DAPR_DASHBOARD_PINNED_VERSION: 0.14.0
       DAPR_RUNTIME_LATEST_STABLE_VERSION:
       DAPR_DASHBOARD_LATEST_STABLE_VERSION:
-      DAPR_TGZ: dapr-1.11.0.tgz
+      DAPR_TGZ: dapr-1.12.0.tgz
     strategy:
       fail-fast: false # Keep running if one leg fails.
       matrix:

.github/workflows/self_hosted_e2e.yaml

@@ -38,12 +38,15 @@ jobs:
       GOARCH: ${{ matrix.target_arch }}
       GOPROXY: https://proxy.golang.org
       ARCHIVE_OUTDIR: dist/archives
-      DAPR_RUNTIME_PINNED_VERSION: "1.11.0"
-      DAPR_DASHBOARD_PINNED_VERSION: 0.13.0
+      DAPR_RUNTIME_PINNED_VERSION: "1.12.0"
+      DAPR_DASHBOARD_PINNED_VERSION: 0.14.0
       DAPR_RUNTIME_LATEST_STABLE_VERSION:
       DAPR_DASHBOARD_LATEST_STABLE_VERSION:
+      GOLANG_PROTOBUF_REGISTRATION_CONFLICT: warn
       PODMAN_VERSION: 4.4.4
     strategy:
+      # TODO: Remove this when our E2E tests are stable for podman on MacOS.
+      fail-fast: false # Keep running if one leg fails.
       matrix:
         os: [macos-latest, ubuntu-latest, windows-latest]
         target_arch: [amd64]

.gitignore

@@ -24,6 +24,8 @@ cli
 
 # CLI's auto-generated components directory
 **/components
+# Auto generated deploy dir inside .dapr directory
+**/.dapr/deploy
 # Auto generated logs dir inside .dapr directory
 **/.dapr/logs
 

Makefile

@@ -153,7 +153,14 @@ test: test-deps
 ################################################################################
 .PHONY: test-e2e-k8s
 test-e2e-k8s: test-deps
-	gotestsum --jsonfile $(TEST_OUTPUT_FILE) --format standard-verbose -- -timeout 20m -count=1 -tags=e2e ./tests/e2e/kubernetes/...
+	gotestsum --jsonfile $(TEST_OUTPUT_FILE) --format standard-verbose -- -timeout 25m -count=1 -tags=e2e ./tests/e2e/kubernetes/...
+
+################################################################################
+# E2E Tests for K8s Template exec											       #
+################################################################################
+.PHONY: test-e2e-k8s-template
+test-e2e-k8s-template: test-deps
+	gotestsum --jsonfile $(TEST_OUTPUT_FILE) --format standard-verbose -- -timeout 25m -count=1 -tags=templatek8s ./tests/e2e/kubernetes/...
 
 ################################################################################
 # Build, E2E Tests for Kubernetes											   #

cmd/init.go

@@ -33,6 +33,7 @@ var (
 	wait              bool
 	timeout           uint
 	slimMode          bool
+	devMode           bool
 	runtimeVersion    string
 	dashboardVersion  string
 	allNamespaces     bool
@@ -68,6 +69,9 @@ dapr init --image-registry <registry-url>
 # Initialize Dapr in Kubernetes
 dapr init -k
 
+# Initialize Dapr in Kubernetes in dev mode
+dapr init -k --dev
+
 # Initialize Dapr in Kubernetes and wait for the installation to complete (default timeout is 300s/5m)
 dapr init -k --wait --timeout 600
 
@@ -127,6 +131,7 @@ dapr init --runtime-path <path-to-install-directory>
 				DashboardVersion:          dashboardVersion,
 				EnableMTLS:                enableMTLS,
 				EnableHA:                  enableHA,
+				EnableDev:                 devMode,
 				Args:                      values,
 				Wait:                      wait,
 				Timeout:                   timeout,
@@ -202,6 +207,7 @@ func init() {
 	defaultContainerRuntime := string(utils.DOCKER)
 
 	InitCmd.Flags().BoolVarP(&kubernetesMode, "kubernetes", "k", false, "Deploy Dapr to a Kubernetes cluster")
+	InitCmd.Flags().BoolVarP(&devMode, "dev", "", false, "Use Dev mode. Deploy Redis, Zipkin also in the 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")
 	InitCmd.Flags().BoolVarP(&slimMode, "slim", "s", false, "Exclude placement service, Redis and Zipkin containers from self-hosted installation")

cmd/renew_certificate.go

@@ -14,9 +14,11 @@ limitations under the License.
 package cmd
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/spf13/cobra"
@@ -168,22 +170,43 @@ func logErrorAndExit(err error) {
 }
 
 func restartControlPlaneService() error {
-	controlPlaneServices := []string{"deploy/dapr-sentry", "deploy/dapr-operator", "statefulsets/dapr-placement-server"}
+	controlPlaneServices := []string{
+		"deploy/dapr-sentry",
+		"deploy/dapr-sidecar-injector",
+		"deploy/dapr-operator",
+		"statefulsets/dapr-placement-server",
+	}
 	namespace, err := kubernetes.GetDaprNamespace()
 	if err != nil {
 		print.FailureStatusEvent(os.Stdout, "Failed to fetch Dapr namespace")
 	}
-	for _, name := range controlPlaneServices {
-		print.InfoStatusEvent(os.Stdout, fmt.Sprintf("Restarting %s..", name))
-		_, err := utils.RunCmdAndWait("kubectl", "rollout", "restart", name, "-n", namespace)
-		if err != nil {
-			return fmt.Errorf("error in restarting deployment %s. Error is %w", name, err)
-		}
-		_, err = utils.RunCmdAndWait("kubectl", "rollout", "status", name, "-n", namespace)
-		if err != nil {
-			return fmt.Errorf("error in checking status for deployment %s. Error is %w", name, err)
-		}
+
+	errs := make([]error, len(controlPlaneServices))
+	var wg sync.WaitGroup
+	wg.Add(len(controlPlaneServices))
+	for i, name := range controlPlaneServices {
+		go func(i int, name string) {
+			defer wg.Done()
+			print.InfoStatusEvent(os.Stdout, fmt.Sprintf("Restarting %s..", name))
+			_, err := utils.RunCmdAndWait("kubectl", "rollout", "restart", "-n", namespace, name)
+			if err != nil {
+				errs[i] = fmt.Errorf("error in restarting deployment %s. Error is %w", name, err)
+				return
+			}
+			_, err = utils.RunCmdAndWait("kubectl", "rollout", "status", "-n", namespace, name)
+			if err != nil {
+				errs[i] = fmt.Errorf("error in checking status for deployment %s. Error is %w", name, err)
+				return
+			}
+		}(i, name)
+	}
+
+	wg.Wait()
+
+	if err := errors.Join(errs...); err != nil {
+		return err
 	}
+
 	print.SuccessStatusEvent(os.Stdout, "All control plane services have restarted successfully!")
 	return nil
 }

cmd/run.go

@@ -27,11 +27,12 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
+	"github.com/dapr/cli/pkg/kubernetes"
 	"github.com/dapr/cli/pkg/metadata"
 	"github.com/dapr/cli/pkg/print"
 	runExec "github.com/dapr/cli/pkg/runexec"
+	"github.com/dapr/cli/pkg/runfileconfig"
 	"github.com/dapr/cli/pkg/standalone"
-	"github.com/dapr/cli/pkg/standalone/runfileconfig"
 	daprsyscall "github.com/dapr/cli/pkg/syscall"
 	"github.com/dapr/cli/utils"
 )
@@ -64,6 +65,7 @@ var (
 	apiListenAddresses string
 	runFilePath        string
 	appChannelAddress  string
+	enableRunK8s       bool
 )
 
 const (
@@ -105,23 +107,25 @@ dapr run --run-file dapr.yaml
 
 # Run multiple apps by providing a directory path containing the run config file(dapr.yaml)
 dapr run --run-file /path/to/directory
+
+# Run multiple apps in Kubernetes by proficing path of a run config file
+dapr run --run-file dapr.yaml -k
+
+# Run multiple apps in Kubernetes by providing a directory path containing the run config file(dapr.yaml)
+dapr run --run-file /path/to/directory -k
   `,
 	Args: cobra.MinimumNArgs(0),
 	PreRun: func(cmd *cobra.Command, args []string) {
 		viper.BindPFlag("placement-host-address", cmd.Flags().Lookup("placement-host-address"))
 	},
 	Run: func(cmd *cobra.Command, args []string) {
 		if len(runFilePath) > 0 {
-			if runtime.GOOS == string(windowsOsType) {
-				print.FailureStatusEvent(os.Stderr, "The run command with run file is not supported on Windows")
-				os.Exit(1)
-			}
 			runConfigFilePath, err := getRunFilePath(runFilePath)
 			if err != nil {
 				print.FailureStatusEvent(os.Stderr, "Failed to get run file path: %v", err)
 				os.Exit(1)
 			}
-			executeRunWithAppsConfigFile(runConfigFilePath)
+			executeRunWithAppsConfigFile(runConfigFilePath, enableRunK8s)
 			return
 		}
 		if len(args) == 0 {
@@ -461,6 +465,7 @@ func init() {
 	RunCmd.Flags().IntVar(&appHealthTimeout, "app-health-probe-timeout", 0, "Timeout for app health probes in milliseconds")
 	RunCmd.Flags().IntVar(&appHealthThreshold, "app-health-threshold", 0, "Number of consecutive failures for the app to be considered unhealthy")
 	RunCmd.Flags().BoolVar(&enableAPILogging, "enable-api-logging", false, "Log API calls at INFO verbosity. Valid values are: true or false")
+	RunCmd.Flags().BoolVarP(&enableRunK8s, "kubernetes", "k", false, "Run the multi-app run template against Kubernetes environment.")
 	RunCmd.Flags().StringVar(&apiListenAddresses, "dapr-listen-addresses", "", "Comma separated list of IP addresses that sidecar will listen to")
 	RunCmd.Flags().StringVarP(&runFilePath, "run-file", "f", "", "Path to the run template file for the list of apps to run")
 	RunCmd.Flags().StringVarP(&appChannelAddress, "app-channel-address", "", utils.DefaultAppChannelAddress, "The network address the application listens on")
@@ -481,8 +486,6 @@ func executeRun(runTemplateName, runFilePath string, apps []runfileconfig.App) (
 	// This is done to provide a better grouping, which can be used to control all the proceses started by "dapr run -f".
 	daprsyscall.CreateProcessGroupID()
 
-	print.WarningStatusEvent(os.Stdout, "This is a preview feature and subject to change in future releases.")
-
 	for _, app := range apps {
 		print.StatusEvent(os.Stdout, print.LogInfo, "Validating config and starting app %q", app.RunConfig.AppID)
 		// Set defaults if zero value provided in config yaml.
@@ -511,11 +514,11 @@ func executeRun(runTemplateName, runFilePath string, apps []runfileconfig.App) (
 		// A custom writer used for trimming ASCII color codes from logs when writing to files.
 		var customAppLogWriter io.Writer
 
-		daprdLogWriterCloser := getLogWriter(app.DaprdLogWriteCloser, app.DaprdLogDestination)
+		daprdLogWriterCloser := runfileconfig.GetLogWriter(app.DaprdLogWriteCloser, app.DaprdLogDestination)
 
 		if len(runConfig.Command) == 0 {
 			print.StatusEvent(os.Stdout, print.LogWarning, "No application command found for app %q present in %s", runConfig.AppID, runFilePath)
-			appDaprdWriter = getAppDaprdWriter(app, true)
+			appDaprdWriter = runExec.GetAppDaprdWriter(app, true)
 			appLogWriter = app.DaprdLogWriteCloser
 		} else {
 			err = app.CreateAppLogFile()
@@ -524,8 +527,8 @@ func executeRun(runTemplateName, runFilePath string, apps []runfileconfig.App) (
 				exitWithError = true
 				break
 			}
-			appDaprdWriter = getAppDaprdWriter(app, false)
-			appLogWriter = getLogWriter(app.AppLogWriteCloser, app.AppLogDestination)
+			appDaprdWriter = runExec.GetAppDaprdWriter(app, false)
+			appLogWriter = runfileconfig.GetLogWriter(app.AppLogWriteCloser, app.AppLogDestination)
 		}
 		customAppLogWriter = print.CustomLogWriter{W: appLogWriter}
 		runState, err := startDaprdAndAppProcesses(&runConfig, app.AppDirPath, sigCh,
@@ -562,6 +565,8 @@ func executeRun(runTemplateName, runFilePath string, apps []runfileconfig.App) (
 
 			if runState.AppCMD.Command.Process != nil {
 				putAppProcessIDInMeta(runState)
+				// Attach a windows job object to the app process.
+				utils.AttachJobObjectToProcess(strconv.Itoa(os.Getpid()), runState.AppCMD.Command.Process)
 			}
 		}
 
@@ -592,43 +597,6 @@ func executeRun(runTemplateName, runFilePath string, apps []runfileconfig.App) (
 	return exitWithError, closeError
 }
 
-// getAppDaprdWriter returns the writer for writing logs common to both daprd, app and stdout.
-func getAppDaprdWriter(app runfileconfig.App, isAppCommandEmpty bool) io.Writer {
-	var appDaprdWriter io.Writer
-	if isAppCommandEmpty {
-		if app.DaprdLogDestination != standalone.Console {
-			appDaprdWriter = io.MultiWriter(os.Stdout, app.DaprdLogWriteCloser)
-		} else {
-			appDaprdWriter = os.Stdout
-		}
-	} else {
-		if app.AppLogDestination != standalone.Console && app.DaprdLogDestination != standalone.Console {
-			appDaprdWriter = io.MultiWriter(app.AppLogWriteCloser, app.DaprdLogWriteCloser, os.Stdout)
-		} else if app.AppLogDestination != standalone.Console {
-			appDaprdWriter = io.MultiWriter(app.AppLogWriteCloser, os.Stdout)
-		} else if app.DaprdLogDestination != standalone.Console {
-			appDaprdWriter = io.MultiWriter(app.DaprdLogWriteCloser, os.Stdout)
-		} else {
-			appDaprdWriter = os.Stdout
-		}
-	}
-	return appDaprdWriter
-}
-
-// getLogWriter returns the log writer based on the log destination.
-func getLogWriter(fileLogWriterCloser io.WriteCloser, logDestination standalone.LogDestType) io.Writer {
-	var logWriter io.Writer
-	switch logDestination {
-	case standalone.Console:
-		logWriter = os.Stdout
-	case standalone.File:
-		logWriter = fileLogWriterCloser
-	case standalone.FileAndConsole:
-		logWriter = io.MultiWriter(os.Stdout, fileLogWriterCloser)
-	}
-	return logWriter
-}
-
 func logInformationalStatusToStdout(app runfileconfig.App) {
 	print.InfoStatusEvent(os.Stdout, "Started Dapr with app id %q. HTTP Port: %d. gRPC Port: %d",
 		app.AppID, app.RunConfig.HTTPPort, app.RunConfig.GRPCPort)
@@ -654,9 +622,8 @@ func gracefullyShutdownAppsAndCloseResources(runState []*runExec.RunExec, apps [
 	return err
 }
 
-func executeRunWithAppsConfigFile(runFilePath string) {
-	config := runfileconfig.RunFileConfig{}
-	apps, err := config.GetApps(runFilePath)
+func executeRunWithAppsConfigFile(runFilePath string, k8sEnabled bool) {
+	config, apps, err := getRunConfigFromRunFile(runFilePath)
 	if err != nil {
 		print.StatusEvent(os.Stdout, print.LogFailure, "Error getting apps from config file: %s", err)
 		os.Exit(1)
@@ -665,7 +632,13 @@ func executeRunWithAppsConfigFile(runFilePath string) {
 		print.StatusEvent(os.Stdout, print.LogFailure, "No apps to run")
 		os.Exit(1)
 	}
-	exitWithError, closeErr := executeRun(config.Name, runFilePath, apps)
+	var exitWithError bool
+	var closeErr error
+	if !k8sEnabled {
+		exitWithError, closeErr = executeRun(config.Name, runFilePath, apps)
+	} else {
+		exitWithError, closeErr = kubernetes.Run(runFilePath, config)
+	}
 	if exitWithError {
 		if closeErr != nil {
 			print.StatusEvent(os.Stdout, print.LogFailure, "Error closing resources: %s", closeErr)
@@ -674,6 +647,12 @@ func executeRunWithAppsConfigFile(runFilePath string) {
 	}
 }
 
+func getRunConfigFromRunFile(runFilePath string) (runfileconfig.RunFileConfig, []runfileconfig.App, error) {
+	config := runfileconfig.RunFileConfig{}
+	apps, err := config.GetApps(runFilePath)
+	return config, apps, err
+}
+
 // startDaprdAndAppProcesses is a function to start the App process and the associated Daprd process.
 // This should be called as a blocking function call.
 func startDaprdAndAppProcesses(runConfig *standalone.RunConfig, commandDir string, sigCh chan os.Signal,