refactor(pkg&cmd): optimize code

kubewharf · Dec 6, 2023 · 9f7c946 · 9f7c946
1 parent 296a937
commit 9f7c946
Show file tree

Hide file tree

Showing 16 changed files with 20 additions and 31 deletions.
diff --git a/cmd/main.go b/cmd/main.go
@@ -52,7 +52,6 @@ func main() {
 		_, _ = fmt.Fprintf(os.Stderr, "error: %v\n", err)
 		os.Exit(1)
 	}
-	return
 }
 
 const (

diff --git a/pkg/backend/backend.go b/pkg/backend/backend.go
@@ -155,7 +155,7 @@ func NewBackend(kv storage.KvStorage, config Config, metricCli metrics.Metrics)
 		scanner:               scanner.NewScanner(kv, normalCoder, config.getScannerConfig(), metricCli),
 		config:                config,
 		capacity:              config.WatchCacheSize,
-		watchEventsRingBuffer: make([]atomic.Value, watchersChanCapacity, watchersChanCapacity),
+		watchEventsRingBuffer: make([]atomic.Value, watchersChanCapacity),
 		watchCache:            NewRing(config.WatchCacheSize),
 		watchChan:             make(chan []*proto.Event, watchersChanCapacity),
 		watcherHub: &WatcherHub{

diff --git a/pkg/backend/backend_test.go b/pkg/backend/backend_test.go
@@ -379,7 +379,6 @@ func (ct *createTestcase) run(t *testing.T, s suite, output <-chan []*proto.Even
 			return
 		}
 		ast.Equal(0, len(output), expectNoEvent)
-		return
 	})
 
 }
