[pull] master from dapr:master

.build-tools/.gitignore

@@ -0,0 +1,3 @@
+# Compiled files
+build-tools
+build-tools.exe

.build-tools/README.md

@@ -0,0 +1,18 @@
+# Dapr build-tools CLI
+
+This folder contains a CLI that implements a number of build tools used by Dapr.
+
+The CLI is written in Go and based on the [cobra](https://github.com/spf13/cobra) framework. In order to use it, Go (1.18+) must be installed on your system.
+
+## Running the CLI
+
+You have two ways to run the CLI:
+
+1. Within the `build-tools` directly, you can run the CLI with `go run .` directly. For example `go run . help` shows the help page. Make sure that `GOOS` and `GOARCH` are set to the correct values for your system.
+2. You can build a pre-compiled binary by running `make compile-build-tools` in the root folder of this repository. This will build an executable called `build-tools` (or `build-tools.exe` on Windows) in the `build-tools` folder. You can then run the command directly, for example `./build-tools help`
+
+## Available commands
+
+The list of available commands in this CLI is dynamic and is subject to change at any time. Each command, including the "root" one (no sub-command), are self-documented in the CLI, and you can read the help page by adding `--help`.
+
+For example, `./build-tools --help` shows the full list of commands the CLI offers. `./build-tools e2e --help` shows the help page for the `e2e` sub-command.

.build-tools/cmd/check-lint-version.go

@@ -0,0 +1,111 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"regexp"
+
+	"github.com/spf13/cobra"
+	"golang.org/x/mod/semver"
+	"gopkg.in/yaml.v3"
+)
+
+var (
+	ErrVersionNotSupported = errors.New("version not supported")
+	ErrVersionNotFound     = errors.New("version not found")
+)
+
+type GHWorkflow struct {
+	Jobs struct {
+		Lint struct {
+			Env struct {
+				GOVER           string `yaml:"GOVER"`
+				GOLANGCILINTVER string `yaml:"GOLANGCILINT_VER"`
+			} `yaml:"env"`
+		} `yaml:"lint"`
+	} `yaml:"jobs"`
+}
+
+func parseWorkflowVersionFromFile(path string) (string, error) {
+	var ghWorkflow GHWorkflow
+
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+	err = yaml.Unmarshal(raw, &ghWorkflow)
+	if err != nil {
+		return "", err
+	}
+	return ghWorkflow.Jobs.Lint.Env.GOLANGCILINTVER, err
+}
+
+func getCurrentVersion() (string, error) {
+	out, err := exec.Command("golangci-lint", "--version").Output()
+	if err != nil {
+		return "", err
+	}
+
+	regex, err := regexp.Compile(`golangci-lint\shas\sversion\sv?([\d+.]+[\d])`)
+	if err != nil {
+		return "", err
+	}
+
+	matches := regex.FindStringSubmatch(string(out))
+
+	if matches == nil {
+		return "", fmt.Errorf("no version found: %v", string(out))
+	}
+	return fmt.Sprintf("v%s", matches[1]), err
+}
+
+func isVersionValid(workflowVersion, currentVersion string) bool {
+	res := semver.MajorMinor(workflowVersion) == semver.MajorMinor(currentVersion)
+	return res
+}
+
+func compareVersions(path string) (string, error) {
+	workflowVersion, err := parseWorkflowVersionFromFile(path)
+	if err != nil {
+		return fmt.Sprintf("Error parsing workflow version: %v", err), ErrVersionNotFound
+	}
+	currentVersion, err := getCurrentVersion()
+	if err != nil {
+		return fmt.Sprintf("Error getting current version: %v", err), ErrVersionNotFound
+	}
+	validVersion := isVersionValid(workflowVersion, currentVersion)
+	if !validVersion {
+		return fmt.Sprintf("Invalid version, expected: %s, current: %s ", workflowVersion, currentVersion), ErrVersionNotSupported
+	}
+	return fmt.Sprintf("Linter version is valid (MajorMinor): %s", currentVersion), nil
+}
+
+func getCmdCheckLint(cmdType string) *cobra.Command {
+	// Base command
+	cmd := &cobra.Command{
+		Use:   cmdType,
+		Short: "Compare local golangci-lint version against workflow version",
+		Run: func(cmd *cobra.Command, args []string) {
+			path := cmd.Flag("path").Value.String()
+			res, err := compareVersions(path)
+			fmt.Println(res)
+			if err != nil {
+				fmt.Println("Please install the correct version using the guide - https://golangci-lint.run/welcome/install/")
+				if err == ErrVersionNotSupported {
+					fmt.Println("Alternatively review the golangci-lint version in the workflow file at .github/workflows/dapr.yml")
+				}
+				os.Exit(1)
+			}
+		},
+	}
+	cmd.PersistentFlags().String("path", "../.github/workflows/dapr.yml", "Path to workflow file")
+	return cmd
+}
+
+func init() {
+	// checkLintCmd represents the checkLint command
+	checkLintCmd := getCmdCheckLint("check-linter")
+	rootCmd.AddCommand(checkLintCmd)
+}

