Merge branch 'master' into feat/add-no-warning-flag

Author: mukundansundar

.github/workflows/self_hosted_e2e.yaml

@@ -45,15 +45,15 @@ jobs:
       DAPR_TGZ: dapr-1.7.0.tgz
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-10.15]
+        os: [macos-10.15, ubuntu-latest, windows-latest]
         target_arch: [amd64]
         include:
           - os: ubuntu-latest
             target_os: linux
           - os: macOS-10.15
             target_os: darwin
-            #- os: windows-latest
-            #target_os: windows
+          - os: windows-latest
+            target_os: windows
     steps:
       - name: Set up Go ${{ env.GOVER }}
         uses: actions/setup-go@v2
@@ -88,6 +88,7 @@ jobs:
         if: github.event.schedule == '0 */6 * * *'
         env:
           DAPR_DEFAULT_IMAGE_REGISTRY: ghcr
+          DAPR_E2E_INIT_SLIM: ${{ contains(matrix.os, 'windows-latest') }}
         run: |
           export TEST_OUTPUT_FILE=$GITHUB_WORKSPACE/test-e2e-standalone.json
           echo "TEST_OUTPUT_FILE=$TEST_OUTPUT_FILE" >> $GITHUB_ENV
@@ -96,6 +97,8 @@ jobs:
         shell: bash
       - name: Run E2E tests with Docker hub
         if: github.event.schedule != '0 */6 * * *'
+        env:
+          DAPR_E2E_INIT_SLIM: ${{ contains(matrix.os, 'windows-latest') }}
         run: |
           export TEST_OUTPUT_FILE=$GITHUB_WORKSPACE/test-e2e-standalone.json
           echo "TEST_OUTPUT_FILE=$TEST_OUTPUT_FILE" >> $GITHUB_ENV

pkg/kubernetes/upgrade.go

