Merge pull request #1519 from saschagrunert/importShadow

Fix `importshadow` linter

Author: k8s-ci-robot

Diff for: .golangci.yml

@@ -147,11 +147,13 @@ linters-settings:
       - filepathJoin
       - hexLiteral
       - httpNoBody
+      - importShadow
       - indexAlloc
       - initClause
       - methodExprCall
       - nestingReduce
       - nilValReturn
+      - octalLiteral
       - preferDecodeRune
       - preferFilepathJoin
       - preferFprint
@@ -188,8 +190,6 @@ linters-settings:
       - weakCond
       - yodaStyleExpr
       # - hugeParam
-      # - importShadow
-      # - octalLiteral
       # - paramTypeCombine
       # - unnamedResult
       # - whyNoLint

Diff for: cmd/crictl/exec.go

@@ -185,8 +185,8 @@ func Exec(ctx context.Context, client internalapi.RuntimeService, opts execOptio
 	return stream(ctx, opts.stdin, opts.tty, opts.transport, URL)
 }
 
-func stream(ctx context.Context, in, tty bool, transport string, url *url.URL) error {
-	executor, err := getExecutor(transport, url)
+func stream(ctx context.Context, in, tty bool, transport string, parsedURL *url.URL) error {
+	executor, err := getExecutor(transport, parsedURL)
 	if err != nil {
 		return fmt.Errorf("get executor: %w", err)
 	}
@@ -227,15 +227,15 @@ func stream(ctx context.Context, in, tty bool, transport string, url *url.URL) e
 	return t.Safe(func() error { return executor.StreamWithContext(ctx, streamOptions) })
 }
 
-func getExecutor(transport string, url *url.URL) (exec remoteclient.Executor, err error) {
+func getExecutor(transport string, parsedURL *url.URL) (exec remoteclient.Executor, err error) {
 	config := &rest.Config{TLSClientConfig: rest.TLSClientConfig{Insecure: true}}
 
 	switch transport {
 	case transportSpdy:
-		return remoteclient.NewSPDYExecutor(config, "POST", url)
+		return remoteclient.NewSPDYExecutor(config, "POST", parsedURL)
 
 	case transportWebsocket:
-		return remoteclient.NewWebSocketExecutor(config, "GET", url.String())
+		return remoteclient.NewWebSocketExecutor(config, "GET", parsedURL.String())
 
 	default:
 		return nil, fmt.Errorf("unknown transport: %s", transport)

Diff for: cmd/crictl/portforward.go

@@ -84,23 +84,22 @@ func PortForward(client internalapi.RuntimeService, opts portforwardOptions) err
 	if err != nil {
 		return err
 	}
-	portforwardURL := r.Url
 
-	URL, err := url.Parse(portforwardURL)
+	parsedURL, err := url.Parse(r.Url)
 	if err != nil {
 		return err
 	}
 
-	if URL.Host == "" {
-		URL.Host = kubeletURLHost
+	if parsedURL.Host == "" {
+		parsedURL.Host = kubeletURLHost
 	}
 
-	if URL.Scheme == "" {
-		URL.Scheme = kubeletURLSchema
+	if parsedURL.Scheme == "" {
+		parsedURL.Scheme = kubeletURLSchema
 	}
 
-	logrus.Debugf("PortForward URL: %v", URL)
-	dialer, err := getDialer(opts.transport, URL)
+	logrus.Debugf("PortForward URL: %v", parsedURL)
+	dialer, err := getDialer(opts.transport, parsedURL)
 	if err != nil {
 		return fmt.Errorf("get dialer: %w", err)
 	}
@@ -115,7 +114,7 @@ func PortForward(client internalapi.RuntimeService, opts portforwardOptions) err
 	return pf.ForwardPorts()
 }
 
-func getDialer(transport string, url *url.URL) (exec httpstream.Dialer, err error) {
+func getDialer(transport string, parsedURL *url.URL) (exec httpstream.Dialer, err error) {
 	config := &rest.Config{TLSClientConfig: rest.TLSClientConfig{Insecure: true}}
 
 	switch transport {
@@ -124,10 +123,10 @@ func getDialer(transport string, url *url.URL) (exec httpstream.Dialer, err erro
 		if err != nil {
 			return nil, fmt.Errorf("get SPDY round tripper: %w", err)
 		}
-		return spdy.NewDialer(upgrader, &http.Client{Transport: tr}, "POST", url), nil
+		return spdy.NewDialer(upgrader, &http.Client{Transport: tr}, "POST", parsedURL), nil
 
 	case transportWebsocket:
-		return portforward.NewSPDYOverWebsocketDialer(url, config)
+		return portforward.NewSPDYOverWebsocketDialer(parsedURL, config)
 
 	default:
 		return nil, fmt.Errorf("unknown transport: %s", transport)

Diff for: pkg/validate/image.go

@@ -192,8 +192,8 @@ func testRemoveImage(c internalapi.ImageManagerService, imageName string) {
 	removeImage(c, imageName)
 
 	By("Check image list empty")
-	status := framework.ImageStatus(c, imageName)
-	Expect(status).To(BeNil(), "Should have none image in list")
+	imageStatus := framework.ImageStatus(c, imageName)
+	Expect(imageStatus).To(BeNil(), "Should have none image in list")
 }
 
 // testPullPublicImage pulls the image named imageName, make sure it success and remove the image.
@@ -204,12 +204,12 @@ func testPullPublicImage(c internalapi.ImageManagerService, imageName string, po
 	framework.PullPublicImage(c, imageName, podConfig)
 
 	By("Check image list to make sure pulling image success : " + imageName)
-	status := framework.ImageStatus(c, imageName)
-	Expect(status).NotTo(BeNil(), "Should have one image in list")
-	Expect(status.Id).NotTo(BeNil(), "Image Id should not be nil")
-	Expect(status.Size_).NotTo(BeNil(), "Image Size should not be nil")
+	imageStatus := framework.ImageStatus(c, imageName)
+	Expect(imageStatus).NotTo(BeNil(), "Should have one image in list")
+	Expect(imageStatus.Id).NotTo(BeNil(), "Image Id should not be nil")
+	Expect(imageStatus.Size_).NotTo(BeNil(), "Image Size should not be nil")
 	if statusCheck != nil {
-		statusCheck(status)
+		statusCheck(imageStatus)
 	}
 
 	testRemoveImage(c, imageName)

Diff for: pkg/validate/streaming.go

@@ -153,7 +153,7 @@ func createExec(c internalapi.RuntimeService, execReq *runtimeapi.ExecRequest) s
 	By("exec given command in container: " + execReq.ContainerId)
 	resp, err := c.Exec(context.TODO(), execReq)
 	framework.ExpectNoError(err, "failed to exec in container %q", execReq.ContainerId)
-	framework.Logf("Get exec url: " + resp.Url)
+	framework.Logf("Get exec URL: " + resp.Url)
 	return resp.Url
 }
 
@@ -184,8 +184,8 @@ func checkExec(c internalapi.RuntimeService, execServerURL, stdout string, stdou
 
 	// Only http is supported now.
 	// TODO: support streaming APIs via tls.
-	url := parseURL(c, execServerURL)
-	e, err := remoteclient.NewSPDYExecutor(&rest.Config{TLSClientConfig: rest.TLSClientConfig{Insecure: true}}, "POST", url)
+	parsedURL := parseURL(c, execServerURL)
+	e, err := remoteclient.NewSPDYExecutor(&rest.Config{TLSClientConfig: rest.TLSClientConfig{Insecure: true}}, "POST", parsedURL)
 	framework.ExpectNoError(err, "failed to create executor for %q", execServerURL)
 
 	streamOptions := remoteclient.StreamOptions{
@@ -210,26 +210,26 @@ func checkExec(c internalapi.RuntimeService, execServerURL, stdout string, stdou
 		Expect(localOut.String()).To(ContainSubstring(stdout), "The stdout of exec should contain "+stdout)
 	}
 	Expect(localErr.String()).To(BeEmpty(), "The stderr of exec should be empty")
-	framework.Logf("Check exec url %q succeed", execServerURL)
+	framework.Logf("Check exec URL %q succeed", execServerURL)
 }
 
 func parseURL(c internalapi.RuntimeService, serverURL string) *url.URL {
-	url, err := url.Parse(serverURL)
-	framework.ExpectNoError(err, "failed to parse url:  %q", serverURL)
+	parsedURL, err := url.Parse(serverURL)
+	framework.ExpectNoError(err, "failed to parse URL:  %q", serverURL)
 
 	version := getVersion(c)
 	if version.RuntimeName == "docker" {
-		if url.Host == "" {
-			url.Host = defaultStreamServerAddress
+		if parsedURL.Host == "" {
+			parsedURL.Host = defaultStreamServerAddress
 		}
-		if url.Scheme == "" {
-			url.Scheme = defaultStreamServerScheme
+		if parsedURL.Scheme == "" {
+			parsedURL.Scheme = defaultStreamServerScheme
 		}
 	}
 
-	Expect(url.Host).NotTo(BeEmpty(), "The host of url should not be empty")
-	framework.Logf("Parse url %q succeed", serverURL)
-	return url
+	Expect(parsedURL.Host).NotTo(BeEmpty(), "The host of URL should not be empty")
+	framework.Logf("Parse URL %q succeed", serverURL)
+	return parsedURL
 }
 
 func createDefaultAttach(c internalapi.RuntimeService, containerID string) string {
@@ -244,7 +244,7 @@ func createDefaultAttach(c internalapi.RuntimeService, containerID string) strin
 
 	resp, err := c.Attach(context.TODO(), req)
 	framework.ExpectNoError(err, "failed to attach in container %q", containerID)
-	framework.Logf("Get attach url: " + resp.Url)
+	framework.Logf("Get attach URL: " + resp.Url)
 	return resp.Url
 }
 
@@ -295,8 +295,8 @@ func checkAttach(c internalapi.RuntimeService, attachServerURL string) {
 
 	// Only http is supported now.
 	// TODO: support streaming APIs via tls.
-	url := parseURL(c, attachServerURL)
-	e, err := remoteclient.NewSPDYExecutor(&rest.Config{TLSClientConfig: rest.TLSClientConfig{Insecure: true}}, "POST", url)
+	parsedURL := parseURL(c, attachServerURL)
+	e, err := remoteclient.NewSPDYExecutor(&rest.Config{TLSClientConfig: rest.TLSClientConfig{Insecure: true}}, "POST", parsedURL)
 	framework.ExpectNoError(err, "failed to create executor for %q", attachServerURL)
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -311,7 +311,7 @@ func checkAttach(c internalapi.RuntimeService, attachServerURL string) {
 	framework.ExpectNoError(err, "failed to open streamer for %q", attachServerURL)
 
 	Expect(localErr.String()).To(BeEmpty(), "The stderr of attach should be empty")
-	framework.Logf("Check attach url %q succeed", attachServerURL)
+	framework.Logf("Check attach URL %q succeed", attachServerURL)
 }
 
 func createDefaultPortForward(c internalapi.RuntimeService, podID string) string {
@@ -322,7 +322,7 @@ func createDefaultPortForward(c internalapi.RuntimeService, podID string) string
 
 	resp, err := c.PortForward(context.TODO(), req)
 	framework.ExpectNoError(err, "failed to port forward PodSandbox %q", podID)
-	framework.Logf("Get port forward url: " + resp.Url)
+	framework.Logf("Get port forward URL: " + resp.Url)
 	return resp.Url
 }
 
@@ -333,8 +333,8 @@ func checkPortForward(c internalapi.RuntimeService, portForwardSeverURL string,
 
 	transport, upgrader, err := spdy.RoundTripperFor(&rest.Config{TLSClientConfig: rest.TLSClientConfig{Insecure: true}})
 	framework.ExpectNoError(err, "failed to create spdy round tripper")
-	url := parseURL(c, portForwardSeverURL)
-	dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", url)
+	parsedURL := parseURL(c, portForwardSeverURL)
+	dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", parsedURL)
 	pf, err := portforward.New(dialer, []string{fmt.Sprintf("%d:%d", hostPort, containerPort)}, stopChan, readyChan, os.Stdout, os.Stderr)
 	framework.ExpectNoError(err, "failed to create port forward for %q", portForwardSeverURL)
 
@@ -347,5 +347,5 @@ func checkPortForward(c internalapi.RuntimeService, portForwardSeverURL string,
 
 	By(fmt.Sprintf("check if we can get nginx main page via localhost:%d", hostPort))
 	checkMainPage(c, "", hostPort, 0)
-	framework.Logf("Check port forward url %q succeed", portForwardSeverURL)
+	framework.Logf("Check port forward URL %q succeed", portForwardSeverURL)
 }