fix(client): update method signatures to include additional parameters. #1000451798

- Modify LookupPath to accept a boolean parameter
- Update InodeGet_ll to accept a boolean parameter
- Adjust ReadDirLimit_ll to include a boolean parameter
- Enhance MarkDecommissionStatus to include additional string parameter

Signed-off-by: Victor1319 <zengxuewei@oppo.com>

client/fs/super.go

@@ -1023,7 +1023,7 @@ func (s *Super) warmUpPath(metaResource proto.WarmUpMetaResource) {
 	log.LogInfof("warmUpPath: start warming up path %s", metaResource.DirPath)
 
 	// Get the inode for the path
-	ino, err := s.mw.LookupPath(metaResource.DirPath)
+	ino, err := s.mw.LookupPath(metaResource.DirPath, false)
 	if err != nil {
 		log.LogWarnf("warmUpPath: failed to get inode for path %s, err: %v", metaResource.DirPath, err)
 		atomic.StoreInt32(&warmUpPath.Status, proto.WarmStatusFailed)
@@ -1059,7 +1059,7 @@ func (s *Super) warmUpDirectory(dirIno uint64, currentGoroutineNum *int64, wg *s
 		}
 	}()
 	// Get directory info and cache it
-	dirInfo, err := s.mw.InodeGet_ll(dirIno)
+	dirInfo, err := s.mw.InodeGet_ll(dirIno, false)
 	if err != nil {
 		log.LogWarnf("warmUpDirectory: failed to get dir info for ino %d, err: %v", dirIno, err)
 		return
@@ -1083,7 +1083,7 @@ func (s *Super) warmUpDirectory(dirIno uint64, currentGoroutineNum *int64, wg *s
 		}
 		// Read directory contents in batches
 		log.LogDebugf("warmUpDirectory: reading dir ino=%d marker=%s limit=%d", dirIno, marker, s.readDirLimit)
-		children, err := s.mw.ReadDirLimit_ll(dirIno, marker, uint64(s.readDirLimit))
+		children, err := s.mw.ReadDirLimit_ll(dirIno, marker, uint64(s.readDirLimit), false)
 		if err != nil {
 			log.LogWarnf("warmUpDirectory: failed to read dir for ino %d, marker %s, err: %v", dirIno, marker, err)
 			return

master/cluster.go

@@ -5986,7 +5986,7 @@ func (c *Cluster) TryDecommissionRunningDiskIgnoreDps(disk *DecommissionDisk) {
 	for _, ignoreDp := range ignorePartitions {
 		triggerCondition := fmt.Sprintf("disk(%v)_%v_dp(%v)", disk.SrcAddr+"_"+disk.DiskPath, disk.Type, ignoreDp.PartitionID)
 		if err = ignoreDp.MarkDecommissionStatus(node.Addr, disk.DstAddr, disk.DiskPath, 0, disk.DecommissionRaftForce,
-			disk.DecommissionTerm, disk.Type, disk.DecommissionWeight, c, ns, triggerCondition); err != nil {
+			disk.DecommissionTerm, disk.Type, disk.DecommissionWeight, c, nil, nil, triggerCondition); err != nil {
 			if strings.Contains(err.Error(), proto.ErrDecommissionDiskErrDPFirst.Error()) {
 				c.syncUpdateDataPartition(ignoreDp)
 				// still decommission dp but not involved in the calculation of the decommission progress.

master/data_partition.go

@@ -2076,12 +2076,12 @@ func (partition *DataPartition) ProcessNextDecommissionSrcHost(c *Cluster) bool
 	}
 
 	if partition.IsDecommissionSuccess() {
-		partition.SetDecommissionStatus(DecommissionInitial)
+		partition.SetDecommissionStatus(DecommissionInitial, "processNextDecommissionSrcHost", "")
 	}
 
 	if err = partition.MarkDecommissionStatus(nextSrcAddr, nextDstAddr, replica.DiskPath, partition.DecommissionDstNodeSet,
 		partition.DecommissionRaftForce, partition.DecommissionTerm, partition.DecommissionType, partition.DecommissionWeight,
-		c, updatedSrcHosts, updatedDstHosts,
+		c, updatedSrcHosts, updatedDstHosts, "processNextDecommissionSrcHost",
 	); err != nil {
 		log.LogWarnf("action[ProcessNextDecommissionSrcHost] dp(%v) mark decommission failed, err %v",
 			partition.PartitionID, err)

master/flash_group.go

@@ -116,7 +116,8 @@ func (m *Server) createFlashGroup(w http.ResponseWriter, r *http.Request) {
 }
 
 func (c *Cluster) createFlashGroup(setSlots []uint32, setWeight uint32, gradualFlag bool,
-	step uint32) (fg *flashgroupmanager.FlashGroup, err error) {
+	step uint32,
+) (fg *flashgroupmanager.FlashGroup, err error) {
 	defer func() {
 		if err != nil {
 			log.LogErrorf("action[addFlashGroup],clusterID[%v] err:%v ", c.Name, err.Error())

proto/packet.go

@@ -310,21 +310,21 @@ const (
 	OpApplyWarmupMetaToken      uint8 = 0xCD
 
 	// async operations: Master、SDK -> MetaNode
-	OpMetaAsyncReadDir           uint8 = 0xC0
-	OpMetaAsyncLookup            uint8 = 0xC1 // Async version of OpMetaLookup
-	OpMetaAsyncInodeGet          uint8 = 0xC2 // Async version of OpMetaInodeGet
-	OpMetaAsyncCreateInode       uint8 = 0xC3 // Async version of OpMetaCreateInode
-	OpMetaAsyncCreateDentry      uint8 = 0xC4 // Async version of OpMetaCreateDentry
-	OpMetaAsyncDeleteDentry      uint8 = 0xC5 // Async version of OpMetaDeleteDentry
-	OpQuotaAsyncCreateDentry     uint8 = 0xC6 // Async version of OpQuotaCreateDentry
-	OpMetaAsyncXAttrSet          uint8 = 0xC7 // Async version of OpMetaSetXAttr
-	OpMetaAsyncXAttrGet          uint8 = 0xC8 // Async version of OpMetaGetXAttr
-	OpMetaAsyncLockDir           uint8 = 0xC9 // Async version of OpMetaLockDir
-	OpMetaAsyncTxCreateInode     uint8 = 0xCA // Async version of OpMetaTxCreateInode
-	OpMetaAsyncTxCreateDentry    uint8 = 0xCC // Async version of OpMetaTxCreateDentry
-	OpMetaAsyncTxCreate          uint8 = 0xCD // Async version of OpMetaTxCreate
-	OpMetaAsyncGetInodeQuota     uint8 = 0xCE // Async version of OpMetaGetInodeQuota
-	OpMetaAsyncUnlinkInode       uint8 = 0xCF // Async version of OpMetaUnlinkInode
+	OpMetaAsyncReadDir           uint8 = 0x82
+	OpMetaAsyncLookup            uint8 = 0xE3 // Async version of OpMetaLookup
+	OpMetaAsyncInodeGet          uint8 = 0xE6 // Async version of OpMetaInodeGet
+	OpMetaAsyncCreateInode       uint8 = 0xE7 // Async version of OpMetaCreateInode
+	OpMetaAsyncCreateDentry      uint8 = 0xD4 // Async version of OpMetaCreateDentry
+	OpMetaAsyncDeleteDentry      uint8 = 0xE8 // Async version of OpMetaDeleteDentry
+	OpQuotaAsyncCreateDentry     uint8 = 0xE4 // Async version of OpQuotaCreateDentry
+	OpMetaAsyncXAttrSet          uint8 = 0xD7 // Async version of OpMetaSetXAttr
+	OpMetaAsyncXAttrGet          uint8 = 0xD8 // Async version of OpMetaGetXAttr
+	OpMetaAsyncLockDir           uint8 = 0xD9 // Async version of OpMetaLockDir
+	OpMetaAsyncTxCreateInode     uint8 = 0xDA // Async version of OpMetaTxCreateInode
+	OpMetaAsyncTxCreateDentry    uint8 = 0xDC // Async version of OpMetaTxCreateDentry
+	OpMetaAsyncTxCreate          uint8 = 0xE1 // Async version of OpMetaTxCreate
+	OpMetaAsyncGetInodeQuota     uint8 = 0xE2 // Async version of OpMetaGetInodeQuota
+	OpMetaAsyncUnlinkInode       uint8 = 0xDF // Async version of OpMetaUnlinkInode
 	OpMetaAsyncEvictInode        uint8 = 0x94 // Async version of OpMetaEvictInode
 	OpMetaAsyncLinkInode         uint8 = 0x95 // Async version of OpMetaLinkInode
 	OpMetaAsyncUpdateDentry      uint8 = 0x96 // Async version of OpMetaUpdateDentry

remotecache/flashgroupmanager/flash_group.go

@@ -306,7 +306,8 @@ func (fg *FlashGroup) GetPendingSlotsCount() (count int) {
 }
 
 func (fg *FlashGroup) UpdateStatus(status proto.FlashGroupStatus,
-	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc, flashNodeTopo *FlashNodeTopology) (err error) {
+	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc, flashNodeTopo *FlashNodeTopology,
+) (err error) {
 	fg.lock.Lock()
 	defer fg.lock.Unlock()
 	oldStatus := fg.Status
@@ -322,7 +323,8 @@ func (fg *FlashGroup) UpdateStatus(status proto.FlashGroupStatus,
 }
 
 func (fg *FlashGroup) UpdateSlots(topology *FlashNodeTopology, needDeleteFgFlag bool, syncDeleteFlashGroupFunc SyncDeleteFlashGroupFunc,
-	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc) (err error) {
+	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc,
+) (err error) {
 	fg.lock.Lock()
 	var updatedSlotsNum uint32
 	var newSlotStatus proto.SlotStatus

remotecache/flashgroupmanager/flash_node.go

@@ -129,7 +129,8 @@ func (flashNode *FlashNode) checkLiveliness() {
 
 func (flashNode *FlashNode) createHeartbeatTask(masterAddr string, flashNodeHandleReadTimeout int,
 	flashNodeReadDataNodeTimeout int, flashHotKeyMissCount int,
-	flashReadFlowLimit int64, flashWriteFlowLimit int64, flashKeyFlowLimit int64) (task *proto.AdminTask) {
+	flashReadFlowLimit int64, flashWriteFlowLimit int64, flashKeyFlowLimit int64,
+) (task *proto.AdminTask) {
 	request := &proto.HeartBeatRequest{
 		CurrTime:   time.Now().Unix(),
 		MasterAddr: masterAddr,

remotecache/flashgroupmanager/flash_node_topology.go

@@ -102,7 +102,8 @@ func NewFlashNodeTopology() (t *FlashNodeTopology) {
 }
 
 func (t *FlashNodeTopology) gradualCreateFlashGroup(fgID uint64, syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc,
-	setSlots []uint32, setWeight uint32, step uint32) (flashGroup *FlashGroup, err error) {
+	setSlots []uint32, setWeight uint32, step uint32,
+) (flashGroup *FlashGroup, err error) {
 	t.createFlashGroupLock.Lock()
 	defer t.createFlashGroupLock.Unlock()
 
@@ -130,7 +131,8 @@ func (t *FlashNodeTopology) gradualCreateFlashGroup(fgID uint64, syncUpdateFlash
 }
 
 func (t *FlashNodeTopology) createFlashGroup(fgID uint64, syncAddFlashGroupFunc SyncAddFlashGroupFunc,
-	setSlots []uint32, setWeight uint32) (flashGroup *FlashGroup, err error) {
+	setSlots []uint32, setWeight uint32,
+) (flashGroup *FlashGroup, err error) {
 	t.createFlashGroupLock.Lock()
 	defer t.createFlashGroupLock.Unlock()
 
@@ -315,7 +317,8 @@ func (t *FlashNodeTopology) GetFlashGroupsAdminView(fgStatus proto.FlashGroupSta
 }
 
 func (t *FlashNodeTopology) gradualRemoveFlashGroup(flashGroup *FlashGroup,
-	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc, step uint32) (err error) {
+	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc, step uint32,
+) (err error) {
 	t.createFlashGroupLock.Lock()
 	defer t.createFlashGroupLock.Unlock()
 
@@ -324,7 +327,8 @@ func (t *FlashNodeTopology) gradualRemoveFlashGroup(flashGroup *FlashGroup,
 
 func (t *FlashNodeTopology) gradualExpandOrShrinkFlashGroupSlots(flashGroup *FlashGroup,
 	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc, newSlotStatus proto.SlotStatus,
-	pendingSlots []uint32, step uint32) (err error) {
+	pendingSlots []uint32, step uint32,
+) (err error) {
 	flashGroup.lock.Lock()
 	oldSlotStatus := flashGroup.SlotStatus
 	oldStep := flashGroup.Step
@@ -416,7 +420,8 @@ func (t *FlashNodeTopology) Clear() {
 }
 
 func (t *FlashNodeTopology) AddFlashNode(clusterName, nodeAddr, zoneName, version string,
-	allocateCommonIDFunc AllocateCommonIDFunc, syncAddFlashNodeFunc SyncAddFlashNodeFunc) (id uint64, err error) {
+	allocateCommonIDFunc AllocateCommonIDFunc, syncAddFlashNodeFunc SyncAddFlashNodeFunc,
+) (id uint64, err error) {
 	t.mu.Lock()
 	defer func() {
 		t.mu.Unlock()
@@ -474,7 +479,8 @@ func (t *FlashNodeTopology) ListFlashNodes(showAll, active bool) map[string][]*p
 }
 
 func (t *FlashNodeTopology) UpdateFlashNode(flashNode *FlashNode, enable bool,
-	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (err error) {
+	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (err error) {
 	flashNode.Lock()
 	defer flashNode.Unlock()
 	if flashNode.IsEnable != enable {
@@ -492,7 +498,8 @@ func (t *FlashNodeTopology) UpdateFlashNode(flashNode *FlashNode, enable bool,
 }
 
 func (t *FlashNodeTopology) RemoveFlashNode(clusterName string, flashNode *FlashNode,
-	syncDeleteFlashNodeFunc SyncDeleteFlashNodeFunc) (err error) {
+	syncDeleteFlashNodeFunc SyncDeleteFlashNodeFunc,
+) (err error) {
 	log.LogWarnf("action[removeFlashNode], ZoneName[%s] Node[%s] offline", flashNode.ZoneName, flashNode.Addr)
 	var flashGroupID uint64
 	if flashGroupID, err = t.deleteFlashNode(clusterName, flashNode, syncDeleteFlashNodeFunc); err != nil {
@@ -523,7 +530,8 @@ func (t *FlashNodeTopology) RemoveFlashNode(clusterName string, flashNode *Flash
 }
 
 func (t *FlashNodeTopology) deleteFlashNode(clusterName string, flashNode *FlashNode,
-	syncDeleteFlashNodeFunc SyncDeleteFlashNodeFunc) (oldFlashGroupID uint64, err error) {
+	syncDeleteFlashNodeFunc SyncDeleteFlashNodeFunc,
+) (oldFlashGroupID uint64, err error) {
 	flashNode.Lock()
 	defer flashNode.Unlock()
 	oldFlashGroupID = flashNode.FlashGroupID
@@ -578,7 +586,8 @@ func (t *FlashNodeTopology) TurnFlashGroup(enabled bool) {
 
 func (t *FlashNodeTopology) CreateFlashGroup(id uint64, syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc,
 	syncAddFlashGroupFunc SyncAddFlashGroupFunc, setSlots []uint32, setWeight uint32, gradualFlag bool,
-	step uint32) (fg *FlashGroup, err error) {
+	step uint32,
+) (fg *FlashGroup, err error) {
 	if gradualFlag {
 		if fg, err = t.gradualCreateFlashGroup(id, syncUpdateFlashGroupFunc, setSlots, setWeight, step); err != nil {
 			return
@@ -595,7 +604,8 @@ func (t *FlashNodeTopology) CreateFlashGroup(id uint64, syncUpdateFlashGroupFunc
 func (t *FlashNodeTopology) RemoveFlashGroup(id uint64, gradualFlag bool,
 	step uint32, syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc,
 	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
-	syncDeleteFlashGroupFunc SyncDeleteFlashGroupFunc) (flashGroup *FlashGroup, err error) {
+	syncDeleteFlashGroupFunc SyncDeleteFlashGroupFunc,
+) (flashGroup *FlashGroup, err error) {
 	if flashGroup, err = t.GetFlashGroup(id); err != nil {
 		return
 	}
@@ -622,7 +632,8 @@ func (t *FlashNodeTopology) RemoveFlashGroup(id uint64, gradualFlag bool,
 }
 
 func (t *FlashNodeTopology) removeAllFlashNodeFromFlashGroup(flashGroup *FlashGroup,
-	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (err error) {
+	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (err error) {
 	flashNodeHosts := flashGroup.GetFlashNodeHosts(false)
 	successHost := make([]string, 0)
 	for _, flashNodeHost := range flashNodeHosts {
@@ -638,7 +649,8 @@ func (t *FlashNodeTopology) removeAllFlashNodeFromFlashGroup(flashGroup *FlashGr
 }
 
 func (t *FlashNodeTopology) removeFlashNodeFromFlashGroup(addr string, flashGroup *FlashGroup,
-	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (err error) {
+	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (err error) {
 	var flashNode *FlashNode
 	if flashNode, err = t.setFlashNodeToUnused(addr, flashGroup.ID, syncUpdateFlashNodeFunc); err != nil {
 		return
@@ -682,7 +694,8 @@ func (t *FlashNodeTopology) setFlashNodeToUnused(addr string, flashGroupID uint6
 }
 
 func (t *FlashNodeTopology) FlashGroupAddFlashNode(flashGroupID uint64, addr string, zoneName string,
-	count int, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (flashGroup *FlashGroup, err error) {
+	count int, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (flashGroup *FlashGroup, err error) {
 	if flashGroup, err = t.GetFlashGroup(flashGroupID); err != nil {
 		return
 	}
@@ -699,7 +712,8 @@ func (t *FlashNodeTopology) FlashGroupAddFlashNode(flashGroupID uint64, addr str
 }
 
 func (t *FlashNodeTopology) addFlashNodeToFlashGroup(addr string, flashGroup *FlashGroup,
-	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (err error) {
+	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (err error) {
 	var flashNode *FlashNode
 	if flashNode, err = t.setFlashNodeToFlashGroup(addr, flashGroup.ID, syncUpdateFlashNodeFunc); err != nil {
 		return
@@ -709,7 +723,8 @@ func (t *FlashNodeTopology) addFlashNodeToFlashGroup(addr string, flashGroup *Fl
 }
 
 func (t *FlashNodeTopology) setFlashNodeToFlashGroup(addr string, flashGroupID uint64,
-	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (flashNode *FlashNode, err error) {
+	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (flashNode *FlashNode, err error) {
 	if flashNode, err = t.PeekFlashNode(addr); err != nil {
 		return
 	}
@@ -735,7 +750,8 @@ func (t *FlashNodeTopology) setFlashNodeToFlashGroup(addr string, flashGroupID u
 }
 
 func (t *FlashNodeTopology) selectFlashNodesFromZoneAddToFlashGroup(zoneName string, count int, excludeHosts []string,
-	flashGroup *FlashGroup, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (err error) {
+	flashGroup *FlashGroup, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (err error) {
 	flashNodeZone, err := t.GetZone(zoneName)
 	if err != nil {
 		return
@@ -758,7 +774,8 @@ func (t *FlashNodeTopology) selectFlashNodesFromZoneAddToFlashGroup(zoneName str
 }
 
 func (t *FlashNodeTopology) FlashGroupRemoveFlashNode(flashGroupID uint64, addr string, zoneName string,
-	count int, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (flashGroup *FlashGroup, err error) {
+	count int, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (flashGroup *FlashGroup, err error) {
 	if flashGroup, err = t.GetFlashGroup(flashGroupID); err != nil {
 		return
 	}
@@ -772,7 +789,8 @@ func (t *FlashNodeTopology) FlashGroupRemoveFlashNode(flashGroupID uint64, addr
 }
 
 func (t *FlashNodeTopology) removeFlashNodesFromTargetZone(zoneName string, count int,
-	flashGroup *FlashGroup, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (err error) {
+	flashGroup *FlashGroup, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (err error) {
 	flashNodeHosts := flashGroup.getTargetZoneFlashNodeHosts(zoneName)
 	if len(flashNodeHosts) < count {
 		return fmt.Errorf("flashNodeHostsCount:%v less than expectCount:%v,flashNodeHosts:%v", len(flashNodeHosts), count, flashNodeHosts)
@@ -822,7 +840,8 @@ func (t *FlashNodeTopology) SaveFlashGroup(group *FlashGroup) {
 }
 
 func (t *FlashNodeTopology) CreateFlashNodeHeartBeatTasks(leader string, handleReadTimeout, readDataNodeTimeout,
-	hotKeyMissCount int, flashReadFlowLimit int64, flashWriteFlowLimit int64, flashKeyFlowLimit int64) []*proto.AdminTask {
+	hotKeyMissCount int, flashReadFlowLimit int64, flashWriteFlowLimit int64, flashKeyFlowLimit int64,
+) []*proto.AdminTask {
 	tasks := make([]*proto.AdminTask, 0)
 	t.flashNodeMap.Range(func(addr, flashNode interface{}) bool {
 		node := flashNode.(*FlashNode)
@@ -895,7 +914,8 @@ func (t *FlashNodeTopology) Load() (err error) {
 }
 
 func (t *FlashNodeTopology) UpdateFlashGroupSlots(syncDeleteFlashGroupFunc SyncDeleteFlashGroupFunc,
-	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) {
+	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) {
 	isNotUpdated := true
 	t.flashGroupMap.Range(func(key, value interface{}) bool {
 		flashGroup := value.(*FlashGroup)
@@ -923,7 +943,8 @@ func (t *FlashNodeTopology) UpdateFlashGroupSlots(syncDeleteFlashGroupFunc SyncD
 }
 
 func (t *FlashNodeTopology) updateFlashGroupSlots(flashGroup *FlashGroup, syncDeleteFlashGroupFunc SyncDeleteFlashGroupFunc,
-	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (err error) {
+	syncUpdateFlashGroupFunc SyncUpdateFlashGroupFunc, syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (err error) {
 	var needDeleteFgFlag bool
 
 	if flashGroup.GetSlotStatus() == proto.SlotStatus_Deleting {
@@ -935,7 +956,8 @@ func (t *FlashNodeTopology) updateFlashGroupSlots(flashGroup *FlashGroup, syncDe
 }
 
 func (t *FlashNodeTopology) checkShrinkOrDeleteFlashGroup(flashGroup *FlashGroup,
-	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc) (needDeleteFgFlag bool, err error) {
+	syncUpdateFlashNodeFunc SyncUpdateFlashNodeFunc,
+) (needDeleteFgFlag bool, err error) {
 	leftPendingSlotsNum := uint32(flashGroup.GetPendingSlotsCount()) - flashGroup.Step
 	if (leftPendingSlotsNum <= 0) && (flashGroup.GetPendingSlotsCount() == flashGroup.GetSlotsCount()) {
 		needDeleteFgFlag = true

tool/remotecache-config/cmd/cluster.go

@@ -209,9 +209,10 @@ func newClusterSetParasCmd(client *master.MasterClient) *cobra.Command {
 			if err = client.AdminAPI().SetClusterParas("", "", "",
 				"", "", "", "", clientIDKey,
 				"", "",
-				"", "",
+				"", "", "",
 				"", "", "", "", "", "",
-				"", "", handleTimeout, readDataNodeTimeout,
+				"", "", handleTimeout, readDataNodeTimeout, "",
+				"", "",
 				optRcTTL, optRcReadTimeout, optRemoteCacheMultiRead, optFlashNodeTimeoutCount,
 				optRemoteCacheSameZoneTimeout, optRemoteCacheSameRegionTimeout, optFlashHotKeyMissCount,
 				optFlashReadFlowLimit, optFlashWriteFlowLimit, optFlashKeyFlowLimit, optRemoteClientFlowLimit); err != nil {