.build-tools/cmd/check-lint-version_test.go

@@ -0,0 +1,91 @@
+package cmd
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseWorkflow(t *testing.T) {
+	t.Run("parse invalid workflow file", func(t *testing.T) {
+		parsedVersion, err := parseWorkflowVersionFromFile("../testdata/check-lint-version/invalid.yml")
+		assert.Equal(t, "", parsedVersion)
+		assert.Error(t, err)
+	})
+
+	t.Run("parse workflow file with a missing key", func(t *testing.T) {
+		parsedVersion, err := parseWorkflowVersionFromFile("../testdata/check-lint-version/invalid-test.yml")
+		assert.Equal(t, "", parsedVersion)
+		assert.NoError(t, err)
+	})
+
+	t.Run("parse an invalid workflow file", func(t *testing.T) {
+		parsedVersion, err := parseWorkflowVersionFromFile("../testdata/check-lint-version/invalid-yaml.yml")
+		assert.Equal(t, "", parsedVersion)
+		assert.Error(t, err)
+	})
+
+	t.Run("parse testing workflow file", func(t *testing.T) {
+		parsedVersion, err := parseWorkflowVersionFromFile("../testdata/check-lint-version/valid-test.yml")
+		assert.Equal(t, "123.123.123", parsedVersion)
+		assert.NoError(t, err)
+	})
+}
+
+func TestGetCurrentVersion(t *testing.T) {
+	t.Run("get current version from system", func(t *testing.T) {
+		currentVersion, err := getCurrentVersion()
+		assert.Equal(t, "v1.61.0", currentVersion)
+		assert.NoError(t, err)
+	})
+
+	// TODO: test failure to detect current version
+
+	// TODO: test failure to compile regex expression
+
+	// TODO: test failure finding matches
+}
+
+func TestIsVersionValid(t *testing.T) {
+	t.Run("compare versions - exactly equal to", func(t *testing.T) {
+		assert.Equal(t, true, isVersionValid("v1.54.2", "v1.54.2"))
+	})
+
+	t.Run("compare versions - patch version greater (workflow)", func(t *testing.T) {
+		assert.Equal(t, true, isVersionValid("v1.54.3", "v1.54.2"))
+	})
+
+	t.Run("compare versions - patch version greater (installed)", func(t *testing.T) {
+		assert.Equal(t, true, isVersionValid("v1.54.2", "v1.54.3"))
+	})
+
+	t.Run("compare versions - invalid (installed)", func(t *testing.T) {
+		assert.Equal(t, false, isVersionValid("v1.54.2", "v1.52.2"))
+	})
+
+	t.Run("compare versions - invalid (workflow)", func(t *testing.T) {
+		assert.Equal(t, false, isVersionValid("v1.52.2", "v1.54.2"))
+	})
+}
+
+func TestCompareVersions(t *testing.T) {
+	t.Run("Valid comparison", func(t *testing.T) {
+		res, err := compareVersions("../../.github/workflows/dapr.yml")
+		assert.Contains(t, res, "Linter version is valid")
+		assert.NoError(t, err)
+	})
+
+	t.Run("Invalid comparison", func(t *testing.T) {
+		res, err := compareVersions("../testdata/check-lint-version/invalid-test.yml")
+		assert.Contains(t, res, "Invalid version")
+		assert.Error(t, err)
+	})
+
+	// TODO: test function for failure to get the current version using getCurrentVersion()
+
+	t.Run("Invalid path for comparison", func(t *testing.T) {
+		res, err := compareVersions("../testdata/check-lint-version/invalid-test-incorrect-path.yml")
+		assert.Contains(t, res, "Error parsing workflow")
+		assert.Error(t, err)
+	})
+}

.build-tools/cmd/e2e.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2021 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 cmd
+
+func init() {
+	// e2eCmd represents the e2e command
+	e2eCmd := getCmdE2EPerf("e2e")
+	rootCmd.AddCommand(e2eCmd)
+}

.build-tools/cmd/perf.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2021 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 cmd
+
+func init() {
+	// perfCmd represents the perf command
+	perfCmd := getCmdE2EPerf("perf")
+	rootCmd.AddCommand(perfCmd)
+}

.build-tools/cmd/root.go

@@ -0,0 +1,35 @@
+/*
+Copyright 2021 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 cmd
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+// rootCmd represents the base command when called without any subcommands
+var rootCmd = &cobra.Command{
+	Use:   "dapr-build-tools",
+	Short: "Build tools for Dapr",
+	Long:  `A collection of commands and tools used to build and package Dapr`,
+}
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+func Execute() {
+	err := rootCmd.Execute()
+	if err != nil {
+		os.Exit(1)
+	}
+}