dapr
/
cli
mirror of https://github.com/dapr/cli.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Upgrade to linter version 1.26.0 (#381)

This commit is contained in:
Mukundan Sundararajan 2020-06-13 13:03:45 -07:00 committed by GitHub
parent a73e74526b
commit 51e208c826
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 148 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.github/workflows/dapr_cli.yaml vendored
View File

@ -22,6 +22,7 @@ jobs:
runs-on: ${{ matrix.os }}
env:
GOVER: 1.14
GOLANGCILINT_VER: 1.26.0
GOOS: ${{ matrix.target_os }}
GOARCH: ${{ matrix.target_arch }}
GOPROXY: https://proxy.golang.org
@ -50,7 +51,7 @@ jobs:
- name: Install golangci-lint
if: matrix.target_arch != 'arm'
run: |
curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b "${{ env.GOROOT }}/bin" v1.23.8
curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b "${{ env.GOROOT }}/bin" v${{ env.GOLANGCILINT_VER }}
- name: Check out code into the Go module directory
uses: actions/checkout@v2
- name: Run linter

6
.golangci.yml
View File

@ -232,4 +232,8 @@ linters:
- scopelint
- unparam
- wsl
- gomnd
- gomnd
- testpackage
- nestif
- goerr113
- godot

4
cmd/mtls.go
View File

