fix: golangci-lint error

Signed-off-by: PoAn Yang <poan.yang@suse.com>

app/cmd/start.go

@@ -84,19 +84,21 @@ func StartCmd() cli.Command {
 func cleanup(pm *process.Manager) {
 	logrus.Infof("Trying to gracefully shut down %v", types.ProcessManagerGrpcService)
 
-	pmResp, err := pm.ProcessList(nil, &rpc.ProcessListRequest{})
+	pmResp, err := pm.ProcessList(context.TODO(), &rpc.ProcessListRequest{})
 	if err != nil {
 		logrus.WithError(err).Errorf("Failed to list processes before shutting down %v", types.ProcessManagerGrpcService)
 		return
 	}
 	for _, p := range pmResp.Processes {
-		pm.ProcessDelete(nil, &rpc.ProcessDeleteRequest{
+		if _, err := pm.ProcessDelete(context.TODO(), &rpc.ProcessDeleteRequest{
 			Name: p.Spec.Name,
-		})
+		}); err != nil {
+			logrus.WithError(err).Errorf("Failed to delete process %s", p.Spec.Name)
+		}
 	}
 
 	for i := 0; i < types.WaitCount; i++ {
-		pmResp, err := pm.ProcessList(nil, &rpc.ProcessListRequest{})
+		pmResp, err := pm.ProcessList(context.TODO(), &rpc.ProcessListRequest{})
 		if err != nil {
 			logrus.WithError(err).Errorf("Failed to list processes when shutting down %v", types.ProcessManagerGrpcService)
 			break
@@ -275,7 +277,7 @@ func start(c *cli.Context) (err error) {
 		listeners[types.SpdkGrpcService] = spdkGRPCListener
 	}
 
-	g, ctx := errgroup.WithContext(ctx)
+	g, _ := errgroup.WithContext(ctx)
 
 	// Register signal handler
 	sigs := make(chan os.Signal, 1)
@@ -375,6 +377,9 @@ func setupDiskGRPCServer(ctx context.Context, listen, spdkServiceAddress string,
 
 func setupSPDKGRPCServer(ctx context.Context, portRange, listen string) (*grpc.Server, net.Listener, error) {
 	portStart, portEnd, err := util.ParsePortRange(portRange)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	srv, err := spdk.NewServer(ctx, portStart, portEnd)
 	if err != nil {

pkg/api/instance.go

@@ -38,7 +38,7 @@ func RPCToInstance(obj *rpc.InstanceResponse) *Instance {
 		Name: obj.Spec.Name,
 		Type: obj.Spec.Type,
 		//lint:ignore SA1019 replaced with DataEngine
-		BackendStoreDriver: obj.Spec.BackendStoreDriver.String(),
+		BackendStoreDriver: obj.Spec.BackendStoreDriver.String(), // nolint: staticcheck
 		DataEngine:         dataEngines[obj.Spec.DataEngine.String()],
 		PortCount:          obj.Spec.PortCount,
 		PortArgs:           obj.Spec.PortArgs,

pkg/disk/disk.go

@@ -91,6 +91,7 @@ func (s *Server) startMonitoring() {
 		case <-s.ctx.Done():
 			logrus.Infof("%s: stopped monitoring replicas due to the context done", types.DiskGrpcService)
 			done = true
+		default:
 		}
 		if done {
 			break

pkg/instance/instance.go

@@ -89,6 +89,7 @@ func (s *Server) startMonitoring() {
 		case <-s.ctx.Done():
 			logrus.Infof("%s: stopped monitoring replicas due to the context done", types.InstanceGrpcService)
 			done = true
+		default:
 		}
 		if done {
 			break

pkg/process/command.go

@@ -6,6 +6,8 @@ import (
 	"path/filepath"
 	"sync"
 	"syscall"
+
+	"github.com/sirupsen/logrus"
 )
 
 type Executor interface {
@@ -72,23 +74,29 @@ func (bc *BinaryCommand) StopWithSignal(signal syscall.Signal) {
 	bc.RLock()
 	defer bc.RUnlock()
 	if bc.Process != nil {
-		bc.Process.Signal(signal)
+		if err := bc.Process.Signal(signal); err != nil {
+			logrus.WithError(err).Error("failed to send signal to process")
+		}
 	}
 }
 
 func (bc *BinaryCommand) Stop() {
 	bc.RLock()
 	defer bc.RUnlock()
 	if bc.Process != nil {
-		bc.Process.Signal(syscall.SIGINT)
+		if err := bc.Process.Signal(syscall.SIGINT); err != nil {
+			logrus.WithError(err).Error("failed to send signal to process")
+		}
 	}
 }
 
 func (bc *BinaryCommand) Kill() {
 	bc.RLock()
 	defer bc.RUnlock()
 	if bc.Process != nil {
-		bc.Process.Signal(syscall.SIGKILL)
+		if err := bc.Process.Signal(syscall.SIGKILL); err != nil {
+			logrus.WithError(err).Error("failed to send signal to process")
+		}
 	}
 }
 

pkg/process/process_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/google/uuid"
 	rpc "github.com/longhorn/types/pkg/generated/imrpc"
 	"github.com/sirupsen/logrus"
 	"google.golang.org/grpc"
@@ -38,10 +37,6 @@ type TestSuite struct {
 
 var _ = Suite(&TestSuite{})
 
-func generateUUID() string {
-	return uuid.New().String()
-}
-
 type ProcessWatcher struct {
 	grpc.ServerStream
 }
@@ -85,18 +80,21 @@ func (s *TestSuite) TestCRUD(c *C) {
 		go func(i int) {
 			defer wg.Done()
 			name := "test_crud_process-" + strconv.Itoa(i)
-			go s.pm.ProcessWatch(nil, pw)
+			go func() {
+				err := s.pm.ProcessWatch(nil, pw)
+				c.Assert(err, IsNil)
+			}()
 
 			createReq := &rpc.ProcessCreateRequest{
 				Spec: createProcessSpec(name, TestBinary),
 			}
-			createResp, err := s.pm.ProcessCreate(nil, createReq)
+			createResp, err := s.pm.ProcessCreate(context.TODO(), createReq)
 			c.Assert(err, IsNil)
 			c.Assert(createResp.Status.State, Not(Equals), types.ProcessStateStopping)
 			c.Assert(createResp.Status.State, Not(Equals), types.ProcessStateStopped)
 			c.Assert(createResp.Status.State, Not(Equals), types.ProcessStateError)
 
-			getResp, err := s.pm.ProcessGet(nil, &rpc.ProcessGetRequest{
+			getResp, err := s.pm.ProcessGet(context.TODO(), &rpc.ProcessGetRequest{
 				Name: name,
 			})
 			c.Assert(err, IsNil)
@@ -105,7 +103,7 @@ func (s *TestSuite) TestCRUD(c *C) {
 			c.Assert(getResp.Status.State, Not(Equals), types.ProcessStateStopped)
 			c.Assert(getResp.Status.State, Not(Equals), types.ProcessStateError)
 
-			listResp, err := s.pm.ProcessList(nil, &rpc.ProcessListRequest{})
+			listResp, err := s.pm.ProcessList(context.TODO(), &rpc.ProcessListRequest{})
 			c.Assert(err, IsNil)
 			c.Assert(listResp.Processes[name], NotNil)
 			c.Assert(listResp.Processes[name].Spec.Name, Equals, name)
@@ -115,7 +113,7 @@ func (s *TestSuite) TestCRUD(c *C) {
 
 			running := false
 			for j := 0; j < RetryCount; j++ {
-				getResp, err := s.pm.ProcessGet(nil, &rpc.ProcessGetRequest{
+				getResp, err := s.pm.ProcessGet(context.TODO(), &rpc.ProcessGetRequest{
 					Name: name,
 				})
 				c.Assert(err, IsNil)
@@ -130,7 +128,7 @@ func (s *TestSuite) TestCRUD(c *C) {
 			deleteReq := &rpc.ProcessDeleteRequest{
 				Name: name,
 			}
-			deleteResp, err := s.pm.ProcessDelete(nil, deleteReq)
+			deleteResp, err := s.pm.ProcessDelete(context.TODO(), deleteReq)
 			c.Assert(err, IsNil)
 			c.Assert(deleteResp.Deleted, Equals, true)
 			c.Assert(deleteResp.Status.State, Not(Equals), types.ProcessStateStarting)
@@ -150,7 +148,10 @@ func (s *TestSuite) TestProcessDeletion(c *C) {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
-			go s.pm.ProcessWatch(nil, pw)
+			go func() {
+				err := s.pm.ProcessWatch(nil, pw)
+				c.Assert(err, IsNil)
+			}()
 			name := "test_process_deletion-" + strconv.Itoa(i)
 
 			assertProcessCreation(c, s.pm, name, TestBinary)
@@ -190,7 +191,10 @@ func (s *TestSuite) TestProcessReplace(c *C) {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
-			go s.pm.ProcessWatch(nil, pw)
+			go func() {
+				err := s.pm.ProcessWatch(nil, pw)
+				c.Assert(err, IsNil)
+			}()
 			name := "test_process_replace-" + strconv.Itoa(i)
 			assertProcessCreation(c, s.pm, name, TestBinary)
 			assertProcessReplace(c, s.pm, name, TestBinaryReplace)
@@ -218,12 +222,15 @@ func (s *TestSuite) TestProcessReplaceMissingBinary(c *C) {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
-			go s.pm.ProcessWatch(nil, pw)
+			go func() {
+				err := s.pm.ProcessWatch(nil, pw)
+				c.Assert(err, NotNil)
+			}()
 			name := "test_process_missing_binary_replace-" + strconv.Itoa(i)
 			assertProcessCreation(c, s.pm, name, TestBinary)
 
 			// replacement for a missing binary should error
-			_, err := s.pm.ProcessReplace(nil, &rpc.ProcessReplaceRequest{
+			_, err := s.pm.ProcessReplace(context.TODO(), &rpc.ProcessReplaceRequest{
 				Spec:            createProcessSpec(name, TestBinaryMissing),
 				TerminateSignal: "SIGHUP",
 			})
@@ -244,15 +251,18 @@ func (s *TestSuite) TestProcessReplaceDuringDeletion(c *C) {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
-			go s.pm.ProcessWatch(nil, pw)
+			go func() {
+				err := s.pm.ProcessWatch(nil, pw)
+				c.Assert(err, NotNil)
+			}()
 			name := "test_process_deletion_replace-" + strconv.Itoa(i)
 			assertProcessCreation(c, s.pm, name, TestBinary)
 			assertProcessDeletion(c, s.pm, name)
 
 			// TODO: we should change the deletion handling in a future version
 			// since deletion happens async this might error or not
 			// depending on if the process has already been deleted from the map
-			replaceResp, err := s.pm.ProcessReplace(nil, &rpc.ProcessReplaceRequest{
+			replaceResp, err := s.pm.ProcessReplace(context.TODO(), &rpc.ProcessReplaceRequest{
 				Spec:            createProcessSpec(name, TestBinaryReplace),
 				TerminateSignal: "SIGHUP",
 			})
@@ -290,7 +300,7 @@ func assertProcessReplace(c *C, pm *Manager, name, binary string) {
 		Spec:            createProcessSpec(name, binary),
 		TerminateSignal: "SIGHUP",
 	}
-	rsp, err := pm.ProcessReplace(nil, replaceReq)
+	rsp, err := pm.ProcessReplace(context.TODO(), replaceReq)
 
 	c.Assert(err, IsNil)
 	c.Assert(rsp, NotNil)
@@ -301,13 +311,13 @@ func assertProcessCreation(c *C, pm *Manager, name, binary string) {
 		Spec: createProcessSpec(name, binary),
 	}
 
-	createResp, err := pm.ProcessCreate(nil, createReq)
+	createResp, err := pm.ProcessCreate(context.TODO(), createReq)
 	c.Assert(err, IsNil)
 	c.Assert(createResp.Status.State, Not(Equals), types.ProcessStateStopping)
 	c.Assert(createResp.Status.State, Not(Equals), types.ProcessStateStopped)
 	c.Assert(createResp.Status.State, Not(Equals), types.ProcessStateError)
 
-	createResp, err = pm.ProcessCreate(nil, createReq)
+	createResp, err = pm.ProcessCreate(context.TODO(), createReq)
 	c.Assert(createResp, IsNil)
 	c.Assert(err, NotNil)
 	c.Assert(status.Code(err), Equals, codes.AlreadyExists)
@@ -325,7 +335,7 @@ func assertProcessDeletion(c *C, pm *Manager, name string) {
 		deleteReq := &rpc.ProcessDeleteRequest{
 			Name: name,
 		}
-		deleteResp, err := pm.ProcessDelete(nil, deleteReq)
+		deleteResp, err := pm.ProcessDelete(context.TODO(), deleteReq)
 		if err == nil {
 			c.Assert(deleteResp.Deleted, Equals, true)
 		} else {
@@ -346,7 +356,7 @@ func createProcessSpec(name, binary string) *rpc.ProcessSpec {
 
 func waitForProcessState(pm *Manager, name string, predicate func(process *rpc.ProcessResponse) bool) (bool, error) {
 	for j := 0; j < RetryCount; j++ {
-		getResp, err := pm.ProcessGet(nil, &rpc.ProcessGetRequest{
+		getResp, err := pm.ProcessGet(context.TODO(), &rpc.ProcessGetRequest{
 			Name: name,
 		})
 
@@ -367,7 +377,7 @@ func waitForProcessListState(pm *Manager, predicate func(processes map[string]*r
 	// 	or that it has some marker that it's in the process of deletion unfortunately the deletion marker is only on the rpc response
 	// 	and not the process struct so there is no way for the process list to signal deletion
 	for j := 0; j < RetryCount; j++ {
-		listResp, err := pm.ProcessList(nil, &rpc.ProcessListRequest{})
+		listResp, err := pm.ProcessList(context.TODO(), &rpc.ProcessListRequest{})
 		if err != nil {
 			return false, err
 		}

pkg/proxy/proxy.go

@@ -57,7 +57,6 @@ type Proxy struct {
 	rpc.UnimplementedProxyEngineServiceServer
 	ctx           context.Context
 	logsDir       string
-	shutdownCh    chan error
 	HealthChecker HealthChecker
 	ops           map[rpc.DataEngine]ProxyOps
 }
@@ -86,6 +85,7 @@ func (p *Proxy) startMonitoring() {
 		case <-p.ctx.Done():
 			logrus.Infof("%s: stopped monitoring replicas due to the context done", types.ProxyGRPCService)
 			done = true
+		default:
 		}
 		if done {
 			break

pkg/util/grpcutil.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/backoff"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/keepalive"
@@ -29,7 +30,12 @@ func Connect(endpoint string, tlsConfig *tls.Config, dialOptions ...grpc.DialOpt
 		return nil, err
 	}
 
-	dialOptions = append(dialOptions, grpc.WithBackoffMaxDelay(time.Second))
+	dialOptions = append(dialOptions, grpc.WithConnectParams(grpc.ConnectParams{
+		Backoff: backoff.Config{
+			MaxDelay: time.Second,
+		},
+	}))
+
 	if tlsConfig != nil {
 		dialOptions = append(dialOptions, grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)))
 	} else {

pkg/util/log.go

@@ -21,8 +21,6 @@ type LonghornFormatter struct {
 	*logrus.TextFormatter
 
 	LogsDir string
-
-	logFiles []*os.File
 }
 
 type LonghornWriter struct {

scripts/validate

@@ -10,20 +10,8 @@ PACKAGES="$(find -name '*.go' | xargs -I{} dirname {} |  cut -f2 -d/ | sort -u |
 echo Running: go vet
 go vet ${PACKAGES}
 
-if [ ! -z "${DRONE_REPO}" ] && [ ! -z "${DRONE_PULL_REQUEST}" ]; then
-	wget https://github.com/$DRONE_REPO/pull/$DRONE_PULL_REQUEST.patch
-	echo "Running: golangci-lint run --new-from-patch=${DRONE_PULL_REQUEST}.patch"
-	golangci-lint run --new-from-patch="${DRONE_PULL_REQUEST}.patch"
-	rm "${DRONE_PULL_REQUEST}.patch"
-elif [ ! -z "${DRONE_COMMIT_REF}" ]; then
-	echo "Running: golangci-lint run --new-from-rev=${DRONE_COMMIT_REF}"
-	golangci-lint run --new-from-rev=${DRONE_COMMIT_REF}
-else
-	git symbolic-ref -q HEAD && REV="origin/HEAD" || REV="HEAD^"
-	headSHA=$(git rev-parse --short=12 ${REV})
-	echo "Running: golangci-lint run --new-from-rev=${headSHA}"
-	golangci-lint run --new-from-rev=${headSHA}
-fi
+echo "Running: golangci-lint"
+golangci-lint run --timeout=5m
 
 echo Running: go fmt
 test -z "$(go fmt ${PACKAGES} | tee /dev/stderr)"