@@ -541,9 +540,7 @@ func sortKvs(kvs []*proto.KeyValue) []*proto.KeyValue {
 
 func extractPartitions(resp *proto.ListPartitionResponse) [][]byte {
 	ret := make([][]byte, len(resp.PartitionKeys))
-	for idx, kv := range resp.PartitionKeys {
-		ret[idx] = kv
-	}
+	copy(ret, resp.PartitionKeys)
 	return ret
 }
 

diff --git a/pkg/backend/range.go b/pkg/backend/range.go
@@ -46,7 +46,7 @@ func (b *backend) Get(ctx context.Context, r *proto.GetRequest) (resp *proto.Get
 	requireRev := r.GetRevision()
 
 	val, modRev, err := b.get(ctx, r.Key, requireRev)
-	if err == storage.ErrKeyNotFound {
+	if errors.Is(err, storage.ErrKeyNotFound) {
 		return &proto.GetResponse{
 			Header: responseHeader(curRev),
 		}, nil
@@ -79,7 +79,7 @@ func (b *backend) getLatestInternalVal(ctx context.Context, key []byte) (val []b
 
 func (b *backend) get(ctx context.Context, key []byte, revision uint64) (val []byte, modRevision uint64, err error) {
 	val, modRevision, err = b.getInternalVal(ctx, key, revision)
-	if bytes.Compare(val, tombStoneBytes) == 0 {
+	if bytes.Equal(val, tombStoneBytes) {
 		return nil, modRevision, storage.ErrKeyNotFound
 	}
 	return val, modRevision, err
@@ -107,7 +107,7 @@ func (b *backend) getInternalVal(ctx context.Context, key []byte, revision uint6
 	}
 
 	userKey, modRev, err := b.coder.Decode(iter.Key())
-	if modRev == 0 || bytes.Compare(userKey, key) != 0 {
+	if modRev == 0 || !bytes.Equal(userKey, key) {
 		// it's marked by deleting
 		return nil, modRev, storage.ErrKeyNotFound
 	}

diff --git a/pkg/backend/retry/retry.go b/pkg/backend/retry/retry.go
@@ -222,7 +222,7 @@ func (a *asyncFifoRetryImpl) retry(ctx context.Context) (breakLoop bool) {
 func (a *asyncFifoRetryImpl) overwrite(ctx context.Context, key []byte, prevOpRev uint64) (rev uint64, err error) {
 	val, modRev, err := a.getter(ctx, key)
 	if err != nil {
-		if err == storage.ErrKeyNotFound {
+		if errors.Is(err, storage.ErrKeyNotFound) {
 			return 0, nil
 		}
 		return 0, err
@@ -250,7 +250,7 @@ func (a *asyncFifoRetryImpl) overwrite(ctx context.Context, key []byte, prevOpRe
 	revBytes := make([]byte, 8, 9)
 	binary.BigEndian.PutUint64(revBytes, rev)
 
-	if bytes.Compare(val, a.config.Tombstone) == 0 {
+	if bytes.Equal(val, a.config.Tombstone) {
 		// append delete flag after revision bytes
 		revBytes = append(revBytes, 0)
 		prevRevBytes = append(prevRevBytes, 0)

diff --git a/pkg/backend/ring.go b/pkg/backend/ring.go
@@ -30,7 +30,7 @@ type Ring struct {
 
 func NewRing(l int) *Ring {
 	return &Ring{
-		arr: make([]*proto.Event, l, l),
+		arr: make([]*proto.Event, l),
 		l:   l,
 	}
 }

diff --git a/pkg/backend/scanner/scanner.go b/pkg/backend/scanner/scanner.go
@@ -378,7 +378,7 @@ func (w *worker) runWithBackoffRetry(ctx context.Context, receiver resultReceive
 
 	if err != nil {
 		// fail after retry, scanErr records the latest scan err
-		if err == wait.ErrWaitTimeout {
+		if errors.Is(err, wait.ErrWaitTimeout) {
 			err = fmt.Errorf("partition %d reached the max retry time: %d, encounter latest error %v", w.idx, scanBackoffSteps, scanErr)
 		}
 	}
@@ -510,7 +510,7 @@ func (w *worker) info() string {
 }
 
 func (w *worker) isSkippedRawKey(rawKey []byte, rev uint64) bool {
-	if len(w.lastCompactFailedRawKey) > 0 && bytes.Compare(w.lastCompactFailedRawKey, rawKey) == 0 {
+	if len(w.lastCompactFailedRawKey) > 0 && bytes.Equal(w.lastCompactFailedRawKey, rawKey) {
 		klog.InfoS("compact skip", "rawKey", string(rawKey), "rev", rev)
 		w.metricCli.EmitCounter("compact.skip", 1)
 		return true

diff --git a/pkg/endpoint/config.go b/pkg/endpoint/config.go
@@ -173,7 +173,7 @@ func (sc *SecurityConfig) isInsecure() bool {
 	return sc.CertFile == "" &&
 		sc.KeyFile == "" &&
 		sc.CA == "" &&
-		sc.ClientAuth == false
+		!sc.ClientAuth
 }
 
 func (sc *SecurityConfig) init() (err error) {

diff --git a/pkg/endpoint/server.go b/pkg/endpoint/server.go
@@ -127,7 +127,6 @@ func (gs *rootServer) run(ctx context.Context) (err error) {
 		klog.InfoS("root server start to listen", "port", gs.port)
 		err = mux.Serve()
 		klog.ErrorS(err, "root server shutdown cause by temporary network error", "port", gs.port)
-		return
 	}()
 
 	return runServers(ctx, mux, gs.services)

diff --git a/pkg/metrics/prometheus/prometheus.go b/pkg/metrics/prometheus/prometheus.go
@@ -150,9 +150,8 @@ func (pw *prometheusWrapper) labelsToMap(labels []metrics.T) (ret map[string]str
 
 func (pw *prometheusWrapper) extractLabelNames(labels []metrics.T) (ret []string) {
 	ret = make([]string, len(labels)+len(pw.globalLabelNames))
-	for i, labelName := range pw.globalLabelNames {
-		ret[i] = labelName
-	}
+	copy(ret, pw.globalLabelNames)
+
 	offset := len(pw.globalLabelNames)
 	for i, label := range labels {
 		ret[i+offset] = label.Name

diff --git a/pkg/server/etcd/watch.go b/pkg/server/etcd/watch.go
@@ -221,7 +221,7 @@ func (w *watcher) List(ctx context.Context, id int64, r *etcdserverpb.WatchCreat
 		revision := r.StartRevision * -1
 		// range stream eof, tell client range ends
 		// if has err, CancelReason is not nil
-		if watchResponse.Canceled == true {
+		if watchResponse.Canceled {
 			klog.InfoS("receive cancel message", "watcher", w.id, "watch", id, "key", r.Key, "end", r.RangeEnd, r.StartRevision*-1)
 			// indicates eof
 			revision = -1
@@ -340,8 +340,5 @@ func (w *watcher) Watch(ctx context.Context, id int64, r *etcdserverpb.WatchCrea
 
 func isPureWatchRequest(r *etcdserverpb.WatchCreateRequest) bool {
 	// if starts with /, it is a normal watch request, not a range stream request
-	if strings.HasPrefix(string(r.Key), "/") {
-		return true
-	}
-	return false
+	return strings.HasPrefix(string(r.Key), "/")
 }
diff --git a/pkg/server/server.go b/pkg/server/server.go
@@ -145,7 +145,6 @@ func (s *server) electionHandler(w http.ResponseWriter, req *http.Request) {
 	w.WriteHeader(http.StatusOK)
 	respBytes, _ := json.Marshal(info)
 	w.Write(respBytes)
-	return
 }
 
 func (s *server) revisionHandler(w http.ResponseWriter, req *http.Request) {

diff --git a/pkg/server/service/etcdproxy/etcd_proxy.go b/pkg/server/service/etcdproxy/etcd_proxy.go
@@ -51,7 +51,7 @@ func (e *etcdProxy) EtcdProxyEnabled() bool {
 
 // defaultCallOption is a copy of etcd client default call option
 var defaultCallOption = []grpc.CallOption{
-	grpc.FailFast(false),
+	grpc.WaitForReady(false),
 	grpc.MaxCallSendMsgSize(2 * 1024 * 1024),
 	grpc.MaxCallRecvMsgSize(math.MaxInt32),
 }

diff --git a/pkg/storage/badger/batch.go b/pkg/storage/badger/batch.go
@@ -63,14 +63,14 @@ func (b *batch) CAS(key []byte, newVal []byte, oldVal []byte, ttl int64) {
 	f := func() error {
 		item, err := b.txn.Get(key)
 		if err != nil {
-			if err == badger.ErrKeyNotFound {
+			if errors.Is(err, badger.ErrKeyNotFound) {
 				return storage.NewErrConflict(idx, key, nil)
 			}
 			return err
 		}
 
 		err = item.Value(func(val []byte) error {
-			if bytes.Compare(oldVal, val) != 0 {
+			if !bytes.Equal(oldVal, val) {
 				return storage.NewErrConflict(idx, key, val)
 			}
 			return nil

diff --git a/pkg/storage/memkv/batch.go b/pkg/storage/memkv/batch.go
@@ -80,7 +80,7 @@ func (b *batch) CAS(key []byte, newVal []byte, oldVal []byte, ttl int64) {
 		return
 	}
 
-	if bytes.Compare(val, oldVal) != 0 {
+	if !bytes.Equal(val, oldVal) {
 		b.err = storage.NewErrConflict(b.opCount, key, oldVal)
 		//b.err = errors.Errorf("cas failed: key %s old val is %s but expect %s", key, string(elem.Value.([]byte)), oldVal)
 	}
@@ -123,7 +123,7 @@ func (b *batch) DelCurrent(it storage.Iter) {
 		return
 	}
 
-	if bytes.Compare(b.get(it.Key()), it.Val()) != 0 {
+	if !bytes.Equal(b.get(it.Key()), it.Val()) {
 		b.err = storage.ErrCASFailed
 	}
 

diff --git a/pkg/storage/memkv/iter.go b/pkg/storage/memkv/iter.go
@@ -82,7 +82,6 @@ func (it *iter) init() {
 			elem = elem.Prev()
 		}
 	}
-	return
 }
 
 func (it *iter) inRange(elem *skiplist.Element) bool {