adds check for binary in current directory and path

- added function `BinPathFromPathEnv` which will give path for the
supplied binary name
- added test for above function
- written two more functions `LogFatal` and `LogFatalf` in log package
- added check for `minikube` and `kubectl` binary in the code
- removed hardcoded strings for the above two

Changes committed:
	modified:   common/common.go
	modified:   environments/minikube/general.go
	modified:   environments/minikube/setup.go
	modified:   utils/k8s/general.go
	modified:   utils/k8s/k8s.go
	modified:   utils/log/logger.go
	new file:   utils/system/path_check_test.go
	new file:   utils/system/path_check_unix.go

Signed-off-by: Abhishek Kashyap <abhishek.kashyap@mayadata.io>

Author: Abhishek Kashyap

common/common.go

@@ -18,4 +18,6 @@ const (
 	Minikube = "minikube"
 	// Docker is the name of Docker which is "docker"
 	Docker = "docker"
+	// Kubectl is the name of Kubectl which is "kubectl"
+	Kubectl = "kubectl"
 )

environments/minikube/general.go

@@ -18,6 +18,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/golang/glog"
 	"github.com/openebs/CITF/common"
 	"github.com/openebs/CITF/utils/log"
 	sysutil "github.com/openebs/CITF/utils/system"
@@ -32,6 +33,13 @@ var (
 )
 
 func init() {
+	// Check if `minikube` is present
+	minikubePath, err := sysutil.BinPathFromPathEnv(common.Minikube)
+	if minikubePath == "" {
+		logger.LogFatalf(err, "%q not found in current directory or in directories represented by PATH environment variable", common.Minikube)
+	}
+	glog.Infof("%q found on path: %q", common.Minikube, minikubePath)
+
 	// `sudo` use detection
 	useSudoEnv := strings.ToLower(strings.TrimSpace(os.Getenv("USE_SUDO")))
 	if useSudoEnv == "true" { // If it is mentioned in the environment variable to use sudo

environments/minikube/setup.go

@@ -16,6 +16,8 @@ package minikube
 import (
 	"fmt"
 	"os"
+
+	"github.com/openebs/CITF/common"
 )
 
 // runPostStartCommandsForMinikube runs the commands required when run minikube as --vm-driver=none
@@ -42,7 +44,7 @@ func (minikube Minikube) runPostStartCommandsForMinikubeNoneDriver() {
 
 // StartMinikube method starts minikube with `--vm-driver=none` option.
 func (minikube Minikube) StartMinikube() error {
-	err := runCommand("minikube start --vm-driver=none")
+	err := runCommand(common.Minikube + " start --vm-driver=none")
 	// We can also use following:
 	// "minikube start --vm-driver=none --feature-gates=MountPropagation=true --cpus=1 --memory=1024 --v=3 --alsologtostderr"
 	if err != nil {
@@ -75,7 +77,7 @@ func (minikube Minikube) Setup() error {
 	minikubeStatus, err := minikube.Status()
 
 	logger.PrintfDebugMessageIfError(err, "error occurred while checking minikube status")
-	logger.PrintfDebugMessageIfNotError(err, "minikube status: %q", minikubeStatus)
+	logger.PrintfDebugMessageIfNotError(err, common.Minikube+" status: %q", minikubeStatus)
 
 	teardownRequired := false
 	startRequired := false

utils/k8s/general.go

@@ -16,8 +16,11 @@ package k8s
 import (
 	"fmt"
 
+	"github.com/golang/glog"
+	"github.com/openebs/CITF/common"
 	"github.com/openebs/CITF/config"
 	"github.com/openebs/CITF/utils/log"
+	sysutil "github.com/openebs/CITF/utils/system"
 	api_core_v1 "k8s.io/api/core/v1"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
@@ -34,6 +37,16 @@ type K8S struct {
 	Clientset *kubernetes.Clientset
 }
 
+func init() {
+	// check if `kubectl` is present
+	kubectlPath, err := sysutil.BinPathFromPathEnv(common.Kubectl)
+	if kubectlPath == "" {
+		// we don't want to exit here because k8s package may be used as a wrapper over client-go as well
+		glog.Errorf("%q not found in current directory or in directories represented by PATH environment variable: %+v", common.Kubectl, err)
+	}
+	glog.Infof("%q found on path: %q", common.Kubectl, kubectlPath)
+}
+
 // NewK8S returns K8S struct
 func NewK8S() (K8S, error) {
 	config, err := GetClientConfig()

utils/k8s/k8s.go

@@ -26,6 +26,7 @@ import (
 	"errors"
 
 	"github.com/golang/glog"
+	"github.com/openebs/CITF/common"
 	strutil "github.com/openebs/CITF/utils/string"
 	sysutil "github.com/openebs/CITF/utils/system"
 	core_v1 "k8s.io/api/core/v1"
@@ -414,7 +415,7 @@ func (k8s K8S) GetDaemonsetStructFromYamlBytes(yamlBytes []byte) (v1beta1.Daemon
 func (k8s K8S) YAMLApply(yamlPath string) error {
 	// TODO: Try using API call first. i.e. Using client-go
 
-	err := sysutil.RunCommand("kubectl apply -f " + yamlPath)
+	err := sysutil.RunCommand(common.Kubectl + " apply -f " + yamlPath)
 	logger.LogErrorf(err, "error occurred while applying the %s", yamlPath)
 	if err != nil {
 		return fmt.Errorf("failed applying %s", yamlPath)
@@ -489,7 +490,7 @@ func (k8s K8S) ExecToPodThroughAPI(command, containerName, podName, namespace st
 // :return: string: Output of the command. (STDOUT)
 //           error: If any error has occurred otherwise `nil`
 func (k8s K8S) ExecToPodThroughKubectl(command, containerName, podName, namespace string) (string, error) {
-	kubectlCommand := "kubectl"
+	kubectlCommand := common.Kubectl
 
 	// adding namespace if namespace is not blank string
 	if len(namespace) != 0 {
@@ -561,7 +562,7 @@ func (k8s K8S) GetLog(podName, namespace string) (string, error) {
 use_kubectl:
 	glog.Errorf("Error while getting log with API call. Error: %+v", err)
 
-	return sysutil.ExecCommand("kubectl -n " + namespace + " logs " + podName)
+	return sysutil.ExecCommand(common.Kubectl + " -n " + namespace + " logs " + podName)
 }
 
 // BlockUntilPodIsUp blocks until all containers of the given pod is ready

utils/log/logger.go

@@ -77,6 +77,22 @@ func (logger Logger) LogNonErrorf(err error, message string, a ...interface{}) {
 	}
 }
 
+// LogFatal logs error using `glog.Error` only when err is not nil.
+// Please follow convensions for error message e.g. start with lowercase, don't end with period etc.
+func (logger Logger) LogFatal(err error, message string) {
+	if err != nil {
+		glog.Fatal(message+":", err)
+	}
+}
+
+// LogFatalf formats according to a format specifier and logs error using `glog.Error` only when err is not nil.
+// Please follow convensions for error message e.g. start with lowercase, don't end with period etc.
+func (logger Logger) LogFatalf(err error, message string, a ...interface{}) {
+	if err != nil {
+		glog.Fatal(fmt.Sprintf(message, a...)+":", err)
+	}
+}
+
 // PrintError wtires error message to os.StdErr only when err is not nil.
 // Spaces are always added between operands and a newline is appended.
 // It returns the number of bytes written and any write error encountered.

utils/system/path_check_test.go

@@ -0,0 +1,59 @@
+// +build linux darwin
+
+package system
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestBinPathFromPathEnv(t *testing.T) {
+	type args struct {
+		BinName string
+	}
+
+	tests := []struct {
+		Name string
+		Args args
+	}{
+		{
+			Name: "check path of minikube",
+			Args: args{
+				BinName: "minikube",
+			},
+		},
+		{
+			Name: "check path of kubectl",
+			Args: args{
+				BinName: "kubectl",
+			},
+		},
+		{
+			Name: "check path of some-radom-binary",
+			Args: args{
+				BinName: "some-radom-binary",
+			},
+		},
+	}
+
+	os.Setenv("PATH", "~/front:"+os.Getenv("PATH")+":~/back")
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			t.Log("os.Getenv(\"PATH\")=", os.Getenv("PATH"))
+			// Assumption: `which` is present in the system
+			want, _ := ExecCommand("which " + tt.Args.BinName)
+			want = strings.TrimSpace(want)
+
+			get, err := BinPathFromPathEnv(tt.Args.BinName)
+			if err != nil {
+				t.Errorf("error occurred while getting path for %q: %+v", tt.Args.BinName, err)
+			}
+			get = strings.TrimSpace(get)
+
+			if get != want {
+				t.Errorf("BinPathFromPathEnv(%q)=%q; want=%q", tt.Args.BinName, get, want)
+			}
+		})
+	}
+}

utils/system/path_check_unix.go

@@ -0,0 +1,43 @@
+// +build linux darwin
+
+package system
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// BinPathFromPathEnv returns absolute file path of the binary which name is supplied from argument
+// if that file found in current directory itself or directories represented by PATH variable,
+// it returns error if any error occurres during the process or empty string otherwise for path otherwise.
+func BinPathFromPathEnv(binName string) (string, error) {
+	var err error
+	pwd, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("error getting current path: %+v", err)
+	}
+
+	pathDirs := strings.Split(os.Getenv("PATH"), ":")
+	pathDirs = append([]string{pwd}, pathDirs...)
+
+	// PATH variable is scanned from left to right so no need of reversal of the slice
+	var files []os.FileInfo
+	for _, pathDir := range pathDirs {
+		files, err = ioutil.ReadDir(pathDir)
+		logger.PrintfDebugMessageIfError(err, "error reading directory entries for directory: %q", pathDir)
+
+		// if error wont be nil, then files will be empty slice so below for will automatically be ignored,
+		// no need of continue statement here
+		for _, file := range files {
+			if !file.IsDir() && file.Name() == binName {
+				return filepath.Join(pathDir, file.Name()), nil
+			}
+		}
+
+	}
+
+	return "", nil
+}