Add generated file

This PR adds generated files under pkg/client and vendor folder.

vendor/k8s.io/kubernetes/pkg/util/netsh/BUILD

@@ -0,0 +1,48 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "netsh.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/util/netsh",
+    deps = [
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/util/netsh/testing:all-srcs",
+    ],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["netsh_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//vendor/github.com/pkg/errors:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+        "//vendor/k8s.io/utils/exec/testing:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/util/netsh/doc.go

@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes 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 netsh provides an interface and implementations for running Windows netsh commands.
+package netsh // import "k8s.io/kubernetes/pkg/util/netsh"

vendor/k8s.io/kubernetes/pkg/util/netsh/netsh.go

@@ -0,0 +1,211 @@
+/*
+Copyright 2016 The Kubernetes 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 netsh
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/golang/glog"
+	utilexec "k8s.io/utils/exec"
+)
+
+// Interface is an injectable interface for running netsh commands.  Implementations must be goroutine-safe.
+type Interface interface {
+	// EnsurePortProxyRule checks if the specified redirect exists, if not creates it
+	EnsurePortProxyRule(args []string) (bool, error)
+	// DeletePortProxyRule deletes the specified portproxy rule.  If the rule did not exist, return error.
+	DeletePortProxyRule(args []string) error
+	// EnsureIPAddress checks if the specified IP Address is added to vEthernet (HNSTransparent) interface, if not, add it.  If the address existed, return true.
+	EnsureIPAddress(args []string, ip net.IP) (bool, error)
+	// DeleteIPAddress checks if the specified IP address is present and, if so, deletes it.
+	DeleteIPAddress(args []string) error
+	// Restore runs `netsh exec` to restore portproxy or addresses using a file.
+	// TODO Check if this is required, most likely not
+	Restore(args []string) error
+
+	// GetInterfaceToAddIP returns the interface name where Service IP needs to be added
+	// IP Address needs to be added for netsh portproxy to redirect traffic
+	// Reads Environment variable INTERFACE_TO_ADD_SERVICE_IP, if it is not defined then "vEthernet (HNSTransparent)" is returned
+	GetInterfaceToAddIP() string
+}
+
+const (
+	cmdNetsh string = "netsh"
+)
+
+// runner implements Interface in terms of exec("netsh").
+type runner struct {
+	mu   sync.Mutex
+	exec utilexec.Interface
+}
+
+// New returns a new Interface which will exec netsh.
+func New(exec utilexec.Interface) Interface {
+	runner := &runner{
+		exec: exec,
+	}
+	return runner
+}
+
+// EnsurePortProxyRule checks if the specified redirect exists, if not creates it.
+func (runner *runner) EnsurePortProxyRule(args []string) (bool, error) {
+	glog.V(4).Infof("running netsh interface portproxy add v4tov4 %v", args)
+	out, err := runner.exec.Command(cmdNetsh, args...).CombinedOutput()
+
+	if err == nil {
+		return true, nil
+	}
+	if ee, ok := err.(utilexec.ExitError); ok {
+		// netsh uses exit(0) to indicate a success of the operation,
+		// as compared to a malformed commandline, for example.
+		if ee.Exited() && ee.ExitStatus() != 0 {
+			return false, nil
+		}
+	}
+	return false, fmt.Errorf("error checking portproxy rule: %v: %s", err, out)
+
+}
+
+// DeletePortProxyRule deletes the specified portproxy rule.  If the rule did not exist, return error.
+func (runner *runner) DeletePortProxyRule(args []string) error {
+	glog.V(4).Infof("running netsh interface portproxy delete v4tov4 %v", args)
+	out, err := runner.exec.Command(cmdNetsh, args...).CombinedOutput()
+
+	if err == nil {
+		return nil
+	}
+	if ee, ok := err.(utilexec.ExitError); ok {
+		// netsh uses exit(0) to indicate a success of the operation,
+		// as compared to a malformed commandline, for example.
+		if ee.Exited() && ee.ExitStatus() == 0 {
+			return nil
+		}
+	}
+	return fmt.Errorf("error deleting portproxy rule: %v: %s", err, out)
+}
+
+// EnsureIPAddress checks if the specified IP Address is added to interface identified by Environment variable INTERFACE_TO_ADD_SERVICE_IP, if not, add it.  If the address existed, return true.
+func (runner *runner) EnsureIPAddress(args []string, ip net.IP) (bool, error) {
+	// Check if the ip address exists
+	intName := runner.GetInterfaceToAddIP()
+	argsShowAddress := []string{
+		"interface", "ipv4", "show", "address",
+		"name=" + intName,
+	}
+
+	ipToCheck := ip.String()
+
+	exists, _ := checkIPExists(ipToCheck, argsShowAddress, runner)
+	if exists == true {
+		glog.V(4).Infof("not adding IP address %q as it already exists", ipToCheck)
+		return true, nil
+	}
+
+	// IP Address is not already added, add it now
+	glog.V(4).Infof("running netsh interface ipv4 add address %v", args)
+	out, err := runner.exec.Command(cmdNetsh, args...).CombinedOutput()
+
+	if err == nil {
+		// Once the IP Address is added, it takes a bit to initialize and show up when querying for it
+		// Query all the IP addresses and see if the one we added is present
+		// PS: We are using netsh interface ipv4 show address here to query all the IP addresses, instead of
+		// querying net.InterfaceAddrs() as it returns the IP address as soon as it is added even though it is uninitialized
+		glog.V(3).Infof("Waiting until IP: %v is added to the network adapter", ipToCheck)
+		for {
+			if exists, _ := checkIPExists(ipToCheck, argsShowAddress, runner); exists {
+				return true, nil
+			}
+			time.Sleep(500 * time.Millisecond)
+		}
+	}
+	if ee, ok := err.(utilexec.ExitError); ok {
+		// netsh uses exit(0) to indicate a success of the operation,
+		// as compared to a malformed commandline, for example.
+		if ee.Exited() && ee.ExitStatus() != 0 {
+			return false, nil
+		}
+	}
+	return false, fmt.Errorf("error adding ipv4 address: %v: %s", err, out)
+}
+
+// DeleteIPAddress checks if the specified IP address is present and, if so, deletes it.
+func (runner *runner) DeleteIPAddress(args []string) error {
+	glog.V(4).Infof("running netsh interface ipv4 delete address %v", args)
+	out, err := runner.exec.Command(cmdNetsh, args...).CombinedOutput()
+
+	if err == nil {
+		return nil
+	}
+	if ee, ok := err.(utilexec.ExitError); ok {
+		// netsh uses exit(0) to indicate a success of the operation,
+		// as compared to a malformed commandline, for example.
+		if ee.Exited() && ee.ExitStatus() == 0 {
+			return nil
+		}
+	}
+	return fmt.Errorf("error deleting ipv4 address: %v: %s", err, out)
+}
+
+// GetInterfaceToAddIP returns the interface name where Service IP needs to be added
+// IP Address needs to be added for netsh portproxy to redirect traffic
+// Reads Environment variable INTERFACE_TO_ADD_SERVICE_IP, if it is not defined then "vEthernet (HNS Internal NIC)" is returned
+func (runner *runner) GetInterfaceToAddIP() string {
+	if iface := os.Getenv("INTERFACE_TO_ADD_SERVICE_IP"); len(iface) > 0 {
+		return iface
+	}
+	return "vEthernet (HNS Internal NIC)"
+}
+
+// Restore is part of Interface.
+func (runner *runner) Restore(args []string) error {
+	return nil
+}
+
+// checkIPExists checks if an IP address exists in 'netsh interface ipv4 show address' output
+func checkIPExists(ipToCheck string, args []string, runner *runner) (bool, error) {
+	ipAddress, err := runner.exec.Command(cmdNetsh, args...).CombinedOutput()
+	if err != nil {
+		return false, err
+	}
+	ipAddressString := string(ipAddress[:])
+	glog.V(3).Infof("Searching for IP: %v in IP dump: %v", ipToCheck, ipAddressString)
+	showAddressArray := strings.Split(ipAddressString, "\n")
+	for _, showAddress := range showAddressArray {
+		if strings.Contains(showAddress, "IP") {
+			ipFromNetsh := getIP(showAddress)
+			if ipFromNetsh == ipToCheck {
+				return true, nil
+			}
+		}
+	}
+
+	return false, nil
+}
+
+// getIP gets ip from showAddress (e.g. "IP Address: 10.96.0.4").
+func getIP(showAddress string) string {
+	list := strings.SplitN(showAddress, ":", 2)
+	if len(list) != 2 {
+		return ""
+	}
+	return strings.TrimSpace(list[1])
+}

vendor/k8s.io/kubernetes/pkg/util/netsh/netsh_test.go

@@ -0,0 +1,467 @@
+/*
+Copyright 2017 The Kubernetes 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 netsh
+
+import (
+	"net"
+	"os"
+	"testing"
+
+	"k8s.io/utils/exec"
+	fakeexec "k8s.io/utils/exec/testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+)
+
+func fakeCommonRunner() *runner {
+	fakeCmd := fakeexec.FakeCmd{
+		CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+			// Success
+			func() ([]byte, error) {
+				return []byte{}, nil
+			},
+			// utilexec.ExitError exists, and status is not 0
+			func() ([]byte, error) {
+				return nil, &fakeexec.FakeExitError{Status: 1}
+			},
+			// utilexec.ExitError exists, and status is 0
+			func() ([]byte, error) {
+				return nil, &fakeexec.FakeExitError{Status: 0}
+			},
+			// other error exists
+			func() ([]byte, error) {
+				return nil, errors.New("not ExitError")
+			},
+		},
+	}
+
+	return &runner{
+		exec: &fakeexec.FakeExec{
+			CommandScript: []fakeexec.FakeCommandAction{
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...)
+				},
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...)
+				},
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...)
+				},
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...)
+				},
+			},
+		},
+	}
+}
+
+func TestEnsurePortProxyRule(t *testing.T) {
+	runner := fakeCommonRunner()
+
+	tests := []struct {
+		name           string
+		arguments      []string
+		expectedResult bool
+		expectedError  bool
+	}{
+		{"Success", []string{"ensure-port-proxy-rule"}, true, false},
+		{"utilexec.ExitError exists, and status is not 0", []string{"ensure-port-proxy-rule"}, false, false},
+		{"utilexec.ExitError exists, and status is 0", []string{"ensure-port-proxy-rule"}, false, true},
+		{"other error exists", []string{"ensure-port-proxy-rule"}, false, true},
+	}
+
+	for _, test := range tests {
+		result, err := runner.EnsurePortProxyRule(test.arguments)
+		if test.expectedError {
+			assert.Errorf(t, err, "Failed to test: %s", test.name)
+		} else {
+			if err != nil {
+				assert.NoErrorf(t, err, "Failed to test: %s", test.name)
+			} else {
+				assert.EqualValuesf(t, test.expectedResult, result, "Failed to test: %s", test.name)
+			}
+		}
+	}
+
+}
+
+func TestDeletePortProxyRule(t *testing.T) {
+	runner := fakeCommonRunner()
+
+	tests := []struct {
+		name          string
+		arguments     []string
+		expectedError bool
+	}{
+		{"Success", []string{"delete-port-proxy-rule"}, false},
+		{"utilexec.ExitError exists, and status is not 0", []string{"delete-port-proxy-rule"}, true},
+		{"utilexec.ExitError exists, and status is 0", []string{"delete-port-proxy-rule"}, false},
+		{"other error exists", []string{"delete-port-proxy-rule"}, true},
+	}
+
+	for _, test := range tests {
+		err := runner.DeletePortProxyRule(test.arguments)
+		if test.expectedError {
+			assert.Errorf(t, err, "Failed to test: %s", test.name)
+		} else {
+			assert.NoErrorf(t, err, "Failed to test: %s", test.name)
+		}
+	}
+}
+
+func TestEnsureIPAddress(t *testing.T) {
+	tests := []struct {
+		name           string
+		arguments      []string
+		ip             net.IP
+		fakeCmdAction  []fakeexec.FakeCommandAction
+		expectedError  bool
+		expectedResult bool
+	}{
+		{
+			"IP address exists",
+			[]string{"delete-port-proxy-rule"},
+			net.IPv4(10, 10, 10, 20),
+			[]fakeexec.FakeCommandAction{
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// IP address exists
+							func() ([]byte, error) {
+								return []byte("IP Address:10.10.10.10\nIP Address:10.10.10.20"), nil
+							},
+						},
+					}, cmd, args...)
+				},
+			},
+			false,
+			true,
+		},
+
+		{
+			"IP address not exists, but set successful(find it in the second time)",
+			[]string{"ensure-ip-address"},
+			net.IPv4(10, 10, 10, 20),
+			[]fakeexec.FakeCommandAction{
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// IP address not exists
+							func() ([]byte, error) {
+								return []byte("IP Address:10.10.10.10"), nil
+							},
+						},
+					}, cmd, args...)
+				},
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// Success to set ip
+							func() ([]byte, error) {
+								return []byte(""), nil
+							},
+						},
+					}, cmd, args...)
+				},
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// IP address still not exists
+							func() ([]byte, error) {
+								return []byte("IP Address:10.10.10.10"), nil
+							},
+						},
+					}, cmd, args...)
+				},
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// IP address exists
+							func() ([]byte, error) {
+								return []byte("IP Address:10.10.10.10\nIP Address:10.10.10.20"), nil
+							},
+						},
+					}, cmd, args...)
+				},
+			},
+			false,
+			true,
+		},
+		{
+			"IP address not exists, utilexec.ExitError exists, but status is not 0)",
+			[]string{"ensure-ip-address"},
+			net.IPv4(10, 10, 10, 20),
+			[]fakeexec.FakeCommandAction{
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// IP address not exists
+							func() ([]byte, error) {
+								return []byte("IP Address:10.10.10.10"), nil
+							},
+						},
+					}, cmd, args...)
+				},
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// Failed to set ip, utilexec.ExitError exists, and status is not 0
+							func() ([]byte, error) {
+								return nil, &fakeexec.FakeExitError{Status: 1}
+							},
+						},
+					}, cmd, args...)
+				},
+			},
+			false,
+			false,
+		},
+		{
+			"IP address not exists, utilexec.ExitError exists, and status is 0)",
+			[]string{"ensure-ip-address"},
+			net.IPv4(10, 10, 10, 20),
+			[]fakeexec.FakeCommandAction{
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// IP address not exists
+							func() ([]byte, error) {
+								return []byte("IP Address:10.10.10.10"), nil
+							},
+						},
+					}, cmd, args...)
+				},
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// Failed to set ip, utilexec.ExitError exists, and status is 0
+							func() ([]byte, error) {
+								return nil, &fakeexec.FakeExitError{Status: 0}
+							},
+						},
+					}, cmd, args...)
+				},
+			},
+			true,
+			false,
+		},
+		{
+			"IP address not exists, and error is not utilexec.ExitError)",
+			[]string{"ensure-ip-address"},
+			net.IPv4(10, 10, 10, 20),
+			[]fakeexec.FakeCommandAction{
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// IP address not exists
+							func() ([]byte, error) {
+								return []byte("IP Address:10.10.10.10"), nil
+							},
+						},
+					}, cmd, args...)
+				},
+				func(cmd string, args ...string) exec.Cmd {
+					return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{
+						CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+							// Failed to set ip, other error exists
+							func() ([]byte, error) {
+								return nil, errors.New("not ExitError")
+							},
+						},
+					}, cmd, args...)
+				},
+			},
+			true,
+			false,
+		},
+	}
+
+	for _, test := range tests {
+		runner := New(&fakeexec.FakeExec{CommandScript: test.fakeCmdAction})
+		result, err := runner.EnsureIPAddress(test.arguments, test.ip)
+		if test.expectedError {
+			assert.Errorf(t, err, "Failed to test: %s", test.name)
+		} else {
+			if err != nil {
+				assert.NoErrorf(t, err, "Failed to test: %s", test.name)
+			} else {
+				assert.EqualValuesf(t, test.expectedResult, result, "Failed to test: %s", test.name)
+			}
+		}
+	}
+}
+
+func TestDeleteIPAddress(t *testing.T) {
+	runner := fakeCommonRunner()
+
+	tests := []struct {
+		name          string
+		arguments     []string
+		expectedError bool
+	}{
+		{"Success", []string{"delete-ip-address"}, false},
+		{"utilexec.ExitError exists, and status is not 0", []string{"delete-ip-address"}, true},
+		{"utilexec.ExitError exists, and status is 0", []string{"delete-ip-address"}, false},
+		{"other error exists", []string{"delete-ip-address"}, true},
+	}
+
+	for _, test := range tests {
+		err := runner.DeleteIPAddress(test.arguments)
+		if test.expectedError {
+			assert.Errorf(t, err, "Failed to test: %s", test.name)
+		} else {
+			assert.NoErrorf(t, err, "Failed to test: %s", test.name)
+		}
+	}
+}
+
+func TestGetInterfaceToAddIP(t *testing.T) {
+	// backup env 'INTERFACE_TO_ADD_SERVICE_IP'
+	backupValue := os.Getenv("INTERFACE_TO_ADD_SERVICE_IP")
+	// recover env
+	defer os.Setenv("INTERFACE_TO_ADD_SERVICE_IP", backupValue)
+
+	tests := []struct {
+		name           string
+		envToBeSet     string
+		expectedResult string
+	}{
+		{"env_value_is_empty", "", "vEthernet (HNS Internal NIC)"},
+		{"env_value_is_not_empty", "eth0", "eth0"},
+	}
+
+	fakeExec := fakeexec.FakeExec{
+		CommandScript: []fakeexec.FakeCommandAction{},
+	}
+	netsh := New(&fakeExec)
+
+	for _, test := range tests {
+		os.Setenv("INTERFACE_TO_ADD_SERVICE_IP", test.envToBeSet)
+		result := netsh.GetInterfaceToAddIP()
+
+		assert.EqualValuesf(t, test.expectedResult, result, "Failed to test: %s", test.name)
+	}
+}
+
+func TestRestore(t *testing.T) {
+	runner := New(&fakeexec.FakeExec{
+		CommandScript: []fakeexec.FakeCommandAction{},
+	})
+
+	result := runner.Restore([]string{})
+	assert.NoErrorf(t, result, "The return value must be nil")
+}
+
+func TestCheckIPExists(t *testing.T) {
+	fakeCmd := fakeexec.FakeCmd{
+		CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+			// Error exists
+			func() ([]byte, error) {
+				return nil, &fakeexec.FakeExitError{Status: 1}
+			},
+			// IP address string is empty
+			func() ([]byte, error) {
+				return []byte(""), nil
+			},
+			// "IP Address:" field not exists
+			func() ([]byte, error) {
+				return []byte("10.10.10.10"), nil
+			},
+			// IP not exists
+			func() ([]byte, error) {
+				return []byte("IP Address:10.10.10.10"), nil
+			},
+			// IP exists
+			func() ([]byte, error) {
+				return []byte("IP Address:10.10.10.10\nIP Address:10.10.10.20"), nil
+			},
+		},
+	}
+	fakeExec := fakeexec.FakeExec{
+		CommandScript: []fakeexec.FakeCommandAction{
+			func(cmd string, args ...string) exec.Cmd {
+				return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...)
+			},
+			func(cmd string, args ...string) exec.Cmd {
+				return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...)
+			},
+			func(cmd string, args ...string) exec.Cmd {
+				return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...)
+			},
+			func(cmd string, args ...string) exec.Cmd {
+				return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...)
+			},
+			func(cmd string, args ...string) exec.Cmd {
+				return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...)
+			},
+		},
+	}
+	fakeRunner := &runner{
+		exec: &fakeExec,
+	}
+
+	tests := []struct {
+		name           string
+		ipToCheck      string
+		arguments      []string
+		expectedError  bool
+		expectedResult bool
+	}{
+		{"Error exists", "10.10.10.20", []string{"check-IP-exists"}, true, false},
+		{"IP address string is empty", "10.10.10.20", []string{"check-IP-exists"}, false, false},
+		{"'IP Address:' field not exists", "10.10.10.20", []string{"check-IP-exists"}, false, false},
+		{"IP not exists", "10.10.10.20", []string{"check-IP-exists"}, false, false},
+		{"IP exists", "10.10.10.20", []string{"check-IP-exists"}, false, true},
+	}
+
+	for _, test := range tests {
+		result, err := checkIPExists(test.ipToCheck, test.arguments, fakeRunner)
+		if test.expectedError {
+			assert.Errorf(t, err, "Failed to test: %s", test.name)
+		} else {
+			assert.EqualValuesf(t, test.expectedResult, result, "Failed to test: %s", test.name)
+		}
+	}
+}
+
+func TestGetIP(t *testing.T) {
+	testcases := []struct {
+		showAddress   string
+		expectAddress string
+	}{
+		{
+			showAddress:   "IP 地址:                           10.96.0.2",
+			expectAddress: "10.96.0.2",
+		},
+		{
+			showAddress:   "IP Address:                           10.96.0.3",
+			expectAddress: "10.96.0.3",
+		},
+		{
+			showAddress:   "IP Address:10.96.0.4",
+			expectAddress: "10.96.0.4",
+		},
+	}
+
+	for _, tc := range testcases {
+		address := getIP(tc.showAddress)
+		if address != tc.expectAddress {
+			t.Errorf("expected address=%q, got %q", tc.expectAddress, address)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/util/netsh/testing/BUILD

@@ -0,0 +1,26 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["fake.go"],
+    importpath = "k8s.io/kubernetes/pkg/util/netsh/testing",
+    deps = ["//pkg/util/netsh:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/util/netsh/testing/fake.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2016 The Kubernetes 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 testing
+
+import (
+	"net"
+
+	"k8s.io/kubernetes/pkg/util/netsh"
+)
+
+// no-op implementation of netsh Interface
+type FakeNetsh struct {
+}
+
+func NewFake() *FakeNetsh {
+	return &FakeNetsh{}
+}
+
+func (*FakeNetsh) EnsurePortProxyRule(args []string) (bool, error) {
+	return true, nil
+}
+
+// DeletePortProxyRule deletes the specified portproxy rule.  If the rule did not exist, return error.
+func (*FakeNetsh) DeletePortProxyRule(args []string) error {
+	// Do Nothing
+	return nil
+}
+
+// EnsureIPAddress checks if the specified IP Address is added to vEthernet (HNSTransparent) interface, if not, add it.  If the address existed, return true.
+func (*FakeNetsh) EnsureIPAddress(args []string, ip net.IP) (bool, error) {
+	return true, nil
+}
+
+// DeleteIPAddress checks if the specified IP address is present and, if so, deletes it.
+func (*FakeNetsh) DeleteIPAddress(args []string) error {
+	// Do Nothing
+	return nil
+}
+
+// Restore runs `netsh exec` to restore portproxy or addresses using a file.
+// TODO Check if this is required, most likely not
+func (*FakeNetsh) Restore(args []string) error {
+	// Do Nothing
+	return nil
+}
+
+// GetInterfaceToAddIP returns the interface name where Service IP needs to be added
+// IP Address needs to be added for netsh portproxy to redirect traffic
+// Reads Environment variable INTERFACE_TO_ADD_SERVICE_IP, if it is not defined then "vEthernet (HNSTransparent)" is returned
+func (*FakeNetsh) GetInterfaceToAddIP() string {
+	return "Interface 1"
+}
+
+var _ = netsh.Interface(&FakeNetsh{})