Merge pull request #41 from jingxu97/Mar/log

Add logs

Author: k8s-ci-robot

cmd/csi-proxy/main.go

@@ -31,6 +31,9 @@ func main() {
 		panic(err)
 	}
 	s := server.NewServer(apiGroups...)
+
+	klog.Info("Starting CSI-Proxy Server ...")
+	klog.Infof("Version: %s", version)
 	if err := s.Start(nil); err != nil {
 		panic(err)
 	}

cmd/csi-proxy/version.go

@@ -0,0 +1,18 @@
+/*
+Copyright 2020 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 main
+
+var (
+	version string = "Unknown"
+)

internal/os/disk/api.go

@@ -26,7 +26,7 @@ func (APIImplementor) ListDiskLocations() (map[string]shared.DiskLocation, error
 	cmd := fmt.Sprintf("Get-Disk | select number, location | ConvertTo-Json")
 	out, err := exec.Command("powershell", "/c", cmd).CombinedOutput()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to list disk location. cmd: %q, output: %q, err %v", cmd, string(out), err)
 	}
 
 	var getDisk []map[string]interface{}
@@ -72,9 +72,9 @@ func (APIImplementor) ListDiskLocations() (map[string]shared.DiskLocation, error
 
 func (APIImplementor) Rescan() error {
 	cmd := "Update-HostStorageCache"
-	_, err := exec.Command("powershell", "/c", cmd).CombinedOutput()
+	out, err := exec.Command("powershell", "/c", cmd).CombinedOutput()
 	if err != nil {
-		return fmt.Errorf("error updating host storage cache %v", err)
+		return fmt.Errorf("error updating host storage cache output: %q, err: %v", string(out), err)
 	}
 	return nil
 }
@@ -127,7 +127,7 @@ func (APIImplementor) GetDiskNumberByName(diskName string) (string, error) {
 	out, err := exec.Command("DiskUtil.exe", "-GetDiskNumberWithId", diskName).CombinedOutput()
 	outString := string(out)
 	if err != nil {
-		return "", fmt.Errorf("error getting disk number. %v, output %v", err, out)
+		return "", fmt.Errorf("error getting disk number by name %s: %v, output %v", diskName, err, out)
 	}
 	return strings.TrimSpace(outString), nil
 }

internal/os/smb/api.go

@@ -5,8 +5,6 @@ import (
 	"os"
 	"os/exec"
 	"strings"
-
-	"k8s.io/klog"
 )
 
 type APIImplementor struct{}
@@ -23,7 +21,7 @@ func (APIImplementor) IsSmbMapped(remotePath string) (bool, error) {
 
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		return false, fmt.Errorf("error checking smb mapping %s, err: %v", remotePath, err)
+		return false, fmt.Errorf("error checking smb mapping. cmd %s, output: %s, err: %v", remotePath, string(out), err)
 	}
 
 	if len(out) == 0 || !strings.EqualFold(strings.TrimSpace(string(out)), "OK") {
@@ -46,17 +44,15 @@ func (APIImplementor) NewSmbLink(remotePath, localPath string) error {
 		fmt.Sprintf("smbremotepath=%s", remotePath),
 		fmt.Sprintf("smblocalpath=%s", localPath),
 	)
-	_, err := cmd.CombinedOutput()
+	output, err := cmd.CombinedOutput()
 	if err != nil {
-		return fmt.Errorf("error linking %s to %s, err: %v", remotePath, localPath, err)
+		return fmt.Errorf("error linking %s to %s. output: %s, err: %v", remotePath, localPath, string(output), err)
 	}
 
 	return nil
 }
 
 func (APIImplementor) NewSmbGlobalMapping(remotePath, username, password string) error {
-	klog.V(4).Infof("NewSmbGlobalMapping: remotePath:%q", remotePath)
-
 	// use PowerShell Environment Variables to store user input string to prevent command line injection
 	// https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_environment_variables?view=powershell-5.1
 	cmdLine := fmt.Sprintf(`$PWord = ConvertTo-SecureString -String $Env:smbpassword -AsPlainText -Force` +
@@ -69,18 +65,16 @@ func (APIImplementor) NewSmbGlobalMapping(remotePath, username, password string)
 		fmt.Sprintf("smbpassword=%s", password),
 		fmt.Sprintf("smbremotepath=%s", remotePath))
 	if output, err := cmd.CombinedOutput(); err != nil {
-		return fmt.Errorf("NewSmbGlobalMapping failed: %v, output: %q", err, string(output))
+		return fmt.Errorf("NewSmbGlobalMapping failed. output: %q, err: %v", string(output), err)
 	}
 	return nil
 }
 
 func (APIImplementor) RemoveSmbGlobalMapping(remotePath string) error {
-	klog.V(4).Infof("RemoveSmbGlobalMapping remotePath (%q)", remotePath)
 	cmd := exec.Command("powershell", "/c", `Remove-SmbGlobalMapping -RemotePath $Env:smbremotepath -Force`)
 	cmd.Env = append(os.Environ(), fmt.Sprintf("smbremotepath=%s", remotePath))
 	if output, err := cmd.CombinedOutput(); err != nil {
-		klog.Errorf("Remove-SmbGlobalMapping failed: %v, output: %q", err, output)
-		return fmt.Errorf("UnmountSmbShare failed: %v, output: %q", err, output)
+		return fmt.Errorf("UnmountSmbShare failed. output: %q, err: %v", string(output), err)
 	}
 	return nil
 }

internal/os/volume/api.go

@@ -4,8 +4,6 @@ import (
 	"fmt"
 	"os/exec"
 	"strings"
-
-	"k8s.io/klog"
 )
 
 const formatFilesystem = "ntfs"
@@ -19,9 +17,7 @@ func New() VolAPIImplementor {
 }
 
 func runExec(cmd string) ([]byte, error) {
-	klog.V(5).Infof("Running command: %s", cmd)
 	out, err := exec.Command("powershell", "/c", cmd).CombinedOutput()
-	klog.V(5).Infof("Result: %s. Len: %d. Error: %v.", string(out), len(string(out)), err)
 	return out, err
 }
 
@@ -30,7 +26,7 @@ func (VolAPIImplementor) ListVolumesOnDisk(diskID string) (volumeIDs []string, e
 	cmd := fmt.Sprintf("(Get-Disk -DeviceId %s |Get-Partition | Get-Volume).UniqueId", diskID)
 	out, err := runExec(cmd)
 	if err != nil {
-		return []string{}, err
+		return []string{}, fmt.Errorf("error list volumes on disk. cmd: %s, output: %s, error: %v", cmd, string(out), err)
 	}
 
 	volumeIds := strings.Split(strings.TrimSpace(string(out)), "\r\n")
@@ -42,7 +38,7 @@ func (VolAPIImplementor) FormatVolume(volumeID string) (err error) {
 	cmd := fmt.Sprintf("Get-Volume -UniqueId \"%s\" | Format-Volume  -FileSystem %s -Confirm:$false", volumeID, formatFilesystem)
 	out, err := runExec(cmd)
 	if err != nil {
-		return fmt.Errorf("error formatting volume %s: %v, %v", volumeID, out, err)
+		return fmt.Errorf("error formatting volume. cmd: %s, output: %s, error: %v", cmd, string(out), err)
 	}
 	// TODO: Do we need to handle anything for len(out) == 0
 	return nil
@@ -53,7 +49,7 @@ func (VolAPIImplementor) IsVolumeFormatted(volumeID string) (bool, error) {
 	cmd := fmt.Sprintf("(Get-Volume -UniqueId \"%s\" -ErrorAction Stop).FileSystemType", volumeID)
 	out, err := runExec(cmd)
 	if err != nil {
-		return false, fmt.Errorf("error checking if volume is formatted %s: %s, %v", volumeID, string(out), err)
+		return false, fmt.Errorf("error checking if volume is formatted. cmd: %s, output: %s, error: %v", cmd, string(out), err)
 	}
 	if len(out) == 0 || !strings.EqualFold(strings.TrimSpace(string(out)), formatFilesystem) {
 		return false, nil
@@ -64,9 +60,9 @@ func (VolAPIImplementor) IsVolumeFormatted(volumeID string) (bool, error) {
 // MountVolume - mounts a volume to a path. This is done using the Add-PartitionAccessPath for presenting the volume via a path.
 func (VolAPIImplementor) MountVolume(volumeID, path string) error {
 	cmd := fmt.Sprintf("Get-Volume -UniqueId \"%s\" | Get-Partition | Add-PartitionAccessPath -AccessPath %s", volumeID, path)
-	_, err := runExec(cmd)
+	out, err := runExec(cmd)
 	if err != nil {
-		return fmt.Errorf("error mount volume %s to path %s. err: %v", volumeID, path, err)
+		return fmt.Errorf("error mount volume to path. cmd: %s, output: %s, error: %v", cmd, string(out), err)
 	}
 	return nil
 }
@@ -76,7 +72,7 @@ func (VolAPIImplementor) DismountVolume(volumeID, path string) error {
 	cmd := fmt.Sprintf("Get-Volume -UniqueId \"%s\" | Get-Partition | Remove-PartitionAccessPath -AccessPath %s", volumeID, path)
 	out, err := runExec(cmd)
 	if err != nil {
-		return fmt.Errorf("error getting driver letter to mount volume %s: %v, %v", volumeID, out, err)
+		return fmt.Errorf("error getting driver letter to mount volume. cmd: %s, output: %s,error: %v", cmd, string(out), err)
 	}
 	return nil
 }
@@ -88,7 +84,7 @@ func (VolAPIImplementor) ResizeVolume(volumeID string, size int64) error {
 	cmd := fmt.Sprintf("Get-Volume -UniqueId \"%s\" | Get-partition | Resize-Partition -Size %d", volumeID, size)
 	out, err := runExec(cmd)
 	if err != nil {
-		return fmt.Errorf("error resizing volume %s: %s, %v", volumeID, string(out), err)
+		return fmt.Errorf("error resizing volume. cmd: %s, output: %s, error: %v", cmd, string(out), err)
 	}
 	return nil
 }

internal/server/disk/server.go

@@ -30,9 +30,11 @@ func NewServer(hostAPI API) (*Server, error) {
 }
 
 func (s *Server) ListDiskLocations(context context.Context, request *internal.ListDiskLocationsRequest, version apiversion.Version) (*internal.ListDiskLocationsResponse, error) {
+	klog.V(4).Infof("calling ListDiskLocations")
 	response := &internal.ListDiskLocationsResponse{}
 	m, err := s.hostAPI.ListDiskLocations()
 	if err != nil {
+		klog.Errorf("failed ListDiskLocations: %v", err)
 		return response, err
 	}
 
@@ -45,64 +47,69 @@ func (s *Server) ListDiskLocations(context context.Context, request *internal.Li
 		d.LUNID = v.LUNID
 		response.DiskLocations[k] = d
 	}
-
 	return response, nil
 }
 
 func (s *Server) PartitionDisk(context context.Context, request *internal.PartitionDiskRequest, version apiversion.Version) (*internal.PartitionDiskResponse, error) {
+	klog.V(4).Infof("calling PartitionDisk with diskID %q", request.DiskID)
 	response := &internal.PartitionDiskResponse{}
 	diskID := request.DiskID
 
-	klog.Infof("Checking if disk %s is initialized", diskID)
 	initialized, err := s.hostAPI.IsDiskInitialized(diskID)
 	if err != nil {
+		klog.Errorf("failed check IsDiskInitialized %v", err)
 		return response, err
 	}
 	if !initialized {
-		klog.Infof("Initializing disk %s", diskID)
+		klog.V(4).Infof("Initializing disk %s", diskID)
 		err = s.hostAPI.InitializeDisk(diskID)
 		if err != nil {
+			klog.Errorf("failed InitializeDisk %v", err)
 			return response, err
 		}
 	} else {
-		klog.Infof("Disk %s already initialized", diskID)
+		klog.V(4).Infof("Disk %s already initialized", diskID)
 	}
 
-	klog.Infof("Checking if disk %s is partitioned", diskID)
+	klog.V(4).Infof("Checking if disk %s is partitioned", diskID)
 	paritioned, err := s.hostAPI.PartitionsExist(diskID)
 	if err != nil {
+		klog.Errorf("failed check PartitionsExist %v", err)
 		return response, err
 	}
 	if !paritioned {
-		klog.Infof("Creating partition on disk %s", diskID)
+		klog.V(4).Infof("Creating partition on disk %s", diskID)
 		err = s.hostAPI.CreatePartition(diskID)
 		if err != nil {
+			klog.Errorf("failed CreatePartition %v", err)
 			return response, err
 		}
 	} else {
-		klog.Infof("Disk %s already partitioned", diskID)
+		klog.V(4).Infof("Disk %s already partitioned", diskID)
 	}
-
 	return response, nil
 }
 
 func (s *Server) Rescan(context context.Context, request *internal.RescanRequest, version apiversion.Version) (*internal.RescanResponse, error) {
+	klog.V(4).Infof("calling PartitionDisk")
 	response := &internal.RescanResponse{}
 	err := s.hostAPI.Rescan()
 	if err != nil {
+		klog.Errorf("failed Rescan %v", err)
 		return nil, err
 	}
 	return response, nil
 }
 
 func (s *Server) GetDiskNumberByName(context context.Context, request *internal.GetDiskNumberByNameRequest, version apiversion.Version) (*internal.GetDiskNumberByNameResponse, error) {
+	klog.V(4).Infof("calling GetDiskNumberByName with diskName %q", request.DiskName)
 	response := &internal.GetDiskNumberByNameResponse{}
 	diskName := request.DiskName
 	number, err := s.hostAPI.GetDiskNumberByName(diskName)
 	if err != nil {
+		klog.Errorf("failed GetDiskNumberByName %v", err)
 		return nil, err
 	}
-
 	response.DiskNumber = number
 	return response, nil
 }

internal/server/filesystem/server.go

@@ -9,6 +9,7 @@ import (
 	"github.com/kubernetes-csi/csi-proxy/client/apiversion"
 	"github.com/kubernetes-csi/csi-proxy/internal/server/filesystem/internal"
 	"github.com/kubernetes-csi/csi-proxy/internal/utils"
+	"k8s.io/klog"
 )
 
 type Server struct {
@@ -117,14 +118,17 @@ func (s *Server) validatePathWindows(pathCtx internal.PathContext, path string)
 
 // PathExists checks if the given path exists on the host.
 func (s *Server) PathExists(ctx context.Context, request *internal.PathExistsRequest, version apiversion.Version) (*internal.PathExistsResponse, error) {
+	klog.V(4).Infof("calling PathExists with path %q", request.Path)
 	err := s.validatePathWindows(request.Context, request.Path)
 	if err != nil {
+		klog.Errorf("failed validatePathWindows %v", err)
 		return &internal.PathExistsResponse{
 			Error: err.Error(),
 		}, err
 	}
 	exists, err := s.hostAPI.PathExists(request.Path)
 	if err != nil {
+		klog.Errorf("failed check PathExists %v", err)
 		return &internal.PathExistsResponse{
 			Error: err.Error(),
 		}, err
@@ -136,14 +140,17 @@ func (s *Server) PathExists(ctx context.Context, request *internal.PathExistsReq
 }
 
 func (s *Server) Mkdir(ctx context.Context, request *internal.MkdirRequest, version apiversion.Version) (*internal.MkdirResponse, error) {
+	klog.V(4).Infof("calling Mkdir with path %q", request.Path)
 	err := s.validatePathWindows(request.Context, request.Path)
 	if err != nil {
+		klog.Errorf("failed validatePathWindows %v", err)
 		return &internal.MkdirResponse{
 			Error: err.Error(),
 		}, err
 	}
 	err = s.hostAPI.Mkdir(request.Path)
 	if err != nil {
+		klog.Errorf("failed Mkdir %v", err)
 		return &internal.MkdirResponse{
 			Error: err.Error(),
 		}, err
@@ -155,14 +162,17 @@ func (s *Server) Mkdir(ctx context.Context, request *internal.MkdirRequest, vers
 }
 
 func (s *Server) Rmdir(ctx context.Context, request *internal.RmdirRequest, version apiversion.Version) (*internal.RmdirResponse, error) {
+	klog.V(2).Infof("calling Rmdir with path %q", request.Path)
 	err := s.validatePathWindows(request.Context, request.Path)
 	if err != nil {
+		klog.Errorf("failed validatePathWindows %v", err)
 		return &internal.RmdirResponse{
 			Error: err.Error(),
 		}, err
 	}
 	err = s.hostAPI.Rmdir(request.Path, request.Force)
 	if err != nil {
+		klog.Errorf("failed Rmdir %v", err)
 		return &internal.RmdirResponse{
 			Error: err.Error(),
 		}, err
@@ -173,21 +183,25 @@ func (s *Server) Rmdir(ctx context.Context, request *internal.RmdirRequest, vers
 }
 
 func (s *Server) LinkPath(ctx context.Context, request *internal.LinkPathRequest, version apiversion.Version) (*internal.LinkPathResponse, error) {
+	klog.V(4).Infof("calling LinkPath with targetPath %q sourcePath %q", request.TargetPath, request.SourcePath)
 	err := s.validatePathWindows(internal.POD, request.TargetPath)
 	if err != nil {
+		klog.Errorf("failed validatePathWindows for target path %v", err)
 		return &internal.LinkPathResponse{
 			Error: err.Error(),
 		}, err
 	}
 	err = s.validatePathWindows(internal.PLUGIN, request.SourcePath)
 	if err != nil {
+		klog.Errorf("failed validatePathWindows for source path %v", err)
 		return &internal.LinkPathResponse{
 			Error: err.Error(),
 		}, err
 	}
 	err = s.hostAPI.LinkPath(request.SourcePath, request.TargetPath)
 	errString := ""
 	if err != nil {
+		klog.Errorf("failed LinkPath %v", err)
 		errString = err.Error()
 	}
 	return &internal.LinkPathResponse{
@@ -196,8 +210,10 @@ func (s *Server) LinkPath(ctx context.Context, request *internal.LinkPathRequest
 }
 
 func (s *Server) IsMountPoint(ctx context.Context, request *internal.IsMountPointRequest, version apiversion.Version) (*internal.IsMountPointResponse, error) {
+	klog.V(4).Infof("calling IsMountPoint with path %q", request.Path)
 	isMount, err := s.hostAPI.IsMountPoint(request.Path)
 	if err != nil {
+		klog.Errorf("failed IsMountPoint %v", err)
 		return &internal.IsMountPointResponse{
 			IsMountPoint: false,
 			Error:        err.Error(),

internal/server/server.go

@@ -6,11 +6,10 @@ import (
 	"sync"
 
 	"github.com/Microsoft/go-winio"
-	"github.com/pkg/errors"
-	"google.golang.org/grpc"
-
 	"github.com/kubernetes-csi/csi-proxy/client"
 	srvtypes "github.com/kubernetes-csi/csi-proxy/internal/server/types"
+	"github.com/pkg/errors"
+	"google.golang.org/grpc"
 )
 
 // Server aggregates a number of API groups and versions,