@ -18,7 +18,7 @@ var MTLSCmd = &cobra.Command{
Run: func(cmd *cobra.Command, args []string) {
enabled, err := kubernetes.IsMTLSEnabled()
if err != nil {
fmt.Println(fmt.Sprintf("error checking mTLS: %s", err))
fmt.Printf("error checking mTLS: %s \n", err)
return
}
@ -26,7 +26,7 @@ var MTLSCmd = &cobra.Command{
if enabled {
status = "enabled"
}
fmt.Println(fmt.Sprintf("Mutual TLS is %s in your Kubernetes cluster", status))
fmt.Printf("Mutual TLS is %s in your Kubernetes cluster \n", status)
},
}

2
pkg/metadata/metadata.go
View File

@ -34,7 +34,7 @@ func Put(httpPort int, key, value string) error {
client := retryablehttp.NewClient()
client.Logger = nil
url := makeMetadataPutEndpoint(httpPort, key)
// nolint:gosec
req, err := retryablehttp.NewRequest("PUT", url, strings.NewReader(value))
if err != nil {
return err

2
pkg/standalone/run.go
View File

@ -211,6 +211,7 @@ func createRedisStateStore(redisHost string, componentsPath string) error {
filePath := filepath.Join(componentsPath, stateStoreYamlFileName)
fmt.Printf("WARNING: Redis State Store file is being overwritten: %s\n", filePath)
// #nosec G306
err = ioutil.WriteFile(filePath, b, 0644)
if err != nil {
return err
@ -245,6 +246,7 @@ func createRedisPubSub(redisHost string, componentsPath string) error {
filePath := filepath.Join(componentsPath, messageBusYamlFileName)
fmt.Printf("WARNING: Redis PubSub file is being overwritten: %s\n", filePath)
// #nosec G306
err = ioutil.WriteFile(filePath, b, 0644)
if err != nil {
return err

266
pkg/standalone/run_test.go
View File

@ -1,133 +1,133 @@
// ------------------------------------------------------------
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
// ------------------------------------------------------------
package standalone
import (
"os"
"runtime"
"strings"
"testing"
"github.com/stretchr/testify/assert"
)
func assertArgument(t *testing.T, key string, expectedValue string, args []string) {
var value string
for index, arg := range args {
if arg == "--"+key {
nextIndex := index + 1
if nextIndex < len(args) {
if !strings.HasPrefix(args[nextIndex], "--") {
value = args[nextIndex]
}
}
}
}
assert.Equal(t, expectedValue, value)
}
func setupRun(t *testing.T) {
componentsDir := GetDefaultComponentsFolder()
err := os.MkdirAll(componentsDir, 0700)
assert.Equal(t, nil, err, "Unable to setup components dir before running test")
}
func tearDownRun(t *testing.T) {
componentsDir := GetDefaultComponentsFolder()
err := os.RemoveAll(componentsDir)
assert.Equal(t, nil, err, "Unable to delete components dir after running test")
}
func TestRun(t *testing.T) {
// Setup the components directory which is done at init time
setupRun(t)
// Setup the tearDown routine to run in the end
defer tearDownRun(t)
t.Run("run happy http", func(t *testing.T) {
output, err := Run(&RunConfig{
AppID: "MyID",
AppPort: 3000,
HTTPPort: 8000,
GRPCPort: 50001,
LogLevel: "WARN",
Arguments: []string{"MyCommand", "--my-arg"},
EnableProfiling: false,
ProfilePort: 9090,
Protocol: "http",
RedisHost: "localhost",
PlacementHost: "localhost",
ComponentsPath: GetDefaultComponentsFolder(),
})
assert.Nil(t, err)
assert.NotNil(t, output)
assert.Equal(t, "MyID", output.AppID)
assert.Equal(t, 8000, output.DaprHTTPPort)
assert.Equal(t, 50001, output.DaprGRPCPort)
assert.Contains(t, output.DaprCMD.Args[0], "daprd")
assertArgument(t, "app-id", "MyID", output.DaprCMD.Args)
assertArgument(t, "dapr-http-port", "8000", output.DaprCMD.Args)
assertArgument(t, "dapr-grpc-port", "50001", output.DaprCMD.Args)
assertArgument(t, "log-level", "WARN", output.DaprCMD.Args)
assertArgument(t, "max-concurrency", "-1", output.DaprCMD.Args)
assertArgument(t, "protocol", "http", output.DaprCMD.Args)
assertArgument(t, "app-port", "3000", output.DaprCMD.Args)
assertArgument(t, "components-path", GetDefaultComponentsFolder(), output.DaprCMD.Args)
if runtime.GOOS == "windows" {
assertArgument(t, "placement-address", "localhost:6050", output.DaprCMD.Args)
} else {
assertArgument(t, "placement-address", "localhost:50005", output.DaprCMD.Args)
}
assert.Equal(t, "MyCommand", output.AppCMD.Args[0])
assert.Equal(t, "--my-arg", output.AppCMD.Args[1])
})
t.Run("run without app command", func(t *testing.T) {
output, err := Run(&RunConfig{
AppID: "MyID",
AppPort: 3000,
HTTPPort: 8000,
GRPCPort: 50001,
LogLevel: "INFO",
EnableProfiling: false,
ProfilePort: 9090,
Protocol: "http",
RedisHost: "localhost",
PlacementHost: "localhost",
ComponentsPath: GetDefaultComponentsFolder(),
})
assert.Nil(t, err)
assert.NotNil(t, output)
assert.Equal(t, "MyID", output.AppID)
assert.Equal(t, 8000, output.DaprHTTPPort)
assert.Equal(t, 50001, output.DaprGRPCPort)
assert.Contains(t, output.DaprCMD.Args[0], "daprd")
assertArgument(t, "app-id", "MyID", output.DaprCMD.Args)
assertArgument(t, "dapr-http-port", "8000", output.DaprCMD.Args)
assertArgument(t, "dapr-grpc-port", "50001", output.DaprCMD.Args)
assertArgument(t, "log-level", "INFO", output.DaprCMD.Args)
assertArgument(t, "max-concurrency", "-1", output.DaprCMD.Args)
assertArgument(t, "protocol", "http", output.DaprCMD.Args)
assertArgument(t, "app-port", "3000", output.DaprCMD.Args)
assertArgument(t, "components-path", GetDefaultComponentsFolder(), output.DaprCMD.Args)
if runtime.GOOS == "windows" {
assertArgument(t, "placement-address", "localhost:6050", output.DaprCMD.Args)
} else {
assertArgument(t, "placement-address", "localhost:50005", output.DaprCMD.Args)
}
assert.Nil(t, output.AppCMD)
})
}
// ------------------------------------------------------------
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
// ------------------------------------------------------------
package standalone
import (
"os"
"runtime"
"strings"
"testing"
"github.com/stretchr/testify/assert"
)
func assertArgument(t *testing.T, key string, expectedValue string, args []string) {
var value string
for index, arg := range args {
if arg == "--"+key {
nextIndex := index + 1
if nextIndex < len(args) {
if !strings.HasPrefix(args[nextIndex], "--") {
value = args[nextIndex]
}
}
}
}
assert.Equal(t, expectedValue, value)
}
func setupRun(t *testing.T) {
componentsDir := GetDefaultComponentsFolder()
err := os.MkdirAll(componentsDir, 0700)
assert.Equal(t, nil, err, "Unable to setup components dir before running test")
}
func tearDownRun(t *testing.T) {
componentsDir := GetDefaultComponentsFolder()
err := os.RemoveAll(componentsDir)
assert.Equal(t, nil, err, "Unable to delete components dir after running test")
}
func TestRun(t *testing.T) {
// Setup the components directory which is done at init time
setupRun(t)
// Setup the tearDown routine to run in the end
defer tearDownRun(t)
t.Run("run happy http", func(t *testing.T) {
output, err := Run(&RunConfig{
AppID: "MyID",
AppPort: 3000,
HTTPPort: 8000,
GRPCPort: 50001,
LogLevel: "WARN",
Arguments: []string{"MyCommand", "--my-arg"},
EnableProfiling: false,
ProfilePort: 9090,
Protocol: "http",
RedisHost: "localhost",
PlacementHost: "localhost",
ComponentsPath: GetDefaultComponentsFolder(),
})
assert.Nil(t, err)
assert.NotNil(t, output)
assert.Equal(t, "MyID", output.AppID)
assert.Equal(t, 8000, output.DaprHTTPPort)
assert.Equal(t, 50001, output.DaprGRPCPort)
assert.Contains(t, output.DaprCMD.Args[0], "daprd")
assertArgument(t, "app-id", "MyID", output.DaprCMD.Args)
assertArgument(t, "dapr-http-port", "8000", output.DaprCMD.Args)
assertArgument(t, "dapr-grpc-port", "50001", output.DaprCMD.Args)
assertArgument(t, "log-level", "WARN", output.DaprCMD.Args)
assertArgument(t, "max-concurrency", "-1", output.DaprCMD.Args)
assertArgument(t, "protocol", "http", output.DaprCMD.Args)
assertArgument(t, "app-port", "3000", output.DaprCMD.Args)
assertArgument(t, "components-path", GetDefaultComponentsFolder(), output.DaprCMD.Args)
if runtime.GOOS == "windows" {
assertArgument(t, "placement-address", "localhost:6050", output.DaprCMD.Args)
} else {
assertArgument(t, "placement-address", "localhost:50005", output.DaprCMD.Args)
}
assert.Equal(t, "MyCommand", output.AppCMD.Args[0])
assert.Equal(t, "--my-arg", output.AppCMD.Args[1])
})
t.Run("run without app command", func(t *testing.T) {
output, err := Run(&RunConfig{
AppID: "MyID",
AppPort: 3000,
HTTPPort: 8000,
GRPCPort: 50001,
LogLevel: "INFO",
EnableProfiling: false,
ProfilePort: 9090,
Protocol: "http",
RedisHost: "localhost",
PlacementHost: "localhost",
ComponentsPath: GetDefaultComponentsFolder(),
})
assert.Nil(t, err)
assert.NotNil(t, output)
assert.Equal(t, "MyID", output.AppID)
assert.Equal(t, 8000, output.DaprHTTPPort)
assert.Equal(t, 50001, output.DaprGRPCPort)
assert.Contains(t, output.DaprCMD.Args[0], "daprd")
assertArgument(t, "app-id", "MyID", output.DaprCMD.Args)
assertArgument(t, "dapr-http-port", "8000", output.DaprCMD.Args)
assertArgument(t, "dapr-grpc-port", "50001", output.DaprCMD.Args)
assertArgument(t, "log-level", "INFO", output.DaprCMD.Args)
assertArgument(t, "max-concurrency", "-1", output.DaprCMD.Args)
assertArgument(t, "protocol", "http", output.DaprCMD.Args)
assertArgument(t, "app-port", "3000", output.DaprCMD.Args)
assertArgument(t, "components-path", GetDefaultComponentsFolder(), output.DaprCMD.Args)
if runtime.GOOS == "windows" {
assertArgument(t, "placement-address", "localhost:6050", output.DaprCMD.Args)
} else {
assertArgument(t, "placement-address", "localhost:50005", output.DaprCMD.Args)
}
assert.Nil(t, output.AppCMD)
})
}

4
pkg/standalone/standalone.go
View File

@ -239,7 +239,6 @@ func runRedis(wg *sync.WaitGroup, errorChan chan<- error, dir, version string, d
}
func confirmContainerIsRunning(containerName string) error {
// e.g. docker ps --filter name=dapr_redis --filter status=running --format {{.Names}}
args := []string{"ps", "--filter", "name=" + containerName, "--filter", "status=running", "--format", "{{.Names}}"}
@ -451,6 +450,7 @@ func unzip(filepath, targetDir string) (string, error) {
}
defer outputFile.Close()
// #nosec G110
_, err = io.Copy(outputFile, zippedFile)
if err != nil {
return "", err
@ -503,6 +503,7 @@ func untar(filepath, targetDir string) (string, error) {
return "", err
}
// #nosec G110
if _, err := io.Copy(f, tr); err != nil {
return "", err
}
@ -541,6 +542,7 @@ func moveFileToPath(filepath string, installLocation string) (string, error) {
return "", err
}
// #nosec G306
if err = ioutil.WriteFile(destFilePath, input, 0644); err != nil {
if runtime.GOOS != daprWindowsOS && strings.Contains(err.Error(), "permission denied") {
err = errors.New(err.Error() + " - please run with sudo")

1
pkg/version/version.go
View File

@ -36,7 +36,6 @@ func GetRuntimeVersion() string {
return "n/a\n"
}
return string(out)
}
type githubRepoReleaseItem struct {