@@ -128,6 +128,9 @@ func Upgrade(conf UpgradeConfig) error {
 
 func highAvailabilityEnabled(status []StatusOutput) bool {
 	for _, s := range status {
+		if s.Name == "dapr-dashboard" {
+			continue
+		}
 		if s.Replicas > 1 {
 			return true
 		}

pkg/standalone/standalone.go

@@ -55,7 +55,7 @@ const (
 	// used when DAPR_DEFAULT_IMAGE_REGISTRY is not set.
 	dockerContainerRegistryName = "dockerhub"
 	daprDockerImageName         = "daprio/dapr"
-	redisDockerImageName        = "redis"
+	redisDockerImageName        = "redis:6"
 	zipkinDockerImageName       = "openzipkin/zipkin"
 
 	// used when DAPR_DEFAULT_IMAGE_REGISTRY is set as GHCR.

pkg/standalone/standalone_test.go

@@ -105,7 +105,7 @@ func TestResolveImageWithGHCR(t *testing.T) {
 }
 
 func TestResolveImageWithDockerHub(t *testing.T) {
-	expectedRedisImageName := "redis"
+	expectedRedisImageName := "redis:6"
 	expectedZipkinImageName := "openzipkin/zipkin"
 	expectedPlacementImageName := "daprio/dapr"
 

tests/e2e/common/common.go

@@ -90,7 +90,7 @@ func GetVersionsFromEnv(t *testing.T) (string, string) {
 
 func UpgradeTest(details VersionDetails, opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		args := []string{
 			"upgrade", "-k",
 			"--runtime-version", details.RuntimeVersion,
@@ -117,7 +117,7 @@ func UpgradeTest(details VersionDetails, opts TestOptions) func(t *testing.T) {
 }
 
 func EnsureUninstall(all bool) (string, error) {
-	daprPath := getDaprPath()
+	daprPath := GetDaprPath()
 
 	var _command [10]string
 	command := append(_command[0:], "uninstall", "-k")
@@ -187,7 +187,7 @@ func GetTestsPostCertificateRenewal(details VersionDetails, opts TestOptions) []
 
 func MTLSTestOnInstallUpgrade(opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		output, err := spawn.Command(daprPath, "mtls", "-k")
 		require.NoError(t, err, "expected no error on querying for mtls")
 		if !opts.MTLSEnabled {
@@ -233,7 +233,7 @@ func MTLSTestOnInstallUpgrade(opts TestOptions) func(t *testing.T) {
 
 func ComponentsTestOnInstallUpgrade(opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		// if dapr is installed.
 		if opts.ApplyComponentChanges {
 			// apply any changes to the component.
@@ -256,7 +256,7 @@ func ComponentsTestOnInstallUpgrade(opts TestOptions) func(t *testing.T) {
 
 func StatusTestOnInstallUpgrade(details VersionDetails, opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		output, err := spawn.Command(daprPath, "status", "-k")
 		require.NoError(t, err, "status check failed")
 		var notFound map[string][]string
@@ -419,7 +419,7 @@ func CRDTest(details VersionDetails, opts TestOptions) func(t *testing.T) {
 
 func GenerateNewCertAndRenew(details VersionDetails, opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		err := exportCurrentCertificate(daprPath)
 		require.NoError(t, err, "expected no error on certificate exporting")
 
@@ -445,7 +445,7 @@ func GenerateNewCertAndRenew(details VersionDetails, opts TestOptions) func(t *t
 
 func UseProvidedPrivateKeyAndRenewCerts(details VersionDetails, opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		args := []string{
 			"mtls", "renew-certificate", "-k",
 			"--private-key", "../testdata/example-root.key",
@@ -473,7 +473,7 @@ func UseProvidedPrivateKeyAndRenewCerts(details VersionDetails, opts TestOptions
 
 func UseProvidedNewCertAndRenew(details VersionDetails, opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		args := []string{
 			"mtls", "renew-certificate", "-k",
 			"--ca-root-certificate", "./certs/ca.crt",
@@ -507,7 +507,7 @@ func UseProvidedNewCertAndRenew(details VersionDetails, opts TestOptions) func(t
 
 func NegativeScenarioForCertRenew() func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		args := []string{
 			"mtls", "renew-certificate", "-k",
 			"--ca-root-certificate", "invalid_cert_file.pem",
@@ -551,7 +551,7 @@ func NegativeScenarioForCertRenew() func(t *testing.T) {
 
 func CheckMTLSStatus(details VersionDetails, opts TestOptions, shouldWarningExist bool) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		output, err := spawn.Command(daprPath, "mtls", "-k")
 		require.NoError(t, err, "expected no error on querying for mtls")
 		if !opts.MTLSEnabled {
@@ -595,7 +595,7 @@ func (v VersionDetails) constructFoundMap(res Resource) map[string]bool {
 	return foundMap
 }
 
-func getDaprPath() string {
+func GetDaprPath() string {
 	distDir := fmt.Sprintf("%s_%s", runtime.GOOS, runtime.GOARCH)
 
 	return filepath.Join("..", "..", "..", "dist", distDir, "release", "dapr")
@@ -642,7 +642,7 @@ func getClient() (*k8s.Clientset, error) {
 
 func installTest(details VersionDetails, opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		args := []string{
 			"init", "-k",
 			"--wait",
@@ -693,7 +693,7 @@ func kubernetesTestOnUninstall() func(t *testing.T) {
 	return func(t *testing.T) {
 		_, err := EnsureUninstall(true)
 		require.NoError(t, err, "uninstall failed")
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		output, err := spawn.Command(daprPath, "uninstall", "-k")
 		require.NoError(t, err, "expected no error on uninstall without install")
 		require.Contains(t, output, "Removing Dapr from your cluster...", "expected output to contain message")
@@ -704,7 +704,7 @@ func kubernetesTestOnUninstall() func(t *testing.T) {
 
 func uninstallMTLSTest() func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		output, err := spawn.Command(daprPath, "mtls", "-k")
 		require.Error(t, err, "expected error to be return if dapr not installed")
 		require.Contains(t, output, "error checking mTLS: system configuration not found", "expected output to match")
@@ -713,7 +713,7 @@ func uninstallMTLSTest() func(t *testing.T) {
 
 func componentsTestOnUninstall(all bool) func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		// On Dapr uninstall CRDs are not removed, consequently the components will not be removed.
 		// TODO Related to https://github.com/dapr/cli/issues/656.
 		// For now the components remain.
@@ -747,7 +747,7 @@ func componentsTestOnUninstall(all bool) func(t *testing.T) {
 
 func statusTestOnUninstall() func(t *testing.T) {
 	return func(t *testing.T) {
-		daprPath := getDaprPath()
+		daprPath := GetDaprPath()
 		output, err := spawn.Command(daprPath, "status", "-k")
 		t.Log("checking status fails as expected")
 		require.Error(t, err, "status check did not fail as expected")

tests/e2e/spawn/spawn.go

@@ -14,9 +14,40 @@ limitations under the License.
 package spawn
 
 import (
+	"bufio"
+	"context"
 	"os/exec"
 )
 
+// CommandWithContext runs a command with its arguments in background.
+// The provided context is used to kill the command (by calling os.Process.Kill)
+// if the context becomes done before the command completes on its own.
+// The return channel can be used to read the stdout.
+func CommandWithContext(ctx context.Context, command string, arguments ...string) (chan string, error) {
+	cmd := exec.CommandContext(ctx, command, arguments...)
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, err
+	}
+
+	if err = cmd.Start(); err != nil {
+		return nil, err
+	}
+
+	stdOutChan := make(chan string)
+
+	go func() {
+		scanner := bufio.NewScanner(stdout)
+		for scanner.Scan() {
+			stdOutChan <- scanner.Text()
+		}
+		close(stdOutChan)
+		cmd.Wait()
+	}()
+
+	return stdOutChan, nil
+}
+
 // Command runs a command with its arguments and returns the stdout or stderr or the error.
 func Command(command string, arguments ...string) (string, error) {
 	cmd := exec.Command(command, arguments...)

tests/e2e/standalone/commands.go

@@ -0,0 +1,134 @@
+//go:build e2e
+// +build e2e
+
+/*
+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_test
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"github.com/dapr/cli/tests/e2e/common"
+	"github.com/dapr/cli/tests/e2e/spawn"
+)
+
+// cmdDashboard runs the Dapr dashboard and blocks until it is started.
+// If the context is done, the dashboard is stopped.
+func cmdDashboard(ctx context.Context, port string) error {
+	stdOutChan, err := spawn.CommandWithContext(ctx, common.GetDaprPath(), "dashboard", "--port", port)
+	if err != nil {
+		return err
+	}
+	for output := range stdOutChan {
+		if strings.Contains(output, "Dapr Dashboard running on") {
+			return nil
+		}
+	}
+	return errors.New("Dashboard could not be started")
+}
+
+// cmdInit installs Dapr with the init command and returns the command output and error.
+//
+// When DAPR_E2E_INIT_SLIM is true, it will install Dapr without Docker containers.
+// This is useful for scenarios where Docker containers are not available, e.g.,
+// in GitHub actions Windows runner.
+//
+// Arguments to the init command can be passed via args.
+func cmdInit(runtimeVersion string, args ...string) (string, error) {
+	initArgs := []string{"init", "--log-as-json", "--runtime-version", runtimeVersion}
+
+	if isSlimMode() {
+		initArgs = append(initArgs, "--slim")
+	}
+
+	initArgs = append(initArgs, args...)
+
+	return spawn.Command(common.GetDaprPath(), initArgs...)
+}
+
+// cmdInvoke invokes a method on the specified app and returns the command output and error.
+func cmdInvoke(appId, method, unixDomainSocket string, args ...string) (string, error) {
+	invokeArgs := []string{"invoke", "--log-as-json", "--app-id", appId, "--method", method}
+
+	if unixDomainSocket != "" {
+		invokeArgs = append(invokeArgs, "--unix-domain-socket", unixDomainSocket)
+	}
+
+	invokeArgs = append(invokeArgs, args...)
+
+	return spawn.Command(common.GetDaprPath(), invokeArgs...)
+}
+
+// cmdList lists the running dapr instances and returns the command output and error.
+// format can be empty, "table", "json", or "yaml"
+func cmdList(output string) (string, error) {
+	args := []string{"list"}
+
+	if output != "" {
+		args = append(args, "-o", output)
+	}
+
+	return spawn.Command(common.GetDaprPath(), args...)
+}
+
+// cmdPublish publishes a message to the specified pubsub and topic, and returns the command output and error.
+func cmdPublish(appId, pubsub, topic, unixDomainSocket string, args ...string) (string, error) {
+	publishArgs := []string{"publish", "--log-as-json", "--publish-app-id", appId, "--pubsub", pubsub, "--topic", topic}
+
+	if unixDomainSocket != "" {
+		publishArgs = append(publishArgs, "--unix-domain-socket", unixDomainSocket)
+	}
+
+	publishArgs = append(publishArgs, args...)
+
+	return spawn.Command(common.GetDaprPath(), publishArgs...)
+}
+
+// cmdRun runs a Dapr instance and returns the command output and error.
+func cmdRun(unixDomainSocket string, args ...string) (string, error) {
+	runArgs := append([]string{"run"})
+
+	if unixDomainSocket != "" {
+		runArgs = append(runArgs, "--unix-domain-socket", unixDomainSocket)
+	}
+
+	runArgs = append(runArgs, args...)
+
+	return spawn.Command(common.GetDaprPath(), runArgs...)
+}
+
+// cmdStop stops the specified app and returns the command output and error.
+func cmdStop(appId string, args ...string) (string, error) {
+	stopArgs := append([]string{"stop", "--log-as-json", "--app-id", appId}, args...)
+	return spawn.Command(common.GetDaprPath(), stopArgs...)
+}
+
+// cmdUninstall uninstalls Dapr with --all flag and returns the command output and error.
+func cmdUninstall() (string, error) {
+	return spawn.Command(common.GetDaprPath(), "uninstall", "--all")
+}
+
+// cmdVersion checks the version of Dapr and returns the command output and error.
+// output can be empty or "json"
+func cmdVersion(output string) (string, error) {
+	args := []string{"version"}
+
+	if output != "" {
+		args = append(args, "-o", output)
+	}
+
+	return spawn.Command(common.GetDaprPath(), args...)
+}