From 5d607865ad5bc3213c670289ee33016d1e4be117 Mon Sep 17 00:00:00 2001 From: will-2012 <117156346+will-2012@users.noreply.github.com> Date: Tue, 12 Dec 2023 13:19:52 +0800 Subject: [PATCH 01/27] chore: refine some log format (#1269) Co-authored-by: will@2012 --- modular/gater/metadata_handler.go | 79 ++++++++++++++++--------------- 1 file changed, 40 insertions(+), 39 deletions(-) diff --git a/modular/gater/metadata_handler.go b/modular/gater/metadata_handler.go index 38e9c8ab9..876a9f6c9 100644 --- a/modular/gater/metadata_handler.go +++ b/modular/gater/metadata_handler.go @@ -72,12 +72,12 @@ func (g *GateModular) getUserBucketsHandler(w http.ResponseWriter, r *http.Reque handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get user buckets", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -146,12 +146,12 @@ func (g *GateModular) listObjectsByBucketNameHandler(w http.ResponseWriter, r *h handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list objects by bucket name", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -298,12 +298,12 @@ func (g *GateModular) getObjectMetaHandler(w http.ResponseWriter, r *http.Reques handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get object meta", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -354,12 +354,12 @@ func (g *GateModular) getBucketMetaHandler(w http.ResponseWriter, r *http.Reques handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get bucket meta", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -410,12 +410,12 @@ func (g *GateModular) verifyPermissionHandler(w http.ResponseWriter, r *http.Req handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to verify permission", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -499,12 +499,12 @@ func (g *GateModular) getGroupListHandler(w http.ResponseWriter, r *http.Request handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get group list", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -601,12 +601,12 @@ func (g *GateModular) listObjectsByIDsHandler(w http.ResponseWriter, r *http.Req handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list objects by ids", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -681,12 +681,12 @@ func (g *GateModular) listBucketsByIDsHandler(w http.ResponseWriter, r *http.Req handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list buckets by ids", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -757,12 +757,12 @@ func (g *GateModular) getPaymentByBucketIDHandler(w http.ResponseWriter, r *http handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get payment by bucket id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -809,12 +809,12 @@ func (g *GateModular) getPaymentByBucketNameHandler(w http.ResponseWriter, r *ht handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get payment by bucket name", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -860,12 +860,12 @@ func (g *GateModular) getBucketByBucketNameHandler(w http.ResponseWriter, r *htt handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get bucket by bucket name", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -913,12 +913,12 @@ func (g *GateModular) getBucketByBucketIDHandler(w http.ResponseWriter, r *http. handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get bucket by bucket id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -971,12 +971,12 @@ func (g *GateModular) listDeletedObjectsByBlockNumberRangeHandler(w http.Respons handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list deleted objects by block number range", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1039,12 +1039,12 @@ func (g *GateModular) getUserBucketsCountHandler(w http.ResponseWriter, r *http. handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get user buckets count", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1094,12 +1094,12 @@ func (g *GateModular) listExpiredBucketsBySpHandler(w http.ResponseWriter, r *ht handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list expired buckets by sp", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1172,12 +1172,12 @@ func (g *GateModular) verifyPermissionByIDHandler(w http.ResponseWriter, r *http handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to verify permission by id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1260,12 +1260,12 @@ func (g *GateModular) listVirtualGroupFamiliesBySpIDHandler(w http.ResponseWrite handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list virtual group families by sp id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1314,12 +1314,12 @@ func (g *GateModular) getVirtualGroupFamilyHandler(w http.ResponseWriter, r *htt handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get virtual group families by vgf id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1368,12 +1368,12 @@ func (g *GateModular) getGlobalVirtualGroupByGvgIDHandler(w http.ResponseWriter, handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get global virtual group by gvg id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1424,12 +1424,12 @@ func (g *GateModular) getGlobalVirtualGroupHandler(w http.ResponseWriter, r *htt handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get global virtual group by lvg id and bucket id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1485,12 +1485,12 @@ func (g *GateModular) listGlobalVirtualGroupsBySecondarySPHandler(w http.Respons handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list global virtual group by secondary sp id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1539,12 +1539,12 @@ func (g *GateModular) listGlobalVirtualGroupsByBucketHandler(w http.ResponseWrit handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list global virtual group by bucket id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1599,12 +1599,12 @@ func (g *GateModular) listObjectsInGVGAndBucketHandler(w http.ResponseWriter, r handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list objects by gvg and bucket id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1684,12 +1684,12 @@ func (g *GateModular) listObjectsByGVGAndBucketForGCHandler(w http.ResponseWrite handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list objects by gvg and bucket for gc", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1767,12 +1767,12 @@ func (g *GateModular) listObjectsInGVGHandler(w http.ResponseWriter, r *http.Req handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list objects by gvg id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1841,12 +1841,12 @@ func (g *GateModular) listMigrateBucketEventsHandler(w http.ResponseWriter, r *h handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list migrate bucket events", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1904,12 +1904,12 @@ func (g *GateModular) listSwapOutEventsHandler(w http.ResponseWriter, r *http.Re handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list swap out events", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -1966,12 +1966,12 @@ func (g *GateModular) listSpExitEventsHandler(w http.ResponseWriter, r *http.Req handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list migrate bucket events", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2032,6 +2032,7 @@ func (g *GateModular) getSPInfoHandler(w http.ResponseWriter, r *http.Request) { } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2077,12 +2078,12 @@ func (g *GateModular) getStatusHandler(w http.ResponseWriter, r *http.Request) { handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get status", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2124,12 +2125,12 @@ func (g *GateModular) getUserGroupsHandler(w http.ResponseWriter, r *http.Reques handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get groups info by a user address", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2198,12 +2199,12 @@ func (g *GateModular) getGroupMembersHandler(w http.ResponseWriter, r *http.Requ handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get group members by group id", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2272,12 +2273,12 @@ func (g *GateModular) getUserOwnedGroupsHandler(w http.ResponseWriter, r *http.R handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to retrieve groups where the user is the owner", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2348,12 +2349,12 @@ func (g *GateModular) listObjectPoliciesHandler(w http.ResponseWriter, r *http.R handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list policies by object info", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2436,12 +2437,12 @@ func (g *GateModular) listPaymentAccountStreamsHandler(w http.ResponseWriter, r handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list payment account streams", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2487,12 +2488,12 @@ func (g *GateModular) listUserPaymentAccountsHandler(w http.ResponseWriter, r *h handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list payment accounts by owner address", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2542,12 +2543,12 @@ func (g *GateModular) listGroupsByIDsHandler(w http.ResponseWriter, r *http.Requ handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to list groups by ids", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2618,12 +2619,12 @@ func (g *GateModular) getSPMigratingBucketNumberHandler(w http.ResponseWriter, r handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get the latest active migrating bucket by specific sp", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2676,12 +2677,12 @@ func (g *GateModular) verifyMigrateGVGPermissionHandler(w http.ResponseWriter, r handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to verify the destination sp id of bucket migration & swap out", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) @@ -2744,12 +2745,12 @@ func (g *GateModular) getBucketSizeHandler(w http.ResponseWriter, r *http.Reques handlerName := mux.CurrentRoute(r).GetName() if err != nil { reqCtx.SetError(gfsperrors.MakeGfSpError(err)) - log.CtxErrorw(reqCtx.Context(), "failed to get bucket total object size", reqCtx.String()) modelgateway.MakeErrorResponse(w, err) MetadataHandlerFailureMetrics(err, startTime, handlerName) } else { MetadataHandlerSuccessMetrics(startTime, handlerName) } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) }() reqCtx, _ = NewRequestContext(r, g) From c126f634e5964fed3540f8df21c7096f4526292a Mon Sep 17 00:00:00 2001 From: will-2012 <117156346+will-2012@users.noreply.github.com> Date: Fri, 15 Dec 2023 13:43:12 +0800 Subject: [PATCH 02/27] chore: refine config comment (#1273) * chore: refine config comment * chore: polish query upload progress description --------- Co-authored-by: will@2012 --- base/gfspconfig/config.go | 10 +++++----- store/types/store.go | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/base/gfspconfig/config.go b/base/gfspconfig/config.go index 49625f2b0..5ea0ff09d 100644 --- a/base/gfspconfig/config.go +++ b/base/gfspconfig/config.go @@ -103,7 +103,7 @@ type ChainConfig struct { type SpAccountConfig struct { SpOperatorAddress string `comment:"required"` OperatorPrivateKey string `comment:"required"` - FundingPrivateKey string `comment:"required"` + FundingPrivateKey string `comment:"optional"` SealPrivateKey string `comment:"required"` ApprovalPrivateKey string `comment:"required"` GcPrivateKey string `comment:"required"` @@ -156,10 +156,10 @@ type ExecutorConfig struct { } type P2PConfig struct { - P2PPrivateKey string `comment:"required"` - P2PAddress string `comment:"required"` - P2PAntAddress string `comment:"required"` - P2PBootstrap []string `comment:"required"` + P2PPrivateKey string `comment:"optional"` + P2PAddress string `comment:"optional"` + P2PAntAddress string `comment:"optional"` + P2PBootstrap []string `comment:"optional"` P2PPingPeriod int `comment:"optional"` } diff --git a/store/types/store.go b/store/types/store.go index c2f3a31be..5d954f883 100644 --- a/store/types/store.go +++ b/store/types/store.go @@ -25,7 +25,7 @@ var ToReadableDescription = map[readableUploadProgressType]string{ UploadProgressSealed: "object is succeed to upload and seal onto the chain", UploadProgressUploadToPrimaryFailed: "something is wrong in uploading to primary", UploadProgressAllocSecondaryFailed: "something is wrong in allocating secondary SPs", - UploadProgressReplicateSecondaryFailed: "something is wrong in uploading to primary", + UploadProgressReplicateSecondaryFailed: "something is wrong in replicating secondary SPs", UploadProgressSignObjectFailed: "something is wrong in signing the object", UploadProgressSealObjectFailed: "something is wrong in sealing object", UploadProgressObjectDiscontinued: "object has been discontinued", From e7aeec1f625b67c793c5ab29a7db6078be752d58 Mon Sep 17 00:00:00 2001 From: Chris Li Date: Mon, 18 Dec 2023 14:25:22 +0800 Subject: [PATCH 03/27] feat: bucket migration state improvement (#1250) --- base/gfspapp/manage_server.go | 38 +- base/gfspapp/manage_server_test.go | 50 + base/gfspclient/gater.go | 18 +- base/gfspclient/helper_test.go | 13 +- base/gfspclient/interface.go | 8 +- base/gfspclient/interface_mock.go | 162 +- base/gfspclient/manager.go | 49 +- base/gfspclient/metadata.go | 22 +- base/gfspconfig/config.go | 3 + base/types/gfspserver/manage.pb.go | 1331 +++++++++++++++-- base/types/gfspserver/query_task.pb.go | 174 ++- base/types/gfsptask/migrate_gvg.go | 31 + base/types/gfsptask/task.pb.go | 449 ++++-- core/module/modular.go | 12 +- core/module/modular_mock.go | 97 +- core/module/null_modular.go | 13 +- core/spdb/entity.go | 22 +- core/spdb/spdb.go | 25 +- core/spdb/spdb_mock.go | 314 ++++ core/task/null_task.go | 8 + core/task/task.go | 20 + modular/approver/approve_task.go | 26 + modular/approver/approve_task_test.go | 12 +- modular/authenticator/authenticator.go | 10 + modular/executor/execute_gc.go | 87 +- modular/gater/bucket_handler.go | 90 ++ modular/gater/bucket_handler_test.go | 187 +++ modular/gater/const.go | 4 + modular/gater/migrate_handler.go | 100 +- modular/gater/router.go | 5 + modular/gater/router_test.go | 16 + modular/manager/bucket_migrate_scheduler.go | 478 ++++-- modular/manager/manage_task.go | 45 +- modular/manager/manager.go | 46 +- modular/manager/manager_options.go | 2 + modular/manager/migrate_service.go | 138 +- modular/manager/migrate_unit.go | 5 +- modular/metadata/metadata_sp_exit_service.go | 49 + .../metadata/metadata_sp_exit_service_test.go | 57 + modular/metadata/types/metadata.pb.go | 1195 ++++++++++----- proto/base/types/gfspserver/manage.proto | 32 +- proto/base/types/gfspserver/query_task.proto | 2 + proto/base/types/gfsptask/task.proto | 6 + proto/modular/metadata/types/metadata.proto | 15 + proto/store/types/store.proto | 27 + store/bsdb/database.go | 2 + store/bsdb/database_mock.go | 46 +- store/bsdb/event_migration_bucket.go | 28 + store/bsdb/filters.go | 6 + store/sqldb/const.go | 2 + store/sqldb/migrate.go | 322 +++- store/sqldb/migrate_schema.go | 24 + store/sqldb/migrate_test.go | 7 +- store/sqldb/store.go | 4 + store/types/store.pb.go | 131 +- 55 files changed, 4914 insertions(+), 1151 deletions(-) diff --git a/base/gfspapp/manage_server.go b/base/gfspapp/manage_server.go index 8703cef66..4740231cb 100644 --- a/base/gfspapp/manage_server.go +++ b/base/gfspapp/manage_server.go @@ -360,22 +360,48 @@ func (g *GfSpBaseApp) GfSpQueryTasksStats(ctx context.Context, _ *gfspserver.GfS }, nil } -func (g *GfSpBaseApp) GfSpNotifyPreMigrate(ctx context.Context, req *gfspserver.GfSpNotifyPreMigrateBucketRequest) ( +func (g *GfSpBaseApp) GfSpQueryBucketMigrationProgress(ctx context.Context, req *gfspserver.GfSpQueryBucketMigrationProgressRequest) ( + *gfspserver.GfSpQueryBucketMigrationProgressResponse, error) { + var ( + progress *gfspserver.MigrateBucketProgressMeta + err error + ) + if progress, err = g.manager.QueryBucketMigrationProgress(ctx, req.GetBucketId()); err != nil { + log.CtxErrorw(ctx, "failed to query bucket migration progress", "bucket_id", req.GetBucketId(), "error", err) + return nil, err + } + + return &gfspserver.GfSpQueryBucketMigrationProgressResponse{ + Progress: progress, + }, nil +} + +func (g *GfSpBaseApp) GfSpNotifyPreMigrateBucketAndDeductQuota(ctx context.Context, req *gfspserver.GfSpNotifyPreMigrateBucketRequest) ( *gfspserver.GfSpNotifyPreMigrateBucketResponse, error) { - if err := g.manager.NotifyPreMigrateBucket(ctx, req.GetBucketId()); err != nil { + var ( + quota *gfsptask.GfSpBucketQuotaInfo + err error + ) + if quota, err = g.manager.NotifyPreMigrateBucketAndDeductQuota(ctx, req.GetBucketId()); err != nil { + log.CtxErrorw(ctx, "failed to notify pre migrate bucket and deduct quota", "bucket_id", req.GetBucketId(), "error", err) return nil, err } - return &gfspserver.GfSpNotifyPreMigrateBucketResponse{}, nil + return &gfspserver.GfSpNotifyPreMigrateBucketResponse{Quota: quota}, nil } -func (g *GfSpBaseApp) GfSpNotifyPostMigrate(ctx context.Context, req *gfspserver.GfSpNotifyPostMigrateBucketRequest) ( +func (g *GfSpBaseApp) GfSpNotifyPostMigrateAndRecoupQuota(ctx context.Context, req *gfspserver.GfSpNotifyPostMigrateBucketRequest) ( *gfspserver.GfSpNotifyPostMigrateBucketResponse, error) { - if err := g.manager.NotifyPostMigrateBucket(ctx, req.GetBucketMigrationInfo()); err != nil { + var ( + quota *gfsptask.GfSpBucketQuotaInfo + err error + ) + if quota, err = g.manager.NotifyPostMigrateBucketAndRecoupQuota(ctx, req.GetBucketMigrationInfo()); err != nil { + log.CtxErrorw(ctx, "failed to notify post migrate bucket and recoup quota", "bucket_migration_info", req.GetBucketMigrationInfo(), "error", err) return nil, err } - return &gfspserver.GfSpNotifyPostMigrateBucketResponse{}, nil + return &gfspserver.GfSpNotifyPostMigrateBucketResponse{Quota: quota}, nil } func (g *GfSpBaseApp) GfSpResetRecoveryFailedList(ctx context.Context, _ *gfspserver.GfSpResetRecoveryFailedListRequest) ( diff --git a/base/gfspapp/manage_server_test.go b/base/gfspapp/manage_server_test.go index 1daca79c4..fbf08417c 100644 --- a/base/gfspapp/manage_server_test.go +++ b/base/gfspapp/manage_server_test.go @@ -632,3 +632,53 @@ func TestGfSpBaseApp_GfSpNotifyMigrateSwapOutFailure(t *testing.T) { assert.Equal(t, mockErr, err) assert.Nil(t, result) } + +func TestGfSpBaseApp_GfSpNotifyPreMigrateBucketAndDeductQuotaSuccess(t *testing.T) { + g := setup(t) + ctrl := gomock.NewController(t) + m := module.NewMockManager(ctrl) + g.manager = m + quota := &gfsptask.GfSpBucketQuotaInfo{BucketId: 2} + m.EXPECT().NotifyPreMigrateBucketAndDeductQuota(gomock.Any(), gomock.Any()).Return(quota, nil).Times(1) + req := &gfspserver.GfSpNotifyPreMigrateBucketRequest{BucketId: 2} + result, err := g.GfSpNotifyPreMigrateBucketAndDeductQuota(context.TODO(), req) + assert.Nil(t, err) + assert.Equal(t, &gfspserver.GfSpNotifyPreMigrateBucketResponse{Err: nil, Quota: quota}, result) +} + +func TestGfSpBaseApp_GfSpNotifyPreMigrateBucketAndDeductQuotaFailure(t *testing.T) { + g := setup(t) + ctrl := gomock.NewController(t) + m := module.NewMockManager(ctrl) + g.manager = m + m.EXPECT().NotifyPreMigrateBucketAndDeductQuota(gomock.Any(), gomock.Any()).Return(nil, mockErr).Times(1) + req := &gfspserver.GfSpNotifyPreMigrateBucketRequest{BucketId: 2} + result, err := g.GfSpNotifyPreMigrateBucketAndDeductQuota(context.TODO(), req) + assert.Equal(t, mockErr, err) + assert.Nil(t, result) +} + +func TestGfSpBaseApp_GfSpNotifyPostMigrateBucketAndRecoupQuotaSuccess(t *testing.T) { + g := setup(t) + ctrl := gomock.NewController(t) + m := module.NewMockManager(ctrl) + g.manager = m + quota := &gfsptask.GfSpBucketQuotaInfo{BucketId: 2} + m.EXPECT().NotifyPostMigrateBucketAndRecoupQuota(gomock.Any(), gomock.Any()).Return(quota, nil).Times(1) + req := &gfspserver.GfSpNotifyPostMigrateBucketRequest{BucketId: 2} + result, err := g.GfSpNotifyPostMigrateAndRecoupQuota(context.TODO(), req) + assert.Nil(t, err) + assert.Equal(t, &gfspserver.GfSpNotifyPostMigrateBucketResponse{Quota: quota}, result) +} + +func TestGfSpBaseApp_GfSpPostMigrateBucketAndRecoupQuotaFailure(t *testing.T) { + g := setup(t) + ctrl := gomock.NewController(t) + m := module.NewMockManager(ctrl) + g.manager = m + m.EXPECT().NotifyPostMigrateBucketAndRecoupQuota(gomock.Any(), gomock.Any()).Return(nil, mockErr).Times(1) + req := &gfspserver.GfSpNotifyPostMigrateBucketRequest{BucketId: 2} + result, err := g.GfSpNotifyPostMigrateAndRecoupQuota(context.TODO(), req) + assert.Equal(t, mockErr, err) + assert.Nil(t, result) +} diff --git a/base/gfspclient/gater.go b/base/gfspclient/gater.go index 945c7a2cc..898fa48e4 100644 --- a/base/gfspclient/gater.go +++ b/base/gfspclient/gater.go @@ -67,6 +67,8 @@ const ( GnfdUnsignedApprovalMsgHeader = "X-Gnfd-Unsigned-Msg" // GnfdSignedApprovalMsgHeader defines signed msg, which is used by get-approval GnfdSignedApprovalMsgHeader = "X-Gnfd-Signed-Msg" + // GnfdQuotaInfoHeader defines quota info, which is used by sp + GnfdQuotaInfoHeader = "X-Gnfd-Quota-Info" ) func (s *GfSpClient) ReplicatePieceToSecondary(ctx context.Context, endpoint string, receive coretask.ReceivePieceTask, @@ -243,13 +245,13 @@ func (s *GfSpClient) QueryLatestBucketQuota(ctx context.Context, endpoint string return gfsptask.GfSpBucketQuotaInfo{}, fmt.Errorf("failed to query latest bucket quota, bucket(%s), status_code(%d), endpoint(%s)", queryMsg, resp.StatusCode, endpoint) } - signedMsg, err := hex.DecodeString(resp.Header.Get(GnfdSignedApprovalMsgHeader)) + quotaInfoMsg, err := hex.DecodeString(resp.Header.Get(GnfdQuotaInfoHeader)) if err != nil { return gfsptask.GfSpBucketQuotaInfo{}, err } quotaResult := gfsptask.GfSpBucketQuotaInfo{} - if err = proto.Unmarshal(signedMsg, "aResult); err != nil { + if err = proto.Unmarshal(quotaInfoMsg, "aResult); err != nil { return gfsptask.GfSpBucketQuotaInfo{}, err } @@ -280,13 +282,13 @@ func (s *GfSpClient) PreMigrateBucket(ctx context.Context, srcSPEndpoint string, return gfsptask.GfSpBucketQuotaInfo{}, fmt.Errorf("failed to pre migrate bucket, bucket_migration_info(%s), status_code(%d), endpoint(%s)", preMsg, resp.StatusCode, srcSPEndpoint) } - signedMsg, err := hex.DecodeString(resp.Header.Get(GnfdSignedApprovalMsgHeader)) + quotaInfoMsg, err := hex.DecodeString(resp.Header.Get(GnfdQuotaInfoHeader)) if err != nil { return gfsptask.GfSpBucketQuotaInfo{}, err } quotaResult := gfsptask.GfSpBucketQuotaInfo{} - if err = proto.Unmarshal(signedMsg, "aResult); err != nil { + if err = proto.Unmarshal(quotaInfoMsg, "aResult); err != nil { return gfsptask.GfSpBucketQuotaInfo{}, err } @@ -319,13 +321,13 @@ func (s *GfSpClient) PostMigrateBucket(ctx context.Context, srcSPEndpoint string return gfsptask.GfSpBucketQuotaInfo{}, fmt.Errorf("failed to post migrate bucket to src sp, bucket(%d), status_code(%d), endpoint(%s)", bucketID, resp.StatusCode, srcSPEndpoint) } - signedMsg, err := hex.DecodeString(resp.Header.Get(GnfdSignedApprovalMsgHeader)) + quotaInfoMsg, err := hex.DecodeString(resp.Header.Get(GnfdQuotaInfoHeader)) if err != nil { return gfsptask.GfSpBucketQuotaInfo{}, err } quotaResult := gfsptask.GfSpBucketQuotaInfo{} - if err = proto.Unmarshal(signedMsg, "aResult); err != nil { + if err = proto.Unmarshal(quotaInfoMsg, "aResult); err != nil { return gfsptask.GfSpBucketQuotaInfo{}, err } @@ -358,13 +360,13 @@ func (s *GfSpClient) QuerySPHasEnoughQuotaForMigrateBucket(ctx context.Context, bucketID, resp.StatusCode, srcSPEndpoint) } - signedMsg, err := hex.DecodeString(resp.Header.Get(GnfdSignedApprovalMsgHeader)) + quotaInfoMsg, err := hex.DecodeString(resp.Header.Get(GnfdQuotaInfoHeader)) if err != nil { return err } quotaResult := gfsptask.GfSpBucketQuotaInfo{} - if err = proto.Unmarshal(signedMsg, "aResult); err != nil { + if err = proto.Unmarshal(quotaInfoMsg, "aResult); err != nil { return err } diff --git a/base/gfspclient/helper_test.go b/base/gfspclient/helper_test.go index 80a855a6b..edd52cb94 100644 --- a/base/gfspclient/helper_test.go +++ b/base/gfspclient/helper_test.go @@ -348,14 +348,23 @@ func (s mockManagerServer) GfSpQueryTasksStats(ctx context.Context, req *gfspser }, nil } -func (s mockManagerServer) GfSpNotifyPreMigrate(ctx context.Context, req *gfspserver.GfSpNotifyPreMigrateBucketRequest) (*gfspserver.GfSpNotifyPreMigrateBucketResponse, error) { +func (s mockManagerServer) GfSpQueryBucketMigrationProgress(ctx context.Context, req *gfspserver.GfSpQueryBucketMigrationProgressRequest) (*gfspserver.GfSpQueryBucketMigrationProgressResponse, error) { + if req == nil { + return nil, mockRPCErr + } + return &gfspserver.GfSpQueryBucketMigrationProgressResponse{ + Progress: &gfspserver.MigrateBucketProgressMeta{}, + }, nil +} + +func (s mockManagerServer) GfSpNotifyPreMigrateBucketAndDeductQuota(ctx context.Context, req *gfspserver.GfSpNotifyPreMigrateBucketRequest) (*gfspserver.GfSpNotifyPreMigrateBucketResponse, error) { if req == nil { return nil, mockRPCErr } return &gfspserver.GfSpNotifyPreMigrateBucketResponse{}, nil } -func (s mockManagerServer) GfSpNotifyPostMigrate(ctx context.Context, req *gfspserver.GfSpNotifyPostMigrateBucketRequest) (*gfspserver.GfSpNotifyPostMigrateBucketResponse, error) { +func (s mockManagerServer) GfSpNotifyPostMigrateAndRecoupQuota(ctx context.Context, req *gfspserver.GfSpNotifyPostMigrateBucketRequest) (*gfspserver.GfSpNotifyPostMigrateBucketResponse, error) { if req == nil { return nil, mockRPCErr } diff --git a/base/gfspclient/interface.go b/base/gfspclient/interface.go index e4239d983..52a6dc425 100644 --- a/base/gfspclient/interface.go +++ b/base/gfspclient/interface.go @@ -88,8 +88,9 @@ type ManagerAPI interface { PickVirtualGroupFamilyID(ctx context.Context, task coretask.ApprovalCreateBucketTask) (uint32, error) NotifyMigrateSwapOut(ctx context.Context, swapOut *virtualgrouptypes.MsgSwapOut) error GetTasksStats(ctx context.Context) (*gfspserver.TasksStats, error) - NotifyPreMigrateBucket(ctx context.Context, bucketID uint64) error - NotifyPostMigrateBucket(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) error + GetMigrateBucketProgress(ctx context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) + NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) + NotifyPreMigrateBucketAndDeductQuota(ctx context.Context, bucketID uint64) (*gfsptask.GfSpBucketQuotaInfo, error) } // MetadataAPI for mock sue @@ -110,7 +111,7 @@ type MetadataAPI interface { GetBucketMeta(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.VGFInfoBucket, *payment_types.StreamRecord, error) GetEndpointBySpID(ctx context.Context, spID uint32, opts ...grpc.DialOption) (string, error) GetBucketReadQuota(ctx context.Context, bucket *storagetypes.BucketInfo, yearMonth string, opts ...grpc.DialOption) (uint64, uint64, uint64, uint64, error) - GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (gfsptask.GfSpBucketQuotaInfo, error) + GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (*gfsptask.GfSpBucketQuotaInfo, error) ListBucketReadRecord(ctx context.Context, bucket *storagetypes.BucketInfo, startTimestampUs, endTimestampUs, maxRecordNum int64, opts ...grpc.DialOption) ([]*types.ReadRecord, int64, error) GetUploadObjectState(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (int32, string, error) GetUploadObjectSegment(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (uint32, error) @@ -127,6 +128,7 @@ type MetadataAPI interface { ListGlobalVirtualGroupsByBucket(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) ([]*virtualgrouptypes.GlobalVirtualGroup, error) ListGlobalVirtualGroupsBySecondarySP(ctx context.Context, spID uint32, opts ...grpc.DialOption) ([]*virtualgrouptypes.GlobalVirtualGroup, error) ListMigrateBucketEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListMigrateBucketEvents, error) + ListCompleteMigrationBucketEvents(ctx context.Context, blockID uint64, srcSpID uint32, opts ...grpc.DialOption) ([]*storagetypes.EventCompleteMigrationBucket, error) ListSwapOutEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListSwapOutEvents, error) ListSpExitEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) (*types.ListSpExitEvents, error) GetObjectByID(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (*storagetypes.ObjectInfo, error) diff --git a/base/gfspclient/interface_mock.go b/base/gfspclient/interface_mock.go index b0b3daf95..94570be84 100644 --- a/base/gfspclient/interface_mock.go +++ b/base/gfspclient/interface_mock.go @@ -1,10 +1,6 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: ./interface.go -// -// Generated by this command: -// -// mockgen -source=./interface.go -destination=./interface_mock.go -package=gfspclient -// +// Source: base/gfspclient/interface.go + // Package gfspclient is a generated GoMock package. package gfspclient @@ -302,7 +298,7 @@ func (m *MockGfSpClientAPI) DeleteGlobalVirtualGroup(ctx context.Context, delete } // DeleteGlobalVirtualGroup indicates an expected call of DeleteGlobalVirtualGroup. -func (mr *MockGfSpClientAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG any) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalVirtualGroup", reflect.TypeOf((*MockGfSpClientAPI)(nil).DeleteGlobalVirtualGroup), ctx, deleteGVG) } @@ -317,7 +313,7 @@ func (m *MockGfSpClientAPI) Deposit(ctx context.Context, deposit *types4.MsgDepo } // Deposit indicates an expected call of Deposit. -func (mr *MockGfSpClientAPIMockRecorder) Deposit(ctx, deposit any) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) Deposit(ctx, deposit interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deposit", reflect.TypeOf((*MockGfSpClientAPI)(nil).Deposit), ctx, deposit) } @@ -624,14 +620,14 @@ func (mr *MockGfSpClientAPIMockRecorder) GetGroupMembers(ctx, groupID, startAfte } // GetLatestBucketReadQuota mocks base method. -func (m *MockGfSpClientAPI) GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (gfsptask.GfSpBucketQuotaInfo, error) { +func (m *MockGfSpClientAPI) GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, bucketID} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetLatestBucketReadQuota", varargs...) - ret0, _ := ret[0].(gfsptask.GfSpBucketQuotaInfo) + ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -663,6 +659,21 @@ func (mr *MockGfSpClientAPIMockRecorder) GetLatestObjectID(ctx interface{}, opts return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestObjectID", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetLatestObjectID), varargs...) } +// GetMigrateBucketProgress mocks base method. +func (m *MockGfSpClientAPI) GetMigrateBucketProgress(ctx context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetMigrateBucketProgress", ctx, bucketID) + ret0, _ := ret[0].(*gfspserver.MigrateBucketProgressMeta) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetMigrateBucketProgress indicates an expected call of GetMigrateBucketProgress. +func (mr *MockGfSpClientAPIMockRecorder) GetMigrateBucketProgress(ctx, bucketID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMigrateBucketProgress", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetMigrateBucketProgress), ctx, bucketID) +} + // GetObject mocks base method. func (m *MockGfSpClientAPI) GetObject(ctx context.Context, downloadObjectTask task.DownloadObjectTask, opts ...grpc.DialOption) ([]byte, error) { m.ctrl.T.Helper() @@ -1099,6 +1110,26 @@ func (mr *MockGfSpClientAPIMockRecorder) ListBucketsByIDs(ctx, bucketIDs, includ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsByIDs", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListBucketsByIDs), varargs...) } +// ListCompleteMigrationBucketEvents mocks base method. +func (m *MockGfSpClientAPI) ListCompleteMigrationBucketEvents(ctx context.Context, blockID uint64, srcSpID uint32, opts ...grpc.DialOption) ([]*types3.EventCompleteMigrationBucket, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, blockID, srcSpID} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListCompleteMigrationBucketEvents", varargs...) + ret0, _ := ret[0].([]*types3.EventCompleteMigrationBucket) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCompleteMigrationBucketEvents indicates an expected call of ListCompleteMigrationBucketEvents. +func (mr *MockGfSpClientAPIMockRecorder) ListCompleteMigrationBucketEvents(ctx, blockID, srcSpID interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, blockID, srcSpID}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompleteMigrationBucketEvents", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListCompleteMigrationBucketEvents), varargs...) +} + // ListDeletedObjectsByBlockNumberRange mocks base method. func (m *MockGfSpClientAPI) ListDeletedObjectsByBlockNumberRange(ctx context.Context, spOperatorAddress string, startBlockNumber, endBlockNumber uint64, includePrivate bool, opts ...grpc.DialOption) ([]*types.Object, uint64, error) { m.ctrl.T.Helper() @@ -1512,32 +1543,34 @@ func (mr *MockGfSpClientAPIMockRecorder) NotifyMigrateSwapOut(ctx, swapOut inter return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyMigrateSwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyMigrateSwapOut), ctx, swapOut) } -// NotifyPostMigrateBucket mocks base method. -func (m *MockGfSpClientAPI) NotifyPostMigrateBucket(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) error { +// NotifyPostMigrateBucketAndRecoupQuota mocks base method. +func (m *MockGfSpClientAPI) NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NotifyPostMigrateBucket", ctx, bmInfo) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "NotifyPostMigrateBucketAndRecoupQuota", ctx, bmInfo) + ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// NotifyPostMigrateBucket indicates an expected call of NotifyPostMigrateBucket. -func (mr *MockGfSpClientAPIMockRecorder) NotifyPostMigrateBucket(ctx, bmInfo interface{}) *gomock.Call { +// NotifyPostMigrateBucketAndRecoupQuota indicates an expected call of NotifyPostMigrateBucketAndRecoupQuota. +func (mr *MockGfSpClientAPIMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmInfo interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyPostMigrateBucket), ctx, bmInfo) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucketAndRecoupQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyPostMigrateBucketAndRecoupQuota), ctx, bmInfo) } -// NotifyPreMigrateBucket mocks base method. -func (m *MockGfSpClientAPI) NotifyPreMigrateBucket(ctx context.Context, bucketID uint64) error { +// NotifyPreMigrateBucketAndDeductQuota mocks base method. +func (m *MockGfSpClientAPI) NotifyPreMigrateBucketAndDeductQuota(ctx context.Context, bucketID uint64) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NotifyPreMigrateBucket", ctx, bucketID) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "NotifyPreMigrateBucketAndDeductQuota", ctx, bucketID) + ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// NotifyPreMigrateBucket indicates an expected call of NotifyPreMigrateBucket. -func (mr *MockGfSpClientAPIMockRecorder) NotifyPreMigrateBucket(ctx, bucketID interface{}) *gomock.Call { +// NotifyPreMigrateBucketAndDeductQuota indicates an expected call of NotifyPreMigrateBucketAndDeductQuota. +func (mr *MockGfSpClientAPIMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyPreMigrateBucket), ctx, bucketID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucketAndDeductQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyPreMigrateBucketAndDeductQuota), ctx, bucketID) } // P2PConn mocks base method. @@ -2831,6 +2864,21 @@ func (mr *MockManagerAPIMockRecorder) CreateUploadObject(ctx, task interface{}) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUploadObject", reflect.TypeOf((*MockManagerAPI)(nil).CreateUploadObject), ctx, task) } +// GetMigrateBucketProgress mocks base method. +func (m *MockManagerAPI) GetMigrateBucketProgress(ctx context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetMigrateBucketProgress", ctx, bucketID) + ret0, _ := ret[0].(*gfspserver.MigrateBucketProgressMeta) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetMigrateBucketProgress indicates an expected call of GetMigrateBucketProgress. +func (mr *MockManagerAPIMockRecorder) GetMigrateBucketProgress(ctx, bucketID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMigrateBucketProgress", reflect.TypeOf((*MockManagerAPI)(nil).GetMigrateBucketProgress), ctx, bucketID) +} + // GetTasksStats mocks base method. func (m *MockManagerAPI) GetTasksStats(ctx context.Context) (*gfspserver.TasksStats, error) { m.ctrl.T.Helper() @@ -2860,32 +2908,34 @@ func (mr *MockManagerAPIMockRecorder) NotifyMigrateSwapOut(ctx, swapOut interfac return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyMigrateSwapOut", reflect.TypeOf((*MockManagerAPI)(nil).NotifyMigrateSwapOut), ctx, swapOut) } -// NotifyPostMigrateBucket mocks base method. -func (m *MockManagerAPI) NotifyPostMigrateBucket(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) error { +// NotifyPostMigrateBucketAndRecoupQuota mocks base method. +func (m *MockManagerAPI) NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NotifyPostMigrateBucket", ctx, bmInfo) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "NotifyPostMigrateBucketAndRecoupQuota", ctx, bmInfo) + ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// NotifyPostMigrateBucket indicates an expected call of NotifyPostMigrateBucket. -func (mr *MockManagerAPIMockRecorder) NotifyPostMigrateBucket(ctx, bmInfo interface{}) *gomock.Call { +// NotifyPostMigrateBucketAndRecoupQuota indicates an expected call of NotifyPostMigrateBucketAndRecoupQuota. +func (mr *MockManagerAPIMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmInfo interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucket", reflect.TypeOf((*MockManagerAPI)(nil).NotifyPostMigrateBucket), ctx, bmInfo) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucketAndRecoupQuota", reflect.TypeOf((*MockManagerAPI)(nil).NotifyPostMigrateBucketAndRecoupQuota), ctx, bmInfo) } -// NotifyPreMigrateBucket mocks base method. -func (m *MockManagerAPI) NotifyPreMigrateBucket(ctx context.Context, bucketID uint64) error { +// NotifyPreMigrateBucketAndDeductQuota mocks base method. +func (m *MockManagerAPI) NotifyPreMigrateBucketAndDeductQuota(ctx context.Context, bucketID uint64) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NotifyPreMigrateBucket", ctx, bucketID) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "NotifyPreMigrateBucketAndDeductQuota", ctx, bucketID) + ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// NotifyPreMigrateBucket indicates an expected call of NotifyPreMigrateBucket. -func (mr *MockManagerAPIMockRecorder) NotifyPreMigrateBucket(ctx, bucketID interface{}) *gomock.Call { +// NotifyPreMigrateBucketAndDeductQuota indicates an expected call of NotifyPreMigrateBucketAndDeductQuota. +func (mr *MockManagerAPIMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucket", reflect.TypeOf((*MockManagerAPI)(nil).NotifyPreMigrateBucket), ctx, bucketID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucketAndDeductQuota", reflect.TypeOf((*MockManagerAPI)(nil).NotifyPreMigrateBucketAndDeductQuota), ctx, bucketID) } // PickVirtualGroupFamilyID mocks base method. @@ -3146,14 +3196,14 @@ func (mr *MockMetadataAPIMockRecorder) GetGroupMembers(ctx, groupID, startAfter, } // GetLatestBucketReadQuota mocks base method. -func (m *MockMetadataAPI) GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (gfsptask.GfSpBucketQuotaInfo, error) { +func (m *MockMetadataAPI) GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, bucketID} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetLatestBucketReadQuota", varargs...) - ret0, _ := ret[0].(gfsptask.GfSpBucketQuotaInfo) + ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -3507,6 +3557,26 @@ func (mr *MockMetadataAPIMockRecorder) ListBucketsByIDs(ctx, bucketIDs, includeR return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsByIDs", reflect.TypeOf((*MockMetadataAPI)(nil).ListBucketsByIDs), varargs...) } +// ListCompleteMigrationBucketEvents mocks base method. +func (m *MockMetadataAPI) ListCompleteMigrationBucketEvents(ctx context.Context, blockID uint64, srcSpID uint32, opts ...grpc.DialOption) ([]*types3.EventCompleteMigrationBucket, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, blockID, srcSpID} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListCompleteMigrationBucketEvents", varargs...) + ret0, _ := ret[0].([]*types3.EventCompleteMigrationBucket) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCompleteMigrationBucketEvents indicates an expected call of ListCompleteMigrationBucketEvents. +func (mr *MockMetadataAPIMockRecorder) ListCompleteMigrationBucketEvents(ctx, blockID, srcSpID interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, blockID, srcSpID}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompleteMigrationBucketEvents", reflect.TypeOf((*MockMetadataAPI)(nil).ListCompleteMigrationBucketEvents), varargs...) +} + // ListDeletedObjectsByBlockNumberRange mocks base method. func (m *MockMetadataAPI) ListDeletedObjectsByBlockNumberRange(ctx context.Context, spOperatorAddress string, startBlockNumber, endBlockNumber uint64, includePrivate bool, opts ...grpc.DialOption) ([]*types.Object, uint64, error) { m.ctrl.T.Helper() @@ -4250,7 +4320,7 @@ func (m *MockSignerAPI) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG } // DeleteGlobalVirtualGroup indicates an expected call of DeleteGlobalVirtualGroup. -func (mr *MockSignerAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG any) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalVirtualGroup", reflect.TypeOf((*MockSignerAPI)(nil).DeleteGlobalVirtualGroup), ctx, deleteGVG) } @@ -4265,7 +4335,7 @@ func (m *MockSignerAPI) Deposit(ctx context.Context, deposit *types4.MsgDeposit) } // Deposit indicates an expected call of Deposit. -func (mr *MockSignerAPIMockRecorder) Deposit(ctx, deposit any) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) Deposit(ctx, deposit interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deposit", reflect.TypeOf((*MockSignerAPI)(nil).Deposit), ctx, deposit) } diff --git a/base/gfspclient/manager.go b/base/gfspclient/manager.go index a0faf95f0..d51aed1b9 100644 --- a/base/gfspclient/manager.go +++ b/base/gfspclient/manager.go @@ -201,46 +201,46 @@ func (s *GfSpClient) GetTasksStats(ctx context.Context) (*gfspserver.TasksStats, return resp.GetStats(), nil } -func (s *GfSpClient) NotifyPreMigrateBucket(ctx context.Context, bucketID uint64) error { +func (s *GfSpClient) NotifyPreMigrateBucketAndDeductQuota(ctx context.Context, bucketID uint64) (*gfsptask.GfSpBucketQuotaInfo, error) { conn, connErr := s.ManagerConn(ctx) if connErr != nil { log.CtxErrorw(ctx, "client failed to connect manager", "error", connErr) - return ErrRPCUnknownWithDetail("client failed to connect manager, error: ", connErr) + return &gfsptask.GfSpBucketQuotaInfo{}, ErrRPCUnknownWithDetail("client failed to connect manager, error: ", connErr) } req := &gfspserver.GfSpNotifyPreMigrateBucketRequest{ BucketId: bucketID, } - resp, err := gfspserver.NewGfSpManageServiceClient(conn).GfSpNotifyPreMigrate(ctx, req) + resp, err := gfspserver.NewGfSpManageServiceClient(conn).GfSpNotifyPreMigrateBucketAndDeductQuota(ctx, req) if err != nil { - log.CtxErrorw(ctx, "client failed to notify pre migrate bucket", "request", req, "error", err) - return ErrRPCUnknownWithDetail("client failed to notify pre migrate bucket, error: ", err) + log.CtxErrorw(ctx, "client failed to notify pre migrate bucket and deduct quota", "request", req, "error", err) + return &gfsptask.GfSpBucketQuotaInfo{}, ErrRPCUnknownWithDetail("client failed to notify pre migrate bucket, error: ", err) } if resp.GetErr() != nil { - log.CtxErrorw(ctx, "failed to notify pre migrate bucket", "request", req, "error", resp.GetErr()) - return resp.GetErr() + log.CtxErrorw(ctx, "failed to notify pre migrate bucket and deduct quota", "request", req, "error", resp.GetErr()) + return &gfsptask.GfSpBucketQuotaInfo{}, resp.GetErr() } - return nil + return resp.Quota, nil } -func (s *GfSpClient) NotifyPostMigrateBucket(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) error { +func (s *GfSpClient) NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) { conn, connErr := s.ManagerConn(ctx) if connErr != nil { log.CtxErrorw(ctx, "client failed to connect manager", "error", connErr) - return ErrRPCUnknownWithDetail("client failed to connect manager, error: ", connErr) + return &gfsptask.GfSpBucketQuotaInfo{}, ErrRPCUnknownWithDetail("client failed to connect manager, error: ", connErr) } req := &gfspserver.GfSpNotifyPostMigrateBucketRequest{ BucketMigrationInfo: bmInfo, } - resp, err := gfspserver.NewGfSpManageServiceClient(conn).GfSpNotifyPostMigrate(ctx, req) + resp, err := gfspserver.NewGfSpManageServiceClient(conn).GfSpNotifyPostMigrateAndRecoupQuota(ctx, req) if err != nil { - log.CtxErrorw(ctx, "client failed to notify post migrate bucket", "request", req, "error", err) - return ErrRPCUnknownWithDetail("client failed to notify post migrate bucket, error: ", err) + log.CtxErrorw(ctx, "client failed to notify post migrate bucket and recoup quota", "request", req, "error", err) + return &gfsptask.GfSpBucketQuotaInfo{}, ErrRPCUnknownWithDetail("client failed to notify post migrate bucket and recoup quota, error: ", err) } if resp.GetErr() != nil { - log.CtxErrorw(ctx, "failed to notify post migrate bucket", "request", req, "error", resp.GetErr()) - return resp.GetErr() + log.CtxErrorw(ctx, "failed to notify post migrate bucket and recoup quota", "request", req, "error", resp.GetErr()) + return &gfsptask.GfSpBucketQuotaInfo{}, resp.GetErr() } - return nil + return resp.Quota, nil } func (s *GfSpClient) ResetRecoveryFailedList(ctx context.Context) ([]string, error) { @@ -256,3 +256,20 @@ func (s *GfSpClient) ResetRecoveryFailedList(ctx context.Context) ([]string, err } return resp.GetRecoveryFailedList(), nil } + +func (s *GfSpClient) GetMigrateBucketProgress(ctx context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) { + conn, connErr := s.ManagerConn(ctx) + if connErr != nil { + log.CtxErrorw(ctx, "client failed to connect manager", "error", connErr) + return nil, ErrRPCUnknownWithDetail("client failed to connect manager, error: ", connErr) + } + req := &gfspserver.GfSpQueryBucketMigrationProgressRequest{ + BucketId: bucketID, + } + resp, err := gfspserver.NewGfSpManageServiceClient(conn).GfSpQueryBucketMigrationProgress(ctx, req) + if err != nil { + log.CtxErrorw(ctx, "client failed to query bucket migration's progress", "error", err) + return nil, ErrRPCUnknownWithDetail("client failed to query bucket migration's progress, error: ", err) + } + return resp.GetProgress(), nil +} diff --git a/base/gfspclient/metadata.go b/base/gfspclient/metadata.go index 27038b1f3..535f84d4f 100644 --- a/base/gfspclient/metadata.go +++ b/base/gfspclient/metadata.go @@ -355,9 +355,9 @@ func (s *GfSpClient) GetBucketReadQuota(ctx context.Context, bucket *storage_typ } func (s *GfSpClient) GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) ( - gfsptask.GfSpBucketQuotaInfo, error) { + *gfsptask.GfSpBucketQuotaInfo, error) { conn, connErr := s.Connection(ctx, s.metadataEndpoint, opts...) - quota := gfsptask.GfSpBucketQuotaInfo{} + quota := &gfsptask.GfSpBucketQuotaInfo{} if connErr != nil { log.CtxErrorw(ctx, "client failed to connect metadata", "error", connErr) return quota, ErrRPCUnknownWithDetail("client failed to connect metadata, error: ", connErr) @@ -698,6 +698,24 @@ func (s *GfSpClient) ListMigrateBucketEvents(ctx context.Context, blockID uint64 return resp.Events, nil } +func (s *GfSpClient) ListCompleteMigrationBucketEvents(ctx context.Context, blockID uint64, srcSpId uint32, opts ...grpc.DialOption) ([]*storage_types.EventCompleteMigrationBucket, error) { + conn, connErr := s.Connection(ctx, s.metadataEndpoint, opts...) + if connErr != nil { + log.CtxErrorw(ctx, "client failed to connect metadata", "error", connErr) + return nil, ErrRPCUnknownWithDetail("client failed to connect metadata, error: ", connErr) + } + defer conn.Close() + req := &types.GfSpListCompleteMigrationBucketEventsRequest{ + BlockId: blockID, + SrcSpId: srcSpId, + } + resp, err := types.NewGfSpMetadataServiceClient(conn).GfSpListCompleteMigrationBucketEvents(ctx, req) + if err != nil { + return nil, ErrRPCUnknownWithDetail("client failed to list complete migrate bucket events, error: ", err) + } + return resp.CompleteEvents, nil +} + func (s *GfSpClient) ListSwapOutEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListSwapOutEvents, error) { conn, connErr := s.Connection(ctx, s.metadataEndpoint, opts...) if connErr != nil { diff --git a/base/gfspconfig/config.go b/base/gfspconfig/config.go index 5ea0ff09d..cf5399b70 100644 --- a/base/gfspconfig/config.go +++ b/base/gfspconfig/config.go @@ -285,4 +285,7 @@ type ManagerConfig struct { // retry reject unseal when the task's create_timestamp + RejectUnsealThresholdSecond <= now.time() && // create_timestamp + 2*RejectUnsealThresholdSecond > now.time(). RejectUnsealThresholdSecond uint64 `comment:"optional"` + + // EnableBucketMigrateCache is used to enable bucket migrate's bucket cache. + EnableBucketMigrateCache bool `comment:"optional"` } diff --git a/base/types/gfspserver/manage.pb.go b/base/types/gfspserver/manage.pb.go index 94951b62d..4323755bb 100644 --- a/base/types/gfspserver/manage.pb.go +++ b/base/types/gfspserver/manage.pb.go @@ -890,7 +890,8 @@ func (m *GfSpNotifyPreMigrateBucketRequest) GetBucketId() uint64 { } type GfSpNotifyPreMigrateBucketResponse struct { - Err *gfsperrors.GfSpError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` + Err *gfsperrors.GfSpError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` + Quota *gfsptask.GfSpBucketQuotaInfo `protobuf:"bytes,2,opt,name=quota,proto3" json:"quota,omitempty"` } func (m *GfSpNotifyPreMigrateBucketResponse) Reset() { *m = GfSpNotifyPreMigrateBucketResponse{} } @@ -933,6 +934,13 @@ func (m *GfSpNotifyPreMigrateBucketResponse) GetErr() *gfsperrors.GfSpError { return nil } +func (m *GfSpNotifyPreMigrateBucketResponse) GetQuota() *gfsptask.GfSpBucketQuotaInfo { + if m != nil { + return m.Quota + } + return nil +} + type GfSpNotifyPostMigrateBucketRequest struct { // bucket_id is the id of the bucket BucketId uint64 `protobuf:"varint,1,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"` @@ -987,7 +995,8 @@ func (m *GfSpNotifyPostMigrateBucketRequest) GetBucketMigrationInfo() *gfsptask. } type GfSpNotifyPostMigrateBucketResponse struct { - Err *gfsperrors.GfSpError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` + Err *gfsperrors.GfSpError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` + Quota *gfsptask.GfSpBucketQuotaInfo `protobuf:"bytes,2,opt,name=quota,proto3" json:"quota,omitempty"` } func (m *GfSpNotifyPostMigrateBucketResponse) Reset() { *m = GfSpNotifyPostMigrateBucketResponse{} } @@ -1030,6 +1039,13 @@ func (m *GfSpNotifyPostMigrateBucketResponse) GetErr() *gfsperrors.GfSpError { return nil } +func (m *GfSpNotifyPostMigrateBucketResponse) GetQuota() *gfsptask.GfSpBucketQuotaInfo { + if m != nil { + return m.Quota + } + return nil +} + type GfSpQueryTasksStatsRequest struct { } @@ -1210,6 +1226,222 @@ func (m *TasksStats) GetRecoveryFailedList() []string { return nil } +type GfSpQueryBucketMigrationProgressRequest struct { + BucketId uint64 `protobuf:"varint,1,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"` +} + +func (m *GfSpQueryBucketMigrationProgressRequest) Reset() { + *m = GfSpQueryBucketMigrationProgressRequest{} +} +func (m *GfSpQueryBucketMigrationProgressRequest) String() string { return proto.CompactTextString(m) } +func (*GfSpQueryBucketMigrationProgressRequest) ProtoMessage() {} +func (*GfSpQueryBucketMigrationProgressRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7801aa704e62bc53, []int{17} +} +func (m *GfSpQueryBucketMigrationProgressRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GfSpQueryBucketMigrationProgressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GfSpQueryBucketMigrationProgressRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GfSpQueryBucketMigrationProgressRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GfSpQueryBucketMigrationProgressRequest.Merge(m, src) +} +func (m *GfSpQueryBucketMigrationProgressRequest) XXX_Size() int { + return m.Size() +} +func (m *GfSpQueryBucketMigrationProgressRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GfSpQueryBucketMigrationProgressRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GfSpQueryBucketMigrationProgressRequest proto.InternalMessageInfo + +func (m *GfSpQueryBucketMigrationProgressRequest) GetBucketId() uint64 { + if m != nil { + return m.BucketId + } + return 0 +} + +type GfSpQueryBucketMigrationProgressResponse struct { + Progress *MigrateBucketProgressMeta `protobuf:"bytes,1,opt,name=progress,proto3" json:"progress,omitempty"` +} + +func (m *GfSpQueryBucketMigrationProgressResponse) Reset() { + *m = GfSpQueryBucketMigrationProgressResponse{} +} +func (m *GfSpQueryBucketMigrationProgressResponse) String() string { return proto.CompactTextString(m) } +func (*GfSpQueryBucketMigrationProgressResponse) ProtoMessage() {} +func (*GfSpQueryBucketMigrationProgressResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7801aa704e62bc53, []int{18} +} +func (m *GfSpQueryBucketMigrationProgressResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GfSpQueryBucketMigrationProgressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GfSpQueryBucketMigrationProgressResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GfSpQueryBucketMigrationProgressResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GfSpQueryBucketMigrationProgressResponse.Merge(m, src) +} +func (m *GfSpQueryBucketMigrationProgressResponse) XXX_Size() int { + return m.Size() +} +func (m *GfSpQueryBucketMigrationProgressResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GfSpQueryBucketMigrationProgressResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GfSpQueryBucketMigrationProgressResponse proto.InternalMessageInfo + +func (m *GfSpQueryBucketMigrationProgressResponse) GetProgress() *MigrateBucketProgressMeta { + if m != nil { + return m.Progress + } + return nil +} + +type MigrateBucketProgressMeta struct { + BucketId uint64 `protobuf:"varint,1,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"` + SubscribedBlockHeight uint64 `protobuf:"varint,2,opt,name=subscribed_block_height,json=subscribedBlockHeight,proto3" json:"subscribed_block_height,omitempty"` + MigrateState uint32 `protobuf:"varint,3,opt,name=migrate_state,json=migrateState,proto3" json:"migrate_state,omitempty"` + TotalGvgNum uint32 `protobuf:"varint,4,opt,name=total_gvg_num,json=totalGvgNum,proto3" json:"total_gvg_num,omitempty"` + MigratedFinishedGvgNum uint32 `protobuf:"varint,5,opt,name=migrated_finished_gvg_num,json=migratedFinishedGvgNum,proto3" json:"migrated_finished_gvg_num,omitempty"` + GcFinishedGvgNum uint32 `protobuf:"varint,6,opt,name=gc_finished_gvg_num,json=gcFinishedGvgNum,proto3" json:"gc_finished_gvg_num,omitempty"` + PreDeductedQuota uint64 `protobuf:"varint,7,opt,name=pre_deducted_quota,json=preDeductedQuota,proto3" json:"pre_deducted_quota,omitempty"` + RecoupQuota uint64 `protobuf:"varint,8,opt,name=recoup_quota,json=recoupQuota,proto3" json:"recoup_quota,omitempty"` + LastGcObjectId uint64 `protobuf:"varint,9,opt,name=last_gc_object_id,json=lastGcObjectId,proto3" json:"last_gc_object_id,omitempty"` + LastGcGvgId uint64 `protobuf:"varint,10,opt,name=last_gc_gvg_id,json=lastGcGvgId,proto3" json:"last_gc_gvg_id,omitempty"` + MigratedBytes uint64 `protobuf:"varint,11,opt,name=migrated_bytes,json=migratedBytes,proto3" json:"migrated_bytes,omitempty"` +} + +func (m *MigrateBucketProgressMeta) Reset() { *m = MigrateBucketProgressMeta{} } +func (m *MigrateBucketProgressMeta) String() string { return proto.CompactTextString(m) } +func (*MigrateBucketProgressMeta) ProtoMessage() {} +func (*MigrateBucketProgressMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_7801aa704e62bc53, []int{19} +} +func (m *MigrateBucketProgressMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MigrateBucketProgressMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MigrateBucketProgressMeta.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MigrateBucketProgressMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_MigrateBucketProgressMeta.Merge(m, src) +} +func (m *MigrateBucketProgressMeta) XXX_Size() int { + return m.Size() +} +func (m *MigrateBucketProgressMeta) XXX_DiscardUnknown() { + xxx_messageInfo_MigrateBucketProgressMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_MigrateBucketProgressMeta proto.InternalMessageInfo + +func (m *MigrateBucketProgressMeta) GetBucketId() uint64 { + if m != nil { + return m.BucketId + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetSubscribedBlockHeight() uint64 { + if m != nil { + return m.SubscribedBlockHeight + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetMigrateState() uint32 { + if m != nil { + return m.MigrateState + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetTotalGvgNum() uint32 { + if m != nil { + return m.TotalGvgNum + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetMigratedFinishedGvgNum() uint32 { + if m != nil { + return m.MigratedFinishedGvgNum + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetGcFinishedGvgNum() uint32 { + if m != nil { + return m.GcFinishedGvgNum + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetPreDeductedQuota() uint64 { + if m != nil { + return m.PreDeductedQuota + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetRecoupQuota() uint64 { + if m != nil { + return m.RecoupQuota + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetLastGcObjectId() uint64 { + if m != nil { + return m.LastGcObjectId + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetLastGcGvgId() uint64 { + if m != nil { + return m.LastGcGvgId + } + return 0 +} + +func (m *MigrateBucketProgressMeta) GetMigratedBytes() uint64 { + if m != nil { + return m.MigratedBytes + } + return 0 +} + type GfSpResetRecoveryFailedListRequest struct { } @@ -1217,7 +1449,7 @@ func (m *GfSpResetRecoveryFailedListRequest) Reset() { *m = GfSpResetRec func (m *GfSpResetRecoveryFailedListRequest) String() string { return proto.CompactTextString(m) } func (*GfSpResetRecoveryFailedListRequest) ProtoMessage() {} func (*GfSpResetRecoveryFailedListRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7801aa704e62bc53, []int{17} + return fileDescriptor_7801aa704e62bc53, []int{20} } func (m *GfSpResetRecoveryFailedListRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1254,7 +1486,7 @@ func (m *GfSpResetRecoveryFailedListResponse) Reset() { *m = GfSpResetRe func (m *GfSpResetRecoveryFailedListResponse) String() string { return proto.CompactTextString(m) } func (*GfSpResetRecoveryFailedListResponse) ProtoMessage() {} func (*GfSpResetRecoveryFailedListResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7801aa704e62bc53, []int{18} + return fileDescriptor_7801aa704e62bc53, []int{21} } func (m *GfSpResetRecoveryFailedListResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1308,6 +1540,9 @@ func init() { proto.RegisterType((*GfSpQueryTasksStatsRequest)(nil), "base.types.gfspserver.GfSpQueryTasksStatsRequest") proto.RegisterType((*GfSpQueryTasksStatsResponse)(nil), "base.types.gfspserver.GfSpQueryTasksStatsResponse") proto.RegisterType((*TasksStats)(nil), "base.types.gfspserver.TasksStats") + proto.RegisterType((*GfSpQueryBucketMigrationProgressRequest)(nil), "base.types.gfspserver.GfSpQueryBucketMigrationProgressRequest") + proto.RegisterType((*GfSpQueryBucketMigrationProgressResponse)(nil), "base.types.gfspserver.GfSpQueryBucketMigrationProgressResponse") + proto.RegisterType((*MigrateBucketProgressMeta)(nil), "base.types.gfspserver.MigrateBucketProgressMeta") proto.RegisterType((*GfSpResetRecoveryFailedListRequest)(nil), "base.types.gfspserver.GfSpResetRecoveryFailedListRequest") proto.RegisterType((*GfSpResetRecoveryFailedListResponse)(nil), "base.types.gfspserver.GfSpResetRecoveryFailedListResponse") } @@ -1317,95 +1552,115 @@ func init() { } var fileDescriptor_7801aa704e62bc53 = []byte{ - // 1393 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x5f, 0x6f, 0xdc, 0x44, - 0x10, 0x3f, 0x37, 0x7f, 0x6f, 0xf2, 0xa7, 0xed, 0x36, 0xa9, 0xc2, 0xb5, 0x5c, 0x13, 0x07, 0xd4, - 0xbf, 0xb9, 0xa3, 0x01, 0x51, 0xe0, 0x01, 0xd1, 0x14, 0x7a, 0x54, 0x34, 0x34, 0x38, 0x6d, 0xa0, - 0x95, 0x90, 0xbb, 0xe7, 0xdb, 0x73, 0x97, 0xf8, 0x6c, 0xb3, 0x6b, 0x5f, 0x1b, 0x1e, 0xf8, 0x06, - 0x48, 0x95, 0x10, 0x7c, 0x01, 0xbe, 0x06, 0x1f, 0x80, 0xc7, 0x3e, 0xc2, 0x1b, 0x6a, 0x25, 0xbe, - 0x00, 0x2f, 0x3c, 0xa2, 0xdd, 0xb5, 0xef, 0x6c, 0xdf, 0xd9, 0x97, 0x26, 0x0d, 0x12, 0x2f, 0x17, - 0x67, 0x76, 0x7e, 0xbf, 0x99, 0xdd, 0x99, 0x9d, 0x19, 0x1b, 0xf4, 0x26, 0xe6, 0xa4, 0x1e, 0xec, - 0xf9, 0x84, 0xd7, 0xed, 0x36, 0xf7, 0x39, 0x61, 0x5d, 0xc2, 0xea, 0x1d, 0xec, 0x62, 0x9b, 0xd4, - 0x7c, 0xe6, 0x05, 0x1e, 0x5a, 0x14, 0x3a, 0x35, 0xa9, 0x53, 0xeb, 0xeb, 0x54, 0x56, 0x32, 0x50, - 0xc2, 0x98, 0xc7, 0x78, 0x5d, 0xfe, 0x51, 0xc8, 0xca, 0x72, 0x46, 0xc5, 0xa1, 0x1d, 0x1a, 0xd4, - 0xe5, 0x6f, 0xa4, 0x51, 0xcd, 0x68, 0x04, 0x98, 0xef, 0xd6, 0xc5, 0x4f, 0xcc, 0x60, 0x33, 0x42, - 0xdc, 0x36, 0x25, 0x4e, 0xab, 0xde, 0xa5, 0x2c, 0x08, 0xb1, 0x63, 0x33, 0x2f, 0xf4, 0xeb, 0xc1, - 0x13, 0xa5, 0xa1, 0xff, 0xad, 0xc1, 0x42, 0xa3, 0xbd, 0xed, 0x6f, 0x10, 0x9b, 0xba, 0x77, 0x31, - 0xdf, 0x35, 0xc8, 0xb7, 0x21, 0xe1, 0x01, 0xba, 0x0f, 0x28, 0xf4, 0x1d, 0x0f, 0xb7, 0x4c, 0xaf, - 0xf9, 0x0d, 0xb1, 0x02, 0x53, 0xd0, 0x2e, 0x69, 0xcb, 0xda, 0x85, 0x99, 0xf5, 0x8b, 0xb5, 0xcc, - 0x9e, 0xa4, 0x49, 0x41, 0x73, 0x4f, 0x42, 0xee, 0x48, 0x84, 0x60, 0xfb, 0xb4, 0x64, 0x9c, 0x08, - 0x33, 0x32, 0x14, 0xc2, 0x59, 0x46, 0x78, 0xd8, 0xc1, 0x4d, 0x87, 0x98, 0x43, 0x8c, 0x1c, 0x93, - 0x46, 0xd6, 0x73, 0x8d, 0x18, 0x31, 0x78, 0x88, 0xb5, 0xd7, 0x58, 0xde, 0xe2, 0x46, 0x19, 0xa6, - 0x98, 0xda, 0x9c, 0xfe, 0x19, 0x2c, 0x66, 0x36, 0xcd, 0x7d, 0xcf, 0xe5, 0x04, 0xad, 0xc3, 0x18, - 0x61, 0x2c, 0xda, 0xe6, 0x72, 0xd6, 0x03, 0x15, 0x23, 0xe9, 0xc3, 0x27, 0xe2, 0xd1, 0x10, 0xca, - 0xfa, 0x5d, 0x40, 0x42, 0x72, 0x9d, 0xef, 0x26, 0xcf, 0xef, 0x43, 0x00, 0xd7, 0x6b, 0x11, 0x53, - 0x86, 0x2b, 0x22, 0x3c, 0x97, 0x25, 0x54, 0xb1, 0x14, 0xe8, 0xdb, 0xe2, 0xc9, 0x28, 0x0b, 0x88, - 0x7c, 0xd4, 0xff, 0x99, 0x84, 0x53, 0x29, 0xda, 0x83, 0x7b, 0x88, 0x4c, 0x58, 0x60, 0xc4, 0x77, - 0xa8, 0x85, 0x03, 0x62, 0xfa, 0x94, 0x58, 0x24, 0x79, 0xd0, 0x97, 0x0b, 0x0e, 0x3a, 0x02, 0x6d, - 0x09, 0x4c, 0x74, 0xc2, 0x88, 0x0d, 0x48, 0xd1, 0x36, 0x9c, 0xe0, 0x04, 0x3b, 0xa9, 0x28, 0x8e, - 0x49, 0xf2, 0xf3, 0xb9, 0xe4, 0xdb, 0x04, 0x3b, 0xa9, 0xd0, 0xcd, 0xf3, 0x94, 0x44, 0x64, 0x20, - 0x23, 0x16, 0xa1, 0xdd, 0x94, 0xcf, 0xe3, 0x23, 0x32, 0xd0, 0x50, 0x90, 0xa4, 0xc7, 0x27, 0x58, - 0x46, 0x86, 0x36, 0x61, 0xde, 0xb6, 0x52, 0xde, 0x4e, 0x48, 0xda, 0x37, 0x73, 0x69, 0x1b, 0x37, - 0x52, 0xbe, 0xce, 0xda, 0x56, 0xc2, 0xd3, 0xaf, 0x61, 0xc1, 0xb6, 0xcc, 0xef, 0xbc, 0x4e, 0x93, - 0xa6, 0x7c, 0x9d, 0x94, 0xa4, 0x97, 0x0a, 0x48, 0x1f, 0x48, 0x4c, 0xd2, 0xd9, 0x93, 0xb6, 0x95, - 0x11, 0xa2, 0x06, 0xcc, 0xda, 0x96, 0xd9, 0x21, 0x01, 0x56, 0xb4, 0x53, 0x92, 0x76, 0xb5, 0x80, - 0x76, 0x93, 0x04, 0x38, 0xe2, 0x03, 0xdb, 0x8a, 0xff, 0x8b, 0x4e, 0xd4, 0xeb, 0x12, 0x96, 0xf4, - 0x72, 0x7a, 0xf4, 0x89, 0x0a, 0x48, 0xf6, 0x44, 0x53, 0x32, 0x91, 0x01, 0x1d, 0x6a, 0x33, 0x91, - 0x60, 0x76, 0xd7, 0x56, 0xc4, 0xe5, 0x11, 0x19, 0xb0, 0xa9, 0x00, 0x8d, 0x9d, 0x46, 0x9c, 0x01, - 0x11, 0x45, 0xa3, 0x6b, 0x4b, 0x52, 0x0a, 0x4b, 0xb6, 0x65, 0x36, 0x43, 0x6b, 0x97, 0x04, 0xa6, - 0x5a, 0xa3, 0x9e, 0xab, 0xc8, 0x41, 0x92, 0xd7, 0x0a, 0x0e, 0x61, 0x43, 0xe2, 0x36, 0x63, 0x58, - 0x64, 0x63, 0xd1, 0xb6, 0x86, 0x2c, 0x6c, 0x00, 0x4c, 0xb3, 0xe8, 0x8a, 0xe9, 0x7f, 0x94, 0x55, - 0x79, 0x30, 0x88, 0xef, 0xb1, 0xe0, 0x3f, 0x2a, 0x8a, 0xff, 0xcf, 0x3b, 0x3a, 0x78, 0x91, 0xc6, - 0x8f, 0xe2, 0x22, 0x4d, 0x1c, 0xcd, 0x45, 0x9a, 0x3c, 0xe8, 0x45, 0x32, 0x61, 0xa1, 0xe5, 0x3d, - 0x76, 0x07, 0x32, 0x61, 0x6a, 0x44, 0xb0, 0x3e, 0x8e, 0x40, 0xa9, 0x23, 0x40, 0xad, 0x01, 0xa9, - 0x30, 0x60, 0x3d, 0xc2, 0x8e, 0x43, 0x5c, 0x9b, 0x0c, 0xde, 0xd5, 0x7c, 0x03, 0x37, 0x62, 0x50, - 0x2a, 0x1b, 0xac, 0x01, 0x69, 0x4e, 0x71, 0x2d, 0xbf, 0x8a, 0xe2, 0x3a, 0xaa, 0xbd, 0xc3, 0x91, - 0xb4, 0xf7, 0x9c, 0xe2, 0x36, 0x73, 0x54, 0xc5, 0x6d, 0xf6, 0x28, 0x8b, 0xdb, 0xdc, 0xab, 0x2d, - 0x6e, 0x89, 0xc9, 0xe7, 0x36, 0x9c, 0xce, 0x96, 0xb6, 0x43, 0x8c, 0x3e, 0x3f, 0x69, 0xb0, 0x22, - 0x44, 0x5b, 0xd4, 0xda, 0xdd, 0x51, 0xf3, 0x65, 0x43, 0xcc, 0x97, 0x37, 0x71, 0x87, 0x3a, 0x7b, - 0x71, 0xd5, 0xf4, 0xe1, 0x8c, 0xc5, 0x88, 0x38, 0xbd, 0x68, 0xb7, 0xd8, 0xf7, 0x99, 0xd7, 0xc5, - 0x4e, 0xb2, 0x7c, 0x5e, 0xcd, 0xcf, 0x69, 0x89, 0x55, 0xfb, 0xba, 0x1e, 0x21, 0xa5, 0xe7, 0x4b, - 0x56, 0xce, 0x8a, 0xee, 0x81, 0x5e, 0xe4, 0xd6, 0x21, 0x46, 0xa9, 0x45, 0x98, 0xec, 0xda, 0x6d, - 0x93, 0xb6, 0x64, 0x61, 0x9e, 0x33, 0x26, 0xba, 0x76, 0xfb, 0x56, 0x4b, 0xc7, 0x70, 0x4e, 0x28, - 0x7e, 0xee, 0x05, 0xb4, 0xbd, 0x17, 0x85, 0x7e, 0xfb, 0x31, 0xf6, 0xef, 0x84, 0x41, 0x7f, 0x20, - 0x9c, 0xe6, 0x8f, 0xb1, 0x6f, 0x7a, 0x61, 0x3c, 0x0e, 0xae, 0xd6, 0xfa, 0xe3, 0x79, 0x2d, 0x39, - 0x9e, 0xd7, 0x36, 0xb9, 0x1d, 0xa3, 0xa7, 0xb8, 0x7a, 0xd0, 0x77, 0x60, 0x39, 0xdf, 0xc4, 0x21, - 0x62, 0xf8, 0x91, 0x0a, 0xa1, 0xe2, 0xdd, 0x62, 0x24, 0xa2, 0x56, 0xa7, 0x1a, 0x3b, 0x7f, 0x06, - 0xca, 0x51, 0xec, 0x68, 0x4b, 0xd2, 0x8f, 0x1b, 0xd3, 0x4a, 0x70, 0xab, 0xa5, 0x7f, 0xa5, 0x4e, - 0x3b, 0x8f, 0xe1, 0x10, 0xbe, 0xfd, 0xa2, 0xa5, 0xa8, 0x3d, 0x1e, 0xbc, 0xb4, 0x77, 0xe8, 0x21, - 0x2c, 0x0e, 0x5c, 0x32, 0xea, 0xb6, 0xbd, 0xa8, 0xb3, 0x5e, 0xc9, 0xcd, 0xbb, 0xcc, 0x4d, 0xba, - 0xe5, 0xb6, 0x3d, 0xe3, 0x54, 0x73, 0x50, 0xa8, 0xdf, 0x87, 0xd5, 0x42, 0x27, 0x0f, 0x71, 0x00, - 0x67, 0xa1, 0x22, 0x24, 0x5f, 0x84, 0x84, 0xed, 0x89, 0xcc, 0xe6, 0xdb, 0x01, 0x0e, 0x78, 0xb4, - 0x6f, 0x7d, 0x07, 0xce, 0x0c, 0x5d, 0x8d, 0x0c, 0x5e, 0x83, 0x09, 0x2e, 0x04, 0x91, 0xc9, 0x95, - 0xda, 0xd0, 0x37, 0xd1, 0x5a, 0x02, 0xa9, 0xf4, 0xf5, 0xbf, 0x8e, 0x01, 0xf4, 0xa5, 0x68, 0x05, - 0x66, 0xa3, 0x32, 0x6e, 0x79, 0xa1, 0xab, 0xb2, 0x77, 0xce, 0x98, 0x51, 0xb2, 0x1b, 0x42, 0x84, - 0xce, 0xc3, 0xf1, 0xfe, 0xf4, 0xa2, 0xb4, 0xd4, 0xfd, 0x98, 0xef, 0x89, 0x95, 0xe2, 0xeb, 0x00, - 0x72, 0x0a, 0x51, 0x3a, 0x63, 0x52, 0xa7, 0x2c, 0x24, 0x6a, 0xf9, 0x1d, 0x38, 0x3d, 0xd0, 0x3b, - 0x94, 0xea, 0xb8, 0x54, 0x5d, 0xc8, 0xd4, 0x7f, 0x85, 0x5a, 0x85, 0xb9, 0x0e, 0x7e, 0x12, 0xe9, - 0x53, 0xd7, 0x96, 0xf3, 0xc2, 0x9c, 0x31, 0xdb, 0xc1, 0x4f, 0xee, 0xc5, 0x32, 0x74, 0x09, 0x4e, - 0x26, 0x8b, 0xb8, 0x62, 0x9d, 0x94, 0x8a, 0xc7, 0xfb, 0xa5, 0x39, 0xe1, 0x86, 0x6c, 0x02, 0x7b, - 0xa6, 0xcf, 0x3c, 0x8b, 0x70, 0x1e, 0x01, 0xa6, 0x62, 0x37, 0xd4, 0xea, 0x96, 0x5a, 0x54, 0xa8, - 0xb7, 0xa0, 0x27, 0x37, 0xdb, 0x98, 0x3a, 0xa4, 0x65, 0x3a, 0x94, 0x07, 0x4b, 0xd3, 0xcb, 0x63, - 0x17, 0xca, 0x46, 0xdc, 0x9d, 0xf6, 0x6e, 0xca, 0xa5, 0xdb, 0x94, 0x07, 0xfa, 0x1b, 0x2a, 0xbd, - 0x0d, 0xc2, 0x45, 0x9e, 0x64, 0x97, 0xe3, 0x30, 0x7f, 0xa9, 0xf2, 0x2b, 0x57, 0x2b, 0x0a, 0x77, - 0x9e, 0x79, 0x2d, 0xcf, 0xfc, 0xfa, 0xaf, 0x65, 0x38, 0x29, 0x7b, 0x95, 0xfc, 0x5e, 0xb1, 0x4d, - 0x58, 0x97, 0x5a, 0x04, 0x39, 0x30, 0x97, 0x7a, 0x39, 0x46, 0x97, 0x73, 0x12, 0x67, 0xd8, 0x77, - 0x83, 0xca, 0x95, 0xfd, 0x29, 0x47, 0xa3, 0x76, 0x09, 0xb5, 0x61, 0x26, 0xf1, 0x9a, 0x8b, 0x2e, - 0x16, 0xc0, 0xd3, 0x6f, 0xd8, 0x95, 0x4b, 0xfb, 0x51, 0xed, 0xd9, 0xf1, 0x60, 0x3e, 0xdd, 0xf8, - 0x50, 0x91, 0xa7, 0x03, 0xa3, 0x7f, 0x65, 0x6d, 0x9f, 0xda, 0x3d, 0x83, 0x3f, 0x6a, 0xea, 0xee, - 0x0e, 0x6f, 0x42, 0xe8, 0xbd, 0x02, 0xbe, 0xc2, 0x76, 0x5a, 0x79, 0xff, 0x00, 0xc8, 0x9e, 0x57, - 0x3f, 0x68, 0xb0, 0x94, 0xd7, 0x46, 0xd0, 0xbb, 0x05, 0xcc, 0x05, 0xad, 0xad, 0x72, 0xed, 0xa5, - 0x71, 0x3d, 0x7f, 0xbe, 0x57, 0x5f, 0x39, 0x32, 0x25, 0x0c, 0x5d, 0x2d, 0x60, 0x1c, 0x5e, 0x0c, - 0x2b, 0xeb, 0x2f, 0x03, 0x49, 0x9e, 0xc7, 0xc2, 0xb0, 0xe6, 0x55, 0x18, 0x9f, 0xc2, 0x5e, 0x59, - 0x18, 0x9f, 0xe2, 0x1e, 0xa9, 0x97, 0xd0, 0x53, 0x4d, 0xbd, 0x7b, 0x0e, 0x34, 0x13, 0xb4, 0x0f, - 0xda, 0x9c, 0xfe, 0x58, 0xf9, 0xe0, 0x20, 0xd0, 0x9e, 0x4b, 0x3f, 0x6b, 0xaa, 0xcd, 0xe4, 0xd4, - 0x9f, 0x42, 0xc7, 0x8a, 0x2b, 0x5b, 0xa1, 0x63, 0x23, 0xca, 0x9d, 0x5e, 0xda, 0x78, 0xf8, 0xdb, - 0xf3, 0xaa, 0xf6, 0xec, 0x79, 0x55, 0xfb, 0xf3, 0x79, 0x55, 0x7b, 0xfa, 0xa2, 0x5a, 0x7a, 0xf6, - 0xa2, 0x5a, 0xfa, 0xfd, 0x45, 0xb5, 0xf4, 0xe0, 0xa6, 0x4d, 0x83, 0x47, 0x61, 0xb3, 0x66, 0x79, - 0x9d, 0x7a, 0xd3, 0x6d, 0xae, 0x59, 0x8f, 0x30, 0x75, 0xeb, 0xfd, 0x69, 0x6b, 0x8d, 0x07, 0x1e, - 0xc3, 0x36, 0x59, 0x13, 0x33, 0x23, 0x6d, 0x11, 0x56, 0x1f, 0xfa, 0x21, 0xb7, 0x39, 0x29, 0x3f, - 0x92, 0xbe, 0xfd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x48, 0x96, 0xe3, 0x23, 0xe8, 0x15, 0x00, - 0x00, + // 1720 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x6f, 0xdb, 0xd8, + 0x11, 0xb7, 0x62, 0xf9, 0x43, 0x23, 0xdb, 0xb1, 0x19, 0x3b, 0x75, 0x94, 0xd4, 0xb1, 0xe9, 0x06, + 0x71, 0x3e, 0x2c, 0x25, 0x6e, 0x91, 0x8f, 0x1e, 0xd2, 0xda, 0x49, 0xad, 0x18, 0xb5, 0x13, 0x87, + 0x4e, 0x5c, 0x34, 0x40, 0xc1, 0x50, 0xe4, 0x13, 0xfd, 0x6a, 0x8a, 0x64, 0xde, 0x23, 0x15, 0xbb, + 0x87, 0x1e, 0x7b, 0x2b, 0x50, 0xa0, 0x68, 0xd1, 0x5e, 0x16, 0x58, 0x2c, 0xf6, 0x7f, 0xd9, 0x63, + 0x8e, 0xbb, 0xb7, 0x45, 0x02, 0xec, 0x65, 0x8f, 0x7b, 0xd9, 0xe3, 0xe2, 0x7d, 0x50, 0x12, 0x29, + 0x91, 0x72, 0xec, 0x78, 0x17, 0x7b, 0x71, 0x98, 0x99, 0xf9, 0xfd, 0xde, 0xbc, 0x79, 0x33, 0xf3, + 0x86, 0x14, 0xa8, 0x35, 0x83, 0xa2, 0x4a, 0x70, 0xe8, 0x23, 0x5a, 0xb1, 0xeb, 0xd4, 0xa7, 0x88, + 0x34, 0x11, 0xa9, 0x34, 0x0c, 0xd7, 0xb0, 0x51, 0xd9, 0x27, 0x5e, 0xe0, 0x29, 0x33, 0xcc, 0xa6, + 0xcc, 0x6d, 0xca, 0x6d, 0x9b, 0xd2, 0x42, 0x02, 0x8a, 0x08, 0xf1, 0x08, 0xad, 0xf0, 0x7f, 0x04, + 0xb2, 0x34, 0x9f, 0x30, 0x71, 0x70, 0x03, 0x07, 0x15, 0xfe, 0x57, 0x5a, 0xcc, 0x25, 0x2c, 0x02, + 0x83, 0xee, 0x57, 0xd8, 0x9f, 0x88, 0xc1, 0x26, 0x08, 0xb9, 0x75, 0x8c, 0x1c, 0xab, 0xd2, 0xc4, + 0x24, 0x08, 0x0d, 0xc7, 0x26, 0x5e, 0xe8, 0x57, 0x82, 0x03, 0x61, 0xa1, 0x7e, 0x97, 0x83, 0xe9, + 0x6a, 0x7d, 0xc7, 0x5f, 0x43, 0x36, 0x76, 0x9f, 0x1b, 0x74, 0x5f, 0x43, 0xaf, 0x43, 0x44, 0x03, + 0xe5, 0xcf, 0xa0, 0x84, 0xbe, 0xe3, 0x19, 0x96, 0xee, 0xd5, 0xfe, 0x8a, 0xcc, 0x40, 0x67, 0xb4, + 0xb3, 0xb9, 0xf9, 0xdc, 0x52, 0x71, 0xe5, 0x5a, 0x39, 0xb1, 0x27, 0xbe, 0x24, 0xa3, 0x79, 0xc1, + 0x21, 0x4f, 0x39, 0x82, 0xb1, 0x3d, 0x1e, 0xd0, 0x26, 0xc3, 0x84, 0x4c, 0x09, 0xe1, 0x12, 0x41, + 0x34, 0x6c, 0x18, 0x35, 0x07, 0xe9, 0x3d, 0x16, 0x39, 0xc3, 0x17, 0x59, 0x49, 0x5d, 0x44, 0x8b, + 0xc0, 0x3d, 0x56, 0xbb, 0x40, 0xd2, 0x94, 0x6b, 0x05, 0x18, 0x21, 0x62, 0x73, 0xea, 0x1f, 0x61, + 0x26, 0xb1, 0x69, 0xea, 0x7b, 0x2e, 0x45, 0xca, 0x0a, 0x0c, 0x22, 0x42, 0xe4, 0x36, 0xe7, 0x93, + 0x1e, 0x88, 0x33, 0xe2, 0x3e, 0xfc, 0x81, 0x3d, 0x6a, 0xcc, 0x58, 0x7d, 0x0e, 0x0a, 0x93, 0xac, + 0xd2, 0xfd, 0xce, 0xf8, 0x3d, 0x00, 0x70, 0x3d, 0x0b, 0xe9, 0xfc, 0xb8, 0x24, 0xe1, 0xe5, 0x24, + 0xa1, 0x38, 0x4b, 0x86, 0xde, 0x64, 0x4f, 0x5a, 0x81, 0x41, 0xf8, 0xa3, 0xfa, 0xfd, 0x30, 0x9c, + 0x8b, 0xd1, 0x1e, 0xdf, 0x43, 0x45, 0x87, 0x69, 0x82, 0x7c, 0x07, 0x9b, 0x46, 0x80, 0x74, 0x1f, + 0x23, 0x13, 0x75, 0x06, 0xfa, 0x46, 0x46, 0xa0, 0x25, 0x68, 0x9b, 0x61, 0x64, 0x84, 0x15, 0xd2, + 0x25, 0x55, 0x76, 0x60, 0x92, 0x22, 0xc3, 0x89, 0x9d, 0xe2, 0x20, 0x27, 0xbf, 0x9a, 0x4a, 0xbe, + 0x83, 0x0c, 0x27, 0x76, 0x74, 0x13, 0x34, 0x26, 0x61, 0x19, 0x48, 0x90, 0x89, 0x70, 0x33, 0xe6, + 0x73, 0xbe, 0x4f, 0x06, 0x6a, 0x02, 0xd2, 0xe9, 0xf1, 0x24, 0x49, 0xc8, 0x94, 0x2d, 0x98, 0xb0, + 0xcd, 0x98, 0xb7, 0x43, 0x9c, 0xf6, 0x4a, 0x2a, 0x6d, 0xf5, 0x61, 0xcc, 0xd7, 0x31, 0xdb, 0xec, + 0xf0, 0xf4, 0x2f, 0x30, 0x6d, 0x9b, 0xfa, 0xdf, 0xbc, 0x46, 0x0d, 0xc7, 0x7c, 0x1d, 0xe6, 0xa4, + 0xd7, 0x33, 0x48, 0x5f, 0x72, 0x4c, 0xa7, 0xb3, 0x53, 0xb6, 0x99, 0x10, 0x2a, 0x55, 0x18, 0xb3, + 0x4d, 0xbd, 0x81, 0x02, 0x43, 0xd0, 0x8e, 0x70, 0xda, 0xc5, 0x0c, 0xda, 0x2d, 0x14, 0x18, 0x92, + 0x0f, 0x6c, 0x33, 0xfa, 0x9f, 0x8c, 0xa8, 0xd7, 0x44, 0xa4, 0xd3, 0xcb, 0xd1, 0xfe, 0x11, 0x65, + 0x90, 0x64, 0x44, 0x63, 0x32, 0x96, 0x01, 0x0d, 0x6c, 0x13, 0x96, 0x60, 0x76, 0xd3, 0x16, 0xc4, + 0x85, 0x3e, 0x19, 0xb0, 0x25, 0x00, 0xd5, 0xdd, 0x6a, 0x94, 0x01, 0x92, 0xa2, 0xda, 0xb4, 0x39, + 0x29, 0x86, 0x59, 0xdb, 0xd4, 0x6b, 0xa1, 0xb9, 0x8f, 0x02, 0x5d, 0xe8, 0xb0, 0xe7, 0x0a, 0x72, + 0xe0, 0xe4, 0xe5, 0x8c, 0x20, 0xac, 0x71, 0xdc, 0x56, 0x04, 0x93, 0x6b, 0xcc, 0xd8, 0x66, 0x0f, + 0xc5, 0x1a, 0xc0, 0x28, 0x91, 0x25, 0xa6, 0x7e, 0x55, 0x10, 0xed, 0x41, 0x43, 0xbe, 0x47, 0x82, + 0x1f, 0xa9, 0x29, 0xfe, 0x3c, 0x6b, 0xb4, 0xbb, 0x90, 0xf2, 0xa7, 0x51, 0x48, 0x43, 0xa7, 0x53, + 0x48, 0xc3, 0xc7, 0x2d, 0x24, 0x1d, 0xa6, 0x2d, 0xef, 0x8d, 0xdb, 0x95, 0x09, 0x23, 0x7d, 0x0e, + 0xeb, 0x91, 0x04, 0xc5, 0x42, 0xa0, 0x58, 0x5d, 0x52, 0xb6, 0x80, 0xb9, 0x67, 0x38, 0x0e, 0x72, + 0x6d, 0xd4, 0x5d, 0xab, 0xe9, 0x0b, 0x3c, 0x8c, 0x40, 0xb1, 0x6c, 0x30, 0xbb, 0xa4, 0x29, 0xcd, + 0xb5, 0xf0, 0x31, 0x9a, 0x6b, 0xbf, 0xeb, 0x1d, 0x4e, 0xe5, 0x7a, 0x4f, 0x69, 0x6e, 0xc5, 0xd3, + 0x6a, 0x6e, 0x63, 0xa7, 0xd9, 0xdc, 0xc6, 0x3f, 0x6e, 0x73, 0xeb, 0x98, 0x7c, 0x36, 0xe1, 0x7c, + 0xb2, 0xb5, 0x9d, 0x60, 0xf4, 0xf9, 0x4f, 0x0e, 0x16, 0x98, 0x68, 0x1b, 0x9b, 0xfb, 0xbb, 0x62, + 0xbe, 0xac, 0xb2, 0xf9, 0x72, 0xdd, 0x68, 0x60, 0xe7, 0x30, 0xea, 0x9a, 0x3e, 0x5c, 0x34, 0x09, + 0x62, 0xd1, 0x93, 0xbb, 0x35, 0x7c, 0x9f, 0x78, 0x4d, 0xc3, 0xe9, 0x6c, 0x9f, 0xb7, 0xd3, 0x73, + 0x9a, 0x63, 0xc5, 0xbe, 0x56, 0x25, 0x92, 0x7b, 0x3e, 0x6b, 0xa6, 0x68, 0x54, 0x0f, 0xd4, 0x2c, + 0xb7, 0x4e, 0x30, 0x4a, 0xcd, 0xc0, 0x70, 0xd3, 0xae, 0xeb, 0xd8, 0xe2, 0x8d, 0x79, 0x5c, 0x1b, + 0x6a, 0xda, 0xf5, 0x0d, 0x4b, 0x35, 0xe0, 0x32, 0x33, 0x7c, 0xe2, 0x05, 0xb8, 0x7e, 0x28, 0x8f, + 0x7e, 0xe7, 0x8d, 0xe1, 0x3f, 0x0d, 0x83, 0xf6, 0x40, 0x38, 0x4a, 0xdf, 0x18, 0xbe, 0xee, 0x85, + 0xd1, 0x38, 0xb8, 0x58, 0x6e, 0x8f, 0xe7, 0xe5, 0xce, 0xf1, 0xbc, 0xbc, 0x45, 0xed, 0x08, 0x3d, + 0x42, 0xc5, 0x83, 0xba, 0x0b, 0xf3, 0xe9, 0x4b, 0x9c, 0xe0, 0x0c, 0x7f, 0x2f, 0x8e, 0x50, 0xf0, + 0x6e, 0x13, 0x24, 0xa9, 0x45, 0x54, 0x23, 0xe7, 0x2f, 0x42, 0x41, 0x9e, 0x1d, 0xb6, 0x38, 0x7d, + 0x5e, 0x1b, 0x15, 0x82, 0x0d, 0x4b, 0xfd, 0x5f, 0x4e, 0x84, 0x3b, 0x8d, 0xe2, 0x04, 0xe1, 0x7e, + 0x00, 0x43, 0xaf, 0x43, 0x2f, 0x30, 0xe4, 0x35, 0xb8, 0x94, 0x9a, 0x24, 0x62, 0xad, 0x67, 0xcc, + 0x76, 0xc3, 0xad, 0x7b, 0x9a, 0x80, 0xa9, 0x9f, 0xc5, 0x5d, 0xf3, 0x68, 0xf0, 0xc1, 0xdb, 0x53, + 0x5e, 0xc1, 0x4c, 0x57, 0x95, 0x62, 0xb7, 0xee, 0x49, 0x9f, 0x6e, 0xf6, 0xf1, 0xa9, 0x55, 0x8a, + 0xdc, 0xaf, 0x73, 0xb5, 0x6e, 0xa1, 0xfa, 0xff, 0x1c, 0x2c, 0x66, 0x7a, 0xf9, 0x13, 0x46, 0xf0, + 0x12, 0x94, 0x98, 0xf6, 0x59, 0x88, 0xc8, 0x21, 0xab, 0x2d, 0xba, 0x13, 0x18, 0x01, 0x95, 0x81, + 0x53, 0x77, 0xe1, 0x62, 0x4f, 0xad, 0x74, 0xf8, 0x2e, 0x0c, 0x51, 0x26, 0x90, 0x2e, 0x2f, 0x94, + 0x7b, 0xbe, 0x0b, 0x97, 0x3b, 0x90, 0xc2, 0x5e, 0xfd, 0xe6, 0x0c, 0x40, 0x5b, 0xaa, 0x2c, 0xc0, + 0x98, 0xbc, 0x48, 0x4c, 0x2f, 0x74, 0x45, 0xfd, 0x8c, 0x6b, 0x45, 0x21, 0x7b, 0xc8, 0x44, 0xca, + 0x55, 0x38, 0xdb, 0x9e, 0x9f, 0x84, 0x95, 0xa8, 0xd0, 0x89, 0x96, 0x58, 0x18, 0xfe, 0x12, 0x80, + 0xcf, 0x41, 0xc2, 0x66, 0x90, 0xdb, 0x14, 0x98, 0x44, 0xa8, 0x7f, 0x03, 0xe7, 0xbb, 0x6e, 0x2f, + 0x61, 0x9a, 0xe7, 0xa6, 0xd3, 0x89, 0x1b, 0x48, 0xa0, 0x16, 0x61, 0xbc, 0x61, 0x1c, 0x48, 0x7b, + 0xec, 0xda, 0x7c, 0x62, 0x19, 0xd7, 0xc6, 0x1a, 0xc6, 0xc1, 0x8b, 0x48, 0xa6, 0x5c, 0x87, 0xa9, + 0xce, 0x6b, 0x44, 0xb0, 0x0e, 0x73, 0xc3, 0xb3, 0xed, 0xcb, 0xa1, 0xc3, 0x0d, 0x7e, 0x0d, 0x1d, + 0xea, 0x3e, 0xf1, 0x4c, 0x44, 0xa9, 0x04, 0x8c, 0x44, 0x6e, 0x08, 0xed, 0xb6, 0x50, 0x0a, 0xd4, + 0x2d, 0x68, 0xc9, 0xf5, 0xba, 0x81, 0x1d, 0x64, 0xe9, 0x0e, 0xa6, 0xc1, 0xec, 0xe8, 0xfc, 0xe0, + 0x52, 0x41, 0x8b, 0xee, 0xc7, 0xc3, 0x75, 0xae, 0xda, 0xc4, 0x34, 0x50, 0xd7, 0xe1, 0x6a, 0xeb, + 0x00, 0x13, 0xf9, 0xba, 0x4d, 0x3c, 0x9b, 0x20, 0x4a, 0x8f, 0xd4, 0x03, 0x0e, 0x60, 0xa9, 0x3f, + 0x8f, 0xcc, 0x8a, 0x4d, 0x18, 0xf5, 0xa5, 0x4c, 0x26, 0xc6, 0xad, 0x94, 0xc4, 0x88, 0x95, 0x41, + 0xc4, 0xc3, 0xa6, 0x30, 0xad, 0xc5, 0xa0, 0x7e, 0x3b, 0x08, 0x17, 0x52, 0xed, 0xb2, 0x2b, 0xfb, + 0x0e, 0xfc, 0x82, 0x86, 0x35, 0x6a, 0x12, 0x5c, 0x43, 0x96, 0x5e, 0x73, 0x3c, 0x73, 0x5f, 0xdf, + 0x43, 0xd8, 0xde, 0x13, 0xb9, 0x93, 0xd7, 0x66, 0xda, 0xea, 0x35, 0xa6, 0x7d, 0xcc, 0x95, 0xfc, + 0xb4, 0xe5, 0x41, 0xb2, 0x74, 0x45, 0x32, 0x8b, 0xc6, 0xa4, 0x90, 0xe5, 0x2c, 0x52, 0x54, 0x18, + 0x0f, 0xbc, 0xc0, 0x70, 0xf8, 0x59, 0xbb, 0x61, 0x43, 0xe6, 0x4f, 0x91, 0x0b, 0xab, 0x4d, 0xfb, + 0x49, 0xd8, 0x50, 0xee, 0xc3, 0x05, 0x89, 0xb1, 0xf4, 0x3a, 0x76, 0x31, 0xdd, 0x43, 0x56, 0xcb, + 0x5e, 0xa4, 0xd0, 0xf9, 0xc8, 0x60, 0x5d, 0xea, 0x25, 0x74, 0x19, 0xce, 0xd9, 0x66, 0x37, 0x48, + 0xa4, 0xd3, 0xa4, 0x6d, 0x26, 0xcc, 0x6f, 0x82, 0xe2, 0x13, 0xa4, 0x5b, 0xc8, 0x0a, 0x4d, 0xb6, + 0x9a, 0xe8, 0x09, 0x23, 0x7c, 0x97, 0x93, 0x3e, 0x41, 0x8f, 0xa4, 0x82, 0xd7, 0x3f, 0xab, 0x37, + 0x96, 0x2b, 0xa1, 0x2f, 0xed, 0x46, 0xb9, 0x5d, 0x51, 0xc8, 0x84, 0xc9, 0x35, 0x98, 0x72, 0x0c, + 0x1a, 0xe8, 0xed, 0xf1, 0x1f, 0x5b, 0x7c, 0x7e, 0xcc, 0x6b, 0x13, 0x4c, 0x51, 0x95, 0x73, 0xfd, + 0x86, 0xa5, 0x2c, 0xc2, 0x44, 0x64, 0xca, 0xdc, 0xc4, 0x16, 0x1f, 0x01, 0xf3, 0x5a, 0x51, 0xd8, + 0x55, 0x9b, 0xf6, 0x86, 0xa5, 0x5c, 0x81, 0x89, 0x56, 0x28, 0x6a, 0x87, 0x01, 0xa2, 0x7c, 0x74, + 0xcb, 0x6b, 0x51, 0xa4, 0xad, 0x35, 0x26, 0x54, 0x7f, 0x25, 0xfa, 0xb9, 0x86, 0x28, 0xeb, 0x8b, + 0xc9, 0x74, 0x8e, 0xda, 0xd2, 0x9f, 0x44, 0x3f, 0x4d, 0xb5, 0x92, 0x89, 0x98, 0x56, 0x2e, 0xb9, + 0xb4, 0x72, 0x59, 0xf9, 0x47, 0x11, 0xa6, 0xf8, 0x74, 0xc7, 0xbf, 0xf0, 0xed, 0x20, 0xd2, 0xc4, + 0x26, 0x52, 0x1c, 0x18, 0x8f, 0x7d, 0x4e, 0x52, 0x6e, 0xa4, 0xe4, 0x73, 0xaf, 0x2f, 0x6d, 0xa5, + 0x9b, 0x47, 0x33, 0x96, 0x2f, 0xa7, 0x03, 0x4a, 0x1d, 0x8a, 0x1d, 0x1f, 0x86, 0x94, 0x6b, 0x19, + 0xf0, 0xf8, 0x37, 0xa9, 0xd2, 0xf5, 0xa3, 0x98, 0xb6, 0xd6, 0xf1, 0x60, 0x22, 0x3e, 0x2a, 0x2a, + 0x59, 0x9e, 0x76, 0xbd, 0x2c, 0x97, 0x96, 0x8f, 0x68, 0xdd, 0x5a, 0xf0, 0xdf, 0x39, 0x71, 0xd7, + 0xf4, 0x1e, 0xdb, 0x94, 0x7b, 0x19, 0x7c, 0x99, 0x03, 0x68, 0xe9, 0xfe, 0x31, 0x90, 0x2d, 0xaf, + 0xfe, 0x99, 0x83, 0xd9, 0xb4, 0xc1, 0x4b, 0xb9, 0x93, 0xc1, 0x9c, 0x31, 0x0c, 0x96, 0xee, 0x7e, + 0x30, 0xae, 0xe5, 0xcf, 0xdf, 0xc5, 0x77, 0xc1, 0xc4, 0x95, 0xab, 0xdc, 0xce, 0x60, 0xec, 0x7d, + 0x79, 0x97, 0x56, 0x3e, 0x04, 0xd2, 0x5a, 0xff, 0xf3, 0x9c, 0x18, 0x44, 0xb3, 0x5a, 0xbd, 0xf2, + 0xa0, 0x1f, 0x75, 0xf6, 0x5d, 0x53, 0xfa, 0xdd, 0xb1, 0xf1, 0x2d, 0x3f, 0x3f, 0xcd, 0x89, 0x2b, + 0xa9, 0xf7, 0x54, 0xba, 0xea, 0x5a, 0xa2, 0xe5, 0x89, 0x6e, 0x76, 0xaf, 0xef, 0x79, 0xa4, 0x4c, + 0xc6, 0x99, 0xb9, 0x95, 0x3d, 0x10, 0xab, 0x03, 0xca, 0x27, 0x69, 0x83, 0xdf, 0xaa, 0x6b, 0x69, + 0x1d, 0xcd, 0xf6, 0x08, 0x8b, 0xa4, 0x8c, 0xb6, 0xa5, 0xdf, 0x1e, 0x07, 0xda, 0x72, 0xf0, 0xbf, + 0x39, 0x31, 0xe0, 0xa5, 0x74, 0xd2, 0x4c, 0xc7, 0xb2, 0x7b, 0x74, 0xa6, 0x63, 0x7d, 0x1a, 0xb7, + 0x3a, 0xb0, 0xf6, 0xea, 0x8b, 0x77, 0x73, 0xb9, 0xb7, 0xef, 0xe6, 0x72, 0x5f, 0xbf, 0x9b, 0xcb, + 0xfd, 0xeb, 0xfd, 0xdc, 0xc0, 0xdb, 0xf7, 0x73, 0x03, 0x5f, 0xbe, 0x9f, 0x1b, 0x78, 0xb9, 0x6e, + 0xe3, 0x60, 0x2f, 0xac, 0x95, 0x4d, 0xaf, 0x51, 0xa9, 0xb9, 0xb5, 0x65, 0x73, 0xcf, 0xc0, 0x6e, + 0xa5, 0xfd, 0xa6, 0xb5, 0x4c, 0x03, 0x8f, 0x18, 0x36, 0x5a, 0x66, 0xef, 0x8b, 0xd8, 0x42, 0xa4, + 0xd2, 0xf3, 0x47, 0x9c, 0xda, 0x30, 0xff, 0x81, 0xe4, 0xd7, 0x3f, 0x04, 0x00, 0x00, 0xff, 0xff, + 0xcc, 0x8d, 0xc3, 0x30, 0xe4, 0x19, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1426,8 +1681,9 @@ type GfSpManageServiceClient interface { GfSpPickVirtualGroupFamily(ctx context.Context, in *GfSpPickVirtualGroupFamilyRequest, opts ...grpc.CallOption) (*GfSpPickVirtualGroupFamilyResponse, error) GfSpNotifyMigrateSwapOut(ctx context.Context, in *GfSpNotifyMigrateSwapOutRequest, opts ...grpc.CallOption) (*GfSpNotifyMigrateSwapOutResponse, error) GfSpQueryTasksStats(ctx context.Context, in *GfSpQueryTasksStatsRequest, opts ...grpc.CallOption) (*GfSpQueryTasksStatsResponse, error) - GfSpNotifyPreMigrate(ctx context.Context, in *GfSpNotifyPreMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPreMigrateBucketResponse, error) - GfSpNotifyPostMigrate(ctx context.Context, in *GfSpNotifyPostMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPostMigrateBucketResponse, error) + GfSpQueryBucketMigrationProgress(ctx context.Context, in *GfSpQueryBucketMigrationProgressRequest, opts ...grpc.CallOption) (*GfSpQueryBucketMigrationProgressResponse, error) + GfSpNotifyPreMigrateBucketAndDeductQuota(ctx context.Context, in *GfSpNotifyPreMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPreMigrateBucketResponse, error) + GfSpNotifyPostMigrateAndRecoupQuota(ctx context.Context, in *GfSpNotifyPostMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPostMigrateBucketResponse, error) GfSpResetRecoveryFailedList(ctx context.Context, in *GfSpResetRecoveryFailedListRequest, opts ...grpc.CallOption) (*GfSpResetRecoveryFailedListResponse, error) } @@ -1493,18 +1749,27 @@ func (c *gfSpManageServiceClient) GfSpQueryTasksStats(ctx context.Context, in *G return out, nil } -func (c *gfSpManageServiceClient) GfSpNotifyPreMigrate(ctx context.Context, in *GfSpNotifyPreMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPreMigrateBucketResponse, error) { +func (c *gfSpManageServiceClient) GfSpQueryBucketMigrationProgress(ctx context.Context, in *GfSpQueryBucketMigrationProgressRequest, opts ...grpc.CallOption) (*GfSpQueryBucketMigrationProgressResponse, error) { + out := new(GfSpQueryBucketMigrationProgressResponse) + err := c.cc.Invoke(ctx, "/base.types.gfspserver.GfSpManageService/GfSpQueryBucketMigrationProgress", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gfSpManageServiceClient) GfSpNotifyPreMigrateBucketAndDeductQuota(ctx context.Context, in *GfSpNotifyPreMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPreMigrateBucketResponse, error) { out := new(GfSpNotifyPreMigrateBucketResponse) - err := c.cc.Invoke(ctx, "/base.types.gfspserver.GfSpManageService/GfSpNotifyPreMigrate", in, out, opts...) + err := c.cc.Invoke(ctx, "/base.types.gfspserver.GfSpManageService/GfSpNotifyPreMigrateBucketAndDeductQuota", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *gfSpManageServiceClient) GfSpNotifyPostMigrate(ctx context.Context, in *GfSpNotifyPostMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPostMigrateBucketResponse, error) { +func (c *gfSpManageServiceClient) GfSpNotifyPostMigrateAndRecoupQuota(ctx context.Context, in *GfSpNotifyPostMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPostMigrateBucketResponse, error) { out := new(GfSpNotifyPostMigrateBucketResponse) - err := c.cc.Invoke(ctx, "/base.types.gfspserver.GfSpManageService/GfSpNotifyPostMigrate", in, out, opts...) + err := c.cc.Invoke(ctx, "/base.types.gfspserver.GfSpManageService/GfSpNotifyPostMigrateAndRecoupQuota", in, out, opts...) if err != nil { return nil, err } @@ -1528,8 +1793,9 @@ type GfSpManageServiceServer interface { GfSpPickVirtualGroupFamily(context.Context, *GfSpPickVirtualGroupFamilyRequest) (*GfSpPickVirtualGroupFamilyResponse, error) GfSpNotifyMigrateSwapOut(context.Context, *GfSpNotifyMigrateSwapOutRequest) (*GfSpNotifyMigrateSwapOutResponse, error) GfSpQueryTasksStats(context.Context, *GfSpQueryTasksStatsRequest) (*GfSpQueryTasksStatsResponse, error) - GfSpNotifyPreMigrate(context.Context, *GfSpNotifyPreMigrateBucketRequest) (*GfSpNotifyPreMigrateBucketResponse, error) - GfSpNotifyPostMigrate(context.Context, *GfSpNotifyPostMigrateBucketRequest) (*GfSpNotifyPostMigrateBucketResponse, error) + GfSpQueryBucketMigrationProgress(context.Context, *GfSpQueryBucketMigrationProgressRequest) (*GfSpQueryBucketMigrationProgressResponse, error) + GfSpNotifyPreMigrateBucketAndDeductQuota(context.Context, *GfSpNotifyPreMigrateBucketRequest) (*GfSpNotifyPreMigrateBucketResponse, error) + GfSpNotifyPostMigrateAndRecoupQuota(context.Context, *GfSpNotifyPostMigrateBucketRequest) (*GfSpNotifyPostMigrateBucketResponse, error) GfSpResetRecoveryFailedList(context.Context, *GfSpResetRecoveryFailedListRequest) (*GfSpResetRecoveryFailedListResponse, error) } @@ -1555,11 +1821,14 @@ func (*UnimplementedGfSpManageServiceServer) GfSpNotifyMigrateSwapOut(ctx contex func (*UnimplementedGfSpManageServiceServer) GfSpQueryTasksStats(ctx context.Context, req *GfSpQueryTasksStatsRequest) (*GfSpQueryTasksStatsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GfSpQueryTasksStats not implemented") } -func (*UnimplementedGfSpManageServiceServer) GfSpNotifyPreMigrate(ctx context.Context, req *GfSpNotifyPreMigrateBucketRequest) (*GfSpNotifyPreMigrateBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GfSpNotifyPreMigrate not implemented") +func (*UnimplementedGfSpManageServiceServer) GfSpQueryBucketMigrationProgress(ctx context.Context, req *GfSpQueryBucketMigrationProgressRequest) (*GfSpQueryBucketMigrationProgressResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GfSpQueryBucketMigrationProgress not implemented") +} +func (*UnimplementedGfSpManageServiceServer) GfSpNotifyPreMigrateBucketAndDeductQuota(ctx context.Context, req *GfSpNotifyPreMigrateBucketRequest) (*GfSpNotifyPreMigrateBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GfSpNotifyPreMigrateBucketAndDeductQuota not implemented") } -func (*UnimplementedGfSpManageServiceServer) GfSpNotifyPostMigrate(ctx context.Context, req *GfSpNotifyPostMigrateBucketRequest) (*GfSpNotifyPostMigrateBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GfSpNotifyPostMigrate not implemented") +func (*UnimplementedGfSpManageServiceServer) GfSpNotifyPostMigrateAndRecoupQuota(ctx context.Context, req *GfSpNotifyPostMigrateBucketRequest) (*GfSpNotifyPostMigrateBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GfSpNotifyPostMigrateAndRecoupQuota not implemented") } func (*UnimplementedGfSpManageServiceServer) GfSpResetRecoveryFailedList(ctx context.Context, req *GfSpResetRecoveryFailedListRequest) (*GfSpResetRecoveryFailedListResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GfSpResetRecoveryFailedList not implemented") @@ -1677,38 +1946,56 @@ func _GfSpManageService_GfSpQueryTasksStats_Handler(srv interface{}, ctx context return interceptor(ctx, in, info, handler) } -func _GfSpManageService_GfSpNotifyPreMigrate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _GfSpManageService_GfSpQueryBucketMigrationProgress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GfSpQueryBucketMigrationProgressRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GfSpManageServiceServer).GfSpQueryBucketMigrationProgress(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/base.types.gfspserver.GfSpManageService/GfSpQueryBucketMigrationProgress", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GfSpManageServiceServer).GfSpQueryBucketMigrationProgress(ctx, req.(*GfSpQueryBucketMigrationProgressRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GfSpManageService_GfSpNotifyPreMigrateBucketAndDeductQuota_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GfSpNotifyPreMigrateBucketRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(GfSpManageServiceServer).GfSpNotifyPreMigrate(ctx, in) + return srv.(GfSpManageServiceServer).GfSpNotifyPreMigrateBucketAndDeductQuota(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/base.types.gfspserver.GfSpManageService/GfSpNotifyPreMigrate", + FullMethod: "/base.types.gfspserver.GfSpManageService/GfSpNotifyPreMigrateBucketAndDeductQuota", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GfSpManageServiceServer).GfSpNotifyPreMigrate(ctx, req.(*GfSpNotifyPreMigrateBucketRequest)) + return srv.(GfSpManageServiceServer).GfSpNotifyPreMigrateBucketAndDeductQuota(ctx, req.(*GfSpNotifyPreMigrateBucketRequest)) } return interceptor(ctx, in, info, handler) } -func _GfSpManageService_GfSpNotifyPostMigrate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _GfSpManageService_GfSpNotifyPostMigrateAndRecoupQuota_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GfSpNotifyPostMigrateBucketRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(GfSpManageServiceServer).GfSpNotifyPostMigrate(ctx, in) + return srv.(GfSpManageServiceServer).GfSpNotifyPostMigrateAndRecoupQuota(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/base.types.gfspserver.GfSpManageService/GfSpNotifyPostMigrate", + FullMethod: "/base.types.gfspserver.GfSpManageService/GfSpNotifyPostMigrateAndRecoupQuota", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GfSpManageServiceServer).GfSpNotifyPostMigrate(ctx, req.(*GfSpNotifyPostMigrateBucketRequest)) + return srv.(GfSpManageServiceServer).GfSpNotifyPostMigrateAndRecoupQuota(ctx, req.(*GfSpNotifyPostMigrateBucketRequest)) } return interceptor(ctx, in, info, handler) } @@ -1760,12 +2047,16 @@ var _GfSpManageService_serviceDesc = grpc.ServiceDesc{ Handler: _GfSpManageService_GfSpQueryTasksStats_Handler, }, { - MethodName: "GfSpNotifyPreMigrate", - Handler: _GfSpManageService_GfSpNotifyPreMigrate_Handler, + MethodName: "GfSpQueryBucketMigrationProgress", + Handler: _GfSpManageService_GfSpQueryBucketMigrationProgress_Handler, + }, + { + MethodName: "GfSpNotifyPreMigrateBucketAndDeductQuota", + Handler: _GfSpManageService_GfSpNotifyPreMigrateBucketAndDeductQuota_Handler, }, { - MethodName: "GfSpNotifyPostMigrate", - Handler: _GfSpManageService_GfSpNotifyPostMigrate_Handler, + MethodName: "GfSpNotifyPostMigrateAndRecoupQuota", + Handler: _GfSpManageService_GfSpNotifyPostMigrateAndRecoupQuota_Handler, }, { MethodName: "GfSpResetRecoveryFailedList", @@ -2686,6 +2977,18 @@ func (m *GfSpNotifyPreMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) ( _ = i var l int _ = l + if m.Quota != nil { + { + size, err := m.Quota.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintManage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } if m.Err != nil { { size, err := m.Err.MarshalToSizedBuffer(dAtA[:i]) @@ -2761,6 +3064,18 @@ func (m *GfSpNotifyPostMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) _ = i var l int _ = l + if m.Quota != nil { + { + size, err := m.Quota.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintManage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } if m.Err != nil { { size, err := m.Err.MarshalToSizedBuffer(dAtA[:i]) @@ -2901,7 +3216,7 @@ func (m *TasksStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *GfSpResetRecoveryFailedListRequest) Marshal() (dAtA []byte, err error) { +func (m *GfSpQueryBucketMigrationProgressRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2911,20 +3226,25 @@ func (m *GfSpResetRecoveryFailedListRequest) Marshal() (dAtA []byte, err error) return dAtA[:n], nil } -func (m *GfSpResetRecoveryFailedListRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *GfSpQueryBucketMigrationProgressRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GfSpResetRecoveryFailedListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GfSpQueryBucketMigrationProgressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l + if m.BucketId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.BucketId)) + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } -func (m *GfSpResetRecoveryFailedListResponse) Marshal() (dAtA []byte, err error) { +func (m *GfSpQueryBucketMigrationProgressResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2934,62 +3254,198 @@ func (m *GfSpResetRecoveryFailedListResponse) Marshal() (dAtA []byte, err error) return dAtA[:n], nil } -func (m *GfSpResetRecoveryFailedListResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *GfSpQueryBucketMigrationProgressResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GfSpResetRecoveryFailedListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GfSpQueryBucketMigrationProgressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.RecoveryFailedList) > 0 { - for iNdEx := len(m.RecoveryFailedList) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.RecoveryFailedList[iNdEx]) - copy(dAtA[i:], m.RecoveryFailedList[iNdEx]) - i = encodeVarintManage(dAtA, i, uint64(len(m.RecoveryFailedList[iNdEx]))) - i-- - dAtA[i] = 0xa + if m.Progress != nil { + { + size, err := m.Progress.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintManage(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func encodeVarintManage(dAtA []byte, offset int, v uint64) int { - offset -= sovManage(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *MigrateBucketProgressMeta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *GfSpBeginTaskRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Request != nil { - n += m.Request.Size() - } - return n + +func (m *MigrateBucketProgressMeta) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GfSpBeginTaskRequest_UploadObjectTask) Size() (n int) { - if m == nil { - return 0 - } +func (m *MigrateBucketProgressMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.UploadObjectTask != nil { - l = m.UploadObjectTask.Size() - n += 1 + l + sovManage(uint64(l)) + if m.MigratedBytes != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.MigratedBytes)) + i-- + dAtA[i] = 0x58 } - return n + if m.LastGcGvgId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.LastGcGvgId)) + i-- + dAtA[i] = 0x50 + } + if m.LastGcObjectId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.LastGcObjectId)) + i-- + dAtA[i] = 0x48 + } + if m.RecoupQuota != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.RecoupQuota)) + i-- + dAtA[i] = 0x40 + } + if m.PreDeductedQuota != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.PreDeductedQuota)) + i-- + dAtA[i] = 0x38 + } + if m.GcFinishedGvgNum != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.GcFinishedGvgNum)) + i-- + dAtA[i] = 0x30 + } + if m.MigratedFinishedGvgNum != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.MigratedFinishedGvgNum)) + i-- + dAtA[i] = 0x28 + } + if m.TotalGvgNum != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.TotalGvgNum)) + i-- + dAtA[i] = 0x20 + } + if m.MigrateState != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.MigrateState)) + i-- + dAtA[i] = 0x18 + } + if m.SubscribedBlockHeight != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.SubscribedBlockHeight)) + i-- + dAtA[i] = 0x10 + } + if m.BucketId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.BucketId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GfSpResetRecoveryFailedListRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GfSpResetRecoveryFailedListRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpResetRecoveryFailedListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *GfSpResetRecoveryFailedListResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GfSpResetRecoveryFailedListResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpResetRecoveryFailedListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.RecoveryFailedList) > 0 { + for iNdEx := len(m.RecoveryFailedList) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.RecoveryFailedList[iNdEx]) + copy(dAtA[i:], m.RecoveryFailedList[iNdEx]) + i = encodeVarintManage(dAtA, i, uint64(len(m.RecoveryFailedList[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintManage(dAtA []byte, offset int, v uint64) int { + offset -= sovManage(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GfSpBeginTaskRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Request != nil { + n += m.Request.Size() + } + return n +} + +func (m *GfSpBeginTaskRequest_UploadObjectTask) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UploadObjectTask != nil { + l = m.UploadObjectTask.Size() + n += 1 + l + sovManage(uint64(l)) + } + return n } func (m *GfSpBeginTaskRequest_ResumableUploadObjectTask) Size() (n int) { if m == nil { @@ -3411,6 +3867,10 @@ func (m *GfSpNotifyPreMigrateBucketResponse) Size() (n int) { l = m.Err.Size() n += 1 + l + sovManage(uint64(l)) } + if m.Quota != nil { + l = m.Quota.Size() + n += 1 + l + sovManage(uint64(l)) + } return n } @@ -3440,6 +3900,10 @@ func (m *GfSpNotifyPostMigrateBucketResponse) Size() (n int) { l = m.Err.Size() n += 1 + l + sovManage(uint64(l)) } + if m.Quota != nil { + l = m.Quota.Size() + n += 1 + l + sovManage(uint64(l)) + } return n } @@ -3501,6 +3965,73 @@ func (m *TasksStats) Size() (n int) { return n } +func (m *GfSpQueryBucketMigrationProgressRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BucketId != 0 { + n += 1 + sovManage(uint64(m.BucketId)) + } + return n +} + +func (m *GfSpQueryBucketMigrationProgressResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Progress != nil { + l = m.Progress.Size() + n += 1 + l + sovManage(uint64(l)) + } + return n +} + +func (m *MigrateBucketProgressMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BucketId != 0 { + n += 1 + sovManage(uint64(m.BucketId)) + } + if m.SubscribedBlockHeight != 0 { + n += 1 + sovManage(uint64(m.SubscribedBlockHeight)) + } + if m.MigrateState != 0 { + n += 1 + sovManage(uint64(m.MigrateState)) + } + if m.TotalGvgNum != 0 { + n += 1 + sovManage(uint64(m.TotalGvgNum)) + } + if m.MigratedFinishedGvgNum != 0 { + n += 1 + sovManage(uint64(m.MigratedFinishedGvgNum)) + } + if m.GcFinishedGvgNum != 0 { + n += 1 + sovManage(uint64(m.GcFinishedGvgNum)) + } + if m.PreDeductedQuota != 0 { + n += 1 + sovManage(uint64(m.PreDeductedQuota)) + } + if m.RecoupQuota != 0 { + n += 1 + sovManage(uint64(m.RecoupQuota)) + } + if m.LastGcObjectId != 0 { + n += 1 + sovManage(uint64(m.LastGcObjectId)) + } + if m.LastGcGvgId != 0 { + n += 1 + sovManage(uint64(m.LastGcGvgId)) + } + if m.MigratedBytes != 0 { + n += 1 + sovManage(uint64(m.MigratedBytes)) + } + return n +} + func (m *GfSpResetRecoveryFailedListRequest) Size() (n int) { if m == nil { return 0 @@ -5312,6 +5843,42 @@ func (m *GfSpNotifyPreMigrateBucketResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Quota", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthManage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthManage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Quota == nil { + m.Quota = &gfsptask.GfSpBucketQuotaInfo{} + } + if err := m.Quota.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipManage(dAtA[iNdEx:]) @@ -5503,6 +6070,42 @@ func (m *GfSpNotifyPostMigrateBucketResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Quota", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthManage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthManage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Quota == nil { + m.Quota = &gfsptask.GfSpBucketQuotaInfo{} + } + if err := m.Quota.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipManage(dAtA[iNdEx:]) @@ -5875,6 +6478,420 @@ func (m *TasksStats) Unmarshal(dAtA []byte) error { } return nil } +func (m *GfSpQueryBucketMigrationProgressRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GfSpQueryBucketMigrationProgressRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GfSpQueryBucketMigrationProgressRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketId", wireType) + } + m.BucketId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BucketId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipManage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthManage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GfSpQueryBucketMigrationProgressResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GfSpQueryBucketMigrationProgressResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GfSpQueryBucketMigrationProgressResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthManage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthManage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Progress == nil { + m.Progress = &MigrateBucketProgressMeta{} + } + if err := m.Progress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipManage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthManage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MigrateBucketProgressMeta) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MigrateBucketProgressMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MigrateBucketProgressMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketId", wireType) + } + m.BucketId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BucketId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SubscribedBlockHeight", wireType) + } + m.SubscribedBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SubscribedBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MigrateState", wireType) + } + m.MigrateState = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MigrateState |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalGvgNum", wireType) + } + m.TotalGvgNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalGvgNum |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MigratedFinishedGvgNum", wireType) + } + m.MigratedFinishedGvgNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MigratedFinishedGvgNum |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GcFinishedGvgNum", wireType) + } + m.GcFinishedGvgNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GcFinishedGvgNum |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PreDeductedQuota", wireType) + } + m.PreDeductedQuota = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PreDeductedQuota |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RecoupQuota", wireType) + } + m.RecoupQuota = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RecoupQuota |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastGcObjectId", wireType) + } + m.LastGcObjectId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LastGcObjectId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastGcGvgId", wireType) + } + m.LastGcGvgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LastGcGvgId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MigratedBytes", wireType) + } + m.MigratedBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MigratedBytes |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipManage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthManage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *GfSpResetRecoveryFailedListRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/base/types/gfspserver/query_task.pb.go b/base/types/gfspserver/query_task.pb.go index 20cf8178d..a7e7794ce 100644 --- a/base/types/gfspserver/query_task.pb.go +++ b/base/types/gfspserver/query_task.pb.go @@ -161,10 +161,12 @@ func (m *GfSpQueryBucketMigrateRequest) XXX_DiscardUnknown() { var xxx_messageInfo_GfSpQueryBucketMigrateRequest proto.InternalMessageInfo type GfSpBucketMigrate struct { - BucketName string `protobuf:"bytes,1,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` - BucketId uint64 `protobuf:"varint,2,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"` - Finished uint32 `protobuf:"varint,3,opt,name=finished,proto3" json:"finished,omitempty"` - GvgTask []*GfSpMigrateGVG `protobuf:"bytes,4,rep,name=gvg_task,json=gvgTask,proto3" json:"gvg_task,omitempty"` + BucketName string `protobuf:"bytes,1,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` + BucketId uint64 `protobuf:"varint,2,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"` + Finished uint32 `protobuf:"varint,3,opt,name=finished,proto3" json:"finished,omitempty"` + GvgTask []*GfSpMigrateGVG `protobuf:"bytes,4,rep,name=gvg_task,json=gvgTask,proto3" json:"gvg_task,omitempty"` + State uint32 `protobuf:"varint,5,opt,name=state,proto3" json:"state,omitempty"` + MigratedBytesSize uint64 `protobuf:"varint,6,opt,name=migrated_bytes_size,json=migratedBytesSize,proto3" json:"migrated_bytes_size,omitempty"` } func (m *GfSpBucketMigrate) Reset() { *m = GfSpBucketMigrate{} } @@ -228,6 +230,20 @@ func (m *GfSpBucketMigrate) GetGvgTask() []*GfSpMigrateGVG { return nil } +func (m *GfSpBucketMigrate) GetState() uint32 { + if m != nil { + return m.State + } + return 0 +} + +func (m *GfSpBucketMigrate) GetMigratedBytesSize() uint64 { + if m != nil { + return m.MigratedBytesSize + } + return 0 +} + type GfSpMigrateGVG struct { DestGvgId uint32 `protobuf:"varint,1,opt,name=dest_gvg_id,json=destGvgId,proto3" json:"dest_gvg_id,omitempty"` SrcGvgId uint32 `protobuf:"varint,2,opt,name=src_gvg_id,json=srcGvgId,proto3" json:"src_gvg_id,omitempty"` @@ -545,53 +561,55 @@ func init() { } var fileDescriptor_35e509f6e3771557 = []byte{ - // 727 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcb, 0x6e, 0xd3, 0x5a, - 0x14, 0x8d, 0x93, 0xdc, 0xde, 0xe4, 0xe4, 0xa6, 0xd5, 0x3d, 0xea, 0xc3, 0x0a, 0xe0, 0x1a, 0x4b, - 0x54, 0x19, 0x10, 0x47, 0x0a, 0x74, 0xc0, 0x0c, 0x55, 0x6d, 0xa3, 0xa8, 0x82, 0x0a, 0x07, 0x18, - 0x30, 0x31, 0x7e, 0x6c, 0xbb, 0x26, 0x89, 0xed, 0x9e, 0x73, 0x9c, 0x92, 0x0f, 0x40, 0x4c, 0xf9, - 0x01, 0xbe, 0x01, 0xf1, 0x0d, 0x4c, 0x18, 0x76, 0xc8, 0x10, 0xb5, 0x5f, 0xc1, 0x0c, 0x1d, 0xdb, - 0x49, 0xed, 0xf4, 0x89, 0xca, 0x28, 0xf1, 0x7e, 0xae, 0xbd, 0xd6, 0xf6, 0x36, 0xda, 0x30, 0x0d, - 0x0a, 0x6d, 0x36, 0x09, 0x81, 0xb6, 0x5d, 0x87, 0x86, 0x14, 0xc8, 0x18, 0x48, 0xfb, 0x30, 0x02, - 0x32, 0xd1, 0x99, 0x41, 0x07, 0x6a, 0x48, 0x02, 0x16, 0xe0, 0x15, 0x1e, 0xa7, 0xc6, 0x71, 0xea, - 0x59, 0x5c, 0xe3, 0xfe, 0x5c, 0x3a, 0x10, 0x12, 0x10, 0xda, 0x8e, 0x7f, 0x92, 0x4c, 0xe5, 0x09, - 0x5a, 0xe9, 0x3a, 0xfd, 0xf0, 0x05, 0xaf, 0xf8, 0xd2, 0xa0, 0x03, 0xaa, 0xc1, 0x61, 0x04, 0x94, - 0x61, 0x19, 0xfd, 0xc7, 0x1b, 0xe8, 0x34, 0x32, 0xf5, 0x01, 0x4c, 0x44, 0x41, 0x16, 0x9a, 0x55, - 0x0d, 0x71, 0x5b, 0x3f, 0x32, 0xf7, 0x60, 0xa2, 0x78, 0x68, 0x75, 0x3e, 0x95, 0x86, 0x81, 0x4f, - 0x01, 0x77, 0x50, 0x09, 0x08, 0x89, 0x53, 0x6a, 0x1d, 0x59, 0x9d, 0x03, 0x97, 0xa0, 0x50, 0x79, - 0xee, 0x0e, 0xff, 0xab, 0xf1, 0x60, 0x7c, 0x07, 0x55, 0xe3, 0x7e, 0x9e, 0xef, 0x04, 0x62, 0x51, - 0x2e, 0x35, 0xab, 0x5a, 0x85, 0x1b, 0x7a, 0xbe, 0x13, 0x28, 0xeb, 0xe8, 0xde, 0xac, 0xd5, 0x56, - 0x64, 0x0d, 0x80, 0x3d, 0xf3, 0x5c, 0x62, 0x30, 0x48, 0xd1, 0x2a, 0x5f, 0x04, 0xf4, 0x3f, 0x8f, - 0xc8, 0x39, 0xf1, 0x3a, 0xaa, 0x99, 0xb1, 0x41, 0xf7, 0x8d, 0x11, 0x4c, 0x47, 0x48, 0x4c, 0xcf, - 0x8d, 0x11, 0xf0, 0xa6, 0x69, 0x80, 0x67, 0x8b, 0x45, 0x59, 0x68, 0x96, 0xb5, 0x4a, 0x62, 0xe8, - 0xd9, 0xb8, 0x81, 0x2a, 0x8e, 0xe7, 0x7b, 0xf4, 0x00, 0x6c, 0xb1, 0x24, 0x0b, 0xcd, 0xba, 0x36, - 0x7b, 0xc6, 0x4f, 0x51, 0xc5, 0x1d, 0xbb, 0xb1, 0x04, 0x62, 0x59, 0x2e, 0x35, 0x6b, 0x9d, 0x07, - 0xea, 0x85, 0x1a, 0xc4, 0x63, 0xa6, 0x78, 0xba, 0xaf, 0xbb, 0xda, 0xbf, 0xee, 0xd8, 0xe5, 0x64, - 0x29, 0x9f, 0x05, 0xb4, 0x98, 0xf7, 0x61, 0x09, 0xd5, 0x6c, 0xa0, 0x4c, 0xe7, 0x95, 0x3d, 0x3b, - 0x86, 0x5b, 0xd7, 0xaa, 0xdc, 0xd4, 0x1d, 0xbb, 0x3d, 0x1b, 0xdf, 0x45, 0x88, 0x12, 0x6b, 0xea, - 0x2e, 0x26, 0x90, 0x28, 0xb1, 0x12, 0xef, 0x26, 0x5a, 0x1b, 0x1a, 0x94, 0xe9, 0xa3, 0xa4, 0xa0, - 0xad, 0x07, 0xe6, 0x3b, 0xb0, 0xe2, 0xc9, 0x4a, 0xf1, 0x64, 0xcb, 0xdc, 0x9d, 0xb6, 0xb3, 0xf7, - 0x63, 0x67, 0xcf, 0xc6, 0xab, 0x68, 0x81, 0x32, 0x83, 0x45, 0x54, 0x2c, 0xcb, 0x42, 0xf3, 0x1f, - 0x2d, 0x7d, 0x52, 0xbe, 0x09, 0x48, 0xba, 0x8c, 0xf3, 0x5b, 0xc8, 0xbc, 0x8f, 0x16, 0x53, 0xc6, - 0x53, 0x9c, 0xb1, 0xd6, 0xb5, 0x4e, 0xf3, 0x0a, 0xfa, 0xf2, 0xdd, 0xeb, 0x66, 0x4e, 0x63, 0x4e, - 0x0a, 0x0c, 0x1d, 0x9d, 0x86, 0xd3, 0x49, 0x39, 0x29, 0x30, 0x74, 0xfa, 0x61, 0xcf, 0x56, 0xc4, - 0xcc, 0x8e, 0xf6, 0xc3, 0x9d, 0xf7, 0x1e, 0x9b, 0x6e, 0xcc, 0x57, 0x01, 0xd5, 0xfa, 0x47, 0x46, - 0xb8, 0x1f, 0xb1, 0x57, 0xbe, 0x17, 0xef, 0x3b, 0x3d, 0x32, 0x42, 0x3d, 0x88, 0x58, 0x76, 0xdf, - 0x69, 0x12, 0xb2, 0x07, 0x93, 0x0c, 0x53, 0xc5, 0x2c, 0x53, 0x78, 0x03, 0x2d, 0xd1, 0xc8, 0xb2, - 0x80, 0xd2, 0x80, 0xe4, 0x60, 0xd4, 0x67, 0x66, 0x8e, 0xe5, 0x2f, 0xec, 0xcc, 0x2f, 0x01, 0xad, - 0x9d, 0x1b, 0xe7, 0x16, 0x62, 0x6c, 0x67, 0x66, 0xa6, 0xc4, 0x4a, 0xa5, 0x50, 0x2e, 0x41, 0x95, - 0x61, 0x6b, 0xc6, 0x4b, 0x9f, 0x58, 0x78, 0x17, 0xd5, 0x67, 0x55, 0xf8, 0xb2, 0x8a, 0xa5, 0x1b, - 0x97, 0xa9, 0xa5, 0x65, 0xb6, 0xf9, 0xc5, 0xc9, 0x2b, 0x59, 0xce, 0x2b, 0xd9, 0xf9, 0x50, 0x42, - 0xcb, 0xb9, 0x73, 0xd3, 0x07, 0x32, 0xf6, 0x2c, 0xc0, 0x41, 0xf2, 0x1e, 0x9d, 0x9d, 0x21, 0xfc, - 0xf0, 0x0a, 0x5a, 0xcf, 0x1d, 0xba, 0x46, 0xeb, 0x86, 0xd1, 0x09, 0xcf, 0x4a, 0x01, 0x7f, 0x14, - 0x32, 0x4b, 0x95, 0x3f, 0x38, 0x8f, 0xaf, 0xab, 0x75, 0xd1, 0xf1, 0x6a, 0x6c, 0xfe, 0x61, 0xd6, - 0x0c, 0x09, 0x41, 0x4b, 0x73, 0xeb, 0x80, 0xaf, 0x9d, 0x26, 0xf7, 0x16, 0x34, 0xd4, 0x9b, 0x86, - 0x4f, 0x7b, 0x6e, 0xbd, 0xfd, 0x7e, 0x22, 0x09, 0xc7, 0x27, 0x92, 0xf0, 0xf3, 0x44, 0x12, 0x3e, - 0x9d, 0x4a, 0x85, 0xe3, 0x53, 0xa9, 0xf0, 0xe3, 0x54, 0x2a, 0xbc, 0xd9, 0x75, 0x3d, 0x76, 0x10, - 0x99, 0xaa, 0x15, 0x8c, 0xda, 0xa6, 0x6f, 0xb6, 0xac, 0x03, 0xc3, 0xf3, 0xdb, 0x2e, 0x01, 0xf0, - 0x1d, 0x0f, 0x86, 0x76, 0x8b, 0xb2, 0x80, 0x18, 0x2e, 0xb4, 0x42, 0x12, 0x8c, 0x3d, 0x1b, 0x48, - 0xfb, 0xc2, 0xaf, 0x9b, 0xb9, 0x10, 0x7f, 0x99, 0x1e, 0xfd, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x07, - 0xbe, 0xfd, 0xdd, 0xfd, 0x06, 0x00, 0x00, + // 767 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x4d, 0x6f, 0xf3, 0x44, + 0x10, 0x8e, 0x93, 0xb4, 0x24, 0x1b, 0xf2, 0xbe, 0x7a, 0x97, 0xbe, 0xad, 0x15, 0xc0, 0x35, 0x96, + 0xa8, 0x72, 0x20, 0x8e, 0x14, 0xe8, 0x81, 0x1b, 0xaa, 0xda, 0x46, 0x51, 0x05, 0x15, 0x36, 0x70, + 0xe0, 0x62, 0xfc, 0x31, 0x76, 0x97, 0x24, 0xb6, 0xbb, 0xbb, 0x4e, 0x49, 0xef, 0x88, 0x2b, 0x7f, + 0x80, 0x1f, 0xc1, 0x6f, 0xe0, 0xc2, 0xb1, 0x47, 0x8e, 0xa8, 0xfd, 0x0d, 0x1c, 0xb8, 0xa1, 0x5d, + 0x3b, 0x69, 0x9c, 0x7e, 0xa2, 0x9e, 0x92, 0x9d, 0x79, 0x76, 0xe6, 0x99, 0x67, 0x66, 0xc7, 0x68, + 0xcf, 0x73, 0x19, 0xf4, 0xf9, 0x3c, 0x05, 0xd6, 0x8f, 0x42, 0x96, 0x32, 0xa0, 0x33, 0xa0, 0xfd, + 0xf3, 0x0c, 0xe8, 0xdc, 0xe1, 0x2e, 0x1b, 0x9b, 0x29, 0x4d, 0x78, 0x82, 0xdf, 0x0a, 0x9c, 0x29, + 0x71, 0xe6, 0x2d, 0xae, 0xf3, 0xd1, 0xda, 0x75, 0xa0, 0x34, 0xa1, 0xac, 0x2f, 0x7f, 0xf2, 0x9b, + 0xc6, 0xe7, 0xe8, 0xed, 0x30, 0xb4, 0xd3, 0xaf, 0x45, 0xc4, 0x6f, 0x5c, 0x36, 0x66, 0x16, 0x9c, + 0x67, 0xc0, 0x38, 0xd6, 0xd1, 0xbb, 0x22, 0x81, 0xc3, 0x32, 0xcf, 0x19, 0xc3, 0x5c, 0x55, 0x74, + 0xa5, 0xdb, 0xb4, 0x90, 0xb0, 0xd9, 0x99, 0x77, 0x02, 0x73, 0x83, 0xa0, 0xed, 0xf5, 0xab, 0x2c, + 0x4d, 0x62, 0x06, 0x78, 0x80, 0x6a, 0x40, 0xa9, 0xbc, 0xd2, 0x1a, 0xe8, 0xe6, 0x1a, 0xb9, 0x9c, + 0x85, 0x29, 0xee, 0x1e, 0x89, 0xbf, 0x96, 0x00, 0xe3, 0xf7, 0x51, 0x53, 0xe6, 0x23, 0x71, 0x98, + 0xa8, 0x55, 0xbd, 0xd6, 0x6d, 0x5a, 0x0d, 0x61, 0x18, 0xc5, 0x61, 0x62, 0xec, 0xa2, 0x0f, 0x97, + 0xa9, 0x0e, 0x32, 0x7f, 0x0c, 0xfc, 0x4b, 0x12, 0x51, 0x97, 0x43, 0xc1, 0xd6, 0xf8, 0x47, 0x41, + 0x6f, 0x04, 0xa2, 0xe4, 0xc4, 0xbb, 0xa8, 0xe5, 0x49, 0x83, 0x13, 0xbb, 0x53, 0x58, 0x94, 0x90, + 0x9b, 0xbe, 0x72, 0xa7, 0x20, 0x92, 0x16, 0x00, 0x12, 0xa8, 0x55, 0x5d, 0xe9, 0xd6, 0xad, 0x46, + 0x6e, 0x18, 0x05, 0xb8, 0x83, 0x1a, 0x21, 0x89, 0x09, 0x3b, 0x83, 0x40, 0xad, 0xe9, 0x4a, 0xb7, + 0x6d, 0x2d, 0xcf, 0xf8, 0x0b, 0xd4, 0x88, 0x66, 0x91, 0x6c, 0x81, 0x5a, 0xd7, 0x6b, 0xdd, 0xd6, + 0xe0, 0x63, 0xf3, 0xde, 0x1e, 0xc8, 0x32, 0x0b, 0x3e, 0xc3, 0xef, 0x86, 0xd6, 0x3b, 0xd1, 0x2c, + 0x12, 0x62, 0xe1, 0x2d, 0xb4, 0xc1, 0xb8, 0xcb, 0x41, 0xdd, 0x90, 0xa1, 0xf3, 0x03, 0x36, 0xd1, + 0x7b, 0xd3, 0x1c, 0x1c, 0x38, 0xde, 0x9c, 0x03, 0x73, 0x18, 0xb9, 0x04, 0x75, 0x53, 0x52, 0x7b, + 0xb3, 0x70, 0x1d, 0x08, 0x8f, 0x4d, 0x2e, 0xc1, 0xf8, 0x4d, 0x41, 0xaf, 0xca, 0x19, 0xb0, 0x86, + 0x5a, 0x01, 0x30, 0xee, 0x08, 0x7e, 0x24, 0x90, 0x45, 0xb7, 0xad, 0xa6, 0x30, 0x0d, 0x67, 0xd1, + 0x28, 0xc0, 0x1f, 0x20, 0xc4, 0xa8, 0xbf, 0x70, 0x57, 0xf3, 0xc2, 0x18, 0xf5, 0x73, 0xef, 0x3e, + 0xda, 0x99, 0xb8, 0x8c, 0x3b, 0x4b, 0x16, 0x89, 0xf7, 0x23, 0xf8, 0x52, 0x9f, 0x9a, 0x24, 0xb1, + 0x25, 0xdc, 0x45, 0xba, 0xe0, 0x54, 0x3a, 0x47, 0x01, 0xde, 0x46, 0x9b, 0xa2, 0x80, 0x8c, 0xa9, + 0x75, 0x5d, 0xe9, 0x6e, 0x58, 0xc5, 0xc9, 0xf8, 0x43, 0x41, 0xda, 0x43, 0x9d, 0x7b, 0xc1, 0xb0, + 0x9c, 0xa2, 0x57, 0x45, 0xdf, 0x0a, 0x9e, 0x72, 0x62, 0x5a, 0x83, 0xee, 0x23, 0x4d, 0x28, 0x67, + 0x6f, 0x7b, 0xa5, 0x49, 0x11, 0xa2, 0xc0, 0x24, 0x74, 0x58, 0xba, 0xa8, 0x54, 0x88, 0x02, 0x93, + 0xd0, 0x4e, 0x47, 0x81, 0xa1, 0xae, 0x4c, 0xba, 0x9d, 0x1e, 0xfd, 0x44, 0xf8, 0x62, 0xee, 0x7e, + 0x57, 0x50, 0xcb, 0xbe, 0x70, 0xd3, 0xd3, 0x8c, 0x7f, 0x1b, 0x13, 0xf9, 0x6a, 0xd8, 0x85, 0x9b, + 0x3a, 0x49, 0xc6, 0x57, 0x5f, 0x0d, 0xcb, 0x21, 0x27, 0x30, 0x5f, 0x51, 0xaa, 0xba, 0xaa, 0x14, + 0xde, 0x43, 0xaf, 0x59, 0xe6, 0xfb, 0xc0, 0x58, 0x42, 0x4b, 0x34, 0xda, 0x4b, 0xb3, 0xe0, 0xf2, + 0xf2, 0xc9, 0x33, 0xfe, 0x55, 0xd0, 0xce, 0x9d, 0x72, 0x5e, 0xd0, 0x8c, 0xc3, 0x95, 0x9a, 0x19, + 0xf5, 0x8b, 0x56, 0x18, 0x0f, 0xb0, 0x5a, 0x51, 0x6b, 0xa9, 0x8b, 0x4d, 0x7d, 0x7c, 0x8c, 0xda, + 0xcb, 0x28, 0x62, 0x58, 0xd5, 0xda, 0xb3, 0xc3, 0xb4, 0x8a, 0x30, 0x87, 0x62, 0x6f, 0x95, 0x3b, + 0x59, 0x2f, 0x77, 0x72, 0xf0, 0x73, 0x0d, 0x6d, 0x95, 0x96, 0x96, 0x0d, 0x74, 0x46, 0x7c, 0xc0, + 0x49, 0xfe, 0x8e, 0x6e, 0x97, 0x19, 0xfe, 0xe4, 0x11, 0x59, 0xef, 0xac, 0xcb, 0x4e, 0xef, 0x99, + 0xe8, 0x5c, 0x67, 0xa3, 0x82, 0x7f, 0x51, 0x56, 0x86, 0xaa, 0xbc, 0xb6, 0x3e, 0x7b, 0x2a, 0xd6, + 0x7d, 0x2b, 0xb0, 0xb3, 0xff, 0x3f, 0x6f, 0x2d, 0x99, 0x50, 0xf4, 0x7a, 0x6d, 0x1c, 0xf0, 0x93, + 0xd5, 0x94, 0x5e, 0x41, 0xc7, 0x7c, 0x2e, 0x7c, 0x91, 0xf3, 0xe0, 0x87, 0x3f, 0xaf, 0x35, 0xe5, + 0xea, 0x5a, 0x53, 0xfe, 0xbe, 0xd6, 0x94, 0x5f, 0x6f, 0xb4, 0xca, 0xd5, 0x8d, 0x56, 0xf9, 0xeb, + 0x46, 0xab, 0x7c, 0x7f, 0x1c, 0x11, 0x7e, 0x96, 0x79, 0xa6, 0x9f, 0x4c, 0xfb, 0x5e, 0xec, 0xf5, + 0xfc, 0x33, 0x97, 0xc4, 0xfd, 0x88, 0x02, 0xc4, 0x21, 0x81, 0x49, 0xd0, 0x63, 0x3c, 0xa1, 0x6e, + 0x04, 0xbd, 0x94, 0x26, 0x33, 0x12, 0x00, 0xed, 0xdf, 0xfb, 0x8d, 0xf4, 0x36, 0xe5, 0xf7, 0xed, + 0xd3, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x9e, 0x29, 0x2b, 0xef, 0x43, 0x07, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -863,6 +881,16 @@ func (m *GfSpBucketMigrate) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.MigratedBytesSize != 0 { + i = encodeVarintQueryTask(dAtA, i, uint64(m.MigratedBytesSize)) + i-- + dAtA[i] = 0x30 + } + if m.State != 0 { + i = encodeVarintQueryTask(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x28 + } if len(m.GvgTask) > 0 { for iNdEx := len(m.GvgTask) - 1; iNdEx >= 0; iNdEx-- { { @@ -1213,6 +1241,12 @@ func (m *GfSpBucketMigrate) Size() (n int) { n += 1 + l + sovQueryTask(uint64(l)) } } + if m.State != 0 { + n += 1 + sovQueryTask(uint64(m.State)) + } + if m.MigratedBytesSize != 0 { + n += 1 + sovQueryTask(uint64(m.MigratedBytesSize)) + } return n } @@ -1710,6 +1744,44 @@ func (m *GfSpBucketMigrate) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + m.State = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQueryTask + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.State |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MigratedBytesSize", wireType) + } + m.MigratedBytesSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQueryTask + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MigratedBytesSize |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipQueryTask(dAtA[iNdEx:]) diff --git a/base/types/gfsptask/migrate_gvg.go b/base/types/gfsptask/migrate_gvg.go index c4c5bd2ee..d7ec28d73 100644 --- a/base/types/gfsptask/migrate_gvg.go +++ b/base/types/gfsptask/migrate_gvg.go @@ -373,3 +373,34 @@ func (m *GfSpGCBucketMigrationTask) GetBucketID() uint64 { func (m *GfSpGCBucketMigrationTask) SetBucketID(bucketID uint64) { m.BucketId = bucketID } + +func (m *GfSpGCBucketMigrationTask) SetLastGCObjectID(lastGcObjectId uint64) { + m.LastGcObjectId = lastGcObjectId +} + +func (m *GfSpGCBucketMigrationTask) GetLastGCObjectID() uint64 { + return m.GetLastGcObjectId() +} + +func (m *GfSpGCBucketMigrationTask) SetLastGCGvgID(lastGcGvgID uint64) { + m.LastGcGvgId = lastGcGvgID +} + +func (m *GfSpGCBucketMigrationTask) GetLastGCGvgID() uint64 { + return m.GetLastGcGvgId() +} + +func (m *GfSpGCBucketMigrationTask) SetFinished(finished bool) { + m.Finished = finished +} + +func (m *GfSpGCBucketMigrationTask) SetTotalGvgNum(gvgNum uint64) { + m.TotalGvgNum = gvgNum +} + +func (m *GfSpGCBucketMigrationTask) GetGCFinishedGvgNum() uint64 { + return m.GetGcFinishedGvgNum() +} +func (m *GfSpGCBucketMigrationTask) SetGCFinishedGvgNum(gvgGcNum uint64) { + m.GcFinishedGvgNum = gvgGcNum +} diff --git a/base/types/gfsptask/task.pb.go b/base/types/gfsptask/task.pb.go index e1b3b06d0..1b1ad6d92 100644 --- a/base/types/gfsptask/task.pb.go +++ b/base/types/gfsptask/task.pb.go @@ -1759,8 +1759,14 @@ func (m *GfSpMigratePieceTask) GetIsBucketMigrate() bool { } type GfSpGCBucketMigrationTask struct { - Task *GfSpTask `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"` - BucketId uint64 `protobuf:"varint,2,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"` + Task *GfSpTask `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"` + BucketId uint64 `protobuf:"varint,2,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"` + LastGcObjectId uint64 `protobuf:"varint,3,opt,name=last_gc_object_id,json=lastGcObjectId,proto3" json:"last_gc_object_id,omitempty"` + LastGcGvgId uint64 `protobuf:"varint,4,opt,name=last_gc_gvg_id,json=lastGcGvgId,proto3" json:"last_gc_gvg_id,omitempty"` + // whether the gc of bucket migration succeed + Finished bool `protobuf:"varint,5,opt,name=finished,proto3" json:"finished,omitempty"` + TotalGvgNum uint64 `protobuf:"varint,6,opt,name=total_gvg_num,json=totalGvgNum,proto3" json:"total_gvg_num,omitempty"` + GcFinishedGvgNum uint64 `protobuf:"varint,7,opt,name=gc_finished_gvg_num,json=gcFinishedGvgNum,proto3" json:"gc_finished_gvg_num,omitempty"` } func (m *GfSpGCBucketMigrationTask) Reset() { *m = GfSpGCBucketMigrationTask{} } @@ -1810,6 +1816,41 @@ func (m *GfSpGCBucketMigrationTask) GetBucketId() uint64 { return 0 } +func (m *GfSpGCBucketMigrationTask) GetLastGcObjectId() uint64 { + if m != nil { + return m.LastGcObjectId + } + return 0 +} + +func (m *GfSpGCBucketMigrationTask) GetLastGcGvgId() uint64 { + if m != nil { + return m.LastGcGvgId + } + return 0 +} + +func (m *GfSpGCBucketMigrationTask) GetFinished() bool { + if m != nil { + return m.Finished + } + return false +} + +func (m *GfSpGCBucketMigrationTask) GetTotalGvgNum() uint64 { + if m != nil { + return m.TotalGvgNum + } + return 0 +} + +func (m *GfSpGCBucketMigrationTask) GetGcFinishedGvgNum() uint64 { + if m != nil { + return m.GcFinishedGvgNum + } + return 0 +} + type GfSpBucketMigrationInfo struct { BucketId uint64 `protobuf:"varint,1,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"` // whether the migrate bucket succeed @@ -2037,135 +2078,140 @@ func init() { func init() { proto.RegisterFile("base/types/gfsptask/task.proto", fileDescriptor_0d22df708e229306) } var fileDescriptor_0d22df708e229306 = []byte{ - // 2041 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x1c, 0x49, - 0x15, 0xcf, 0x7c, 0xcf, 0xbc, 0x99, 0x71, 0x9c, 0xce, 0x24, 0x99, 0x7c, 0x8d, 0x9d, 0x36, 0x59, - 0x19, 0xd8, 0xcc, 0xec, 0x7a, 0x15, 0x71, 0x8c, 0xfc, 0xb1, 0xeb, 0xb5, 0x20, 0x9b, 0x6c, 0x3b, - 0xec, 0x61, 0x0f, 0xb4, 0x6a, 0xba, 0xdf, 0xf4, 0x34, 0xee, 0xe9, 0x6e, 0xaa, 0x7b, 0x1c, 0x3b, - 0x67, 0x24, 0x8e, 0x20, 0x2e, 0xdc, 0x38, 0x73, 0x45, 0x42, 0xdc, 0x38, 0x21, 0xad, 0x90, 0xe0, - 0xb0, 0x47, 0x24, 0x2e, 0xab, 0x84, 0x0b, 0xff, 0x05, 0xaa, 0x57, 0xd5, 0x1f, 0x33, 0x19, 0x1b, - 0x27, 0x31, 0x90, 0x20, 0x2e, 0xf6, 0xd4, 0xfb, 0xbd, 0xaa, 0x7a, 0xf5, 0xbe, 0xab, 0x1a, 0x7a, - 0x43, 0x16, 0xe1, 0x20, 0x3e, 0x0e, 0x31, 0x1a, 0x38, 0xa3, 0x28, 0x8c, 0x59, 0x74, 0x30, 0x10, - 0x7f, 0xfa, 0x21, 0x0f, 0xe2, 0x40, 0xbb, 0x2c, 0xf0, 0x3e, 0xe1, 0xfd, 0x04, 0xbf, 0x71, 0x67, - 0x6e, 0x12, 0x72, 0x1e, 0xf0, 0x68, 0x40, 0xff, 0xe4, 0xbc, 0x1b, 0xd7, 0x1d, 0x8e, 0xe8, 0x8f, - 0x5c, 0xf4, 0xec, 0x41, 0x14, 0x4a, 0x5e, 0x05, 0xad, 0xe4, 0xa1, 0x38, 0xe0, 0xcc, 0xc1, 0x41, - 0xc8, 0x38, 0x9b, 0x24, 0x0c, 0x37, 0x17, 0x30, 0xc4, 0x47, 0x0a, 0xec, 0x2d, 0x02, 0x73, 0xab, - 0xaf, 0xe5, 0xf0, 0x43, 0x97, 0xc7, 0x53, 0xe6, 0x39, 0x3c, 0x98, 0xce, 0x88, 0xa0, 0xff, 0xb1, - 0x08, 0xf5, 0xdd, 0xd1, 0x7e, 0xf8, 0x84, 0x45, 0x07, 0x5a, 0x17, 0x6a, 0xcc, 0xb6, 0x39, 0x46, - 0x51, 0xb7, 0xb0, 0x5a, 0x58, 0x6f, 0x18, 0xc9, 0x50, 0x5b, 0x81, 0xa6, 0xc5, 0x91, 0xc5, 0x68, - 0xc6, 0xee, 0x04, 0xbb, 0xc5, 0xd5, 0xc2, 0x7a, 0xc9, 0x00, 0x49, 0x7a, 0xe2, 0x4e, 0x50, 0x30, - 0x4c, 0x43, 0x3b, 0x65, 0x28, 0x49, 0x06, 0x49, 0x22, 0x86, 0x2e, 0xd4, 0x04, 0x12, 0x4c, 0xe3, - 0x6e, 0x99, 0xc0, 0x64, 0xa8, 0xad, 0x41, 0x5b, 0xe8, 0xd2, 0x0c, 0xb9, 0x1b, 0x70, 0x37, 0x3e, - 0xee, 0x56, 0x56, 0x0b, 0xeb, 0x15, 0xa3, 0x25, 0x88, 0x8f, 0x15, 0x4d, 0xeb, 0x40, 0x85, 0x63, - 0xcc, 0x8f, 0xbb, 0x55, 0x9a, 0x2c, 0x07, 0xda, 0x4d, 0x68, 0x4c, 0xd8, 0x91, 0x29, 0x91, 0x1a, - 0x21, 0xf5, 0x09, 0x3b, 0x32, 0x08, 0xbc, 0x03, 0xad, 0x69, 0x84, 0xdc, 0x4c, 0x8e, 0x54, 0xa7, - 0x23, 0x35, 0x05, 0x6d, 0x53, 0x1d, 0x4b, 0x83, 0xb2, 0x17, 0x38, 0x51, 0xb7, 0x41, 0x10, 0xfd, - 0xd6, 0x36, 0xa0, 0x84, 0x9c, 0x77, 0x61, 0xb5, 0xb0, 0xde, 0xdc, 0x58, 0xed, 0xcf, 0x59, 0x5d, - 0x1a, 0xb8, 0x2f, 0x54, 0xf6, 0xb1, 0xf8, 0x69, 0x08, 0x66, 0xfd, 0xab, 0x02, 0xdc, 0x12, 0xa4, - 0x6d, 0x52, 0xc8, 0xd6, 0xd4, 0x3a, 0xc0, 0x78, 0x33, 0x0c, 0x79, 0x70, 0xc8, 0x3c, 0xd2, 0xec, - 0x87, 0x50, 0x16, 0xc7, 0x21, 0xb5, 0x36, 0x37, 0x6e, 0xf7, 0x17, 0xf8, 0x52, 0x3f, 0x31, 0x83, - 0x41, 0xac, 0xda, 0xe7, 0xa0, 0x29, 0x95, 0x0f, 0x69, 0x3d, 0xd3, 0xf5, 0x47, 0x01, 0x69, 0xbe, - 0xb9, 0xb1, 0xd6, 0xcf, 0x6c, 0xdb, 0x57, 0xb6, 0xef, 0x3f, 0x8c, 0x9c, 0xfc, 0xfe, 0xc6, 0xb2, - 0x95, 0x1b, 0xed, 0xf9, 0xa3, 0x40, 0x5b, 0x85, 0xe6, 0xc8, 0xf5, 0x1d, 0xe4, 0x21, 0x77, 0xfd, - 0x98, 0x8c, 0xd4, 0x32, 0xf2, 0x24, 0xfd, 0x37, 0x05, 0xb8, 0x2d, 0xe4, 0x78, 0xe8, 0x3a, 0xfc, - 0xdc, 0x4e, 0xf2, 0x04, 0x2e, 0x4f, 0xe4, 0x7a, 0x0b, 0x8e, 0xf2, 0xad, 0x13, 0x8e, 0x32, 0x23, - 0x81, 0x71, 0x69, 0x92, 0x1f, 0x8a, 0xc3, 0xcc, 0xe9, 0xfc, 0xd1, 0xf0, 0xc7, 0x68, 0x9d, 0xa3, - 0xce, 0x03, 0x5a, 0xef, 0xec, 0x3a, 0x97, 0xfb, 0x27, 0x3a, 0x97, 0xa3, 0x33, 0xea, 0xfc, 0x0f, - 0x65, 0xe8, 0x09, 0x39, 0x0c, 0x0c, 0x3d, 0xd7, 0x62, 0x31, 0x3e, 0x76, 0xd1, 0xc2, 0x37, 0x3d, - 0xca, 0x03, 0x68, 0xbe, 0x7c, 0x86, 0xde, 0xa2, 0x33, 0x64, 0xc2, 0x1a, 0x10, 0x64, 0x82, 0x6f, - 0xc2, 0x92, 0xe2, 0x30, 0x65, 0x4e, 0x22, 0xd9, 0x9b, 0x1b, 0x37, 0x16, 0xad, 0xf1, 0x98, 0x38, - 0x8c, 0xb6, 0x1a, 0xcb, 0xa1, 0x76, 0x1f, 0xae, 0x89, 0xc0, 0x8e, 0x42, 0x33, 0x08, 0x91, 0xb3, - 0x38, 0xc8, 0x82, 0xb1, 0x4c, 0x11, 0xd7, 0x61, 0xd1, 0xc1, 0x7e, 0xf8, 0x48, 0x81, 0x49, 0x54, - 0xae, 0x41, 0x9b, 0xa6, 0xb9, 0x8e, 0xcf, 0xe2, 0x29, 0x47, 0x4a, 0x08, 0x2d, 0xa3, 0x25, 0x98, - 0x13, 0x9a, 0xf6, 0x01, 0x74, 0x18, 0xa9, 0x08, 0x6d, 0xb1, 0x01, 0xfa, 0x76, 0x18, 0x08, 0x05, - 0x57, 0x69, 0x61, 0x2d, 0xc1, 0xf6, 0xc3, 0x8f, 0x15, 0xa2, 0x3d, 0x80, 0x5b, 0xf9, 0x19, 0x2f, - 0x89, 0x54, 0xa3, 0x99, 0xd7, 0xb3, 0x99, 0xf3, 0x72, 0xdd, 0x03, 0x2d, 0x5b, 0x20, 0x15, 0xae, - 0x4e, 0xc2, 0x5d, 0x4a, 0xa7, 0xa5, 0x12, 0xce, 0xed, 0xc7, 0x94, 0x41, 0xd3, 0xfd, 0x1a, 0xf3, - 0xfb, 0x25, 0x26, 0x4f, 0xf6, 0xbb, 0x0b, 0x4b, 0x78, 0x14, 0xba, 0x1c, 0x6d, 0x73, 0x8c, 0xae, - 0x33, 0x8e, 0x29, 0x29, 0x95, 0x8d, 0xb6, 0xa2, 0x7e, 0x4a, 0x44, 0xfd, 0xa7, 0x45, 0xe8, 0x08, - 0xe3, 0xff, 0x30, 0xf4, 0x02, 0x66, 0x4b, 0x6b, 0xbe, 0xae, 0xd7, 0xdc, 0x87, 0x6b, 0xaa, 0x54, - 0x98, 0x54, 0x2b, 0xcc, 0x11, 0x9b, 0xb8, 0xde, 0xb1, 0xe9, 0xda, 0xe4, 0x41, 0x6d, 0xa3, 0xa3, - 0xe0, 0x5d, 0x81, 0x7e, 0x42, 0xe0, 0x9e, 0x3d, 0xef, 0x6c, 0xa5, 0x73, 0x70, 0xb6, 0xf2, 0x2b, - 0x3a, 0x9b, 0xfe, 0xb7, 0xa2, 0x4c, 0x5d, 0x06, 0x46, 0xd3, 0x09, 0x1b, 0x7a, 0x78, 0x1e, 0xfa, - 0x78, 0x1b, 0xa2, 0xe8, 0x2a, 0x54, 0x83, 0xd1, 0x28, 0x42, 0x59, 0x38, 0xcb, 0x86, 0x1a, 0x09, - 0xba, 0x87, 0xbe, 0x13, 0x8f, 0x29, 0x3e, 0xca, 0x86, 0x1a, 0x69, 0xb7, 0xa0, 0x61, 0x05, 0x93, - 0xd0, 0xc3, 0x18, 0x6d, 0x0a, 0x87, 0xba, 0x91, 0x11, 0x4e, 0xb3, 0x70, 0xed, 0x64, 0x0b, 0xeb, - 0x7f, 0x2f, 0xc1, 0xd5, 0x97, 0x93, 0xd4, 0xbb, 0xac, 0xd6, 0x01, 0x5c, 0x8e, 0xd0, 0x0a, 0x7c, - 0x9b, 0xf1, 0xe3, 0x24, 0x26, 0x51, 0xf8, 0x5d, 0x49, 0xe4, 0x8f, 0x14, 0xda, 0x4c, 0x10, 0xed, - 0x43, 0xe8, 0x64, 0x13, 0xd2, 0xf8, 0x8f, 0xba, 0x95, 0xd5, 0xd2, 0x7a, 0xcb, 0xc8, 0x16, 0x4b, - 0x33, 0x00, 0x99, 0x2e, 0x42, 0xe6, 0xa5, 0x76, 0x50, 0x23, 0x61, 0x04, 0xc7, 0x0b, 0x86, 0xcc, - 0x33, 0x67, 0x6d, 0x91, 0x19, 0x41, 0xc2, 0x5f, 0xe4, 0x4c, 0xb1, 0x67, 0xcf, 0x8a, 0x9c, 0x64, - 0x3c, 0xd1, 0xd8, 0xcc, 0x8a, 0x9c, 0x64, 0x3c, 0x71, 0xc6, 0x8e, 0x1f, 0xc4, 0x26, 0x3b, 0x64, - 0xae, 0x27, 0x42, 0x42, 0xe4, 0x21, 0xd7, 0x3e, 0xa2, 0xd4, 0x53, 0x31, 0x2e, 0xf9, 0x41, 0xbc, - 0x99, 0x40, 0xfb, 0xe1, 0x9e, 0x7d, 0xa4, 0x7f, 0xa3, 0x72, 0x89, 0x81, 0x56, 0x70, 0x88, 0xfc, - 0x9d, 0x37, 0xf2, 0x0a, 0x34, 0x23, 0x74, 0x26, 0xe8, 0xc7, 0x74, 0xee, 0x32, 0x29, 0x17, 0x14, - 0x69, 0xcf, 0x3e, 0xd2, 0xae, 0x40, 0x15, 0x2d, 0xc2, 0x64, 0xd7, 0x59, 0x41, 0x4b, 0x90, 0x6f, - 0x03, 0x84, 0xe2, 0xec, 0x66, 0xe4, 0x3e, 0x43, 0x32, 0x5e, 0xd9, 0x68, 0x10, 0x65, 0xdf, 0x7d, - 0x86, 0x22, 0xc4, 0xb2, 0x02, 0x50, 0xa3, 0x02, 0x90, 0x11, 0x04, 0xca, 0xa5, 0xfe, 0xd0, 0xa6, - 0xf2, 0x50, 0x37, 0x32, 0x82, 0xfe, 0xf3, 0x72, 0xaa, 0x62, 0x74, 0x0f, 0xf1, 0x7f, 0x5f, 0xc5, - 0x77, 0x61, 0x89, 0xa3, 0x3d, 0xf5, 0x6d, 0xe6, 0x5b, 0xc7, 0x39, 0x55, 0xb7, 0x33, 0xea, 0x62, - 0x95, 0x97, 0xf2, 0x2a, 0xbf, 0x0b, 0x4b, 0x12, 0xb6, 0xc6, 0x68, 0x1d, 0x44, 0xd3, 0x89, 0xd2, - 0x7b, 0x9b, 0xa8, 0xdb, 0x8a, 0x38, 0x6b, 0x99, 0xfa, 0xbc, 0x65, 0xb2, 0x78, 0x6c, 0xcc, 0xc4, - 0xe3, 0x0d, 0xa8, 0x8f, 0x5c, 0xdf, 0x8d, 0xc6, 0x68, 0x53, 0x8d, 0xad, 0x1b, 0xe9, 0xf8, 0xb4, - 0x58, 0x6d, 0x9e, 0x12, 0xab, 0xdf, 0x86, 0x65, 0xd5, 0xec, 0xca, 0xd6, 0xd5, 0x0d, 0xfc, 0x6e, - 0x8b, 0x96, 0xbe, 0x28, 0xe9, 0x0f, 0x13, 0xb2, 0xfe, 0xab, 0x12, 0x68, 0xc2, 0xb0, 0xfb, 0xc8, - 0xbc, 0x77, 0xbf, 0x5c, 0xfd, 0x27, 0xf2, 0xea, 0x29, 0x36, 0xa9, 0xbe, 0x7a, 0xfe, 0xac, 0x9d, - 0x94, 0x3f, 0xf5, 0xdf, 0x17, 0x65, 0xd5, 0xdb, 0x09, 0x9e, 0xfa, 0x6f, 0x41, 0x33, 0xf1, 0x00, - 0x9a, 0xf9, 0x0b, 0xd4, 0x29, 0x6d, 0x56, 0x76, 0x4f, 0x32, 0x60, 0x98, 0x5d, 0x00, 0xdf, 0xbc, - 0xcd, 0xd2, 0x96, 0xa1, 0xe4, 0x05, 0x4f, 0x29, 0x84, 0x4b, 0x86, 0xf8, 0x29, 0x2e, 0xd1, 0x63, - 0xd7, 0x19, 0xab, 0x90, 0xa5, 0xdf, 0xfa, 0xef, 0x4a, 0x70, 0x25, 0xaf, 0xb8, 0xff, 0x6e, 0x96, - 0x7b, 0x1b, 0xf4, 0x76, 0x07, 0x5a, 0xe8, 0x53, 0x0d, 0xa6, 0x04, 0x46, 0x0a, 0xac, 0x1b, 0x4d, - 0x49, 0xa3, 0xf4, 0x25, 0x32, 0x60, 0x1c, 0xc4, 0xcc, 0x9b, 0x29, 0x3a, 0x44, 0xa1, 0x0c, 0x78, - 0x13, 0x64, 0x3a, 0x34, 0x0f, 0xf0, 0x58, 0x5d, 0x56, 0xea, 0x44, 0xf8, 0x3e, 0xd2, 0x63, 0x87, - 0x04, 0x55, 0xab, 0x58, 0xa7, 0xd9, 0x4d, 0xa2, 0x3d, 0x92, 0xfd, 0x62, 0xca, 0xa2, 0xba, 0xc6, - 0x46, 0x8e, 0xe5, 0x07, 0x44, 0xd2, 0xbf, 0x52, 0x5d, 0xde, 0xf6, 0x98, 0x79, 0x82, 0x0b, 0xff, - 0x6f, 0xb7, 0xb9, 0xf2, 0x56, 0x39, 0x43, 0x79, 0xab, 0x2e, 0x2a, 0x6f, 0x77, 0x61, 0xc9, 0xf5, - 0x63, 0x74, 0xb8, 0x1b, 0x1f, 0x9b, 0x63, 0x16, 0x8d, 0x93, 0xfa, 0x95, 0x52, 0x3f, 0x65, 0xd1, - 0x38, 0xab, 0x82, 0xc4, 0x52, 0xa7, 0x14, 0x28, 0xcd, 0x4e, 0xf0, 0x7b, 0x70, 0x51, 0xc2, 0x36, - 0x8b, 0x99, 0xf4, 0x93, 0x06, 0x85, 0x9d, 0x2c, 0x83, 0x3b, 0x2c, 0x66, 0xc2, 0x57, 0xf4, 0x5f, - 0x17, 0x61, 0x59, 0x58, 0x63, 0x77, 0xfb, 0xcd, 0x52, 0xd6, 0xfb, 0xa0, 0x45, 0x31, 0xe3, 0xb1, - 0x39, 0xf4, 0x02, 0xeb, 0xc0, 0xf4, 0xa7, 0x93, 0x21, 0x72, 0xb2, 0x64, 0xd9, 0x58, 0x26, 0x64, - 0x4b, 0x00, 0x9f, 0x11, 0x5d, 0x5b, 0x87, 0x65, 0xf4, 0xed, 0x59, 0xde, 0x12, 0xf1, 0x2e, 0xa1, - 0x6f, 0xe7, 0x39, 0x3f, 0x80, 0x8e, 0x35, 0xe5, 0x5c, 0x68, 0x75, 0x86, 0x5b, 0xde, 0x70, 0x34, - 0x85, 0xe5, 0x67, 0x7c, 0x04, 0x57, 0x3d, 0x16, 0xc5, 0xa6, 0x8d, 0x74, 0x8f, 0x49, 0x1f, 0x68, - 0x6c, 0x75, 0xfb, 0xb9, 0x2c, 0xd0, 0x1d, 0x09, 0x2a, 0x77, 0xb2, 0xb5, 0x2e, 0xd4, 0xf8, 0xd4, - 0xf7, 0x5d, 0xdf, 0x51, 0x0d, 0x78, 0x32, 0xd4, 0xff, 0x52, 0x90, 0x09, 0x6a, 0x77, 0xfb, 0xcb, - 0x60, 0x32, 0x74, 0xdf, 0xcc, 0xd1, 0x73, 0xdb, 0x14, 0x67, 0xb6, 0x11, 0xf6, 0x92, 0xfa, 0xcb, - 0xc4, 0x95, 0x0a, 0x69, 0x13, 0x39, 0x15, 0x54, 0x87, 0xb6, 0xd0, 0x5c, 0xc6, 0x25, 0x15, 0xd1, - 0x44, 0x3f, 0x3b, 0x4c, 0xbe, 0x49, 0xa9, 0xcc, 0x36, 0x29, 0xfa, 0xcf, 0x0a, 0xb0, 0x24, 0x8f, - 0xf3, 0x10, 0x63, 0xf6, 0xba, 0xe7, 0x58, 0x81, 0x66, 0x62, 0x15, 0xe1, 0xc7, 0xd2, 0xcc, 0xa0, - 0x48, 0xc2, 0x89, 0xef, 0x40, 0x4b, 0xea, 0xdf, 0xb4, 0x82, 0xa9, 0x7a, 0xcd, 0x2a, 0x1b, 0x4d, - 0x49, 0xdb, 0x16, 0x24, 0xfd, 0x97, 0x65, 0xd9, 0xcc, 0xa8, 0xf7, 0xbb, 0xdd, 0x2f, 0x76, 0x5f, - 0x57, 0x9a, 0x9b, 0xd0, 0x48, 0xa2, 0xdf, 0x56, 0xb2, 0xd4, 0x55, 0x6c, 0xdb, 0xda, 0x0e, 0xd4, - 0x22, 0x6e, 0x99, 0xce, 0xa1, 0xa3, 0xd2, 0xc2, 0x77, 0xf3, 0x21, 0x9d, 0x7f, 0xee, 0xee, 0xef, - 0xbe, 0xd4, 0x0a, 0x18, 0xd5, 0x88, 0x5b, 0xbb, 0x87, 0x8e, 0xf6, 0x09, 0xd4, 0x6d, 0x8c, 0x62, - 0x5a, 0xa6, 0xfc, 0xea, 0xcb, 0xd4, 0xc4, 0x64, 0xb1, 0xce, 0x19, 0x5b, 0xdc, 0xfb, 0x20, 0x36, - 0x36, 0xa3, 0x90, 0xbc, 0x71, 0x3e, 0x95, 0x85, 0xfd, 0x7d, 0x95, 0x79, 0x78, 0x70, 0xe8, 0xda, - 0xc8, 0x8d, 0x4a, 0xc4, 0xad, 0xfd, 0x50, 0x74, 0x3b, 0xe4, 0xfa, 0xea, 0x0d, 0x34, 0xef, 0x26, - 0x35, 0x52, 0x4b, 0x47, 0xc0, 0x4a, 0xe1, 0x8b, 0xfd, 0xa5, 0x3e, 0xd7, 0xd4, 0xae, 0x40, 0x53, - 0x3e, 0x22, 0xc9, 0xe7, 0x7a, 0x99, 0x43, 0x40, 0x92, 0xe8, 0xb9, 0x7e, 0xa6, 0x8f, 0x86, 0xf9, - 0x3e, 0xba, 0x9f, 0xbe, 0xe8, 0xda, 0xe6, 0xf0, 0x38, 0xc6, 0x48, 0xa6, 0xa2, 0x26, 0x49, 0x93, - 0xbc, 0xd5, 0xda, 0x5b, 0x02, 0xa1, 0x74, 0xf4, 0x0f, 0x75, 0xad, 0x54, 0x32, 0xbe, 0xf3, 0x77, - 0x1e, 0x11, 0xd6, 0x64, 0xc8, 0xec, 0xdd, 0x51, 0x3e, 0x68, 0xb6, 0xc9, 0x62, 0xe9, 0x93, 0xe3, - 0x79, 0x15, 0x8f, 0xef, 0xc0, 0x25, 0x37, 0x32, 0x67, 0xee, 0x13, 0xf2, 0xde, 0x59, 0x37, 0x2e, - 0xba, 0xd1, 0x56, 0xee, 0x3e, 0x81, 0xfa, 0x01, 0x5c, 0x97, 0x99, 0x60, 0x6b, 0xf6, 0x9a, 0xf1, - 0xef, 0x08, 0x43, 0xfd, 0xb7, 0x45, 0xb8, 0x26, 0xf8, 0xe7, 0xf6, 0x22, 0x3d, 0xcf, 0x4c, 0x2c, - 0xcc, 0xc5, 0x6f, 0xde, 0x39, 0x8b, 0x73, 0xce, 0x79, 0x82, 0x77, 0x95, 0x4e, 0xf0, 0x2e, 0xed, - 0x7b, 0x40, 0x81, 0x28, 0xe2, 0xaa, 0x7c, 0xa6, 0xb8, 0xaa, 0x0a, 0x76, 0x0a, 0xac, 0x24, 0x1e, - 0x2b, 0xaf, 0x12, 0x8f, 0x73, 0xc1, 0x53, 0x3d, 0x3d, 0x78, 0xe6, 0x9f, 0x07, 0xf4, 0x3f, 0x17, - 0xe1, 0x72, 0xa6, 0xb3, 0xcf, 0xa7, 0x41, 0xcc, 0xfe, 0xb5, 0xbe, 0x3a, 0x50, 0x99, 0x04, 0x7e, - 0x3c, 0x26, 0x65, 0x35, 0x0c, 0x39, 0x10, 0x92, 0xa8, 0x29, 0x3e, 0x53, 0x5f, 0xdd, 0x1a, 0x49, - 0x03, 0xf4, 0x19, 0x9b, 0xa0, 0xa8, 0xdf, 0x1c, 0x99, 0x6d, 0x5a, 0x81, 0x1f, 0x4d, 0x27, 0xf4, - 0x6e, 0xfd, 0x0c, 0x55, 0x71, 0x59, 0x16, 0xc8, 0xb6, 0x02, 0x94, 0x22, 0xbb, 0x23, 0x8e, 0x68, - 0xfe, 0x44, 0xc8, 0x34, 0x37, 0x47, 0x56, 0xd9, 0x2b, 0x02, 0x27, 0x91, 0x67, 0x26, 0xbe, 0x07, - 0x17, 0x73, 0x13, 0x73, 0xed, 0x6b, 0x3b, 0xe5, 0x27, 0xbe, 0xf7, 0x41, 0xb3, 0xc6, 0x8c, 0x3b, - 0x68, 0xe7, 0x59, 0x65, 0x12, 0x5b, 0x56, 0x48, 0xc6, 0xbd, 0x06, 0x6d, 0xe6, 0x79, 0xc1, 0xd3, - 0xd4, 0xe3, 0x65, 0x16, 0x6b, 0x11, 0x31, 0xf9, 0x3e, 0xf4, 0xa3, 0x3f, 0x3d, 0xef, 0x15, 0xbe, - 0x7e, 0xde, 0x2b, 0x7c, 0xf3, 0xbc, 0x57, 0xf8, 0xc5, 0x8b, 0xde, 0x85, 0xaf, 0x5f, 0xf4, 0x2e, - 0xfc, 0xf5, 0x45, 0xef, 0xc2, 0x97, 0x3b, 0x8e, 0x1b, 0x8f, 0xa7, 0xc3, 0xbe, 0x15, 0x4c, 0x06, - 0x43, 0x7f, 0x78, 0xcf, 0x1a, 0x33, 0xd7, 0x1f, 0x64, 0x16, 0xbe, 0xa7, 0x62, 0xfa, 0x5e, 0xa8, - 0xec, 0x3b, 0x58, 0xf0, 0x05, 0x78, 0x58, 0xa5, 0xef, 0xa4, 0x1f, 0xfd, 0x33, 0x00, 0x00, 0xff, - 0xff, 0xfe, 0xe0, 0xd5, 0xfb, 0x1f, 0x1e, 0x00, 0x00, + // 2113 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcb, 0x6f, 0x1c, 0x49, + 0x19, 0xdf, 0x79, 0xcf, 0x7c, 0x33, 0xe3, 0x38, 0xed, 0x49, 0x32, 0x79, 0x8d, 0x9d, 0x36, 0x59, + 0x79, 0x61, 0x3d, 0xb3, 0xeb, 0x55, 0xc4, 0x31, 0xf2, 0x63, 0x33, 0x6b, 0x41, 0x1e, 0xdb, 0x0e, + 0x7b, 0xd8, 0x03, 0xad, 0x9a, 0xee, 0x9a, 0x9e, 0xc6, 0xfd, 0xa2, 0xba, 0x7b, 0x62, 0xe7, 0x8c, + 0xc4, 0x11, 0xc4, 0x85, 0x1b, 0x67, 0xc4, 0x0d, 0x09, 0x71, 0xe3, 0x84, 0xb4, 0x42, 0x82, 0xc3, + 0x1e, 0x91, 0xb8, 0xac, 0x12, 0x2e, 0xfc, 0x17, 0xa8, 0xbe, 0xaa, 0x7e, 0xcc, 0x78, 0x6c, 0x9c, + 0xc4, 0x40, 0x82, 0xb8, 0x24, 0xae, 0xef, 0xf7, 0x55, 0xf5, 0x57, 0xdf, 0xe3, 0x57, 0x5f, 0xd5, + 0x40, 0x6f, 0x44, 0x42, 0x3a, 0x88, 0x8e, 0x03, 0x1a, 0x0e, 0xac, 0x71, 0x18, 0x44, 0x24, 0x3c, + 0x1c, 0xf0, 0x7f, 0xfa, 0x01, 0xf3, 0x23, 0x5f, 0x59, 0xe1, 0x78, 0x1f, 0xf1, 0x7e, 0x82, 0xdf, + 0xb8, 0x33, 0x37, 0x89, 0x32, 0xe6, 0xb3, 0x70, 0x80, 0xff, 0x89, 0x79, 0x37, 0xae, 0x5b, 0x8c, + 0x52, 0x6f, 0x6c, 0x53, 0xc7, 0x1c, 0x84, 0x81, 0xd0, 0x95, 0xd0, 0x6a, 0x1e, 0x8a, 0x7c, 0x46, + 0x2c, 0x3a, 0x08, 0x08, 0x23, 0x6e, 0xa2, 0x70, 0x73, 0x81, 0x42, 0x74, 0x24, 0xc1, 0xde, 0x22, + 0x30, 0xb7, 0xfa, 0x7a, 0x0e, 0x9f, 0xda, 0x2c, 0x8a, 0x89, 0x63, 0x31, 0x3f, 0x9e, 0x31, 0x41, + 0xfd, 0x63, 0x11, 0xea, 0xc3, 0xf1, 0x41, 0xf0, 0x94, 0x84, 0x87, 0x4a, 0x17, 0x6a, 0xc4, 0x34, + 0x19, 0x0d, 0xc3, 0x6e, 0x61, 0xad, 0xb0, 0xd1, 0xd0, 0x92, 0xa1, 0xb2, 0x0a, 0x4d, 0x83, 0x51, + 0x12, 0x51, 0x3d, 0xb2, 0x5d, 0xda, 0x2d, 0xae, 0x15, 0x36, 0x4a, 0x1a, 0x08, 0xd1, 0x53, 0xdb, + 0xa5, 0x5c, 0x21, 0x0e, 0xcc, 0x54, 0xa1, 0x24, 0x14, 0x84, 0x08, 0x15, 0xba, 0x50, 0xe3, 0x88, + 0x1f, 0x47, 0xdd, 0x32, 0x82, 0xc9, 0x50, 0x59, 0x87, 0x36, 0xf7, 0xa5, 0x1e, 0x30, 0xdb, 0x67, + 0x76, 0x74, 0xdc, 0xad, 0xac, 0x15, 0x36, 0x2a, 0x5a, 0x8b, 0x0b, 0x9f, 0x48, 0x99, 0xd2, 0x81, + 0x0a, 0xa3, 0x11, 0x3b, 0xee, 0x56, 0x71, 0xb2, 0x18, 0x28, 0x37, 0xa1, 0xe1, 0x92, 0x23, 0x5d, + 0x20, 0x35, 0x44, 0xea, 0x2e, 0x39, 0xd2, 0x10, 0xbc, 0x03, 0xad, 0x38, 0xa4, 0x4c, 0x4f, 0xb6, + 0x54, 0xc7, 0x2d, 0x35, 0xb9, 0x6c, 0x5b, 0x6e, 0x4b, 0x81, 0xb2, 0xe3, 0x5b, 0x61, 0xb7, 0x81, + 0x10, 0xfe, 0xad, 0x6c, 0x41, 0x89, 0x32, 0xd6, 0x85, 0xb5, 0xc2, 0x46, 0x73, 0x6b, 0xad, 0x3f, + 0x17, 0x75, 0x11, 0xe0, 0x3e, 0x77, 0xd9, 0xa7, 0xfc, 0x4f, 0x8d, 0x2b, 0xab, 0x5f, 0x15, 0xe0, + 0x16, 0x17, 0xed, 0xa2, 0x43, 0x76, 0x62, 0xe3, 0x90, 0x46, 0xdb, 0x41, 0xc0, 0xfc, 0x29, 0x71, + 0xd0, 0xb3, 0x1f, 0x43, 0x99, 0x6f, 0x07, 0xdd, 0xda, 0xdc, 0xba, 0xdd, 0x5f, 0x90, 0x4b, 0xfd, + 0x24, 0x0c, 0x1a, 0xaa, 0x2a, 0x9f, 0x83, 0x22, 0x5d, 0x3e, 0xc2, 0xf5, 0x74, 0xdb, 0x1b, 0xfb, + 0xe8, 0xf9, 0xe6, 0xd6, 0x7a, 0x3f, 0x8b, 0x6d, 0x5f, 0xc6, 0xbe, 0xff, 0x30, 0xb4, 0xf2, 0xdf, + 0xd7, 0x96, 0x8d, 0xdc, 0x68, 0xdf, 0x1b, 0xfb, 0xca, 0x1a, 0x34, 0xc7, 0xb6, 0x67, 0x51, 0x16, + 0x30, 0xdb, 0x8b, 0x30, 0x48, 0x2d, 0x2d, 0x2f, 0x52, 0x7f, 0x5d, 0x80, 0xdb, 0xdc, 0x8e, 0x87, + 0xb6, 0xc5, 0x2e, 0x6c, 0x27, 0x4f, 0x61, 0xc5, 0x15, 0xeb, 0x2d, 0xd8, 0xca, 0xb7, 0x4e, 0xd9, + 0xca, 0x8c, 0x05, 0xda, 0x65, 0x37, 0x3f, 0xe4, 0x9b, 0x99, 0xf3, 0xf9, 0xe3, 0xd1, 0x8f, 0xa8, + 0x71, 0x81, 0x3e, 0xf7, 0x71, 0xbd, 0xf3, 0xfb, 0x5c, 0x7c, 0x3f, 0xf1, 0xb9, 0x18, 0x9d, 0xd3, + 0xe7, 0x7f, 0x28, 0x43, 0x8f, 0xdb, 0xa1, 0xd1, 0xc0, 0xb1, 0x0d, 0x12, 0xd1, 0x27, 0x36, 0x35, + 0xe8, 0x9b, 0x6e, 0xe5, 0x3e, 0x34, 0x4f, 0xee, 0xa1, 0xb7, 0x68, 0x0f, 0x99, 0xb1, 0x1a, 0xf8, + 0x99, 0xe1, 0xdb, 0xb0, 0x24, 0x35, 0x74, 0xc1, 0x49, 0x68, 0x7b, 0x73, 0xeb, 0xc6, 0xa2, 0x35, + 0x9e, 0xa0, 0x86, 0xd6, 0x96, 0x63, 0x31, 0x54, 0xee, 0xc1, 0x35, 0x5e, 0xd8, 0x61, 0xa0, 0xfb, + 0x01, 0x65, 0x24, 0xf2, 0xb3, 0x62, 0x2c, 0x63, 0xc5, 0x75, 0x48, 0x78, 0x78, 0x10, 0x3c, 0x96, + 0x60, 0x52, 0x95, 0xeb, 0xd0, 0xc6, 0x69, 0xb6, 0xe5, 0x91, 0x28, 0x66, 0x14, 0x09, 0xa1, 0xa5, + 0xb5, 0xb8, 0x72, 0x22, 0x53, 0x3e, 0x82, 0x0e, 0x41, 0x17, 0x51, 0x93, 0x7f, 0x80, 0x7a, 0x66, + 0xe0, 0x73, 0x07, 0x57, 0x71, 0x61, 0x25, 0xc1, 0x0e, 0x82, 0x4f, 0x25, 0xa2, 0xdc, 0x87, 0x5b, + 0xf9, 0x19, 0x27, 0x4c, 0xaa, 0xe1, 0xcc, 0xeb, 0xd9, 0xcc, 0x79, 0xbb, 0x36, 0x41, 0xc9, 0x16, + 0x48, 0x8d, 0xab, 0xa3, 0x71, 0x97, 0xd3, 0x69, 0xa9, 0x85, 0x73, 0xdf, 0x23, 0x32, 0xa0, 0xe9, + 0xf7, 0x1a, 0xf3, 0xdf, 0x4b, 0x42, 0x9e, 0x7c, 0xef, 0x2e, 0x2c, 0xd1, 0xa3, 0xc0, 0x66, 0xd4, + 0xd4, 0x27, 0xd4, 0xb6, 0x26, 0x11, 0x92, 0x52, 0x59, 0x6b, 0x4b, 0xe9, 0x67, 0x28, 0x54, 0x7f, + 0x52, 0x84, 0x0e, 0x0f, 0xfe, 0x0f, 0x02, 0xc7, 0x27, 0xa6, 0x88, 0xe6, 0xeb, 0x66, 0xcd, 0x3d, + 0xb8, 0x26, 0x8f, 0x0a, 0x1d, 0xcf, 0x0a, 0x7d, 0x4c, 0x5c, 0xdb, 0x39, 0xd6, 0x6d, 0x13, 0x33, + 0xa8, 0xad, 0x75, 0x24, 0x3c, 0xe4, 0xe8, 0x03, 0x04, 0xf7, 0xcd, 0xf9, 0x64, 0x2b, 0x5d, 0x40, + 0xb2, 0x95, 0x5f, 0x31, 0xd9, 0xd4, 0xbf, 0x15, 0x05, 0x75, 0x69, 0x34, 0x8c, 0x5d, 0x32, 0x72, + 0xe8, 0x45, 0xf8, 0xe3, 0x6d, 0xa8, 0xa2, 0xab, 0x50, 0xf5, 0xc7, 0xe3, 0x90, 0x8a, 0x83, 0xb3, + 0xac, 0xc9, 0x11, 0x97, 0x3b, 0xd4, 0xb3, 0xa2, 0x09, 0xd6, 0x47, 0x59, 0x93, 0x23, 0xe5, 0x16, + 0x34, 0x0c, 0xdf, 0x0d, 0x1c, 0x1a, 0x51, 0x13, 0xcb, 0xa1, 0xae, 0x65, 0x82, 0xb3, 0x22, 0x5c, + 0x3b, 0x3d, 0xc2, 0xea, 0xdf, 0x4b, 0x70, 0xf5, 0x24, 0x49, 0xbd, 0xcb, 0x6e, 0x1d, 0xc0, 0x4a, + 0x48, 0x0d, 0xdf, 0x33, 0x09, 0x3b, 0x4e, 0x6a, 0x92, 0xf2, 0xbc, 0x2b, 0x71, 0xfe, 0x48, 0xa1, + 0xed, 0x04, 0x51, 0x3e, 0x86, 0x4e, 0x36, 0x21, 0xad, 0xff, 0xb0, 0x5b, 0x59, 0x2b, 0x6d, 0xb4, + 0xb4, 0x6c, 0xb1, 0x94, 0x01, 0x30, 0x74, 0x21, 0x25, 0x4e, 0x1a, 0x07, 0x39, 0xe2, 0x41, 0xb0, + 0x1c, 0x7f, 0x44, 0x1c, 0x7d, 0x36, 0x16, 0x59, 0x10, 0x04, 0xfc, 0x45, 0x2e, 0x14, 0xfb, 0xe6, + 0xac, 0xc9, 0x09, 0xe3, 0xf1, 0xc6, 0x66, 0xd6, 0xe4, 0x84, 0xf1, 0xf8, 0x1e, 0x3b, 0x9e, 0x1f, + 0xe9, 0x64, 0x4a, 0x6c, 0x87, 0x97, 0x04, 0xe7, 0x21, 0xdb, 0x3c, 0x42, 0xea, 0xa9, 0x68, 0x97, + 0x3d, 0x3f, 0xda, 0x4e, 0xa0, 0x83, 0x60, 0xdf, 0x3c, 0x52, 0xbf, 0x91, 0x5c, 0xa2, 0x51, 0xc3, + 0x9f, 0x52, 0xf6, 0xce, 0x07, 0x79, 0x15, 0x9a, 0x21, 0xb5, 0x5c, 0xea, 0x45, 0xb8, 0xef, 0x32, + 0x3a, 0x17, 0xa4, 0x68, 0xdf, 0x3c, 0x52, 0xae, 0x40, 0x95, 0x1a, 0x88, 0x89, 0xae, 0xb3, 0x42, + 0x0d, 0x2e, 0xbe, 0x0d, 0x10, 0xf0, 0xbd, 0xeb, 0xa1, 0xfd, 0x9c, 0x62, 0xf0, 0xca, 0x5a, 0x03, + 0x25, 0x07, 0xf6, 0x73, 0xca, 0x4b, 0x2c, 0x3b, 0x00, 0x6a, 0x78, 0x00, 0x64, 0x02, 0x8e, 0x32, + 0xe1, 0x3f, 0x6a, 0xe2, 0xf1, 0x50, 0xd7, 0x32, 0x81, 0xfa, 0xb3, 0x72, 0xea, 0x62, 0x6a, 0x4f, + 0xe9, 0xff, 0xbe, 0x8b, 0xef, 0xc2, 0x12, 0xa3, 0x66, 0xec, 0x99, 0xc4, 0x33, 0x8e, 0x73, 0xae, + 0x6e, 0x67, 0xd2, 0xc5, 0x2e, 0x2f, 0xe5, 0x5d, 0x7e, 0x17, 0x96, 0x04, 0x6c, 0x4c, 0xa8, 0x71, + 0x18, 0xc6, 0xae, 0xf4, 0x7b, 0x1b, 0xa5, 0xbb, 0x52, 0x38, 0x1b, 0x99, 0xfa, 0x7c, 0x64, 0xb2, + 0x7a, 0x6c, 0xcc, 0xd4, 0xe3, 0x0d, 0xa8, 0x8f, 0x6d, 0xcf, 0x0e, 0x27, 0xd4, 0xc4, 0x33, 0xb6, + 0xae, 0xa5, 0xe3, 0xb3, 0x6a, 0xb5, 0x79, 0x46, 0xad, 0x7e, 0x00, 0xcb, 0xb2, 0xd9, 0x15, 0xad, + 0xab, 0xed, 0x7b, 0xdd, 0x16, 0x2e, 0x7d, 0x49, 0xc8, 0x1f, 0x26, 0x62, 0xf5, 0x97, 0x25, 0x50, + 0x78, 0x60, 0x0f, 0x28, 0x71, 0xde, 0xfd, 0xe3, 0xea, 0x3f, 0xc1, 0xab, 0x67, 0xc4, 0xa4, 0xfa, + 0xea, 0xfc, 0x59, 0x3b, 0x8d, 0x3f, 0xd5, 0xdf, 0x17, 0xc5, 0xa9, 0xb7, 0xe7, 0x3f, 0xf3, 0xde, + 0x82, 0x66, 0xe2, 0x3e, 0x34, 0xf3, 0x17, 0xa8, 0x33, 0xda, 0xac, 0xec, 0x9e, 0xa4, 0xc1, 0x28, + 0xbb, 0x00, 0xbe, 0x79, 0x9b, 0xa5, 0x2c, 0x43, 0xc9, 0xf1, 0x9f, 0x61, 0x09, 0x97, 0x34, 0xfe, + 0x27, 0xbf, 0x44, 0x4f, 0x6c, 0x6b, 0x22, 0x4b, 0x16, 0xff, 0x56, 0x7f, 0x57, 0x82, 0x2b, 0x79, + 0xc7, 0xfd, 0x77, 0x59, 0xee, 0x6d, 0xf0, 0xdb, 0x1d, 0x68, 0x51, 0x0f, 0xcf, 0x60, 0x24, 0x30, + 0x74, 0x60, 0x5d, 0x6b, 0x0a, 0x19, 0xd2, 0x17, 0x67, 0xc0, 0xc8, 0x8f, 0x88, 0x33, 0x73, 0xe8, + 0xa0, 0x04, 0x19, 0xf0, 0x26, 0x08, 0x3a, 0xd4, 0x0f, 0xe9, 0xb1, 0xbc, 0xac, 0xd4, 0x51, 0xf0, + 0x3d, 0x8a, 0x8f, 0x1d, 0x02, 0x94, 0xad, 0x62, 0x1d, 0x67, 0x37, 0x51, 0xf6, 0x58, 0xf4, 0x8b, + 0xa9, 0x8a, 0xec, 0x1a, 0x1b, 0x39, 0x95, 0xef, 0xa3, 0x48, 0xfd, 0x4a, 0x76, 0x79, 0xbb, 0x13, + 0xe2, 0x70, 0x2d, 0xfa, 0xff, 0xb8, 0xcd, 0x1d, 0x6f, 0x95, 0x73, 0x1c, 0x6f, 0xd5, 0x45, 0xc7, + 0xdb, 0x5d, 0x58, 0xb2, 0xbd, 0x88, 0x5a, 0xcc, 0x8e, 0x8e, 0xf5, 0x09, 0x09, 0x27, 0xc9, 0xf9, + 0x95, 0x4a, 0x3f, 0x23, 0xe1, 0x24, 0x3b, 0x05, 0x51, 0xa5, 0x8e, 0x14, 0x28, 0xc2, 0x8e, 0xf0, + 0xfb, 0x70, 0x49, 0xc0, 0x26, 0x89, 0x88, 0xc8, 0x93, 0x06, 0x96, 0x9d, 0x38, 0x06, 0xf7, 0x48, + 0x44, 0x78, 0xae, 0xa8, 0xbf, 0x2a, 0xc2, 0x32, 0x8f, 0xc6, 0x70, 0xf7, 0xcd, 0x28, 0xeb, 0x43, + 0x50, 0xc2, 0x88, 0xb0, 0x48, 0x1f, 0x39, 0xbe, 0x71, 0xa8, 0x7b, 0xb1, 0x3b, 0xa2, 0x0c, 0x23, + 0x59, 0xd6, 0x96, 0x11, 0xd9, 0xe1, 0xc0, 0x23, 0x94, 0x2b, 0x1b, 0xb0, 0x4c, 0x3d, 0x73, 0x56, + 0xb7, 0x84, 0xba, 0x4b, 0xd4, 0x33, 0xf3, 0x9a, 0x1f, 0x41, 0xc7, 0x88, 0x19, 0xe3, 0x5e, 0x9d, + 0xd1, 0x16, 0x37, 0x1c, 0x45, 0x62, 0xf9, 0x19, 0x9f, 0xc0, 0x55, 0x87, 0x84, 0x91, 0x6e, 0x52, + 0xbc, 0xc7, 0xa4, 0x0f, 0x34, 0xa6, 0xbc, 0xfd, 0xac, 0x70, 0x74, 0x4f, 0x80, 0x32, 0x9d, 0x4c, + 0xa5, 0x0b, 0x35, 0x16, 0x7b, 0x9e, 0xed, 0x59, 0xb2, 0x01, 0x4f, 0x86, 0xea, 0x5f, 0x0a, 0x82, + 0xa0, 0x86, 0xbb, 0x5f, 0xfa, 0xee, 0xc8, 0x7e, 0xb3, 0x44, 0xcf, 0x7d, 0xa6, 0x38, 0xf3, 0x19, + 0x1e, 0x2f, 0xe1, 0xbf, 0xcc, 0x5c, 0xe1, 0x90, 0x36, 0x8a, 0x53, 0x43, 0x55, 0x68, 0x73, 0xcf, + 0x65, 0x5a, 0xc2, 0x11, 0x4d, 0xea, 0x65, 0x9b, 0xc9, 0x37, 0x29, 0x95, 0xd9, 0x26, 0x45, 0xfd, + 0x69, 0x01, 0x96, 0xc4, 0x76, 0x1e, 0xd2, 0x88, 0xbc, 0xee, 0x3e, 0x56, 0xa1, 0x99, 0x44, 0x85, + 0xe7, 0xb1, 0x08, 0x33, 0x48, 0x11, 0x4f, 0xe2, 0x3b, 0xd0, 0x12, 0xfe, 0xd7, 0x0d, 0x3f, 0x96, + 0xaf, 0x59, 0x65, 0xad, 0x29, 0x64, 0xbb, 0x5c, 0xa4, 0xfe, 0xa2, 0x2c, 0x9a, 0x19, 0xf9, 0x7e, + 0x37, 0xfc, 0x62, 0xf8, 0xba, 0xd6, 0xdc, 0x84, 0x46, 0x52, 0xfd, 0xa6, 0xb4, 0xa5, 0x2e, 0x6b, + 0xdb, 0x54, 0xf6, 0xa0, 0x16, 0x32, 0x43, 0xb7, 0xa6, 0x96, 0xa4, 0x85, 0xef, 0xe4, 0x4b, 0x3a, + 0xff, 0xdc, 0xdd, 0x1f, 0x9e, 0x68, 0x05, 0xb4, 0x6a, 0xc8, 0x8c, 0xe1, 0xd4, 0x52, 0x1e, 0x40, + 0xdd, 0xa4, 0x61, 0x84, 0xcb, 0x94, 0x5f, 0x7d, 0x99, 0x1a, 0x9f, 0xcc, 0xd7, 0x39, 0x67, 0x8b, + 0x7b, 0x0f, 0xf8, 0x87, 0xf5, 0x30, 0xc0, 0x6c, 0x9c, 0xa7, 0xb2, 0xa0, 0x7f, 0x20, 0x99, 0x87, + 0xf9, 0x53, 0xdb, 0xa4, 0x4c, 0xab, 0x84, 0xcc, 0x38, 0x08, 0x78, 0xb7, 0x83, 0xa9, 0x2f, 0xdf, + 0x40, 0xf3, 0x69, 0x52, 0x43, 0xb7, 0x74, 0x38, 0x2c, 0x1d, 0xbe, 0x38, 0x5f, 0xea, 0x73, 0x4d, + 0xed, 0x2a, 0x34, 0xc5, 0x23, 0x92, 0x78, 0xae, 0x17, 0x1c, 0x02, 0x42, 0x84, 0xcf, 0xf5, 0x33, + 0x7d, 0x34, 0xcc, 0xf7, 0xd1, 0xfd, 0xf4, 0x45, 0xd7, 0xd4, 0x47, 0xc7, 0x11, 0x0d, 0x05, 0x15, + 0x35, 0xd1, 0x9a, 0xe4, 0xad, 0xd6, 0xdc, 0xe1, 0x08, 0xd2, 0xd1, 0x3f, 0xe4, 0xb5, 0x52, 0xda, + 0xf8, 0xce, 0xdf, 0x79, 0x78, 0x59, 0x63, 0x20, 0xb3, 0x77, 0x47, 0xf1, 0xa0, 0xd9, 0xc6, 0x88, + 0xa5, 0x4f, 0x8e, 0x17, 0x75, 0x78, 0x7c, 0x1b, 0x2e, 0xdb, 0xa1, 0x3e, 0x73, 0x9f, 0x10, 0xf7, + 0xce, 0xba, 0x76, 0xc9, 0x0e, 0x77, 0x72, 0xf7, 0x09, 0xaa, 0xfe, 0xa6, 0x08, 0xd7, 0x05, 0x15, + 0xec, 0xcc, 0xde, 0x33, 0xfe, 0x2d, 0x75, 0xf8, 0x01, 0x5c, 0xc6, 0xdc, 0xb4, 0x8c, 0x13, 0x14, + 0xb7, 0xc4, 0x81, 0xa1, 0x91, 0xe6, 0xe3, 0x3a, 0x2c, 0x25, 0xaa, 0xd6, 0xd4, 0xca, 0x91, 0x9c, + 0xd0, 0x1b, 0x4e, 0xad, 0xb3, 0x49, 0x8e, 0x93, 0xa4, 0xe8, 0x8f, 0xf8, 0x74, 0x2f, 0x76, 0x65, + 0x8b, 0xd4, 0x44, 0xe1, 0x70, 0x6a, 0x3d, 0x8a, 0x5d, 0x65, 0x13, 0x56, 0x2c, 0x43, 0x4f, 0xa6, + 0xa4, 0x9a, 0xa2, 0x4e, 0x96, 0x2d, 0xe3, 0x81, 0x44, 0x84, 0xba, 0xfa, 0xdb, 0x22, 0x5c, 0xe3, + 0xdb, 0x9d, 0x73, 0x15, 0xe6, 0xc9, 0xcc, 0xbe, 0x0b, 0x73, 0xfb, 0xce, 0xdb, 0x59, 0x9c, 0xb3, + 0xf3, 0x94, 0xea, 0x28, 0x9d, 0x52, 0x1d, 0xca, 0x77, 0x01, 0x89, 0x84, 0xf3, 0x42, 0xf9, 0x5c, + 0xbc, 0x50, 0xe5, 0xea, 0x48, 0x0c, 0x09, 0x9f, 0x54, 0x5e, 0x85, 0x4f, 0xe6, 0x8a, 0xbf, 0x7a, + 0x76, 0xf1, 0xcf, 0x3f, 0x6f, 0xa8, 0x7f, 0x2e, 0xc2, 0x4a, 0xe6, 0xb3, 0xcf, 0x63, 0x3f, 0x22, + 0xff, 0xda, 0x5f, 0x1d, 0xa8, 0xb8, 0xbe, 0x17, 0x4d, 0xd0, 0x59, 0x0d, 0x4d, 0x0c, 0xb8, 0x25, + 0x72, 0x8a, 0x47, 0xe4, 0xaf, 0x86, 0x8d, 0xa4, 0x81, 0x7b, 0x44, 0x5c, 0xca, 0xfb, 0x0f, 0x46, + 0x89, 0xa9, 0x1b, 0xbe, 0x17, 0xc6, 0x2e, 0xbe, 0xbb, 0x3f, 0xa7, 0x32, 0x6f, 0x96, 0x39, 0xb2, + 0x2b, 0x01, 0xe9, 0xc8, 0xee, 0x98, 0x51, 0xaa, 0xff, 0x98, 0xdb, 0x34, 0x37, 0x47, 0x74, 0x09, + 0x57, 0x38, 0x8e, 0x26, 0xcf, 0x4c, 0x7c, 0x1f, 0x2e, 0xe5, 0x26, 0xe6, 0xda, 0xef, 0x76, 0xaa, + 0x8f, 0x7a, 0x1f, 0x82, 0x62, 0x4c, 0x08, 0xb3, 0xa8, 0x99, 0x57, 0x95, 0xc9, 0x25, 0x91, 0x4c, + 0x7b, 0x1d, 0xda, 0xc4, 0x71, 0xfc, 0x67, 0x69, 0xc5, 0x0a, 0x16, 0x6e, 0xa1, 0x30, 0xf9, 0x7d, + 0xeb, 0x87, 0x7f, 0x7a, 0xd1, 0x2b, 0x7c, 0xfd, 0xa2, 0x57, 0xf8, 0xe6, 0x45, 0xaf, 0xf0, 0xf3, + 0x97, 0xbd, 0xf7, 0xbe, 0x7e, 0xd9, 0x7b, 0xef, 0xaf, 0x2f, 0x7b, 0xef, 0x7d, 0xb9, 0x67, 0xd9, + 0xd1, 0x24, 0x1e, 0xf5, 0x0d, 0xdf, 0x1d, 0x8c, 0xbc, 0xd1, 0xa6, 0x31, 0x21, 0xb6, 0x37, 0xc8, + 0x22, 0xbc, 0x29, 0x39, 0x69, 0x33, 0x90, 0xf1, 0x1d, 0x2c, 0xf8, 0x05, 0x7b, 0x54, 0xc5, 0xdf, + 0x79, 0x3f, 0xf9, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7b, 0xd1, 0xd8, 0x43, 0xdf, 0x1e, 0x00, + 0x00, } func (m *GfSpTask) Marshal() (dAtA []byte, err error) { @@ -3754,6 +3800,36 @@ func (m *GfSpGCBucketMigrationTask) MarshalToSizedBuffer(dAtA []byte) (int, erro _ = i var l int _ = l + if m.GcFinishedGvgNum != 0 { + i = encodeVarintTask(dAtA, i, uint64(m.GcFinishedGvgNum)) + i-- + dAtA[i] = 0x38 + } + if m.TotalGvgNum != 0 { + i = encodeVarintTask(dAtA, i, uint64(m.TotalGvgNum)) + i-- + dAtA[i] = 0x30 + } + if m.Finished { + i-- + if m.Finished { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if m.LastGcGvgId != 0 { + i = encodeVarintTask(dAtA, i, uint64(m.LastGcGvgId)) + i-- + dAtA[i] = 0x20 + } + if m.LastGcObjectId != 0 { + i = encodeVarintTask(dAtA, i, uint64(m.LastGcObjectId)) + i-- + dAtA[i] = 0x18 + } if m.BucketId != 0 { i = encodeVarintTask(dAtA, i, uint64(m.BucketId)) i-- @@ -4602,6 +4678,21 @@ func (m *GfSpGCBucketMigrationTask) Size() (n int) { if m.BucketId != 0 { n += 1 + sovTask(uint64(m.BucketId)) } + if m.LastGcObjectId != 0 { + n += 1 + sovTask(uint64(m.LastGcObjectId)) + } + if m.LastGcGvgId != 0 { + n += 1 + sovTask(uint64(m.LastGcGvgId)) + } + if m.Finished { + n += 2 + } + if m.TotalGvgNum != 0 { + n += 1 + sovTask(uint64(m.TotalGvgNum)) + } + if m.GcFinishedGvgNum != 0 { + n += 1 + sovTask(uint64(m.GcFinishedGvgNum)) + } return n } @@ -9407,6 +9498,102 @@ func (m *GfSpGCBucketMigrationTask) Unmarshal(dAtA []byte) error { break } } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastGcObjectId", wireType) + } + m.LastGcObjectId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTask + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LastGcObjectId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastGcGvgId", wireType) + } + m.LastGcGvgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTask + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LastGcGvgId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Finished", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTask + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Finished = bool(v != 0) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalGvgNum", wireType) + } + m.TotalGvgNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTask + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalGvgNum |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GcFinishedGvgNum", wireType) + } + m.GcFinishedGvgNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTask + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GcFinishedGvgNum |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) diff --git a/core/module/modular.go b/core/module/modular.go index acadc51fd..c4381b019 100644 --- a/core/module/modular.go +++ b/core/module/modular.go @@ -55,6 +55,8 @@ const ( AuthOpTypeListBucketReadRecord // AuthOpTypeGetRecoveryPiece defines the GetRecoveryPiece operator AuthOpTypeGetRecoveryPiece + // AuthOpTypeQueryBucketMigrationProgress defines the QueryBucketMigrationProgress operator + AuthOpTypeQueryBucketMigrationProgress ) // Authenticator is an abstract interface to verify users authentication. @@ -223,10 +225,12 @@ type Manager interface { HandleMigrateGVGTask(ctx context.Context, task task.MigrateGVGTask) error // QueryTasksStats queries tasks stats from Manager server QueryTasksStats(ctx context.Context) (int, int, int, int, int, int, int, []string) - // NotifyPreMigrateBucket is used to notify src sp pre migrate bucket. - NotifyPreMigrateBucket(ctx context.Context, bucketID uint64) error - // NotifyPostMigrateBucket is used to notify src sp post migrate bucket. - NotifyPostMigrateBucket(ctx context.Context, bmStatus *gfsptask.GfSpBucketMigrationInfo) error + // QueryBucketMigrationProgress queries migration progress from Manager server + QueryBucketMigrationProgress(ctx context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) + // NotifyPreMigrateBucketAndDeductQuota is used to notify src sp pre migrate bucket and deduct quota. + NotifyPreMigrateBucketAndDeductQuota(ctx context.Context, bucketID uint64) (*gfsptask.GfSpBucketQuotaInfo, error) + // NotifyPostMigrateBucketAndRecoupQuota is used to notify src sp post migrate bucket and recoup quota. + NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, bmStatus *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) // ResetRecoveryFailedList reset failed list for recovery ResetRecoveryFailedList(ctx context.Context) []string } diff --git a/core/module/modular_mock.go b/core/module/modular_mock.go index 4046760f4..035f65872 100644 --- a/core/module/modular_mock.go +++ b/core/module/modular_mock.go @@ -1,10 +1,6 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: ./modular.go -// -// Generated by this command: -// -// mockgen -source=./modular.go -destination=./modular_mock.go -package=module -// +// Source: core/module/modular.go + // Package module is a generated GoMock package. package module @@ -1211,32 +1207,34 @@ func (mr *MockManagerMockRecorder) NotifyMigrateSwapOut(ctx, swapOut interface{} return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyMigrateSwapOut", reflect.TypeOf((*MockManager)(nil).NotifyMigrateSwapOut), ctx, swapOut) } -// NotifyPostMigrateBucket mocks base method. -func (m *MockManager) NotifyPostMigrateBucket(ctx context.Context, bmStatus *gfsptask.GfSpBucketMigrationInfo) error { +// NotifyPostMigrateBucketAndRecoupQuota mocks base method. +func (m *MockManager) NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, bmStatus *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NotifyPostMigrateBucket", ctx, bmStatus) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "NotifyPostMigrateBucketAndRecoupQuota", ctx, bmStatus) + ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// NotifyPostMigrateBucket indicates an expected call of NotifyPostMigrateBucket. -func (mr *MockManagerMockRecorder) NotifyPostMigrateBucket(ctx, bmStatus interface{}) *gomock.Call { +// NotifyPostMigrateBucketAndRecoupQuota indicates an expected call of NotifyPostMigrateBucketAndRecoupQuota. +func (mr *MockManagerMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmStatus interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucket", reflect.TypeOf((*MockManager)(nil).NotifyPostMigrateBucket), ctx, bmStatus) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucketAndRecoupQuota", reflect.TypeOf((*MockManager)(nil).NotifyPostMigrateBucketAndRecoupQuota), ctx, bmStatus) } -// NotifyPreMigrateBucket mocks base method. -func (m *MockManager) NotifyPreMigrateBucket(ctx context.Context, bucketID uint64) error { +// NotifyPreMigrateBucketAndDeductQuota mocks base method. +func (m *MockManager) NotifyPreMigrateBucketAndDeductQuota(ctx context.Context, bucketID uint64) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NotifyPreMigrateBucket", ctx, bucketID) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "NotifyPreMigrateBucketAndDeductQuota", ctx, bucketID) + ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// NotifyPreMigrateBucket indicates an expected call of NotifyPreMigrateBucket. -func (mr *MockManagerMockRecorder) NotifyPreMigrateBucket(ctx, bucketID interface{}) *gomock.Call { +// NotifyPreMigrateBucketAndDeductQuota indicates an expected call of NotifyPreMigrateBucketAndDeductQuota. +func (mr *MockManagerMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucket", reflect.TypeOf((*MockManager)(nil).NotifyPreMigrateBucket), ctx, bucketID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucketAndDeductQuota", reflect.TypeOf((*MockManager)(nil).NotifyPreMigrateBucketAndDeductQuota), ctx, bucketID) } // PickVirtualGroupFamily mocks base method. @@ -1269,6 +1267,21 @@ func (mr *MockManagerMockRecorder) QueryBucketMigrate(ctx interface{}) *gomock.C return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBucketMigrate", reflect.TypeOf((*MockManager)(nil).QueryBucketMigrate), ctx) } +// QueryBucketMigrationProgress mocks base method. +func (m *MockManager) QueryBucketMigrationProgress(ctx context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryBucketMigrationProgress", ctx, bucketID) + ret0, _ := ret[0].(*gfspserver.MigrateBucketProgressMeta) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryBucketMigrationProgress indicates an expected call of QueryBucketMigrationProgress. +func (mr *MockManagerMockRecorder) QueryBucketMigrationProgress(ctx, bucketID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBucketMigrationProgress", reflect.TypeOf((*MockManager)(nil).QueryBucketMigrationProgress), ctx, bucketID) +} + // QuerySpExit mocks base method. func (m *MockManager) QuerySpExit(ctx context.Context) (*gfspserver.GfSpQuerySpExitResponse, error) { m.ctrl.T.Helper() @@ -1668,16 +1681,6 @@ type MockSigner struct { recorder *MockSignerMockRecorder } -func (m *MockSigner) Deposit(ctx context.Context, deposit *types1.MsgDeposit) (string, error) { - //TODO implement me - panic("implement me") -} - -func (m *MockSigner) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG *types1.MsgDeleteGlobalVirtualGroup) (string, error) { - //TODO implement me - panic("implement me") -} - // MockSignerMockRecorder is the mock recorder for MockSigner. type MockSignerMockRecorder struct { mock *MockSigner @@ -1755,6 +1758,36 @@ func (mr *MockSignerMockRecorder) CreateGlobalVirtualGroup(ctx, gvg interface{}) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalVirtualGroup", reflect.TypeOf((*MockSigner)(nil).CreateGlobalVirtualGroup), ctx, gvg) } +// DeleteGlobalVirtualGroup mocks base method. +func (m *MockSigner) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG *types1.MsgDeleteGlobalVirtualGroup) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGlobalVirtualGroup", ctx, deleteGVG) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGlobalVirtualGroup indicates an expected call of DeleteGlobalVirtualGroup. +func (mr *MockSignerMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalVirtualGroup", reflect.TypeOf((*MockSigner)(nil).DeleteGlobalVirtualGroup), ctx, deleteGVG) +} + +// Deposit mocks base method. +func (m *MockSigner) Deposit(ctx context.Context, deposit *types1.MsgDeposit) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Deposit", ctx, deposit) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Deposit indicates an expected call of Deposit. +func (mr *MockSignerMockRecorder) Deposit(ctx, deposit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deposit", reflect.TypeOf((*MockSigner)(nil).Deposit), ctx, deposit) +} + // DiscontinueBucket mocks base method. func (m *MockSigner) DiscontinueBucket(ctx context.Context, bucket *types0.MsgDiscontinueBucket) (string, error) { m.ctrl.T.Helper() diff --git a/core/module/null_modular.go b/core/module/null_modular.go index c27fc9cbc..2fea71053 100644 --- a/core/module/null_modular.go +++ b/core/module/null_modular.go @@ -65,17 +65,22 @@ func (*NullModular) PickVirtualGroupFamily(context.Context, task.ApprovalCreateB func (*NullModular) NotifyMigrateSwapOut(context.Context, *virtualgrouptypes.MsgSwapOut) error { return ErrNilModular } -func (*NullModular) NotifyPreMigrateBucket(context.Context, uint64) error { - return ErrNilModular +func (*NullModular) NotifyPreMigrateBucketAndDeductQuota(context.Context, uint64) (*gfsptask.GfSpBucketQuotaInfo, error) { + return &gfsptask.GfSpBucketQuotaInfo{}, ErrNilModular } -func (*NullModular) NotifyPostMigrateBucket(context.Context, *gfsptask.GfSpBucketMigrationInfo) error { - return ErrNilModular + +func (*NullModular) NotifyPostMigrateBucketAndRecoupQuota(context.Context, *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) { + return &gfsptask.GfSpBucketQuotaInfo{}, ErrNilModular } func (m *NullModular) QueryTasksStats(ctx context.Context) (int, int, int, int, int, int, int, []string) { return 0, 0, 0, 0, 0, 0, 0, nil } +func (m *NullModular) QueryBucketMigrationProgress(ctx context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) { + return &gfspserver.MigrateBucketProgressMeta{}, nil +} + func (m *NullModular) ResetRecoveryFailedList(ctx context.Context) []string { return nil } diff --git a/core/spdb/entity.go b/core/spdb/entity.go index ebee68cbe..8575aef0e 100644 --- a/core/spdb/entity.go +++ b/core/spdb/entity.go @@ -119,8 +119,9 @@ type MigrateGVGUnitMeta struct { SrcSPID uint32 DestSPID uint32 LastMigratedObjectID uint64 - MigrateStatus int // scheduler assign unit status. - RetryTime int // + MigrateStatus int // scheduler assign unit status. + RetryTime int // + MigratedBytesSize uint64 // migrated bytes } // SwapOutMeta is used to record swap out meta. @@ -130,3 +131,20 @@ type SwapOutMeta struct { SwapOutMsg *virtualgrouptypes.MsgSwapOut CompletedGVGs []uint32 } + +// MigrateBucketProgressMeta is used to record migrate bucket progress meta. +type MigrateBucketProgressMeta struct { + BucketID uint64 // as primary key + SubscribedBlockHeight uint64 + MigrateState int + + TotalGvgNum uint32 // Total number of GVGs that need to be migrated + MigratedFinishedGvgNum uint32 // Number of successfully migrated GVGs + GcFinishedGvgNum uint32 // Number of successfully gc finished GVGs + + PreDeductedQuota uint64 // Quota pre-deducted by the source sp in the pre-migrate bucket phase + RecoupQuota uint64 // In case of migration failure, the dest sp recoup the quota for the source sp + + LastGcObjectID uint64 // After bucket migration is complete, the progress of GC, up to which object is GC performed. + LastGcGvgID uint64 // which GVG is GC performed. +} diff --git a/core/spdb/spdb.go b/core/spdb/spdb.go index e6d7bfe1f..dc16f5675 100644 --- a/core/spdb/spdb.go +++ b/core/spdb/spdb.go @@ -171,6 +171,8 @@ type MigrateDB interface { QuerySwapOutSubscribeProgress() (uint64, error) // UpdateBucketMigrateSubscribeProgress includes insert and update. UpdateBucketMigrateSubscribeProgress(blockHeight uint64) error + // UpdateBucketMigrateGCSubscribeProgress includes insert and update. + UpdateBucketMigrateGCSubscribeProgress(blockHeight uint64) error // QueryBucketMigrateSubscribeProgress returns blockHeight which is called at startup. QueryBucketMigrateSubscribeProgress() (uint64, error) @@ -187,18 +189,37 @@ type MigrateDB interface { InsertMigrateGVGUnit(meta *MigrateGVGUnitMeta) error // DeleteMigrateGVGUnit deletes the gvg migrate unit. DeleteMigrateGVGUnit(meta *MigrateGVGUnitMeta) error - // UpdateMigrateGVGUnitStatus updates gvg unit status. UpdateMigrateGVGUnitStatus(migrateKey string, migrateStatus int) error // UpdateMigrateGVGUnitLastMigrateObjectID updates gvg unit LastMigrateObjectID. UpdateMigrateGVGUnitLastMigrateObjectID(migrateKey string, lastMigrateObjectID uint64) error // UpdateMigrateGVGRetryCount updates gvg unit retry time UpdateMigrateGVGRetryCount(migrateKey string, retryTime int) error - + // UpdateMigrateGVGMigratedBytesSize updates gvg unit retry time + UpdateMigrateGVGMigratedBytesSize(migrateKey string, migratedBytes uint64) error // QueryMigrateGVGUnit returns the gvg migrate unit info. QueryMigrateGVGUnit(migrateKey string) (*MigrateGVGUnitMeta, error) // ListMigrateGVGUnitsByBucketID is used to load at dest sp startup(bucket migrate). ListMigrateGVGUnitsByBucketID(bucketID uint64) ([]*MigrateGVGUnitMeta, error) // DeleteMigrateGVGUnitsByBucketID is used to delete migrate gvg units at bucket migrate DeleteMigrateGVGUnitsByBucketID(bucketID uint64) error + + // UpdateBucketMigrationProgress update MigrateBucketProgress migrate state. + UpdateBucketMigrationProgress(bucketID uint64, migrateState int) error + // UpdateBucketMigrationPreDeductedQuota update pre-deducted quota and migration state when src sp receives a preMigrateBucket request. + UpdateBucketMigrationPreDeductedQuota(bucketID uint64, deductedQuota uint64, state int) error + // UpdateBucketMigrationRecoupQuota update RecoupQuota and the corresponding state in MigrateBucketProgress. + UpdateBucketMigrationRecoupQuota(bucketID uint64, recoupQuota uint64, state int) error + // UpdateBucketMigrationGCProgress update bucket migration gc progress + UpdateBucketMigrationGCProgress(progressMeta MigrateBucketProgressMeta) error + // UpdateBucketMigrationMigratingProgress update bucket migration migrating progress + UpdateBucketMigrationMigratingProgress(bucketID uint64, gvgUnits uint32, gvgUnitsFinished uint32) error + // QueryMigrateBucketState returns the migrate state. + QueryMigrateBucketState(bucketID uint64) (int, error) + // QueryMigrateBucketProgress returns the migration progress. + QueryMigrateBucketProgress(bucketID uint64) (*MigrateBucketProgressMeta, error) + // ListBucketMigrationToConfirm returns the migrate bucket id to be confirmed. + ListBucketMigrationToConfirm(migrationStates []int) ([]*MigrateBucketProgressMeta, error) + // DeleteMigrateBucket delete the bucket migrate status + DeleteMigrateBucket(bucketID uint64) error } diff --git a/core/spdb/spdb_mock.go b/core/spdb/spdb_mock.go index 57aa737d3..580de2b99 100644 --- a/core/spdb/spdb_mock.go +++ b/core/spdb/spdb_mock.go @@ -121,6 +121,20 @@ func (mr *MockSPDBMockRecorder) DeleteGCObjectProgress(taskKey interface{}) *gom return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGCObjectProgress", reflect.TypeOf((*MockSPDB)(nil).DeleteGCObjectProgress), taskKey) } +// DeleteMigrateBucket mocks base method. +func (m *MockSPDB) DeleteMigrateBucket(bucketID uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteMigrateBucket", bucketID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteMigrateBucket indicates an expected call of DeleteMigrateBucket. +func (mr *MockSPDBMockRecorder) DeleteMigrateBucket(bucketID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMigrateBucket", reflect.TypeOf((*MockSPDB)(nil).DeleteMigrateBucket), bucketID) +} + // DeleteMigrateGVGUnit mocks base method. func (m *MockSPDB) DeleteMigrateGVGUnit(meta *MigrateGVGUnitMeta) error { m.ctrl.T.Helper() @@ -643,6 +657,21 @@ func (mr *MockSPDBMockRecorder) InsertUploadProgress(objectID interface{}) *gomo return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertUploadProgress", reflect.TypeOf((*MockSPDB)(nil).InsertUploadProgress), objectID) } +// ListBucketMigrationToConfirm mocks base method. +func (m *MockSPDB) ListBucketMigrationToConfirm(migrationStates []int) ([]*MigrateBucketProgressMeta, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListBucketMigrationToConfirm", migrationStates) + ret0, _ := ret[0].([]*MigrateBucketProgressMeta) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBucketMigrationToConfirm indicates an expected call of ListBucketMigrationToConfirm. +func (mr *MockSPDBMockRecorder) ListBucketMigrationToConfirm(migrationStates interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMigrationToConfirm", reflect.TypeOf((*MockSPDB)(nil).ListBucketMigrationToConfirm), migrationStates) +} + // ListDestSPSwapOutUnits mocks base method. func (m *MockSPDB) ListDestSPSwapOutUnits() ([]*SwapOutMeta, error) { m.ctrl.T.Helper() @@ -718,6 +747,36 @@ func (mr *MockSPDBMockRecorder) QueryBucketMigrateSubscribeProgress() *gomock.Ca return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBucketMigrateSubscribeProgress", reflect.TypeOf((*MockSPDB)(nil).QueryBucketMigrateSubscribeProgress)) } +// QueryMigrateBucketProgress mocks base method. +func (m *MockSPDB) QueryMigrateBucketProgress(bucketID uint64) (*MigrateBucketProgressMeta, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryMigrateBucketProgress", bucketID) + ret0, _ := ret[0].(*MigrateBucketProgressMeta) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryMigrateBucketProgress indicates an expected call of QueryMigrateBucketProgress. +func (mr *MockSPDBMockRecorder) QueryMigrateBucketProgress(bucketID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateBucketProgress", reflect.TypeOf((*MockSPDB)(nil).QueryMigrateBucketProgress), bucketID) +} + +// QueryMigrateBucketState mocks base method. +func (m *MockSPDB) QueryMigrateBucketState(bucketID uint64) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryMigrateBucketState", bucketID) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryMigrateBucketState indicates an expected call of QueryMigrateBucketState. +func (mr *MockSPDBMockRecorder) QueryMigrateBucketState(bucketID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateBucketState", reflect.TypeOf((*MockSPDB)(nil).QueryMigrateBucketState), bucketID) +} + // QueryMigrateGVGUnit mocks base method. func (m *MockSPDB) QueryMigrateGVGUnit(migrateKey string) (*MigrateGVGUnitMeta, error) { m.ctrl.T.Helper() @@ -848,6 +907,20 @@ func (mr *MockSPDBMockRecorder) UpdateAuthKey(userAddress, domain, oldNonce, new return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthKey", reflect.TypeOf((*MockSPDB)(nil).UpdateAuthKey), userAddress, domain, oldNonce, newNonce, newPublicKey, newExpiryDate) } +// UpdateBucketMigrateGCSubscribeProgress mocks base method. +func (m *MockSPDB) UpdateBucketMigrateGCSubscribeProgress(blockHeight uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrateGCSubscribeProgress", blockHeight) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrateGCSubscribeProgress indicates an expected call of UpdateBucketMigrateGCSubscribeProgress. +func (mr *MockSPDBMockRecorder) UpdateBucketMigrateGCSubscribeProgress(blockHeight interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrateGCSubscribeProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrateGCSubscribeProgress), blockHeight) +} + // UpdateBucketMigrateSubscribeProgress mocks base method. func (m *MockSPDB) UpdateBucketMigrateSubscribeProgress(blockHeight uint64) error { m.ctrl.T.Helper() @@ -862,6 +935,76 @@ func (mr *MockSPDBMockRecorder) UpdateBucketMigrateSubscribeProgress(blockHeight return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrateSubscribeProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrateSubscribeProgress), blockHeight) } +// UpdateBucketMigrationGCProgress mocks base method. +func (m *MockSPDB) UpdateBucketMigrationGCProgress(progressMeta MigrateBucketProgressMeta) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationGCProgress", progressMeta) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationGCProgress indicates an expected call of UpdateBucketMigrationGCProgress. +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationGCProgress(progressMeta interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationGCProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationGCProgress), progressMeta) +} + +// UpdateBucketMigrationMigratingProgress mocks base method. +func (m *MockSPDB) UpdateBucketMigrationMigratingProgress(bucketID uint64, gvgUnits, gvgUnitsFinished uint32) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationMigratingProgress", bucketID, gvgUnits, gvgUnitsFinished) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationMigratingProgress indicates an expected call of UpdateBucketMigrationMigratingProgress. +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationMigratingProgress(bucketID, gvgUnits, gvgUnitsFinished interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationMigratingProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationMigratingProgress), bucketID, gvgUnits, gvgUnitsFinished) +} + +// UpdateBucketMigrationPreDeductedQuota mocks base method. +func (m *MockSPDB) UpdateBucketMigrationPreDeductedQuota(bucketID, deductedQuota uint64, state int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationPreDeductedQuota", bucketID, deductedQuota, state) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationPreDeductedQuota indicates an expected call of UpdateBucketMigrationPreDeductedQuota. +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationPreDeductedQuota(bucketID, deductedQuota, state interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationPreDeductedQuota", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationPreDeductedQuota), bucketID, deductedQuota, state) +} + +// UpdateBucketMigrationProgress mocks base method. +func (m *MockSPDB) UpdateBucketMigrationProgress(bucketID uint64, migrateState int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationProgress", bucketID, migrateState) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationProgress indicates an expected call of UpdateBucketMigrationProgress. +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationProgress(bucketID, migrateState interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationProgress), bucketID, migrateState) +} + +// UpdateBucketMigrationRecoupQuota mocks base method. +func (m *MockSPDB) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota uint64, state int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationRecoupQuota", bucketID, recoupQuota, state) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationRecoupQuota indicates an expected call of UpdateBucketMigrationRecoupQuota. +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota, state interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationRecoupQuota", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationRecoupQuota), bucketID, recoupQuota, state) +} + // UpdateBucketTraffic mocks base method. func (m *MockSPDB) UpdateBucketTraffic(bucketID uint64, update *BucketTraffic) error { m.ctrl.T.Helper() @@ -918,6 +1061,20 @@ func (mr *MockSPDBMockRecorder) UpdateIntegrityChecksum(integrity interface{}) * return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIntegrityChecksum", reflect.TypeOf((*MockSPDB)(nil).UpdateIntegrityChecksum), integrity) } +// UpdateMigrateGVGMigratedBytesSize mocks base method. +func (m *MockSPDB) UpdateMigrateGVGMigratedBytesSize(migrateKey string, migratedBytes uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateMigrateGVGMigratedBytesSize", migrateKey, migratedBytes) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateMigrateGVGMigratedBytesSize indicates an expected call of UpdateMigrateGVGMigratedBytesSize. +func (mr *MockSPDBMockRecorder) UpdateMigrateGVGMigratedBytesSize(migrateKey, migratedBytes interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGMigratedBytesSize", reflect.TypeOf((*MockSPDB)(nil).UpdateMigrateGVGMigratedBytesSize), migrateKey, migratedBytes) +} + // UpdateMigrateGVGRetryCount mocks base method. func (m *MockSPDB) UpdateMigrateGVGRetryCount(migrateKey string, retryTime int) error { m.ctrl.T.Helper() @@ -1925,6 +2082,20 @@ func (m *MockMigrateDB) EXPECT() *MockMigrateDBMockRecorder { return m.recorder } +// DeleteMigrateBucket mocks base method. +func (m *MockMigrateDB) DeleteMigrateBucket(bucketID uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteMigrateBucket", bucketID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteMigrateBucket indicates an expected call of DeleteMigrateBucket. +func (mr *MockMigrateDBMockRecorder) DeleteMigrateBucket(bucketID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMigrateBucket", reflect.TypeOf((*MockMigrateDB)(nil).DeleteMigrateBucket), bucketID) +} + // DeleteMigrateGVGUnit mocks base method. func (m *MockMigrateDB) DeleteMigrateGVGUnit(meta *MigrateGVGUnitMeta) error { m.ctrl.T.Helper() @@ -1981,6 +2152,21 @@ func (mr *MockMigrateDBMockRecorder) InsertSwapOutUnit(meta interface{}) *gomock return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertSwapOutUnit", reflect.TypeOf((*MockMigrateDB)(nil).InsertSwapOutUnit), meta) } +// ListBucketMigrationToConfirm mocks base method. +func (m *MockMigrateDB) ListBucketMigrationToConfirm(migrationStates []int) ([]*MigrateBucketProgressMeta, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListBucketMigrationToConfirm", migrationStates) + ret0, _ := ret[0].([]*MigrateBucketProgressMeta) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBucketMigrationToConfirm indicates an expected call of ListBucketMigrationToConfirm. +func (mr *MockMigrateDBMockRecorder) ListBucketMigrationToConfirm(migrationStates interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMigrationToConfirm", reflect.TypeOf((*MockMigrateDB)(nil).ListBucketMigrationToConfirm), migrationStates) +} + // ListDestSPSwapOutUnits mocks base method. func (m *MockMigrateDB) ListDestSPSwapOutUnits() ([]*SwapOutMeta, error) { m.ctrl.T.Helper() @@ -2026,6 +2212,36 @@ func (mr *MockMigrateDBMockRecorder) QueryBucketMigrateSubscribeProgress() *gomo return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBucketMigrateSubscribeProgress", reflect.TypeOf((*MockMigrateDB)(nil).QueryBucketMigrateSubscribeProgress)) } +// QueryMigrateBucketProgress mocks base method. +func (m *MockMigrateDB) QueryMigrateBucketProgress(bucketID uint64) (*MigrateBucketProgressMeta, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryMigrateBucketProgress", bucketID) + ret0, _ := ret[0].(*MigrateBucketProgressMeta) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryMigrateBucketProgress indicates an expected call of QueryMigrateBucketProgress. +func (mr *MockMigrateDBMockRecorder) QueryMigrateBucketProgress(bucketID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateBucketProgress", reflect.TypeOf((*MockMigrateDB)(nil).QueryMigrateBucketProgress), bucketID) +} + +// QueryMigrateBucketState mocks base method. +func (m *MockMigrateDB) QueryMigrateBucketState(bucketID uint64) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryMigrateBucketState", bucketID) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryMigrateBucketState indicates an expected call of QueryMigrateBucketState. +func (mr *MockMigrateDBMockRecorder) QueryMigrateBucketState(bucketID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateBucketState", reflect.TypeOf((*MockMigrateDB)(nil).QueryMigrateBucketState), bucketID) +} + // QueryMigrateGVGUnit mocks base method. func (m *MockMigrateDB) QueryMigrateGVGUnit(migrateKey string) (*MigrateGVGUnitMeta, error) { m.ctrl.T.Helper() @@ -2086,6 +2302,20 @@ func (mr *MockMigrateDBMockRecorder) QuerySwapOutUnitInSrcSP(swapOutKey interfac return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySwapOutUnitInSrcSP", reflect.TypeOf((*MockMigrateDB)(nil).QuerySwapOutUnitInSrcSP), swapOutKey) } +// UpdateBucketMigrateGCSubscribeProgress mocks base method. +func (m *MockMigrateDB) UpdateBucketMigrateGCSubscribeProgress(blockHeight uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrateGCSubscribeProgress", blockHeight) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrateGCSubscribeProgress indicates an expected call of UpdateBucketMigrateGCSubscribeProgress. +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrateGCSubscribeProgress(blockHeight interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrateGCSubscribeProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrateGCSubscribeProgress), blockHeight) +} + // UpdateBucketMigrateSubscribeProgress mocks base method. func (m *MockMigrateDB) UpdateBucketMigrateSubscribeProgress(blockHeight uint64) error { m.ctrl.T.Helper() @@ -2100,6 +2330,90 @@ func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrateSubscribeProgress(blockH return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrateSubscribeProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrateSubscribeProgress), blockHeight) } +// UpdateBucketMigrationGCProgress mocks base method. +func (m *MockMigrateDB) UpdateBucketMigrationGCProgress(progressMeta MigrateBucketProgressMeta) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationGCProgress", progressMeta) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationGCProgress indicates an expected call of UpdateBucketMigrationGCProgress. +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationGCProgress(progressMeta interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationGCProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationGCProgress), progressMeta) +} + +// UpdateBucketMigrationMigratingProgress mocks base method. +func (m *MockMigrateDB) UpdateBucketMigrationMigratingProgress(bucketID uint64, gvgUnits, gvgUnitsFinished uint32) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationMigratingProgress", bucketID, gvgUnits, gvgUnitsFinished) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationMigratingProgress indicates an expected call of UpdateBucketMigrationMigratingProgress. +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationMigratingProgress(bucketID, gvgUnits, gvgUnitsFinished interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationMigratingProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationMigratingProgress), bucketID, gvgUnits, gvgUnitsFinished) +} + +// UpdateBucketMigrationPreDeductedQuota mocks base method. +func (m *MockMigrateDB) UpdateBucketMigrationPreDeductedQuota(bucketID, deductedQuota uint64, state int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationPreDeductedQuota", bucketID, deductedQuota, state) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationPreDeductedQuota indicates an expected call of UpdateBucketMigrationPreDeductedQuota. +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationPreDeductedQuota(bucketID, deductedQuota, state interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationPreDeductedQuota", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationPreDeductedQuota), bucketID, deductedQuota, state) +} + +// UpdateBucketMigrationProgress mocks base method. +func (m *MockMigrateDB) UpdateBucketMigrationProgress(bucketID uint64, migrateState int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationProgress", bucketID, migrateState) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationProgress indicates an expected call of UpdateBucketMigrationProgress. +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationProgress(bucketID, migrateState interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationProgress), bucketID, migrateState) +} + +// UpdateBucketMigrationRecoupQuota mocks base method. +func (m *MockMigrateDB) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota uint64, state int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBucketMigrationRecoupQuota", bucketID, recoupQuota, state) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateBucketMigrationRecoupQuota indicates an expected call of UpdateBucketMigrationRecoupQuota. +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota, state interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationRecoupQuota", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationRecoupQuota), bucketID, recoupQuota, state) +} + +// UpdateMigrateGVGMigratedBytesSize mocks base method. +func (m *MockMigrateDB) UpdateMigrateGVGMigratedBytesSize(migrateKey string, migratedBytes uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateMigrateGVGMigratedBytesSize", migrateKey, migratedBytes) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateMigrateGVGMigratedBytesSize indicates an expected call of UpdateMigrateGVGMigratedBytesSize. +func (mr *MockMigrateDBMockRecorder) UpdateMigrateGVGMigratedBytesSize(migrateKey, migratedBytes interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGMigratedBytesSize", reflect.TypeOf((*MockMigrateDB)(nil).UpdateMigrateGVGMigratedBytesSize), migrateKey, migratedBytes) +} + // UpdateMigrateGVGRetryCount mocks base method. func (m *MockMigrateDB) UpdateMigrateGVGRetryCount(migrateKey string, retryTime int) error { m.ctrl.T.Helper() diff --git a/core/task/null_task.go b/core/task/null_task.go index 20e250a61..cd7a2cee0 100644 --- a/core/task/null_task.go +++ b/core/task/null_task.go @@ -182,3 +182,11 @@ func (*NullTask) SetStartObjectID(uint64) func (*NullTask) GetStartObjectId() uint64 { return 0 } func (*NullTask) SetEndObjectID(uint64) {} func (*NullTask) GetEndObjectId() uint64 { return 0 } +func (*NullTask) SetLastGCGvgID(lastGCGvgID uint64) {} +func (*NullTask) GetLastGCGvgID() uint64 { return 0 } +func (*NullTask) SetLastGCObjectID(lastGCObjectID uint64) {} +func (*NullTask) GetLastGCObjectID() uint64 { return 0 } +func (*NullTask) SetGCFinishedGvgNum(gvgGcNum uint64) {} +func (*NullTask) GetGCFinishedGvgNum() uint64 { return 0 } +func (*NullTask) SetTotalGvgNum(gvgNum uint64) {} +func (*NullTask) GetTotalGvgNum() uint64 { return 0 } diff --git a/core/task/task.go b/core/task/task.go index 930c1500d..b9a844d07 100644 --- a/core/task/task.go +++ b/core/task/task.go @@ -595,4 +595,24 @@ type GCBucketMigrationTask interface { GetBucketID() uint64 // SetBucketID sets the bucketID SetBucketID(uint64) + // GetLastGCObjectID returns the last gc object id + GetLastGCObjectID() uint64 + // SetLastGCObjectID sets the last gc object id + SetLastGCObjectID(uint64) + // GetLastGCGvgID returns the last gc gvg id + GetLastGCGvgID() uint64 + // SetLastGCGvgID sets the last gc gvg id + SetLastGCGvgID(uint64) + // GetTotalGvgNum returns the total num of gvg + GetTotalGvgNum() uint64 + // SetTotalGvgNum sets the total num of gvg + SetTotalGvgNum(gvgNum uint64) + // GetGCFinishedGvgNum returns the task whether finished + GetGCFinishedGvgNum() uint64 + // SetGCFinishedGvgNum sets the bucket migration task status when finished + SetGCFinishedGvgNum(gvgGcNum uint64) + // GetFinished returns the task whether finished + GetFinished() bool + // SetFinished sets the bucket migration task status when finished + SetFinished(bool) } diff --git a/modular/approver/approve_task.go b/modular/approver/approve_task.go index 68da48f38..4cd869420 100644 --- a/modular/approver/approve_task.go +++ b/modular/approver/approve_task.go @@ -13,6 +13,7 @@ import ( "github.com/bnb-chain/greenfield-storage-provider/core/taskqueue" "github.com/bnb-chain/greenfield-storage-provider/pkg/log" "github.com/bnb-chain/greenfield-storage-provider/pkg/metrics" + storetypes "github.com/bnb-chain/greenfield-storage-provider/store/types" ) var ( @@ -135,6 +136,7 @@ func (a *ApprovalModular) HandleMigrateBucketApprovalTask(ctx context.Context, t err error signature []byte currentHeight uint64 + state int ) if task == nil || task.GetMigrateBucketInfo() == nil { log.CtxErrorw(ctx, "failed to migrate bucket approval due to pointer nil") @@ -154,6 +156,29 @@ func (a *ApprovalModular) HandleMigrateBucketApprovalTask(ctx context.Context, t return true, nil } + migrateBucketMsg := task.GetMigrateBucketInfo() + bucketMeta, _, err := a.baseApp.GfSpClient().GetBucketMeta(ctx, migrateBucketMsg.GetBucketName(), true) + if err != nil { + return false, err + } + bucketID := bucketMeta.GetBucketInfo().Id.Uint64() + + // If the destination SP is still performing garbage collection for the bucket being migrated, the migration action is not allowed. + if state, err = a.baseApp.GfSpDB().QueryMigrateBucketState(bucketID); err != nil { + log.CtxErrorw(ctx, "failed to query migrate bucket state", "error", err) + return false, err + } + if state == int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATION_FINISHED) { + // delete the last finished migrate bucket progress record + if err = a.baseApp.GfSpDB().DeleteMigrateBucket(bucketID); err != nil { + log.CtxErrorw(ctx, "failed to delete migrate bucket state", "bucket_id", bucketID, "error", err) + return false, err + } + } else if state != int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_INIT_UNSPECIFIED) { + log.CtxInfow(ctx, "the bucket is migrating or gc, migrated to this sp should be reject", "bucket_id", bucketID) + return false, fmt.Errorf("the bucket is migrating or gc, try it after gc done") + } + // check src sp has enough quota allow, err := a.migrateBucketQuotaCheck(ctx, task) if err != nil || !allow { @@ -170,6 +195,7 @@ func (a *ApprovalModular) HandleMigrateBucketApprovalTask(ctx context.Context, t } task.GetMigrateBucketInfo().GetDstPrimarySpApproval().Sig = signature _ = a.bucketQueue.Push(task) + log.CtxInfow(ctx, "succeed to hand migrate bucket approval", "task", task, "state", state) return true, nil } diff --git a/modular/approver/approve_task_test.go b/modular/approver/approve_task_test.go index dc337aebb..38f7b53de 100644 --- a/modular/approver/approve_task_test.go +++ b/modular/approver/approve_task_test.go @@ -12,6 +12,7 @@ import ( "github.com/bnb-chain/greenfield-storage-provider/base/gfspclient" "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsptask" "github.com/bnb-chain/greenfield-storage-provider/core/consensus" + "github.com/bnb-chain/greenfield-storage-provider/core/spdb" coretask "github.com/bnb-chain/greenfield-storage-provider/core/task" "github.com/bnb-chain/greenfield-storage-provider/core/taskqueue" @@ -327,7 +328,7 @@ func TestApprovalModular_HandleMigrateBucketApprovalTaskSuccess2(t *testing.T) { m1.EXPECT().QuerySPHasEnoughQuotaForMigrateBucket(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes() m1.EXPECT().SignBucketMigrationInfo(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes() m1.EXPECT().GetBucketMeta(gomock.Any(), gomock.Any(), true).Return(&metadatatypes.VGFInfoBucket{ - BucketInfo: &storagetypes.BucketInfo{Id: math.NewUint(1)}}, nil, nil).Times(1) + BucketInfo: &storagetypes.BucketInfo{Id: math.NewUint(1)}}, nil, nil).AnyTimes() m.EXPECT().Push(gomock.Any()).Return(nil).AnyTimes() // mock consensus @@ -342,6 +343,9 @@ func TestApprovalModular_HandleMigrateBucketApprovalTaskSuccess2(t *testing.T) { }, nil).AnyTimes() mockedConsensus.EXPECT().QueryVirtualGroupFamily(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes() a.baseApp.SetConsensus(mockedConsensus) + mockedSPDB := spdb.NewMockSPDB(ctrl) + mockedSPDB.EXPECT().QueryMigrateBucketState(gomock.Any()).Return(0, nil).Times(1) + a.baseApp.SetGfSpDB(mockedSPDB) req := &gfsptask.GfSpMigrateBucketApprovalTask{ Task: &gfsptask.GfSpTask{}, MigrateBucketInfo: &storagetypes.MsgMigrateBucket{ @@ -376,7 +380,7 @@ func TestApprovalModular_HandleMigrateBucketApprovalTaskFailure2(t *testing.T) { m1.EXPECT().QuerySPHasEnoughQuotaForMigrateBucket(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes() m1.EXPECT().SignBucketMigrationInfo(gomock.Any(), gomock.Any()).Return(nil, mockErr).AnyTimes() m1.EXPECT().GetBucketMeta(gomock.Any(), gomock.Any(), true).Return(&metadatatypes.VGFInfoBucket{ - BucketInfo: &storagetypes.BucketInfo{Id: math.NewUint(1)}}, nil, nil).Times(1) + BucketInfo: &storagetypes.BucketInfo{Id: math.NewUint(1)}}, nil, nil).AnyTimes() // mock consensus mockedConsensus := consensus.NewMockConsensus(ctrl) @@ -391,6 +395,10 @@ func TestApprovalModular_HandleMigrateBucketApprovalTaskFailure2(t *testing.T) { mockedConsensus.EXPECT().QueryVirtualGroupFamily(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes() a.baseApp.SetConsensus(mockedConsensus) + mockedSPDB := spdb.NewMockSPDB(ctrl) + mockedSPDB.EXPECT().QueryMigrateBucketState(gomock.Any()).Return(0, nil).Times(1) + a.baseApp.SetGfSpDB(mockedSPDB) + req := &gfsptask.GfSpMigrateBucketApprovalTask{ Task: &gfsptask.GfSpTask{}, MigrateBucketInfo: &storagetypes.MsgMigrateBucket{ diff --git a/modular/authenticator/authenticator.go b/modular/authenticator/authenticator.go index a2fc78dac..15fdc8cc9 100644 --- a/modular/authenticator/authenticator.go +++ b/modular/authenticator/authenticator.go @@ -198,6 +198,16 @@ func (a *AuthenticationModular) VerifyAuthentication( return false, ErrNoSuchBucket } return true, nil + case coremodule.AuthOpTypeQueryBucketMigrationProgress: + queryTime := time.Now() + bucketInfo, _ := a.baseApp.Consensus().QueryBucketInfo(ctx, bucket) + metrics.PerfAuthTimeHistogram.WithLabelValues("auth_server_migrate_bucket_progress_query_bucket_time").Observe(time.Since(queryTime).Seconds()) + if bucketInfo == nil { + log.CtxErrorw(ctx, "failed to verify authentication of asking query migrate bucket "+ + "progress, bucket not existed", "bucket", bucket) + return false, ErrNoSuchBucket + } + return true, nil case coremodule.AuthOpAskCreateObjectApproval: queryTime := time.Now() bucketInfo, objectInfo, _ := a.baseApp.Consensus().QueryBucketInfoAndObjectInfo(ctx, bucket, object) diff --git a/modular/executor/execute_gc.go b/modular/executor/execute_gc.go index 99fafc898..e69aa58f1 100644 --- a/modular/executor/execute_gc.go +++ b/modular/executor/execute_gc.go @@ -7,7 +7,6 @@ import ( "strings" "time" - "cosmossdk.io/math" "github.com/bnb-chain/greenfield-storage-provider/core/piecestore" "github.com/bnb-chain/greenfield-storage-provider/core/spdb" corespdb "github.com/bnb-chain/greenfield-storage-provider/core/spdb" @@ -16,11 +15,9 @@ import ( metadatatypes "github.com/bnb-chain/greenfield-storage-provider/modular/metadata/types" "github.com/bnb-chain/greenfield-storage-provider/pkg/log" "github.com/bnb-chain/greenfield-storage-provider/pkg/metrics" - "github.com/bnb-chain/greenfield-storage-provider/store/bsdb" "github.com/bnb-chain/greenfield-storage-provider/store/sqldb" storagetypes "github.com/bnb-chain/greenfield/x/storage/types" virtualgrouptypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" - "github.com/forbole/juno/v4/common" ) type GCWorker struct { @@ -384,13 +381,16 @@ func (e *ExecuteModular) gcMetaReadRecord(ctx context.Context, task coretask.GCM } func (e *ExecuteModular) HandleGCBucketMigrationBucket(ctx context.Context, task coretask.GCBucketMigrationTask) { - // TODO gc progress persist in db var ( - groups []*bsdb.GlobalVirtualGroup - err error - startAfter uint64 = 0 - limit uint32 - objects []*metadatatypes.ObjectDetails + gvgList []*virtualgrouptypes.GlobalVirtualGroup + err error + startAfter uint64 = 0 + limit uint32 = 100 + objectList []*metadatatypes.ObjectDetails + gcNum uint64 = 0 + bucketInfo *storagetypes.BucketInfo + gcFinisheGvgNum uint64 = 0 + gvgTotalNum uint64 = 0 ) bucketID := task.GetBucketID() @@ -400,51 +400,78 @@ func (e *ExecuteModular) HandleGCBucketMigrationBucket(ctx context.Context, task return errors.Is(reportErr, manager.ErrCanceledTask) } defer func() { + task.SetTotalGvgNum(gvgTotalNum) + task.SetGCFinishedGvgNum(gcFinisheGvgNum) if err == nil { // succeed + task.SetFinished(true) reportProgress() } else { // failed task.SetError(err) reportProgress() } - log.CtxDebugw(ctx, "succeed to report gc bucket migration task", "task_info", task.Info(), "bucket_id", bucketID, "error", err) + log.CtxDebugw(ctx, "succeed to report gc bucket migration task", "task_info", task.Info(), + "bucket_id", bucketID, "gc_num", gcNum, "error", err) }() // list gvg - groups, err = e.baseApp.GfBsDB().ListGvgByBucketID(common.BigToHash(math.NewUint(bucketID).BigInt())) - if err != nil { - log.CtxErrorw(ctx, "failed to list global virtual group by bucket id", "error", err) + if gvgList, err = e.baseApp.GfSpClient().ListGlobalVirtualGroupsByBucket(ctx, bucketID); err != nil { + log.CtxErrorw(ctx, "failed to list global virtual group by bucket id", "bucket_id", bucketID, "error", err) return } // current chain's gvg info compare metadata info - bucketInfo, err := e.baseApp.Consensus().QueryBucketInfoById(ctx, bucketID) - if err != nil || bucketInfo == nil { - log.Errorw("failed to get bucket by bucket name", "error", err) + if bucketInfo, err = e.baseApp.Consensus().QueryBucketInfoById(ctx, bucketID); err != nil || bucketInfo == nil { + log.Errorw("failed to get bucket by bucket name", "bucket_id", bucketID, "error", err) return } vgfID := bucketInfo.GetGlobalVirtualGroupFamilyId() - log.CtxInfow(ctx, "begin to gc bucket migration by bucket id", "bucket_id", bucketID, "gvgs", groups, "vgfID", vgfID, "error", err) + log.CtxInfow(ctx, "begin to gc bucket migration by bucket id", "bucket_id", bucketID, "gvgList", gvgList, "vgfID", vgfID, "error", err) - for _, gvg := range groups { + gvgTotalNum = uint64(len(gvgList)) + + for _, gvg := range gvgList { if gvg.FamilyId != vgfID { - log.CtxErrorw(ctx, "failed to check gvg's status with chain's status, the gvg may be old data", "error", err) + log.CtxErrorw(ctx, "failed to check gvg's status with chain's status, the gvg may be old data", "bucket_id", bucketID, "gvg", gvg, "error", err) err = errors.New("gvg family id mismatch") return } - objects, err = e.baseApp.GfSpClient().ListObjectsByGVGAndBucketForGC(ctx, gvg.GlobalVirtualGroupId, bucketID, startAfter, limit) - if err != nil { - log.CtxErrorw(ctx, "failed to list objects by gvg and bucket for gc", "error", err) - return - } - // can delete, verify - for _, obj := range objects { - objectInfo := obj.GetObject().GetObjectInfo() - if e.gcWorker.checkGVGMatchSP(ctx, objectInfo, piecestore.PrimarySPRedundancyIndex) == ErrInvalidRedundancyIndex { - err = e.gcWorker.deleteObjectSegmentsAndIntegrity(ctx, objectInfo) - log.CtxInfow(ctx, "succeed to delete objects by gvg and bucket for gc", "object", objectInfo, "error", err) + for { + if objectList, err = e.baseApp.GfSpClient().ListObjectsByGVGAndBucketForGC(ctx, gvg.GetId(), bucketID, startAfter, limit); err != nil { + log.CtxErrorw(ctx, "failed to list objectList by gvg and bucket for gc", "bucket_id", bucketID, "gvg", gvg, "error", err) + return + } + // can delete, verify + for index, obj := range objectList { + gcNum++ + objectInfo := obj.GetObject().GetObjectInfo() + startAfter = obj.GetObject().GetObjectInfo().Id.Uint64() + if e.gcWorker.checkGVGMatchSP(ctx, objectInfo, piecestore.PrimarySPRedundancyIndex) == ErrInvalidRedundancyIndex { + err = e.gcWorker.deleteObjectSegmentsAndIntegrity(ctx, objectInfo) + log.CtxInfow(ctx, "succeed to delete objects by gvg and bucket for gc", "object", objectInfo, "error", err) + } + if gcNum%reportProgressPerN == 0 || index == len(objectList)-1 { + log.Infow("bucket migration gc report task", "current_gvg", gvg, "bucket_id", bucketID, + "last_gc_object_id", obj.GetObject().GetObjectInfo().Id.Uint64()) + task.SetLastGCObjectID(obj.GetObject().GetObjectInfo().Id.Uint64()) + task.SetLastGCGvgID(uint64(gvg.GetId())) + task.SetTotalGvgNum(gvgTotalNum) + task.SetGCFinishedGvgNum(gcFinisheGvgNum) + if err = e.ReportTask(ctx, task); err != nil { // report task is already automatically triggered. + log.CtxErrorw(ctx, "failed to report bucket migration task gc progress", "task_info", task, "error", err) + return + } + } + } + + if len(objectList) < int(limit) { + log.CtxInfow(ctx, "succeed to finish one gvg bucket migration gc", "bucket_id", bucketID, "gvg", gvg) + gcFinisheGvgNum++ + break } } } + + log.CtxInfow(ctx, "succeed to gc bucket migration by bucket id", "bucket_id", bucketID, "gvgs", gvgList, "vgfID", vgfID, "gc_num", gcNum) } func (e *ExecuteModular) gcZombiePieceFromIntegrityMeta(ctx context.Context, task coretask.GCZombiePieceTask) error { diff --git a/modular/gater/bucket_handler.go b/modular/gater/bucket_handler.go index 66d3e002b..d9aa6cab1 100644 --- a/modular/gater/bucket_handler.go +++ b/modular/gater/bucket_handler.go @@ -3,9 +3,11 @@ package gater import ( "encoding/xml" "net/http" + "strings" "time" "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsperrors" + "github.com/bnb-chain/greenfield-storage-provider/base/types/gfspserver" coremodule "github.com/bnb-chain/greenfield-storage-provider/core/module" modelgateway "github.com/bnb-chain/greenfield-storage-provider/model/gateway" metadatatypes "github.com/bnb-chain/greenfield-storage-provider/modular/metadata/types" @@ -228,3 +230,91 @@ func (g *GateModular) listBucketReadRecordHandler(w http.ResponseWriter, r *http } log.Debugw("succeed to list bucket read records", "xml_info", xmlInfo) } + +// queryBucketMigrationProgressHandler handles the query bucket migration progress request. +func (g *GateModular) queryBucketMigrationProgressHandler(w http.ResponseWriter, r *http.Request) { + var ( + err error + reqCtx *RequestContext + authenticated bool + bucketInfo *storagetypes.BucketInfo + errDescription string + migrationState int32 + progressMeta *gfspserver.MigrateBucketProgressMeta + migratedBytes uint64 + ) + startTime := time.Now() + defer func() { + reqCtx.Cancel() + if err != nil { + reqCtx.SetError(gfsperrors.MakeGfSpError(err)) + reqCtx.SetHTTPCode(int(gfsperrors.MakeGfSpError(err).GetHttpStatusCode())) + modelgateway.MakeErrorResponse(w, gfsperrors.MakeGfSpError(err)) + metrics.ReqCounter.WithLabelValues(GatewayTotalFailure).Inc() + metrics.ReqTime.WithLabelValues(GatewayTotalFailure).Observe(time.Since(startTime).Seconds()) + } else { + reqCtx.SetHTTPCode(http.StatusOK) + metrics.ReqCounter.WithLabelValues(GatewayTotalSuccess).Inc() + metrics.ReqTime.WithLabelValues(GatewayTotalSuccess).Observe(time.Since(startTime).Seconds()) + } + log.CtxDebugw(reqCtx.Context(), reqCtx.String()) + }() + + if reqCtx, err = NewRequestContext(r, g); err != nil { + return + } + authenticated, err = g.baseApp.GfSpClient().VerifyAuthentication(reqCtx.Context(), + coremodule.AuthOpTypeQueryBucketMigrationProgress, reqCtx.Account(), reqCtx.bucketName, reqCtx.objectName) + if err != nil { + log.CtxErrorw(reqCtx.Context(), "failed to verify authentication", "error", err) + return + } + if !authenticated { + log.CtxErrorw(reqCtx.Context(), "no permission to operate") + err = ErrNoPermission + return + } + + if bucketInfo, err = g.baseApp.Consensus().QueryBucketInfo(reqCtx.Context(), reqCtx.bucketName); err != nil { + log.CtxErrorw(reqCtx.Context(), "failed to get bucket info from consensus", "error", err) + err = ErrConsensusWithDetail("failed to get bucket info from consensus, error: " + err.Error()) + return + } + + if progressMeta, err = g.baseApp.GfSpClient().GetMigrateBucketProgress(reqCtx.Context(), bucketInfo.Id.Uint64()); err != nil { + log.CtxErrorw(reqCtx.Context(), "failed to get bucket migration job state", "error", err) + if !strings.Contains(err.Error(), "record not found") { + return + } + err = nil + } else { + migrationState = int32(progressMeta.GetMigrateState()) + migratedBytes = progressMeta.GetMigratedBytes() + } + + var xmlInfo = struct { + XMLName xml.Name `xml:"QueryMigrationProgress"` + Version string `xml:"version,attr"` + ErrorDescription string `xml:"ErrorDescription"` + MigratedBytes uint64 `xml:"MigratedBytes"` + MigrationState uint32 `xml:"MigrationState"` + }{ + Version: GnfdResponseXMLVersion, + ErrorDescription: errDescription, + MigratedBytes: migratedBytes, + MigrationState: uint32(migrationState), + } + xmlBody, err := xml.Marshal(&xmlInfo) + if err != nil { + log.Errorw("failed to marshal xml", "error", err) + err = ErrEncodeResponseWithDetail("failed to marshal xml, error: " + err.Error()) + return + } + w.Header().Set(ContentTypeHeader, ContentTypeXMLHeaderValue) + if _, err = w.Write(xmlBody); err != nil { + log.Errorw("failed to write body", "error", err) + err = ErrEncodeResponseWithDetail("failed to write body, error: " + err.Error()) + return + } + log.Debugw("succeed to query bucket migration progress", "xml_info", xmlInfo) +} diff --git a/modular/gater/bucket_handler_test.go b/modular/gater/bucket_handler_test.go index b824fafa5..184c69323 100644 --- a/modular/gater/bucket_handler_test.go +++ b/modular/gater/bucket_handler_test.go @@ -15,8 +15,10 @@ import ( commonhttp "github.com/bnb-chain/greenfield-common/go/http" "github.com/bnb-chain/greenfield-storage-provider/base/gfspclient" + "github.com/bnb-chain/greenfield-storage-provider/base/types/gfspserver" "github.com/bnb-chain/greenfield-storage-provider/core/consensus" metadatatypes "github.com/bnb-chain/greenfield-storage-provider/modular/metadata/types" + storetypes "github.com/bnb-chain/greenfield-storage-provider/store/types" storagetypes "github.com/bnb-chain/greenfield/x/storage/types" ) @@ -495,3 +497,188 @@ func TestGateModular_listBucketReadRecordHandler(t *testing.T) { }) } } + +func mockQueryBucketMigrationProgressRoute(t *testing.T, g *GateModular) *mux.Router { + t.Helper() + router := mux.NewRouter().SkipClean(true) + var routers []*mux.Router + routers = append(routers, router.Host("{bucket:.+}."+g.domain).Subrouter()) + routers = append(routers, router.PathPrefix("/{bucket}").Subrouter()) + for _, r := range routers { + r.NewRoute().Name(queryMigrationProgressRouterName).Methods(http.MethodGet).HandlerFunc(g.queryBucketMigrationProgressHandler). + Queries(GetBucketMigrationProgressQuery, "") + } + return router +} + +func TestGateModular_queryBucketMigrationProgressHandler(t *testing.T) { + cases := []struct { + name string + fn func() *GateModular + request func() *http.Request + wantedResult string + }{ + { + name: "new request context error", + fn: func() *GateModular { + g := setup(t) + ctrl := gomock.NewController(t) + clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) + clientMock.EXPECT().VerifyGNFD1EddsaSignature(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(false, mockErr).Times(1) + g.baseApp.SetGfSpClient(clientMock) + return g + }, + request: func() *http.Request { + path := fmt.Sprintf("%s%s/%s?%s", scheme, mockBucketName, testDomain, GetBucketMigrationProgressQuery) + req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) + validExpiryDateStr := time.Now().Add(time.Hour * 60).Format(ExpiryDateFormat) + req.Header.Set(commonhttp.HTTPHeaderExpiryTimestamp, validExpiryDateStr) + req.Header.Set(GnfdAuthorizationHeader, "GNFD1-EDDSA,Signature=48656c6c6f20476f7068657221") + return req + }, + wantedResult: "mock error", + }, + { + name: "failed to verify authentication", + fn: func() *GateModular { + g := setup(t) + ctrl := gomock.NewController(t) + clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) + clientMock.EXPECT().VerifyGNFD1EddsaSignature(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(false, nil).Times(1) + clientMock.EXPECT().VerifyAuthentication(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(false, mockErr).Times(1) + g.baseApp.SetGfSpClient(clientMock) + return g + }, + request: func() *http.Request { + path := fmt.Sprintf("%s%s/%s?%s", scheme, mockBucketName, testDomain, GetBucketMigrationProgressQuery) + req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) + validExpiryDateStr := time.Now().Add(time.Hour * 60).Format(ExpiryDateFormat) + req.Header.Set(commonhttp.HTTPHeaderExpiryTimestamp, validExpiryDateStr) + req.Header.Set(GnfdAuthorizationHeader, "GNFD1-EDDSA,Signature=48656c6c6f20476f7068657221") + return req + }, + wantedResult: "mock error", + }, + { + name: "no permission to operate", + fn: func() *GateModular { + g := setup(t) + ctrl := gomock.NewController(t) + clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) + clientMock.EXPECT().VerifyGNFD1EddsaSignature(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(false, nil).Times(1) + clientMock.EXPECT().VerifyAuthentication(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(false, nil).Times(1) + g.baseApp.SetGfSpClient(clientMock) + return g + }, + request: func() *http.Request { + path := fmt.Sprintf("%s%s/%s?%s", scheme, mockBucketName, testDomain, GetBucketMigrationProgressQuery) + req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) + validExpiryDateStr := time.Now().Add(time.Hour * 60).Format(ExpiryDateFormat) + req.Header.Set(commonhttp.HTTPHeaderExpiryTimestamp, validExpiryDateStr) + req.Header.Set(GnfdAuthorizationHeader, "GNFD1-EDDSA,Signature=48656c6c6f20476f7068657221") + return req + }, + wantedResult: "no permission", + }, + { + name: "failed to get bucket info from consensus", + fn: func() *GateModular { + g := setup(t) + ctrl := gomock.NewController(t) + clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) + clientMock.EXPECT().VerifyGNFD1EddsaSignature(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(false, nil).Times(1) + clientMock.EXPECT().VerifyAuthentication(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(true, nil).Times(1) + g.baseApp.SetGfSpClient(clientMock) + + consensusMock := consensus.NewMockConsensus(ctrl) + consensusMock.EXPECT().QueryBucketInfo(gomock.Any(), gomock.Any()).Return(nil, mockErr).Times(1) + g.baseApp.SetConsensus(consensusMock) + return g + }, + request: func() *http.Request { + path := fmt.Sprintf("%s%s/%s?%s", scheme, mockBucketName, testDomain, GetBucketMigrationProgressQuery) + req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) + validExpiryDateStr := time.Now().Add(time.Hour * 60).Format(ExpiryDateFormat) + req.Header.Set(commonhttp.HTTPHeaderExpiryTimestamp, validExpiryDateStr) + req.Header.Set(GnfdAuthorizationHeader, "GNFD1-EDDSA,Signature=48656c6c6f20476f7068657221") + return req + }, + wantedResult: "failed to get bucket info from consensus", + }, + { + name: "failed to get bucket migrate progress", + fn: func() *GateModular { + g := setup(t) + ctrl := gomock.NewController(t) + progress := &gfspserver.MigrateBucketProgressMeta{BucketId: 2, MigrateState: uint32(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATION_FINISHED)} + clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) + clientMock.EXPECT().VerifyGNFD1EddsaSignature(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(false, nil).Times(1) + clientMock.EXPECT().VerifyAuthentication(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(true, nil).Times(1) + clientMock.EXPECT().GetMigrateBucketProgress(gomock.Any(), gomock.Any()).Return(progress, mockErr).Times(1) + g.baseApp.SetGfSpClient(clientMock) + + consensusMock := consensus.NewMockConsensus(ctrl) + consensusMock.EXPECT().QueryBucketInfo(gomock.Any(), gomock.Any()).Return(&storagetypes.BucketInfo{ + BucketName: mockBucketName, Id: sdkmath.NewUint(1)}, nil).Times(1) + g.baseApp.SetConsensus(consensusMock) + return g + }, + request: func() *http.Request { + path := fmt.Sprintf("%s%s/%s?%s", scheme, mockBucketName, testDomain, GetBucketMigrationProgressQuery) + req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) + validExpiryDateStr := time.Now().Add(time.Hour * 60).Format(ExpiryDateFormat) + req.Header.Set(commonhttp.HTTPHeaderExpiryTimestamp, validExpiryDateStr) + req.Header.Set(GnfdAuthorizationHeader, "GNFD1-EDDSA,Signature=48656c6c6f20476f7068657221") + return req + }, + wantedResult: "mock error", + }, + { + name: "success", + fn: func() *GateModular { + g := setup(t) + ctrl := gomock.NewController(t) + progress := &gfspserver.MigrateBucketProgressMeta{BucketId: 2, MigrateState: uint32(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATION_FINISHED)} + clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) + clientMock.EXPECT().VerifyGNFD1EddsaSignature(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(false, nil).Times(1) + clientMock.EXPECT().VerifyAuthentication(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(true, nil).Times(1) + clientMock.EXPECT().GetMigrateBucketProgress(gomock.Any(), gomock.Any()).Return(progress, nil).Times(1) + g.baseApp.SetGfSpClient(clientMock) + + consensusMock := consensus.NewMockConsensus(ctrl) + consensusMock.EXPECT().QueryBucketInfo(gomock.Any(), gomock.Any()).Return(&storagetypes.BucketInfo{ + BucketName: mockBucketName, Id: sdkmath.NewUint(1)}, nil).Times(1) + g.baseApp.SetConsensus(consensusMock) + return g + }, + request: func() *http.Request { + path := fmt.Sprintf("%s%s/%s?%s", scheme, mockBucketName, testDomain, GetBucketMigrationProgressQuery) + req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) + validExpiryDateStr := time.Now().Add(time.Hour * 60).Format(ExpiryDateFormat) + req.Header.Set(commonhttp.HTTPHeaderExpiryTimestamp, validExpiryDateStr) + req.Header.Set(GnfdAuthorizationHeader, "GNFD1-EDDSA,Signature=48656c6c6f20476f7068657221") + return req + }, + wantedResult: "", + }, + } + for _, tt := range cases { + t.Run(tt.name, func(t *testing.T) { + router := mockQueryBucketMigrationProgressRoute(t, tt.fn()) + w := httptest.NewRecorder() + router.ServeHTTP(w, tt.request()) + assert.Contains(t, w.Body.String(), tt.wantedResult) + }) + } +} diff --git a/modular/gater/const.go b/modular/gater/const.go index c2fe11a85..cd0b0f0ea 100644 --- a/modular/gater/const.go +++ b/modular/gater/const.go @@ -71,6 +71,8 @@ const ( ListObjectsIncludeRemovedQuery = "include-removed" // GetBucketMetaQuery defines get bucket metadata query, which is used to route request GetBucketMetaQuery = "bucket-meta" + // GetBucketMigrationProgressQuery defines get bucket metadata query, which is used to route request + GetBucketMigrationProgressQuery = "bucket-migration-progress" // GetObjectMetaQuery defines get object metadata query, which is used to route request GetObjectMetaQuery = "object-meta" // GetGroupListSourceTypeQuery defines get group list source type query, which is used to route request @@ -230,6 +232,8 @@ const ( GnfdIntegrityHashHeader = "X-Gnfd-Integrity-Hash" // GnfdPieceHashHeader defines piece hash list, which is used by challenge GnfdPieceHashHeader = "X-Gnfd-Piece-Hash" + // GnfdQuotaInfoHeader defines quota info, which is used by sp + GnfdQuotaInfoHeader = "X-Gnfd-Quota-Info" // GnfdUnsignedApprovalMsgHeader defines unsigned msg, which is used by get-approval GnfdUnsignedApprovalMsgHeader = "X-Gnfd-Unsigned-Msg" // GnfdSignedApprovalMsgHeader defines signed msg, which is used by get-approval diff --git a/modular/gater/migrate_handler.go b/modular/gater/migrate_handler.go index b8f4290bc..a307d8e6c 100644 --- a/modular/gater/migrate_handler.go +++ b/modular/gater/migrate_handler.go @@ -368,6 +368,8 @@ func (g *GateModular) getLatestBucketQuotaHandler(w http.ResponseWriter, r *http bucketID uint64 bucketMigrationInfo *gfsptask.GfSpBucketMigrationInfo allowMigrate bool + bz []byte + quota *gfsptask.GfSpBucketQuotaInfo ) defer func() { @@ -394,22 +396,19 @@ func (g *GateModular) getLatestBucketQuotaHandler(w http.ResponseWriter, r *http } bucketID = bucketMigrationInfo.GetBucketId() - quota, err := g.baseApp.GfSpClient().GetLatestBucketReadQuota( - reqCtx.Context(), bucketID) - if err != nil { + if quota, err = g.baseApp.GfSpClient().GetLatestBucketReadQuota(reqCtx.Context(), bucketID); err != nil { log.CtxErrorw(reqCtx.Context(), "failed to get bucket read quota", "bucket_id", bucketID, "error", err) return } - bz, err := quota.Marshal() - if err != nil { + if bz, err = quota.Marshal(); err != nil { log.CtxErrorw(reqCtx.Context(), "failed to marshal", "bucket_id", bucketID, "error", err) return } - w.Header().Set(GnfdSignedApprovalMsgHeader, hex.EncodeToString(bz)) + w.Header().Set(GnfdQuotaInfoHeader, hex.EncodeToString(bz)) w.Header().Set(ContentTypeHeader, ContentTypeXMLHeaderValue) log.CtxInfow(reqCtx.Context(), "succeed to get latest bucket quota", "bucket_id", @@ -425,6 +424,8 @@ func (g *GateModular) preMigrateBucketHandler(w http.ResponseWriter, r *http.Req bucketSize uint64 bucketMigrationInfo *gfsptask.GfSpBucketMigrationInfo allowMigrate bool + quota *gfsptask.GfSpBucketQuotaInfo + bz []byte ) defer func() { @@ -451,44 +452,23 @@ func (g *GateModular) preMigrateBucketHandler(w http.ResponseWriter, r *http.Req } bucketID = bucketMigrationInfo.GetBucketId() - err = g.baseApp.GfSpClient().NotifyPreMigrateBucket(reqCtx.Context(), bucketID) - if err != nil { + if quota, err = g.baseApp.GfSpClient().NotifyPreMigrateBucketAndDeductQuota(reqCtx.Context(), bucketID); err != nil || quota == nil { log.CtxErrorw(reqCtx.Context(), "failed to pre migrate bucket, the bucket may already notified", "bucket_id", bucketID, "error", err) + // if the bucket has already pre notified ignore the error + if strings.Contains(err.Error(), "the bucket has already notified") { + err = nil + } return } - // get bucket quota and check, lock quota - bucketSize, err = g.getBucketTotalSize(reqCtx.Context(), bucketID) - if err != nil { - return - } - - quota, err := g.baseApp.GfSpClient().GetLatestBucketReadQuota( - reqCtx.Context(), bucketID) - if err != nil { - log.CtxErrorw(reqCtx.Context(), "failed to get bucket read quota", "bucket_id", - bucketID, "error", err) - return - } - - // reduce quota, sql db - err = g.baseApp.GfSpClient().DeductQuotaForBucketMigrate( - reqCtx.Context(), bucketID, bucketSize, quota.GetMonth()) - if err != nil { - log.CtxErrorw(reqCtx.Context(), "failed to get bucket read quota", "bucket_id", - bucketID, "error", err) - return - } - - bz, err := quota.Marshal() - if err != nil { + if bz, err = quota.Marshal(); err != nil { log.CtxErrorw(reqCtx.Context(), "failed to marshal", "bucket_id", bucketID, "error", err) return } - w.Header().Set(GnfdSignedApprovalMsgHeader, hex.EncodeToString(bz)) + w.Header().Set(GnfdQuotaInfoHeader, hex.EncodeToString(bz)) w.Header().Set(ContentTypeHeader, ContentTypeXMLHeaderValue) log.CtxInfow(reqCtx.Context(), "succeed to pre bucket migrate and deduct quota", "bucket_id", @@ -498,13 +478,13 @@ func (g *GateModular) preMigrateBucketHandler(w http.ResponseWriter, r *http.Req // postMigrateBucketHandler notifying the source sp about the completion of migration bucket func (g *GateModular) postMigrateBucketHandler(w http.ResponseWriter, r *http.Request) { var ( - err error - reqCtx *RequestContext - bucketID uint64 - bucketSize uint64 + err error + reqCtx *RequestContext + bucketID uint64 + bucketMigrationInfo *gfsptask.GfSpBucketMigrationInfo allowMigrate bool - extraQuota uint64 + latestQuota *gfsptask.GfSpBucketQuotaInfo ) defer func() { @@ -531,51 +511,19 @@ func (g *GateModular) postMigrateBucketHandler(w http.ResponseWriter, r *http.Re } bucketID = bucketMigrationInfo.GetBucketId() - err = g.baseApp.GfSpClient().NotifyPostMigrateBucket(reqCtx.Context(), bucketMigrationInfo) - if err != nil { + if latestQuota, err = g.baseApp.GfSpClient().NotifyPostMigrateBucketAndRecoupQuota(reqCtx.Context(), bucketMigrationInfo); err != nil { log.CtxErrorw(reqCtx.Context(), "post migrate bucket error, the bucket may already notified", "bucket_id", bucketID, "error", err) return } - latestQuota, err := g.baseApp.GfSpClient().GetLatestBucketReadQuota( - reqCtx.Context(), bucketID) + bz, err := latestQuota.Marshal() if err != nil { - log.CtxErrorw(reqCtx.Context(), "failed to get bucket read quota", "bucket_id", + log.CtxErrorw(reqCtx.Context(), "failed to marshal", "bucket_id", bucketID, "error", err) return } - - if bucketMigrationInfo.GetFinished() { - bz, err := latestQuota.Marshal() - if err != nil { - log.CtxErrorw(reqCtx.Context(), "failed to marshal", "bucket_id", - bucketID, "error", err) - return - } - w.Header().Set(GnfdSignedApprovalMsgHeader, hex.EncodeToString(bz)) - } else { - // get bucket quota and check TODO month check - bucketSize, err = g.getBucketTotalSize(reqCtx.Context(), bucketID) - if err != nil { - return - } - migratedBytes := bucketMigrationInfo.GetMigratedBytesSize() - if migratedBytes >= bucketSize { - // If the data migrated surpasses the total bucket size, quota recoup is skipped. - // This situation may arise due to deletions in the bucket migration process. - log.CtxErrorw(reqCtx.Context(), "failed to recoup extra quota to user", "error", err) - } else { - extraQuota = bucketSize - migratedBytes - quotaUpdateErr := g.baseApp.GfSpClient().RecoupQuota(reqCtx.Context(), bucketMigrationInfo.GetBucketId(), extraQuota, latestQuota.GetMonth()) - // no need to return the db error to user - if quotaUpdateErr != nil { - log.CtxErrorw(reqCtx.Context(), "failed to recoup extra quota to user", "error", err) - } - } - log.CtxDebugw(reqCtx.Context(), "succeed to recoup extra quota to user", "extra_quote", extraQuota) - } - + w.Header().Set(GnfdQuotaInfoHeader, hex.EncodeToString(bz)) w.Header().Set(ContentTypeHeader, ContentTypeXMLHeaderValue) log.CtxInfow(reqCtx.Context(), "succeed to post bucket migrate", "bucket_id", @@ -644,7 +592,7 @@ func (g *GateModular) sufficientQuotaForBucketMigrationHandler(w http.ResponseWr return } - w.Header().Set(GnfdSignedApprovalMsgHeader, hex.EncodeToString(bz)) + w.Header().Set(GnfdQuotaInfoHeader, hex.EncodeToString(bz)) w.Header().Set(ContentTypeHeader, ContentTypeXMLHeaderValue) log.CtxInfow(reqCtx.Context(), "succeed to check bucket migrate quota", "bucket_id", bucketID, "quota", quota, "bucket_size", bucketSize) diff --git a/modular/gater/router.go b/modular/gater/router.go index a64dfb09b..41df6d0e2 100644 --- a/modular/gater/router.go +++ b/modular/gater/router.go @@ -32,6 +32,7 @@ const ( viewObjectByUniversalEndpointName = "ViewObjectByUniversalEndpoint" getObjectMetaRouterName = "GetObjectMeta" getBucketMetaRouterName = "GetBucketMeta" + queryMigrationProgressRouterName = "QueryMigrationProgress" getGroupListRouterName = "GetGroupList" listBucketsByIDsRouterName = "ListBucketsByIDs" listObjectsByIDsRouterName = "ListObjectsByIDs" @@ -169,6 +170,10 @@ func (g *GateModular) RegisterHandler(router *mux.Router) { // Get Bucket Meta r.NewRoute().Name(getBucketMetaRouterName).Methods(http.MethodGet).Queries(GetBucketMetaQuery, "").HandlerFunc(g.getBucketMetaHandler) + // Query migration progress + r.NewRoute().Name(queryMigrationProgressRouterName).Methods(http.MethodGet).HandlerFunc(g.queryBucketMigrationProgressHandler). + Queries(GetBucketMigrationProgressQuery, "") + // Get Object Meta r.NewRoute().Name(getObjectMetaRouterName).Methods(http.MethodGet).Path("/{object:.+}").HandlerFunc(g.getObjectMetaHandler). Queries(GetObjectMetaQuery, "") diff --git a/modular/gater/router_test.go b/modular/gater/router_test.go index 30e78f033..dbd91c223 100644 --- a/modular/gater/router_test.go +++ b/modular/gater/router_test.go @@ -296,6 +296,22 @@ func TestRouters(t *testing.T) { shouldMatch: true, wantedRouterName: getBucketMetaRouterName, }, + { + name: "Get bucket migration progress router, virtual host style", + router: gwRouter, + method: http.MethodGet, + url: fmt.Sprintf("%s%s/%s?%s", scheme, mockBucketName, testDomain, GetBucketMigrationProgressQuery), + shouldMatch: true, + wantedRouterName: queryMigrationProgressRouterName, + }, + { + name: "Get bucket migration progress router, path style", + router: gwRouter, + method: http.MethodGet, + url: fmt.Sprintf("%s%s/%s?%s", scheme, mockBucketName, testDomain, GetBucketMigrationProgressQuery), + shouldMatch: true, + wantedRouterName: queryMigrationProgressRouterName, + }, { name: "Challenge router", router: gwRouter, diff --git a/modular/manager/bucket_migrate_scheduler.go b/modular/manager/bucket_migrate_scheduler.go index d2f6aeb5d..e6473dcd1 100644 --- a/modular/manager/bucket_migrate_scheduler.go +++ b/modular/manager/bucket_migrate_scheduler.go @@ -11,11 +11,7 @@ import ( "cosmossdk.io/math" sdkmath "cosmossdk.io/math" - sptypes "github.com/bnb-chain/greenfield/x/sp/types" - storagetypes "github.com/bnb-chain/greenfield/x/storage/types" - virtualgrouptypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" - sdk "github.com/cosmos/cosmos-sdk/types" - + "github.com/bnb-chain/greenfield-storage-provider/base/gfspapp" "github.com/bnb-chain/greenfield-storage-provider/base/gfspvgmgr" "github.com/bnb-chain/greenfield-storage-provider/base/types/gfspserver" "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsptask" @@ -25,7 +21,12 @@ import ( "github.com/bnb-chain/greenfield-storage-provider/core/vgmgr" "github.com/bnb-chain/greenfield-storage-provider/modular/metadata/types" "github.com/bnb-chain/greenfield-storage-provider/pkg/log" + storetypes "github.com/bnb-chain/greenfield-storage-provider/store/types" "github.com/bnb-chain/greenfield-storage-provider/util" + sptypes "github.com/bnb-chain/greenfield/x/sp/types" + storagetypes "github.com/bnb-chain/greenfield/x/storage/types" + virtualgrouptypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" + sdk "github.com/cosmos/cosmos-sdk/types" ) const ( @@ -186,10 +187,12 @@ func (plan *BucketMigrateExecutePlan) sendCompleteMigrateBucketTx(migrateExecute vgfID uint32 err error ) + if err = UpdateBucketMigrationProgress(plan.manager.baseApp, plan.bucketID, storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATE_GVG_DONE); err != nil { + return err + } // empty bucket, need to pick a vgf if migrateExecuteUnit == nil { - vgfID, err = plan.manager.PickVirtualGroupFamily(context.Background(), &task.NullTask{}) - if err != nil { + if vgfID, err = plan.manager.PickVirtualGroupFamily(context.Background(), &task.NullTask{}); err != nil { log.Errorw("failed to pick vgf for migrate bucket", "error", err) return err } @@ -218,6 +221,9 @@ func (plan *BucketMigrateExecutePlan) sendCompleteMigrateBucketTx(migrateExecute log.Errorw("failed to send complete migrate bucket msg to chain", "msg", migrateBucket, "tx_hash", txHash, "err", txErr) return txErr } + if err = UpdateBucketMigrationProgress(plan.manager.baseApp, plan.bucketID, storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SEND_COMPLETE_TX_DONE); err != nil { + return err + } log.Infow("sent complete migrate bucket msg to chain", "msg", migrateBucket, "tx_hash", txHash) return nil } @@ -236,30 +242,32 @@ func (plan *BucketMigrateExecutePlan) rejectBucketMigration() error { log.Errorw("failed to send reject migrate bucket msg to chain", "msg", rejectMigrateBucket, "tx_hash", txHash, "err", txErr) return txErr } + + if err = UpdateBucketMigrationProgress(plan.manager.baseApp, bucket.BucketInfo.Id.Uint64(), storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SEND_REJECT_TX_DONE); err != nil { + return err + } + log.Infow("sent reject migrate bucket msg to chain", "msg", rejectMigrateBucket, "tx_hash", txHash) return nil } -func (plan *BucketMigrateExecutePlan) syncBucketQuotaFromSrcSP(migrateExecuteUnit *BucketMigrateGVGExecuteUnit) error { +func (plan *BucketMigrateExecutePlan) syncBucketQuotaFromSrcSP(bucketID uint64, srcSPInfo *sptypes.StorageProvider) error { var ( signature []byte err error + quota gfsptask.GfSpBucketQuotaInfo ) - bucketID := migrateExecuteUnit.BucketID - srcSPInfo := migrateExecuteUnit.SrcSP log.Infow("start to query quota from src SP", "src_sp", srcSPInfo, "bucket_id", bucketID) // query src sp, bucket migrate quota queryMsg := &gfsptask.GfSpBucketMigrationInfo{BucketId: bucketID} queryMsg.ExpireTime = time.Now().Unix() + SigExpireTimeSecond - signature, err = plan.manager.baseApp.GfSpClient().SignBucketMigrationInfo(context.Background(), queryMsg) - if err != nil { + if signature, err = plan.manager.baseApp.GfSpClient().SignBucketMigrationInfo(context.Background(), queryMsg); err != nil { log.Errorw("failed to sign migrate bucket", "bucket_migration_info", queryMsg, "error", err) return err } queryMsg.SetSignature(signature) - quota, err := plan.manager.baseApp.GfSpClient().QueryLatestBucketQuota(context.Background(), srcSPInfo.GetEndpoint(), queryMsg) - if err != nil { + if quota, err = plan.manager.baseApp.GfSpClient().QueryLatestBucketQuota(context.Background(), srcSPInfo.GetEndpoint(), queryMsg); err != nil { log.Debugw("failed to query bucket quota from src sp", "src_sp", srcSPInfo, "error", err) return err } @@ -275,53 +283,51 @@ func (plan *BucketMigrateExecutePlan) syncBucketQuotaFromSrcSP(migrateExecuteUni } // set dest sp bucket quota info - err = plan.manager.baseApp.GfSpDB().UpdateBucketTraffic(bucketID, update) - if err != nil { + if err = plan.manager.baseApp.GfSpDB().UpdateBucketTraffic(bucketID, update); err != nil { log.Errorw("failed to update bucket traffic for bucket migrate", "bucket_id", bucketID, "error", err) return err } + + if err = UpdateBucketMigrationProgress(plan.manager.baseApp, bucketID, storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATE_QUOTA_INFO_DONE); err != nil { + return err + } + log.Infow("succeed to query quota from src SP", "src_sp", srcSPInfo, "quota", quota) return nil } func (plan *BucketMigrateExecutePlan) updateMigrateGVGStatus(migrateKey string, task task.MigrateGVGTask, migrateExecuteUnit *BucketMigrateGVGExecuteUnit, migrateStatus MigrateStatus) error { - + var err error + bucketID := migrateExecuteUnit.BucketID + gvgUnitsTotal := uint32(len(plan.gvgUnitMap)) // update migrate gvg status - err := plan.manager.baseApp.GfSpDB().UpdateMigrateGVGUnitStatus(migrateKey, int(migrateStatus)) - if err != nil { + if err = plan.manager.baseApp.GfSpDB().UpdateMigrateGVGUnitStatus(migrateKey, int(migrateStatus)); err != nil { log.Errorw("update migrate gvg status", "migrate_key", migrateKey, "error", err) return err } + migrateExecuteUnit.MigrateStatus = migrateStatus plan.finishedGvgUnits[migrateExecuteUnit.SrcGVG.GetId()] = struct{}{} + gvgUnitsFinished := uint32(len(plan.finishedGvgUnits)) + if err = plan.manager.baseApp.GfSpDB().UpdateBucketMigrationMigratingProgress(bucketID, gvgUnitsTotal, gvgUnitsFinished); err != nil { + log.Errorw("failed to update bucket migration migrating progress", "migrate_key", migrateKey, "total", gvgUnitsTotal, "finished", gvgUnitsFinished, "error", err) + return err + } + // all migrate units success, send tx to chain if len(plan.finishedGvgUnits) == len(plan.gvgUnitMap) { // set bucket quota - err = plan.syncBucketQuotaFromSrcSP(migrateExecuteUnit) - if err != nil { + if err = plan.syncBucketQuotaFromSrcSP(migrateExecuteUnit.BucketID, migrateExecuteUnit.SrcSP); err != nil { log.Errorw("failed to update bucket quota", "error", err, "migrateExecuteUnit", migrateExecuteUnit) return err } - err = plan.sendCompleteMigrateBucketTx(migrateExecuteUnit) - if err != nil { + if err = plan.sendCompleteMigrateBucketTx(migrateExecuteUnit); err != nil { log.Errorw("failed to send complete migrate bucket msg to chain", "error", err, "migrateExecuteUnit", migrateExecuteUnit) return err } - // wait for bucket status change onchain - time.Sleep(blockInterval) - err = plan.scheduler.doneMigrateBucket(migrateExecuteUnit.BucketID) - if err != nil { - log.Errorw("failed to done migrate bucket", "error", err, "bucket_id", migrateExecuteUnit.BucketID) - return err - } - // notify src sp to gc - postMsg := &gfsptask.GfSpBucketMigrationInfo{BucketId: task.GetBucketID(), Finished: task.GetFinished(), MigratedBytesSize: task.GetMigratedBytesSize()} - err = plan.manager.bucketMigrateScheduler.PostMigrateBucket(postMsg, plan.srcSP) - if err != nil { - log.Errorw("failed to post migrate bucket", "msg", postMsg, "error", err) - } + } return nil } @@ -360,6 +366,7 @@ func (plan *BucketMigrateExecutePlan) startMigrateSchedule() { return // Terminate the scheduling default: log.Debugw("start to push migrate gvg task to queue", "plan", plan, "gvg_unit_map", plan.gvgUnitMap) + for _, migrateGVGUnit := range plan.gvgUnitMap { // Skipping units that have already been scheduled if migrateGVGUnit.MigrateStatus != WaitForMigrate { @@ -382,11 +389,13 @@ func (plan *BucketMigrateExecutePlan) startMigrateSchedule() { log.Debugw("success to push migrate gvg task to queue", "migrateGVGUnit", migrateGVGUnit, "migrateGVGTask", migrateGVGTask) // Update database: migrateStatus to migrating - err = plan.manager.baseApp.GfSpDB().UpdateMigrateGVGUnitStatus(migrateGVGUnit.Key(), int(Migrating)) - if err != nil { + if err = plan.manager.baseApp.GfSpDB().UpdateMigrateGVGUnitStatus(migrateGVGUnit.Key(), int(Migrating)); err != nil { log.Errorw("failed to update migrate gvg status", "gvg_unit", migrateGVGUnit, "error", err) return } + if err = UpdateBucketMigrationProgress(plan.manager.baseApp, plan.bucketID, storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATE_GVG_DOING); err != nil { + return + } migrateGVGUnit.MigrateStatus = Migrating } @@ -407,13 +416,13 @@ func (plan *BucketMigrateExecutePlan) Start() error { // BucketMigrateScheduler subscribes bucket migrate events and produces a gvg migrate plan. type BucketMigrateScheduler struct { - manager *ManageModular - selfSP *sptypes.StorageProvider - lastSubscribedBlockHeight uint64 // load from db - executePlanIDMap map[uint64]*BucketMigrateExecutePlan // bucketID -> BucketMigrateExecutePlan - bucketCache *BucketCache - // src sp swap unit plan. - mutex sync.RWMutex + manager *ManageModular + selfSP *sptypes.StorageProvider + lastSubscribedBlockHeight uint64 // load from db + lastSubscribedBlockHeightGC uint64 // src sp subscribe gc progress + executePlanIDMap map[uint64]*BucketMigrateExecutePlan // bucketID -> BucketMigrateExecutePlan + bucketCache *BucketCache + mutex sync.RWMutex // Protects the executePlanIDMap fields } // NewBucketMigrateScheduler returns a bucket migrate scheduler instance. @@ -450,6 +459,9 @@ func (s *BucketMigrateScheduler) Init(m *ManageModular) error { // plan load from db s.loadBucketMigrateExecutePlansFromDB() + // gc task load from db + s.loadBucketMigrateGCTaskFromDB() + log.Infow("succeed to init bucket migrate scheduler", "self_sp", s.selfSP, "last_subscribed_block_height", s.lastSubscribedBlockHeight, "execute_plans", s.executePlanIDMap) @@ -459,11 +471,30 @@ func (s *BucketMigrateScheduler) Init(m *ManageModular) error { func (s *BucketMigrateScheduler) Start() error { go s.subscribeEvents() + go s.confirmEvents() return nil } -// Before processing MigrateBucketEvents, first check if the status of the bucket on the chain meets the expectations. If it meets the expectations, proceed with the execution; otherwise, skip this MigrateBucketEvent event. func (s *BucketMigrateScheduler) checkBucketFromChain(bucketID uint64, expectedStatus storagetypes.BucketStatus) (expected bool, err error) { + var bucketInfo *storagetypes.BucketInfo + + if s.manager.enableBucketMigrateCache { + return s.checkBucketFromChainAndCache(bucketID, expectedStatus) + } + + // check the chain's bucket is migrating + if bucketInfo, err = s.manager.baseApp.Consensus().QueryBucketInfoById(context.Background(), bucketID); err != nil { + return false, err + } + if bucketInfo.GetBucketStatus() != expectedStatus { + log.Debugw("the bucket status is not same, the event will skip", "bucketInfo", bucketInfo, "expectedStatus", expectedStatus) + return false, nil + } + return true, nil +} + +// Before processing MigrateBucketEvents, first check if the status of the bucket on the chain meets the expectations. If it meets the expectations, proceed with the execution; otherwise, skip this MigrateBucketEvent event. +func (s *BucketMigrateScheduler) checkBucketFromChainAndCache(bucketID uint64, expectedStatus storagetypes.BucketStatus) (expected bool, err error) { // check the chain's bucket is migrating key := bucketCacheKey(bucketID) var bucketInfo *storagetypes.BucketInfo @@ -488,7 +519,6 @@ func (s *BucketMigrateScheduler) checkBucketFromChain(bucketID uint64, expectedS } } else { err = QueryBucketInfoFromChainFunc() - } if err != nil || bucketInfo == nil { @@ -502,14 +532,24 @@ func (s *BucketMigrateScheduler) checkBucketFromChain(bucketID uint64, expectedS return true, nil } -func (s *BucketMigrateScheduler) doneMigrateBucket(bucketID uint64) error { - expected, err := s.checkBucketFromChain(bucketID, storagetypes.BUCKET_STATUS_CREATED) - if err != nil { - return err +func (s *BucketMigrateScheduler) getMigratedBytesSize(bucketID uint64) (uint64, error) { + var ( + err error + migrateGVGUnitMeta []*spdb.MigrateGVGUnitMeta + migratedBytes uint64 + ) + if migrateGVGUnitMeta, err = s.manager.baseApp.GfSpDB().ListMigrateGVGUnitsByBucketID(bucketID); err != nil { + return 0, err } - if !expected { - return nil + + for _, migrateUnit := range migrateGVGUnitMeta { + migratedBytes += migrateUnit.MigratedBytesSize } + + return migratedBytes, nil +} + +func (s *BucketMigrateScheduler) doneMigrateBucket(bucketID uint64) error { executePlan, err := s.getExecutePlanByBucketID(bucketID) // 1) Received the CompleteEvents event for the first time. // 2) Subsequently received the CompleteEvents event. @@ -518,6 +558,12 @@ func (s *BucketMigrateScheduler) doneMigrateBucket(bucketID uint64) error { return err } + // notify src sp to gc + postMsg := &gfsptask.GfSpBucketMigrationInfo{BucketId: bucketID, Finished: true} + if err = executePlan.manager.bucketMigrateScheduler.PostMigrateBucket(postMsg, executePlan.srcSP); err != nil { + log.Errorw("failed to post migrate bucket", "msg", postMsg, "error", err) + } + for _, unit := range executePlan.gvgUnitMap { if unit.MigrateStatus != Migrated { log.Errorw("report task may error, unit should be migrated", "unit", unit) @@ -526,15 +572,31 @@ func (s *BucketMigrateScheduler) doneMigrateBucket(bucketID uint64) error { s.deleteExecutePlanByBucketID(bucketID) executePlan.stopSPSchedule() err = s.manager.baseApp.GfSpDB().DeleteMigrateGVGUnitsByBucketID(bucketID) + log.Infow("succeed to done migrate bucket", "bucket_id", bucketID, "error", err) + return err } -func (s *BucketMigrateScheduler) cancelMigrateBucket(bucketID uint64) error { - executePlan, err := s.getExecutePlanByBucketID(bucketID) - if err != nil { - log.Errorw("bucket migrate schedule received EventCompleteMigrationBucket", "bucket_id", bucketID, "error", err) +func (s *BucketMigrateScheduler) cancelMigrateBucket(bucketID uint64, reject bool) error { + var ( + executePlan *BucketMigrateExecutePlan + err error + state storetypes.BucketMigrationState + ) + ctx := context.Background() + if executePlan, err = s.getExecutePlanByBucketID(bucketID); err != nil { + log.Errorw("bucket migrate schedule received EventCancelMigrationBucket", "bucket_id", bucketID, "error", err) return err } + if reject { + state = storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_WAIT_REJECT_TX_EVENT_DONE + } else { + state = storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_WAIT_CANCEL_TX_EVENT_DONE + } + if err = UpdateBucketMigrationProgress(executePlan.manager.baseApp, bucketID, state); err != nil { + return err + } + for _, migrateGVGUnit := range executePlan.gvgUnitMap { key := gfsptask.GfSpMigrateGVGTaskKey(migrateGVGUnit.SrcGVG.GetId(), migrateGVGUnit.BucketID, piecestore.PrimarySPRedundancyIndex) s.manager.migrateGVGQueuePopByKey(key) @@ -542,16 +604,35 @@ func (s *BucketMigrateScheduler) cancelMigrateBucket(bucketID uint64) error { s.deleteExecutePlanByBucketID(bucketID) executePlan.stopSPSchedule() - err = s.manager.baseApp.GfSpDB().DeleteMigrateGVGUnitsByBucketID(bucketID) + if err = s.manager.baseApp.GfSpDB().DeleteMigrateGVGUnitsByBucketID(bucketID); err != nil { + return err + } + + // if bucket migration failed, gc for dest sp + // generate a gc bucket migration task(list objects and delete) + if err = UpdateBucketMigrationProgress(executePlan.manager.baseApp, bucketID, storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_DEST_SP_GC_DOING); err != nil { + return err + } + go s.manager.GenerateGCBucketMigrationTask(ctx, bucketID) + + log.CtxInfow(ctx, "succeed to cancel migration event from memory, the bucket migration will generate a gc task", "bucket_id", bucketID) return err } func (s *BucketMigrateScheduler) processEvents(migrateBucketEvents *types.ListMigrateBucketEvents) error { - // 1. process CancelEvents + var ( + err error + executePlan *BucketMigrateExecutePlan + ) + // 1. process EventCancelMigrationBucket if migrateBucketEvents.CancelEvent != nil { + // no need to process cancel migration event, maybe already canceled + if _, err = s.getExecutePlanByBucketID(migrateBucketEvents.CancelEvent.BucketId.Uint64()); err != nil { + log.Infow("bucket migrate schedule received EventCancelMigrationBucket", "bucket_id", migrateBucketEvents.CancelEvent.BucketId.Uint64(), "error", err) + return nil + } log.Infow("begin to process cancel events", "cancel_event", migrateBucketEvents.CancelEvent) - err := s.cancelMigrateBucket(migrateBucketEvents.CancelEvent.BucketId.Uint64()) - if err != nil { + if err = s.cancelMigrateBucket(migrateBucketEvents.CancelEvent.BucketId.Uint64(), false); err != nil { log.Errorw("failed to process cancel events", "cancel_event", migrateBucketEvents.CancelEvent, "error", err) } return nil @@ -560,35 +641,88 @@ func (s *BucketMigrateScheduler) processEvents(migrateBucketEvents *types.ListMi // 2. process RejectEvents if migrateBucketEvents.RejectEvent != nil { log.Infow("begin to process reject events", "reject_event", migrateBucketEvents.RejectEvent) - err := s.cancelMigrateBucket(migrateBucketEvents.RejectEvent.BucketId.Uint64()) - if err != nil { + + if err = s.cancelMigrateBucket(migrateBucketEvents.RejectEvent.BucketId.Uint64(), true); err != nil { log.Errorw("failed to process cancel events", "cancel_event", migrateBucketEvents.CancelEvent, "error", err) } return nil } - // 3. process CompleteEvents + // 3. process EventCompleteMigrationBucket if migrateBucketEvents.CompleteEvent != nil { return nil } - // 4. process Events + // 4. process EventMigrationBucket if migrateBucketEvents.Event != nil { - executePlan, err := s.produceBucketMigrateExecutePlan(migrateBucketEvents.Event, false) - if err != nil { + if executePlan, err = s.produceBucketMigrateExecutePlan(migrateBucketEvents.Event, false); err != nil || executePlan == nil { log.Errorw("failed to produce bucket migrate execute plan", "Events", migrateBucketEvents.Event, "error", err) return err } - if executePlan != nil { - if err = executePlan.Start(); err != nil { - log.Errorw("failed to start bucket migrate execute plan", "Events", migrateBucketEvents.Event, "executePlan", executePlan, "error", err) - return err - } - s.executePlanIDMap[executePlan.bucketID] = executePlan + if err = executePlan.Start(); err != nil { + log.Errorw("failed to start bucket migrate execute plan", "Events", migrateBucketEvents.Event, "executePlan", executePlan, "error", err) + return err } + s.executePlanIDMap[executePlan.bucketID] = executePlan } return nil } +func (s *BucketMigrateScheduler) confirmCompleteTxEvents(ctx context.Context, event *spdb.MigrateBucketProgressMeta) { + var ( + bucket *types.Bucket + err error + ) + bucketID := event.BucketID + + if event.MigrateState != int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SEND_COMPLETE_TX_DONE) { + return + } + // confirm + if bucket, err = s.manager.baseApp.GfSpClient().GetBucketByBucketID(ctx, int64(bucketID), true); err != nil { + log.Errorw("failed to get bucket by bucket id", "bucket_id", bucketID, "error", err) + return + } + + if bucket.BucketInfo.GetBucketStatus() == storagetypes.BUCKET_STATUS_CREATED { + if err = UpdateBucketMigrationProgress(s.manager.baseApp, bucketID, storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_WAIT_COMPLETE_TX_EVENT_DONE); err != nil { + return + } + if err = s.doneMigrateBucket(bucketID); err != nil { + log.Errorw("failed to done migrate bucket", "EventMigrationBucket", event, "error", err) + return + } + if err = UpdateBucketMigrationProgress(s.manager.baseApp, bucketID, storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATION_FINISHED); err != nil { + return + } + log.CtxInfow(ctx, "succeed to confirm complete events", "EventMigrationBucket", event) + } +} + +// After the dest sp completes the migration, it needs to send the CompleteMigrateBucketTx to the chain. +// The dest sp waits for the successful execution of the transaction and then proceeds to 1) notify the source SP and 2) clean up its own state. +func (s *BucketMigrateScheduler) confirmEvents() { + subscribeBucketMigrateEventsTicker := time.NewTicker(time.Duration(s.manager.subscribeBucketMigrateEventInterval) * time.Millisecond) + defer subscribeBucketMigrateEventsTicker.Stop() + ctx := context.Background() + logNumber := uint64(0) + + for range subscribeBucketMigrateEventsTicker.C { + migrationStates := []int{int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SEND_COMPLETE_TX_DONE), int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SEND_REJECT_TX_DONE)} + confirmEvents, listError := s.manager.baseApp.GfSpDB().ListBucketMigrationToConfirm(migrationStates) + if listError != nil { + logNumber++ + if (logNumber % printLogPerN) == 0 { + log.Errorw("failed to list migrate bucket events to confirm", "block_id", s.lastSubscribedBlockHeight+1, + "error", listError) + } + continue + } + for _, event := range confirmEvents { + s.confirmCompleteTxEvents(ctx, event) + } + } +} + func (s *BucketMigrateScheduler) subscribeEvents() { go func() { logNumber := uint64(0) @@ -621,8 +755,7 @@ func (s *BucketMigrateScheduler) subscribeEvents() { // 2. make plan, start plan for _, migrateBucketEvents := range migrationBucketEvents { log.Infow("loop subscribe bucket migrate event", "migration_bucket_events", migrationBucketEvents, "block_id", s.lastSubscribedBlockHeight+1, "sp_address", s.manager.baseApp.OperatorAddress()) - err := s.processEvents(migrateBucketEvents) - if err != nil { + if err := s.processEvents(migrateBucketEvents); err != nil { log.Errorw("bucket migrate process error", "migration_bucket_events", migrateBucketEvents, "error", err) } } @@ -631,6 +764,55 @@ func (s *BucketMigrateScheduler) subscribeEvents() { UpdateBucketMigrateSubscribeProgressFunc(logNumber) } }() + // src sp subscribe complete migrationBucketEvents for gc + go func() { + logNumber := uint64(0) + + UpdateBucketMigrateGCSubscribeProgressFunc := func(num uint64) { + if updateErr := s.manager.baseApp.GfSpDB().UpdateBucketMigrateGCSubscribeProgress(s.lastSubscribedBlockHeightGC + 1); updateErr != nil { + log.Errorw("failed to update bucket migrate src sp gc progress", "error", updateErr) + } + s.lastSubscribedBlockHeightGC++ + if (num % printLogPerN) == 0 { + log.Infow("src sp gc bucket migrate subscribe progress", "last_subscribed_block_height", s.lastSubscribedBlockHeightGC) + } + } + subscribeBucketMigrateEventsTicker := time.NewTicker(time.Duration(s.manager.subscribeBucketMigrateEventInterval) * time.Millisecond) + defer subscribeBucketMigrateEventsTicker.Stop() + var ( + completeMigrationBucketEvents []*storagetypes.EventCompleteMigrationBucket + subscribeError error + ) + + for range subscribeBucketMigrateEventsTicker.C { + // 1. subscribe migrate bucket events + if completeMigrationBucketEvents, subscribeError = s.manager.baseApp.GfSpClient().ListCompleteMigrationBucketEvents( + context.Background(), s.lastSubscribedBlockHeightGC+1, s.selfSP.GetId()); subscribeError != nil { + logNumber++ + if (logNumber % printLogPerN) == 0 { + log.Errorw("failed to list migrate completed bucket events", "block_id", s.lastSubscribedBlockHeightGC+1, + "error", subscribeError) + } + continue + } + + // 2. src confirm complete migration bucket event and update progress + for _, migrateBucketEvents := range completeMigrationBucketEvents { + log.Infow("loop subscribe completed bucket migrate event", "complete_migration_bucket_events", completeMigrationBucketEvents, "block_id", s.lastSubscribedBlockHeight+1, "sp_address", s.manager.baseApp.OperatorAddress()) + bucketID := migrateBucketEvents.BucketId.Uint64() + ctx := context.Background() + + if err := UpdateBucketMigrationProgress(s.manager.baseApp, bucketID, storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SRC_SP_GC_DOING); err != nil { + return + } + + go s.manager.GenerateGCBucketMigrationTask(ctx, bucketID) + } + + // 3.update subscribe progress to db + UpdateBucketMigrateGCSubscribeProgressFunc(logNumber) + } + }() } // pickGlobalVirtualGroupForBucketMigrate is used to pick a suitable gvg for replicating object. @@ -667,37 +849,27 @@ func (s *BucketMigrateScheduler) PostMigrateBucket(postMsg *gfsptask.GfSpBucketM err error ) - bucketID := postMsg.GetBucketId() - ctx := context.Background() - if srcSPInfo == nil { srcSPInfo = s.getSPInfoByBucketID(postMsg.GetBucketId()) } postMsg.ExpireTime = time.Now().Unix() + SigExpireTimeSecond - signature, err = s.manager.baseApp.GfSpClient().SignBucketMigrationInfo(context.Background(), postMsg) - if err != nil { + if signature, err = s.manager.baseApp.GfSpClient().SignBucketMigrationInfo(context.Background(), postMsg); err != nil { log.Errorw("failed to sign migrate bucket", "bucket_migration", postMsg, "error", err) return err - } else { - postMsg.SetSignature(signature) } + postMsg.SetSignature(signature) - _, err = s.manager.baseApp.GfSpClient().PostMigrateBucket(context.Background(), srcSPInfo.GetEndpoint(), postMsg) - if err != nil { + if _, err = s.manager.baseApp.GfSpClient().PostMigrateBucket(context.Background(), srcSPInfo.GetEndpoint(), postMsg); err != nil { log.Debugw("failed to query bucket quota from src sp", "src_sp", srcSPInfo, "error", err) return err } log.Debugw("succeed to post migrate bucket quota", "src_sp", srcSPInfo, "postMsg", postMsg, "error", err) - // if bucket migration failed, gc for dest sp - if !postMsg.GetFinished() { - // generate a gc bucket migration task(list objects and delete) - go s.manager.GenerateGCBucketMigrationTask(ctx, bucketID, postMsg.GetMigratedBytesSize()) - } + return nil } -// PreMigrateBucket is used to pick a suitable gvg for replicating object. +// PreMigrateBucket is used to Dest SP notifies Src SP and pre-deducts quota. func (s *BucketMigrateScheduler) PreMigrateBucket(bucketID uint64, srcSPInfo *sptypes.StorageProvider) error { var ( signature []byte @@ -707,17 +879,14 @@ func (s *BucketMigrateScheduler) PreMigrateBucket(bucketID uint64, srcSPInfo *sp log.Debugw("start to pre migrate bucket", "bucket_id", bucketID) preMsg := &gfsptask.GfSpBucketMigrationInfo{BucketId: bucketID, Finished: false} preMsg.ExpireTime = time.Now().Unix() + SigExpireTimeSecond - signature, err = s.manager.baseApp.GfSpClient().SignBucketMigrationInfo(context.Background(), preMsg) - if err != nil { + if signature, err = s.manager.baseApp.GfSpClient().SignBucketMigrationInfo(context.Background(), preMsg); err != nil { log.Errorw("failed to sign migrate bucket", "bucket_migration", preMsg, "error", err) return err - } else { - preMsg.SetSignature(signature) } + preMsg.SetSignature(signature) // query src sp, bucket migrate quota - _, err = s.manager.baseApp.GfSpClient().PreMigrateBucket(context.Background(), srcSPInfo.GetEndpoint(), preMsg) - if err != nil { + if _, err = s.manager.baseApp.GfSpClient().PreMigrateBucket(context.Background(), srcSPInfo.GetEndpoint(), preMsg); err != nil { log.Debugw("failed to query bucket quota from src sp", "src_sp", srcSPInfo, "error", err) return err } @@ -821,7 +990,7 @@ func (s *BucketMigrateScheduler) produceBucketMigrateExecutePlan(event *storaget if !expected { return nil, nil } - if s.executePlanIDMap[event.BucketId.Uint64()] != nil { + if _, err = s.getExecutePlanByBucketID(event.BucketId.Uint64()); err == nil { log.Debugw("the bucket is already in migrating", "migration_bucket_events", event) return nil, errors.New("bucket already in migrating") } @@ -877,35 +1046,39 @@ func (s *BucketMigrateScheduler) produceBucketMigrateExecutePlan(event *storaget log.Debugw("produce bucket migrate execute plan list", "primarySPGVGList", primarySPGVGList, "bucket_gvg_list_len", len(primarySPGVGList), "EventMigrationBucket", event) if len(plan.gvgUnitMap) == 0 { + // set bucket quota + if err = plan.syncBucketQuotaFromSrcSP(bucketID, srcSP); err != nil { + log.Errorw("failed to update bucket quota", "bucket_id", bucketID, "error", err) + return nil, err + } + // an empty bucket ends here, and it will not return a plan. The execution will not continue. err = plan.sendCompleteMigrateBucketTx(nil) if err != nil { log.Errorw("failed to send complete migrate bucket msg to chain", "error", err, "EventMigrationBucket", event) return nil, err } - time.Sleep(blockInterval) - err = s.doneMigrateBucket(event.BucketId.Uint64()) - if err != nil { - log.Errorw("failed to done migrate bucket", "error", err, "EventMigrationBucket", event) - return nil, err - } + log.Infow("bucket is empty, send complete migrate bucket tx directly", "bucket_id", bucketID) return nil, nil } // lock quota if !buildMetaByDB { - err = plan.manager.bucketMigrateScheduler.PreMigrateBucket(bucketID, plan.srcSP) - if err != nil { + if err = plan.manager.bucketMigrateScheduler.PreMigrateBucket(bucketID, plan.srcSP); err != nil { log.Errorw("failed to pre migrate bucket(lock src sp quota)", "bucket_id", bucketID, "error", err) return nil, err } + if err = UpdateBucketMigrationProgress(plan.manager.baseApp, bucketID, storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_DEST_SP_PRE_DEDUCT_QUOTA_DONE); err != nil { + return nil, err + } } if err = plan.storeToDB(); err != nil { log.Errorw("failed to generate migrate execute plan due to store db", "error", err) } + log.Infow("succeed to produce bucket migrate execute plan list", "primary_sp_gvg_list", primarySPGVGList, "bucket_gvg_list_len", len(primarySPGVGList), "EventMigrationBucket", event) return plan, err } @@ -935,9 +1108,20 @@ func (s *BucketMigrateScheduler) listExecutePlan() (*gfspserver.GfSpQueryBucketM var res gfspserver.GfSpQueryBucketMigrateResponse var plans []*gfspserver.GfSpBucketMigrate for _, executePlan := range s.executePlanIDMap { - var plan gfspserver.GfSpBucketMigrate + var ( + plan gfspserver.GfSpBucketMigrate + migratedBytesSize uint64 + err error + ) + plan.BucketId = executePlan.bucketID plan.Finished = uint32(len(executePlan.finishedGvgUnits)) + if migratedBytesSize, err = s.getMigratedBytesSize(executePlan.bucketID); err != nil { + // if something error, set migratedBytesSize to zero + log.Errorw("failed to get migrated bytes size", "execute_plan", executePlan, "error", err) + migratedBytesSize = 0 + } + plan.MigratedBytesSize = migratedBytesSize for _, unit := range executePlan.gvgUnitMap { plan.GvgTask = append(plan.GvgTask, &gfspserver.GfSpMigrateGVG{ SrcGvgId: unit.SrcGVG.GetId(), @@ -955,6 +1139,8 @@ func (s *BucketMigrateScheduler) listExecutePlan() (*gfspserver.GfSpQueryBucketM } func (s *BucketMigrateScheduler) UpdateMigrateProgress(task task.MigrateGVGTask) error { + log.Infow("start to update migrate progress", "task", task) + executePlan, err := s.getExecutePlanByBucketID(task.GetBucketID()) if err != nil { return fmt.Errorf("bucket execute plan is not found") @@ -969,9 +1155,13 @@ func (s *BucketMigrateScheduler) UpdateMigrateProgress(task task.MigrateGVGTask) } migrateKey := MakeBucketMigrateKey(migrateExecuteUnit.BucketID, migrateExecuteUnit.SrcGVG.GetId()) + if err = executePlan.manager.baseApp.GfSpDB().UpdateMigrateGVGMigratedBytesSize(migrateKey, task.GetMigratedBytesSize()); err != nil { + log.Errorw("update migrate gvg migrated bytes size", "migrate_key", migrateKey, "migrated_bytes", task.GetMigratedBytesSize(), "error", err) + return err + } + if task.GetFinished() { - err = executePlan.updateMigrateGVGStatus(migrateKey, task, migrateExecuteUnit, Migrated) - if err != nil { + if err = executePlan.updateMigrateGVGStatus(migrateKey, task, migrateExecuteUnit, Migrated); err != nil { log.Errorw("failed to update migrate gvg status", "migrate_key", migrateKey, "error", err) return err } @@ -1011,6 +1201,30 @@ func (s *BucketMigrateScheduler) UpdateMigrateProgress(task task.MigrateGVGTask) return nil } +func (s *BucketMigrateScheduler) UpdateBucketMigrationGCProgress(ctx context.Context, gcBucketMigrationTask task.GCBucketMigrationTask) error { + // update gc progress + var state storetypes.BucketMigrationState + if gcBucketMigrationTask.GetFinished() { + state = storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATION_FINISHED + } else { + state = storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SRC_SP_GC_DOING + } + + meta := spdb.MigrateBucketProgressMeta{ + BucketID: gcBucketMigrationTask.GetBucketID(), + MigrateState: int(state), + LastGcObjectID: gcBucketMigrationTask.GetLastGCObjectID(), + LastGcGvgID: gcBucketMigrationTask.GetLastGCGvgID(), + TotalGvgNum: uint32(gcBucketMigrationTask.GetTotalGvgNum()), + GcFinishedGvgNum: uint32(gcBucketMigrationTask.GetGCFinishedGvgNum()), + } + if err := s.manager.baseApp.GfSpDB().UpdateBucketMigrationGCProgress(meta); err != nil { + log.CtxErrorw(ctx, "failed to update bucket migration gc progress", "task", gcBucketMigrationTask, "error", err) + return err + } + return nil +} + // loadBucketMigrateExecutePlansFromDB 1) subscribe progress 2) plan progress 3) task progress func (s *BucketMigrateScheduler) loadBucketMigrateExecutePlansFromDB() error { var ( @@ -1060,6 +1274,31 @@ func (s *BucketMigrateScheduler) loadBucketMigrateExecutePlansFromDB() error { return err } +// loadBucketMigrateGCTaskFromDB 1) load gc state from db and generate bucket migration task +func (s *BucketMigrateScheduler) loadBucketMigrateGCTaskFromDB() error { + var ( + migrationBucketEvents []*spdb.MigrateBucketProgressMeta + err error + ctx = context.Background() + ) + + migrationStates := []int{int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SRC_SP_GC_DOING), int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_DEST_SP_GC_DOING)} + if migrationBucketEvents, err = s.manager.baseApp.GfSpDB().ListBucketMigrationToConfirm(migrationStates); err != nil { + log.Errorw("failed to list migrate bucket progress meta", "error", err) + return errors.New("failed to list migrate bucket events") + } + + for _, migrateBucketEvents := range migrationBucketEvents { + // if it has CompleteEvents & CancelEvents, skip it + bucketID := migrateBucketEvents.BucketID + go s.manager.GenerateGCBucketMigrationTask(ctx, bucketID) + log.CtxInfow(ctx, "succeed to generate a bucket migration gc task", "bucket_id", bucketID) + } + + log.CtxInfow(ctx, "bucket migrate scheduler load bucket migration progress meta from db and generate gc task success", "bucket_migration_meta", migrationBucketEvents) + return err +} + func bucketCacheKey(bucketId uint64) string { return fmt.Sprintf("bucketid:%d", bucketId) } @@ -1390,3 +1629,26 @@ func (checker *SPConflictChecker) GenerateMigrateBucketUnits(buildMetaByDB bool) log.Infow("succeeded to generate migrate bucket units", "bucket_id", checker.bucketID, "bucket_migrate_units", bucketMigrateUnits, "error", err) return bucketMigrateUnits, err } + +func SendAndConfirmCompleteMigrateBucketTx(baseApp *gfspapp.GfSpBaseApp, msg *storagetypes.MsgCompleteMigrateBucket) error { + return SendAndConfirmTx(baseApp.Consensus(), + func() (string, error) { + var ( + txHash string + txErr error + ) + if txHash, txErr = baseApp.GfSpClient().CompleteMigrateBucket(context.Background(), msg); txErr != nil && !isAlreadyExists(txErr) { + log.Errorw("failed to send complete migrate bucket msg to chain", "complete_migrate_bucket_msg", msg, "error", txErr) + return "", txErr + } + return txHash, nil + }) +} + +func UpdateBucketMigrationProgress(baseApp *gfspapp.GfSpBaseApp, bucketID uint64, migrateState storetypes.BucketMigrationState) error { + if err := baseApp.GfSpDB().UpdateBucketMigrationProgress(bucketID, int(migrateState)); err != nil { + log.Errorw("failed to update bucket migration progress", "bucket_id", bucketID, "state", migrateState, "error", err) + return err + } + return nil +} diff --git a/modular/manager/manage_task.go b/modular/manager/manage_task.go index 3b0b5fb5b..d2cfad019 100644 --- a/modular/manager/manage_task.go +++ b/modular/manager/manage_task.go @@ -680,16 +680,24 @@ func (m *ManageModular) HandleGCMetaTask(ctx context.Context, gcMetaTask task.GC return nil } -func (m *ManageModular) GenerateGCBucketMigrationTask(ctx context.Context, bucketID, bucketSize uint64) { +func (m *ManageModular) GenerateGCBucketMigrationTask(ctx context.Context, bucketID uint64) { // src sp should wait meta data <-time.After(bucketMigrationGCWaitTime) + var ( + bucketSize uint64 + err error + ) + // get bucket quota and check, lock quota + if bucketSize, err = m.getBucketTotalSize(ctx, bucketID); err != nil { + log.Errorw("failed to get bucket total size", "bucket_id", bucketID) + return + } // success generate gc task, gc for bucket migration src sp gcBucketMigrationTask := &gfsptask.GfSpGCBucketMigrationTask{} gcBucketMigrationTask.InitGCBucketMigrationTask(m.baseApp.TaskPriority(gcBucketMigrationTask), bucketID, m.baseApp.TaskTimeout(gcBucketMigrationTask, bucketSize), m.baseApp.TaskMaxRetry(gcBucketMigrationTask)) - err := m.HandleCreateGCBucketMigrationTask(ctx, gcBucketMigrationTask) - if err != nil { + if err = m.HandleCreateGCBucketMigrationTask(ctx, gcBucketMigrationTask); err != nil { log.CtxErrorw(ctx, "failed to begin gc bucket migration task", "info", gcBucketMigrationTask.Info(), "error", err) } log.CtxInfow(ctx, "succeed to generate bucket migration gc task and push to queue", "bucket_id", bucketID, "gcBucketMigrationTask", gcBucketMigrationTask) @@ -712,6 +720,7 @@ func (m *ManageModular) HandleCreateGCBucketMigrationTask(ctx context.Context, t } func (m *ManageModular) HandleGCBucketMigrationTask(ctx context.Context, gcBucketMigrationTask task.GCBucketMigrationTask) error { + var err error if gcBucketMigrationTask == nil { log.CtxError(ctx, "failed to handle gc bucket migration due to gc bucket migration task pointer dangling") return ErrDanglingTask @@ -720,9 +729,16 @@ func (m *ManageModular) HandleGCBucketMigrationTask(ctx context.Context, gcBucke log.CtxErrorw(ctx, "failed to handle gc bucket migration task due to task is not in the gc bucket migration queue", "task_info", gcBucketMigrationTask.Info()) return ErrCanceledTask } + if err = m.bucketMigrateScheduler.UpdateBucketMigrationGCProgress(ctx, gcBucketMigrationTask); err != nil { + return err + } if gcBucketMigrationTask.Error() == nil { - log.CtxInfow(ctx, "succeed to finish the gc bucket migration task", "task_info", gcBucketMigrationTask.Info()) - m.gcBucketMigrationQueue.PopByKey(gcBucketMigrationTask.Key()) + // success + if gcBucketMigrationTask.GetFinished() { + log.CtxInfow(ctx, "succeed to finish the gc bucket migration task", "task_info", gcBucketMigrationTask.Info()) + m.gcBucketMigrationQueue.PopByKey(gcBucketMigrationTask.Key()) + } + return nil } gcBucketMigrationTask.SetUpdateTime(time.Now().Unix()) @@ -738,9 +754,9 @@ func (m *ManageModular) HandleGCBucketMigrationTask(ctx context.Context, gcBucke log.CtxErrorw(ctx, "the reported gc object gc bucket migration task is canceled", "report_info", gcBucketMigrationTask.Info()) return ErrCanceledTask } - err := m.gcBucketMigrationQueue.Push(gcBucketMigrationTask) + err = m.gcBucketMigrationQueue.Push(gcBucketMigrationTask) log.CtxInfow(ctx, "succeed to push gc bucket migration task to queue again", "from", oldTask, "to", gcBucketMigrationTask, "error", err) - return nil + return err } func (m *ManageModular) HandleDownloadObjectTask(ctx context.Context, task task.DownloadObjectTask) error { @@ -814,9 +830,12 @@ func (m *ManageModular) HandleMigrateGVGTask(ctx context.Context, task task.Migr log.CtxErrorw(ctx, "failed to handle migrate gvg due to pointer dangling") return ErrDanglingTask } - var err, pushErr error - cancelTask := false + var ( + err, pushErr error + migratedBytesSize uint64 + ) + cancelTask := false if task.GetBucketID() != 0 { // if there is no execute plan, we should cancel this task if _, err = m.bucketMigrateScheduler.getExecutePlanByBucketID(task.GetBucketID()); err != nil { @@ -832,10 +851,12 @@ func (m *ManageModular) HandleMigrateGVGTask(ctx context.Context, task task.Migr // if cancel migrate bucket, migrated recoup quota if cancelTask { - postMsg := &gfsptask.GfSpBucketMigrationInfo{BucketId: task.GetBucketID(), Finished: task.GetFinished(), MigratedBytesSize: task.GetMigratedBytesSize()} + if migratedBytesSize, err = m.bucketMigrateScheduler.getMigratedBytesSize(task.GetBucketID()); err != nil { + log.CtxErrorw(ctx, "failed to get migrated bytes size", "task", task, "error", err) + } + postMsg := &gfsptask.GfSpBucketMigrationInfo{BucketId: task.GetBucketID(), Finished: task.GetFinished(), MigratedBytesSize: migratedBytesSize} log.CtxInfow(ctx, "start to cancel migrate task and send post migrate bucket to src sp", "post_msg", postMsg, "task", task) - err = m.bucketMigrateScheduler.PostMigrateBucket(postMsg, nil) - if err != nil { + if err = m.bucketMigrateScheduler.PostMigrateBucket(postMsg, nil); err != nil { log.CtxErrorw(ctx, "failed to post migrate bucket", "msg", postMsg, "error", err) } return err diff --git a/modular/manager/manager.go b/modular/manager/manager.go index 9c2a43064..98ef48233 100644 --- a/modular/manager/manager.go +++ b/modular/manager/manager.go @@ -13,6 +13,7 @@ import ( "golang.org/x/exp/slices" "github.com/bnb-chain/greenfield-storage-provider/base/gfspapp" + "github.com/bnb-chain/greenfield-storage-provider/base/types/gfspserver" "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsptask" "github.com/bnb-chain/greenfield-storage-provider/core/module" "github.com/bnb-chain/greenfield-storage-provider/core/rcmgr" @@ -75,9 +76,6 @@ type ManageModular struct { migrateGVGQueue taskqueue.TQueueOnStrategyWithLimit migrateGVGQueueMux sync.Mutex - // src sp used TODO: these should be persisted - migratingBuckets map[uint64]struct{} - maxUploadObjectNumber int gcObjectTimeInterval int @@ -101,10 +99,11 @@ type ManageModular struct { discontinueBucketTimeInterval int discontinueBucketKeepAliveDays int - spID uint32 - virtualGroupManager vgmgr.VirtualGroupManager - bucketMigrateScheduler *BucketMigrateScheduler - spExitScheduler *SPExitScheduler + spID uint32 + virtualGroupManager vgmgr.VirtualGroupManager + bucketMigrateScheduler *BucketMigrateScheduler + spExitScheduler *SPExitScheduler + enableBucketMigrateCache bool subscribeSPExitEventInterval uint subscribeBucketMigrateEventInterval uint @@ -154,8 +153,6 @@ func (m *ManageModular) Start(ctx context.Context) error { m.gcBucketMigrationQueue.SetRetireTaskStrategy(m.ResetGCBucketMigrationQueue) m.gcBucketMigrationQueue.SetFilterTaskStrategy(m.FilterGCTask) - m.migratingBuckets = make(map[uint64]struct{}) - scope, err := m.baseApp.ResourceManager().OpenService(m.Name()) if err != nil { return err @@ -958,6 +955,37 @@ func (m *ManageModular) QueryTasksStats(_ context.Context) (uploadTasks int, return } +func (m *ManageModular) QueryBucketMigrationProgress(_ context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) { + var ( + progress *spdb.MigrateBucketProgressMeta + err error + migratedBytes uint64 + ) + + if progress, err = m.baseApp.GfSpDB().QueryMigrateBucketProgress(bucketID); err != nil { + return nil, err + } + + if migratedBytes, err = m.bucketMigrateScheduler.getMigratedBytesSize(bucketID); err != nil { + return nil, err + } + + progressMeta := &gfspserver.MigrateBucketProgressMeta{ + BucketId: progress.BucketID, + SubscribedBlockHeight: progress.SubscribedBlockHeight, + MigrateState: uint32(progress.MigrateState), + TotalGvgNum: progress.TotalGvgNum, + MigratedFinishedGvgNum: progress.MigratedFinishedGvgNum, + GcFinishedGvgNum: progress.GcFinishedGvgNum, + PreDeductedQuota: progress.PreDeductedQuota, + RecoupQuota: progress.RecoupQuota, + LastGcObjectId: progress.LastGcObjectID, + LastGcGvgId: progress.LastGcGvgID, + MigratedBytes: migratedBytes, + } + return progressMeta, err +} + func (m *ManageModular) ResetRecoveryFailedList(_ context.Context) []string { m.recoveryFailedList = m.recoveryFailedList[:0] return m.recoveryFailedList diff --git a/modular/manager/manager_options.go b/modular/manager/manager_options.go index 4a1816702..dd7a96b23 100644 --- a/modular/manager/manager_options.go +++ b/modular/manager/manager_options.go @@ -292,5 +292,7 @@ func DefaultManagerOptions(manager *ManageModular, cfg *gfspconfig.GfSpConfig) ( manager.enableTaskRetryScheduler = cfg.Manager.EnableTaskRetryScheduler manager.rejectUnsealThresholdSecond = cfg.Manager.RejectUnsealThresholdSecond + manager.enableBucketMigrateCache = cfg.Manager.EnableBucketMigrateCache + return nil } diff --git a/modular/manager/migrate_service.go b/modular/manager/migrate_service.go index 592608b6f..7c350e0c6 100644 --- a/modular/manager/migrate_service.go +++ b/modular/manager/migrate_service.go @@ -6,6 +6,7 @@ import ( "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsptask" "github.com/bnb-chain/greenfield-storage-provider/pkg/log" + storetypes "github.com/bnb-chain/greenfield-storage-provider/store/types" "github.com/bnb-chain/greenfield-storage-provider/util" virtualgrouptypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" ) @@ -45,44 +46,125 @@ func (m *ManageModular) NotifyMigrateSwapOut(ctx context.Context, swapOut *virtu return m.spExitScheduler.AddSwapOutToTaskRunner(swapOut) } -// NotifyPreMigrateBucket is used to notify record bucket is migrating -func (m *ManageModular) NotifyPreMigrateBucket(ctx context.Context, bucketID uint64) error { - _, exists := m.migratingBuckets[bucketID] - if exists { - return fmt.Errorf("bucket already migrating") - } else { - m.migratingBuckets[bucketID] = struct{}{} +// NotifyPreMigrateBucketAndDeductQuota is used to notify record bucket is migrating +func (m *ManageModular) NotifyPreMigrateBucketAndDeductQuota(ctx context.Context, bucketID uint64) (*gfsptask.GfSpBucketQuotaInfo, error) { + var ( + state int + err error + bucketSize uint64 + quota = &gfsptask.GfSpBucketQuotaInfo{} + ) + + if state, err = m.baseApp.GfSpDB().QueryMigrateBucketState(bucketID); err != nil { + log.CtxErrorw(ctx, "failed to query migrate bucket state", "error", err) + return quota, err } - return nil + if state == int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SRC_SP_PRE_DEDUCT_QUOTA_DONE) { + log.CtxInfow(ctx, "the bucket has already notified", "bucket_id", bucketID) + return quota, fmt.Errorf("the bucket has already notified, pre deduct quota done") + } + + // get bucket quota and check, lock quota + if bucketSize, err = m.getBucketTotalSize(ctx, bucketID); err != nil { + return quota, err + } + + if quota, err = m.baseApp.GfSpClient().GetLatestBucketReadQuota(ctx, bucketID); err != nil { + log.CtxErrorw(ctx, "failed to get bucket read quota", "bucket_id", bucketID, "error", err) + return quota, err + } + + // reduce quota, sql db + if err = m.baseApp.GfSpClient().DeductQuotaForBucketMigrate(ctx, bucketID, bucketSize, quota.GetMonth()); err != nil { + log.CtxErrorw(ctx, "failed to get bucket read quota", "bucket_id", bucketID, "error", err) + return quota, err + } + + // update state + if err = m.baseApp.GfSpDB().UpdateBucketMigrationPreDeductedQuota(bucketID, bucketSize, int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SRC_SP_PRE_DEDUCT_QUOTA_DONE)); err != nil { + log.CtxErrorw(ctx, "failed to update migrate bucket state and deduct quota", "bucket_id", bucketID, "error", err) + // if failed to update migrate bucket state, recoup quota and return error + if quotaUpdateErr := m.baseApp.GfSpClient().RecoupQuota(ctx, bucketID, bucketSize, quota.GetMonth()); quotaUpdateErr != nil { + log.CtxErrorw(ctx, "failed to recoup extra quota to user", "error", err) + } + return quota, err + } + + return quota, nil } -// NotifyPostMigrateBucket is used to notify src sp confirm that only one Post migrate bucket is allowed. -func (m *ManageModular) NotifyPostMigrateBucket(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) error { +// NotifyPostMigrateBucketAndRecoupQuota is used to notify src sp confirm that only one Post migrate bucket is allowed. +func (m *ManageModular) NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, bmInfo *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) { + var ( + err error + extraQuota uint64 + bucketSize uint64 + state int + latestQuota = &gfsptask.GfSpBucketQuotaInfo{} + ) + bucketID := bmInfo.GetBucketId() - _, exists := m.migratingBuckets[bucketID] - if exists { - delete(m.migratingBuckets, bucketID) - } else { - return fmt.Errorf("bucket doesn't exit in migratingBuckets") + if state, err = m.baseApp.GfSpDB().QueryMigrateBucketState(bucketID); err != nil { + log.CtxErrorw(ctx, "failed to query migrate bucket state", "error", err) + return latestQuota, err + } + if state != int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SRC_SP_PRE_DEDUCT_QUOTA_DONE) { + log.CtxInfow(ctx, "the bucket has already recoup quota", "bucket_id", bucketID, "state", state, "expected_state", int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_SRC_SP_PRE_DEDUCT_QUOTA_DONE)) + return latestQuota, fmt.Errorf("the bucket has already post, recoup quota done") } - var err error - bucketSizeStr, err := m.baseApp.GfSpClient().GetBucketSize(ctx, bucketID) - if err != nil { - log.Errorf("failed to get bucket total object size", "error", err) - return err + if latestQuota, err = m.baseApp.GfSpClient().GetLatestBucketReadQuota(ctx, bucketID); err != nil { + log.CtxErrorw(ctx, "failed to get bucket read quota", "bucket_id", bucketID, "error", err) + return latestQuota, err } - bucketSize, err := util.StringToUint64(bucketSizeStr) - if err != nil { - log.CtxErrorw(ctx, "failed to convert bucket size to uint64", "bucket_id", - bucketID, "bucket_size", bucketSize, "error", err) - return err + + // get bucket quota and check + if bucketSize, err = m.getBucketTotalSize(ctx, bucketID); err != nil { + log.Errorf("failed to get bucket total object size", "bucket_id", bucketID, "error", err) + return latestQuota, err } - if bmInfo.GetFinished() { - go m.GenerateGCBucketMigrationTask(ctx, bucketID, bucketSize) + // If dest sp notify src sp migration succeed, bucket migration gc trigger by bucket migration complete event in src sp + // otherwise, the src sp will recoup quota + if !bmInfo.GetFinished() { + migratedBytes := bmInfo.GetMigratedBytesSize() + if migratedBytes >= bucketSize { + // If the data migrated surpasses the total bucket size, quota recoup is skipped. + // This situation may arise due to deletions in the bucket migration process. + log.CtxErrorw(ctx, "failed to recoup extra quota to user", "error", err) + } else { + extraQuota = bucketSize - migratedBytes + if quotaUpdateErr := m.baseApp.GfSpClient().RecoupQuota(ctx, bmInfo.GetBucketId(), extraQuota, latestQuota.GetMonth()); quotaUpdateErr != nil { + log.CtxErrorw(ctx, "failed to recoup extra quota to user", "error", err) + return latestQuota, err + } + if err = m.baseApp.GfSpDB().UpdateBucketMigrationRecoupQuota(bucketID, extraQuota, int(storetypes.BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATION_FINISHED)); err != nil { + log.CtxErrorw(ctx, "failed to update bucket migrate progress recoup quota", "error", err) + } + } + log.CtxDebugw(ctx, "succeed to recoup extra quota to user", "extra_quote", extraQuota) } - return nil + return latestQuota, nil +} + +// getBucketTotalSize return the total size of the bucket +func (m *ManageModular) getBucketTotalSize(ctx context.Context, bucketID uint64) (uint64, error) { + var ( + bucketSizeStr string + bucketSize uint64 + err error + ) + + if bucketSizeStr, err = m.baseApp.GfSpClient().GetBucketSize(ctx, bucketID); err != nil { + log.CtxErrorw(ctx, "failed to get bucket size", "bucket_id", bucketID, "error", err) + return 0, err + } + if bucketSize, err = util.StringToUint64(bucketSizeStr); err != nil { + log.CtxErrorw(ctx, "failed to convert bucket size to uint64", "bucket_id", + bucketID, "bucket_size", bucketSizeStr, "error", err) + return 0, err + } + return bucketSize, nil } diff --git a/modular/manager/migrate_unit.go b/modular/manager/migrate_unit.go index 0297b9114..b7bcf1824 100644 --- a/modular/manager/migrate_unit.go +++ b/modular/manager/migrate_unit.go @@ -7,8 +7,11 @@ import ( virtualgrouptypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" ) -type MigrateStatus int32 +type ( + MigrateStatus int32 +) +// MigrateGVGTable status // migrate: WaitForMigrate(created)->Migrating(schedule success)->Migrated(executor report success). var ( WaitForMigrate MigrateStatus = 0 diff --git a/modular/metadata/metadata_sp_exit_service.go b/modular/metadata/metadata_sp_exit_service.go index cb6eacb68..8b601245c 100644 --- a/modular/metadata/metadata_sp_exit_service.go +++ b/modular/metadata/metadata_sp_exit_service.go @@ -244,6 +244,55 @@ func (r *MetadataModular) GfSpListMigrateBucketEvents(ctx context.Context, req * return resp, nil } +// GfSpListCompleteMigrationBucketEvents list migrate bucket events, sp_id should be src sp id +func (r *MetadataModular) GfSpListCompleteMigrationBucketEvents(ctx context.Context, req *types.GfSpListCompleteMigrationBucketEventsRequest) (resp *types.GfSpListCompleteMigrationBucketEventsResponse, err error) { + var ( + completeEvents []*model.EventCompleteMigrationBucket + spCompleteEvent *storage_types.EventCompleteMigrationBucket + completeEventsMap map[common.Hash]*model.EventCompleteMigrationBucket + res []*storage_types.EventCompleteMigrationBucket + filters []func(*gorm.DB) *gorm.DB + latestBlock int64 + ) + + ctx = log.Context(ctx, req) + if latestBlock, err = r.baseApp.GfBsDB().GetLatestBlockNumber(); err != nil { + log.CtxErrorw(ctx, "failed to list migrate bucket events", "error", err) + return nil, err + } + if uint64(latestBlock) < req.BlockId { + log.CtxError(ctx, "failed to list migrate bucket events due to request block id exceed current block syncer block height") + return nil, ErrExceedBlockHeight + } + log.Debugw("GfSpListCompleteMigrationBucketEvents", "src_sp_id", req.SrcSpId, "block_id", req.BlockId) + filters = append(filters, model.CreateAtEqualFilter(int64(req.BlockId))) + if completeEvents, err = r.baseApp.GfBsDB().ListCompleteMigrationBucket(req.SrcSpId, filters...); err != nil { + log.CtxErrorw(ctx, "failed to list complete migrate bucket events", "error", err) + return nil, err + } + + completeEventsMap = make(map[common.Hash]*model.EventCompleteMigrationBucket) + for _, e := range completeEvents { + completeEventsMap[e.BucketID] = e + } + + res = make([]*storage_types.EventCompleteMigrationBucket, 0) + + for _, e := range completeEvents { + spCompleteEvent = &storage_types.EventCompleteMigrationBucket{ + Operator: e.Operator.String(), + BucketName: e.BucketName, + BucketId: math.NewUintFromBigInt(e.BucketID.Big()), + GlobalVirtualGroupFamilyId: e.GlobalVirtualGroupFamilyId, + } + res = append(res, spCompleteEvent) + } + + resp = &types.GfSpListCompleteMigrationBucketEventsResponse{CompleteEvents: res} + log.CtxInfow(ctx, "succeed to list complete migrate bucket events", "request", req, "response", resp) + return resp, nil +} + // GfSpListSwapOutEvents list swap out events func (r *MetadataModular) GfSpListSwapOutEvents(ctx context.Context, req *types.GfSpListSwapOutEventsRequest) (resp *types.GfSpListSwapOutEventsResponse, err error) { var ( diff --git a/modular/metadata/metadata_sp_exit_service_test.go b/modular/metadata/metadata_sp_exit_service_test.go index bdb703e11..6df1af698 100644 --- a/modular/metadata/metadata_sp_exit_service_test.go +++ b/modular/metadata/metadata_sp_exit_service_test.go @@ -832,3 +832,60 @@ func TestMetadataModularGfSpGfSpListSpExitEvents_Fail3(t *testing.T) { }) assert.NotNil(t, err) } + +func TestMetadataModularGfSpListCompleteMigrationBucketEvents_Success(t *testing.T) { + a := setup(t) + ctrl := gomock.NewController(t) + m := bsdb.NewMockBSDB(ctrl) + a.baseApp.SetGfBsDB(m) + m.EXPECT().GetLatestBlockNumber().DoAndReturn( + func() (int64, error) { + return 100000, nil + }, + ).Times(1) + m.EXPECT().ListCompleteMigrationBucket(gomock.Any(), gomock.Any()).DoAndReturn( + func(spID uint32, filters ...func(*gorm.DB) *gorm.DB) ([]*bsdb.EventCompleteMigrationBucket, error) { + return []*bsdb.EventCompleteMigrationBucket{ + &bsdb.EventCompleteMigrationBucket{ + ID: 0, + BucketID: common.HexToHash("1"), + Operator: common.HexToAddress("0x11E0A11A7A01E2E757447B52FBD7152004AC699D"), + BucketName: "", + GlobalVirtualGroupFamilyId: 0, + SrcPrimarySpId: 1, + CreateAt: 2, + CreateTxHash: common.HexToHash("1"), + CreateTime: 2, + }, + }, nil + }, + ).Times(1) + res, err := a.GfSpListCompleteMigrationBucketEvents(context.Background(), &types.GfSpListCompleteMigrationBucketEventsRequest{ + BlockId: 999, + SrcSpId: 1, + }) + assert.Nil(t, err) + assert.Equal(t, 1, len(res.CompleteEvents)) +} + +func TestMetadataModularGfSpListCompleteMigrationBucketEvents_Fail(t *testing.T) { + a := setup(t) + ctrl := gomock.NewController(t) + m := bsdb.NewMockBSDB(ctrl) + a.baseApp.SetGfBsDB(m) + m.EXPECT().GetLatestBlockNumber().DoAndReturn( + func() (int64, error) { + return 100000, nil + }, + ).Times(1) + m.EXPECT().ListCompleteMigrationBucket(gomock.Any(), gomock.Any()).DoAndReturn( + func(spID uint32, filters ...func(*gorm.DB) *gorm.DB) ([]*bsdb.EventCompleteMigrationBucket, error) { + return nil, ErrExceedRequest + }, + ).Times(1) + _, err := a.GfSpListCompleteMigrationBucketEvents(context.Background(), &types.GfSpListCompleteMigrationBucketEventsRequest{ + BlockId: 999, + SrcSpId: 1, + }) + assert.NotNil(t, err) +} diff --git a/modular/metadata/types/metadata.pb.go b/modular/metadata/types/metadata.pb.go index d24b619ce..594d7d056 100644 --- a/modular/metadata/types/metadata.pb.go +++ b/modular/metadata/types/metadata.pb.go @@ -4299,6 +4299,115 @@ func (m *GfSpListMigrateBucketEventsResponse) GetEvents() []*ListMigrateBucketEv return nil } +// GfSpListCompleteMigrationBucketEventsRequest is request type for the GfSpListCompleteMigrationBucketEvents RPC method +type GfSpListCompleteMigrationBucketEventsRequest struct { + // block_id is the unique identification for block + BlockId uint64 `protobuf:"varint,1,opt,name=block_id,json=blockId,proto3" json:"block_id,omitempty"` + // src_sp_id is the unique identification for sp + SrcSpId uint32 `protobuf:"varint,2,opt,name=src_sp_id,json=srcSpId,proto3" json:"src_sp_id,omitempty"` +} + +func (m *GfSpListCompleteMigrationBucketEventsRequest) Reset() { + *m = GfSpListCompleteMigrationBucketEventsRequest{} +} +func (m *GfSpListCompleteMigrationBucketEventsRequest) String() string { + return proto.CompactTextString(m) +} +func (*GfSpListCompleteMigrationBucketEventsRequest) ProtoMessage() {} +func (*GfSpListCompleteMigrationBucketEventsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7cdcff708e247f22, []int{68} +} +func (m *GfSpListCompleteMigrationBucketEventsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GfSpListCompleteMigrationBucketEventsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GfSpListCompleteMigrationBucketEventsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GfSpListCompleteMigrationBucketEventsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GfSpListCompleteMigrationBucketEventsRequest.Merge(m, src) +} +func (m *GfSpListCompleteMigrationBucketEventsRequest) XXX_Size() int { + return m.Size() +} +func (m *GfSpListCompleteMigrationBucketEventsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GfSpListCompleteMigrationBucketEventsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GfSpListCompleteMigrationBucketEventsRequest proto.InternalMessageInfo + +func (m *GfSpListCompleteMigrationBucketEventsRequest) GetBlockId() uint64 { + if m != nil { + return m.BlockId + } + return 0 +} + +func (m *GfSpListCompleteMigrationBucketEventsRequest) GetSrcSpId() uint32 { + if m != nil { + return m.SrcSpId + } + return 0 +} + +// GfSpListCompleteMigrationBucketEventsResponse is response type for the GfSpListCompleteMigrationBucketEvents RPC method +type GfSpListCompleteMigrationBucketEventsResponse struct { + // complete_event defines the complete migration bucket event + CompleteEvents []*types.EventCompleteMigrationBucket `protobuf:"bytes,1,rep,name=complete_events,json=completeEvents,proto3" json:"complete_events,omitempty"` +} + +func (m *GfSpListCompleteMigrationBucketEventsResponse) Reset() { + *m = GfSpListCompleteMigrationBucketEventsResponse{} +} +func (m *GfSpListCompleteMigrationBucketEventsResponse) String() string { + return proto.CompactTextString(m) +} +func (*GfSpListCompleteMigrationBucketEventsResponse) ProtoMessage() {} +func (*GfSpListCompleteMigrationBucketEventsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7cdcff708e247f22, []int{69} +} +func (m *GfSpListCompleteMigrationBucketEventsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GfSpListCompleteMigrationBucketEventsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GfSpListCompleteMigrationBucketEventsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GfSpListCompleteMigrationBucketEventsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GfSpListCompleteMigrationBucketEventsResponse.Merge(m, src) +} +func (m *GfSpListCompleteMigrationBucketEventsResponse) XXX_Size() int { + return m.Size() +} +func (m *GfSpListCompleteMigrationBucketEventsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GfSpListCompleteMigrationBucketEventsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GfSpListCompleteMigrationBucketEventsResponse proto.InternalMessageInfo + +func (m *GfSpListCompleteMigrationBucketEventsResponse) GetCompleteEvents() []*types.EventCompleteMigrationBucket { + if m != nil { + return m.CompleteEvents + } + return nil +} + // GfSpListSwapOutEventsRequest is request type for the GfSpListSwapOutEvents RPC method type GfSpListSwapOutEventsRequest struct { // block_id is the unique identification for block @@ -4311,7 +4420,7 @@ func (m *GfSpListSwapOutEventsRequest) Reset() { *m = GfSpListSwapOutEve func (m *GfSpListSwapOutEventsRequest) String() string { return proto.CompactTextString(m) } func (*GfSpListSwapOutEventsRequest) ProtoMessage() {} func (*GfSpListSwapOutEventsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{68} + return fileDescriptor_7cdcff708e247f22, []int{70} } func (m *GfSpListSwapOutEventsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4368,7 +4477,7 @@ func (m *ListSwapOutEvents) Reset() { *m = ListSwapOutEvents{} } func (m *ListSwapOutEvents) String() string { return proto.CompactTextString(m) } func (*ListSwapOutEvents) ProtoMessage() {} func (*ListSwapOutEvents) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{69} + return fileDescriptor_7cdcff708e247f22, []int{71} } func (m *ListSwapOutEvents) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4428,7 +4537,7 @@ func (m *GfSpListSwapOutEventsResponse) Reset() { *m = GfSpListSwapOutEv func (m *GfSpListSwapOutEventsResponse) String() string { return proto.CompactTextString(m) } func (*GfSpListSwapOutEventsResponse) ProtoMessage() {} func (*GfSpListSwapOutEventsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{70} + return fileDescriptor_7cdcff708e247f22, []int{72} } func (m *GfSpListSwapOutEventsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4478,7 +4587,7 @@ func (m *GfSpListGlobalVirtualGroupsBySecondarySPRequest) String() string { } func (*GfSpListGlobalVirtualGroupsBySecondarySPRequest) ProtoMessage() {} func (*GfSpListGlobalVirtualGroupsBySecondarySPRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{71} + return fileDescriptor_7cdcff708e247f22, []int{73} } func (m *GfSpListGlobalVirtualGroupsBySecondarySPRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4528,7 +4637,7 @@ func (m *GfSpListGlobalVirtualGroupsBySecondarySPResponse) String() string { } func (*GfSpListGlobalVirtualGroupsBySecondarySPResponse) ProtoMessage() {} func (*GfSpListGlobalVirtualGroupsBySecondarySPResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{72} + return fileDescriptor_7cdcff708e247f22, []int{74} } func (m *GfSpListGlobalVirtualGroupsBySecondarySPResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4578,7 +4687,7 @@ func (m *GfSpListGlobalVirtualGroupsByBucketRequest) String() string { } func (*GfSpListGlobalVirtualGroupsByBucketRequest) ProtoMessage() {} func (*GfSpListGlobalVirtualGroupsByBucketRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{73} + return fileDescriptor_7cdcff708e247f22, []int{75} } func (m *GfSpListGlobalVirtualGroupsByBucketRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4628,7 +4737,7 @@ func (m *GfSpListGlobalVirtualGroupsByBucketResponse) String() string { } func (*GfSpListGlobalVirtualGroupsByBucketResponse) ProtoMessage() {} func (*GfSpListGlobalVirtualGroupsByBucketResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{74} + return fileDescriptor_7cdcff708e247f22, []int{76} } func (m *GfSpListGlobalVirtualGroupsByBucketResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4676,7 +4785,7 @@ func (m *GfSpListSpExitEventsRequest) Reset() { *m = GfSpListSpExitEvent func (m *GfSpListSpExitEventsRequest) String() string { return proto.CompactTextString(m) } func (*GfSpListSpExitEventsRequest) ProtoMessage() {} func (*GfSpListSpExitEventsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{75} + return fileDescriptor_7cdcff708e247f22, []int{77} } func (m *GfSpListSpExitEventsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4731,7 +4840,7 @@ func (m *ListSpExitEvents) Reset() { *m = ListSpExitEvents{} } func (m *ListSpExitEvents) String() string { return proto.CompactTextString(m) } func (*ListSpExitEvents) ProtoMessage() {} func (*ListSpExitEvents) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{76} + return fileDescriptor_7cdcff708e247f22, []int{78} } func (m *ListSpExitEvents) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4784,7 +4893,7 @@ func (m *GfSpListSpExitEventsResponse) Reset() { *m = GfSpListSpExitEven func (m *GfSpListSpExitEventsResponse) String() string { return proto.CompactTextString(m) } func (*GfSpListSpExitEventsResponse) ProtoMessage() {} func (*GfSpListSpExitEventsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{77} + return fileDescriptor_7cdcff708e247f22, []int{79} } func (m *GfSpListSpExitEventsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4830,7 +4939,7 @@ func (m *GfSpGetSPInfoRequest) Reset() { *m = GfSpGetSPInfoRequest{} } func (m *GfSpGetSPInfoRequest) String() string { return proto.CompactTextString(m) } func (*GfSpGetSPInfoRequest) ProtoMessage() {} func (*GfSpGetSPInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{78} + return fileDescriptor_7cdcff708e247f22, []int{80} } func (m *GfSpGetSPInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4876,7 +4985,7 @@ func (m *GfSpGetSPInfoResponse) Reset() { *m = GfSpGetSPInfoResponse{} } func (m *GfSpGetSPInfoResponse) String() string { return proto.CompactTextString(m) } func (*GfSpGetSPInfoResponse) ProtoMessage() {} func (*GfSpGetSPInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{79} + return fileDescriptor_7cdcff708e247f22, []int{81} } func (m *GfSpGetSPInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4922,7 +5031,7 @@ func (m *GfSpPrimarySpIncomeDetailsRequest) Reset() { *m = GfSpPrimarySp func (m *GfSpPrimarySpIncomeDetailsRequest) String() string { return proto.CompactTextString(m) } func (*GfSpPrimarySpIncomeDetailsRequest) ProtoMessage() {} func (*GfSpPrimarySpIncomeDetailsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{80} + return fileDescriptor_7cdcff708e247f22, []int{82} } func (m *GfSpPrimarySpIncomeDetailsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4970,7 +5079,7 @@ func (m *GfSpPrimarySpIncomeDetailsResponse) Reset() { *m = GfSpPrimaryS func (m *GfSpPrimarySpIncomeDetailsResponse) String() string { return proto.CompactTextString(m) } func (*GfSpPrimarySpIncomeDetailsResponse) ProtoMessage() {} func (*GfSpPrimarySpIncomeDetailsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{81} + return fileDescriptor_7cdcff708e247f22, []int{83} } func (m *GfSpPrimarySpIncomeDetailsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5026,7 +5135,7 @@ func (m *PrimarySpIncomeDetail) Reset() { *m = PrimarySpIncomeDetail{} } func (m *PrimarySpIncomeDetail) String() string { return proto.CompactTextString(m) } func (*PrimarySpIncomeDetail) ProtoMessage() {} func (*PrimarySpIncomeDetail) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{82} + return fileDescriptor_7cdcff708e247f22, []int{84} } func (m *PrimarySpIncomeDetail) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5079,7 +5188,7 @@ func (m *GfSpSecondarySpIncomeDetailsRequest) Reset() { *m = GfSpSeconda func (m *GfSpSecondarySpIncomeDetailsRequest) String() string { return proto.CompactTextString(m) } func (*GfSpSecondarySpIncomeDetailsRequest) ProtoMessage() {} func (*GfSpSecondarySpIncomeDetailsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{83} + return fileDescriptor_7cdcff708e247f22, []int{85} } func (m *GfSpSecondarySpIncomeDetailsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5127,7 +5236,7 @@ func (m *GfSpSecondarySpIncomeDetailsResponse) Reset() { *m = GfSpSecond func (m *GfSpSecondarySpIncomeDetailsResponse) String() string { return proto.CompactTextString(m) } func (*GfSpSecondarySpIncomeDetailsResponse) ProtoMessage() {} func (*GfSpSecondarySpIncomeDetailsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{84} + return fileDescriptor_7cdcff708e247f22, []int{86} } func (m *GfSpSecondarySpIncomeDetailsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5183,7 +5292,7 @@ func (m *SecondarySpIncomeDetail) Reset() { *m = SecondarySpIncomeDetail func (m *SecondarySpIncomeDetail) String() string { return proto.CompactTextString(m) } func (*SecondarySpIncomeDetail) ProtoMessage() {} func (*SecondarySpIncomeDetail) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{85} + return fileDescriptor_7cdcff708e247f22, []int{87} } func (m *SecondarySpIncomeDetail) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5236,7 +5345,7 @@ func (m *Status) Reset() { *m = Status{} } func (m *Status) String() string { return proto.CompactTextString(m) } func (*Status) ProtoMessage() {} func (*Status) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{86} + return fileDescriptor_7cdcff708e247f22, []int{88} } func (m *Status) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5303,7 +5412,7 @@ func (m *BlockSyncerInfo) Reset() { *m = BlockSyncerInfo{} } func (m *BlockSyncerInfo) String() string { return proto.CompactTextString(m) } func (*BlockSyncerInfo) ProtoMessage() {} func (*BlockSyncerInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{87} + return fileDescriptor_7cdcff708e247f22, []int{89} } func (m *BlockSyncerInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5404,7 +5513,7 @@ func (m *ChainInfo) Reset() { *m = ChainInfo{} } func (m *ChainInfo) String() string { return proto.CompactTextString(m) } func (*ChainInfo) ProtoMessage() {} func (*ChainInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{88} + return fileDescriptor_7cdcff708e247f22, []int{90} } func (m *ChainInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5461,7 +5570,7 @@ func (m *StorageProviderInfo) Reset() { *m = StorageProviderInfo{} } func (m *StorageProviderInfo) String() string { return proto.CompactTextString(m) } func (*StorageProviderInfo) ProtoMessage() {} func (*StorageProviderInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{89} + return fileDescriptor_7cdcff708e247f22, []int{91} } func (m *StorageProviderInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5546,7 +5655,7 @@ func (m *GfSpGetStatusRequest) Reset() { *m = GfSpGetStatusRequest{} } func (m *GfSpGetStatusRequest) String() string { return proto.CompactTextString(m) } func (*GfSpGetStatusRequest) ProtoMessage() {} func (*GfSpGetStatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{90} + return fileDescriptor_7cdcff708e247f22, []int{92} } func (m *GfSpGetStatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5583,7 +5692,7 @@ func (m *GfSpGetStatusResponse) Reset() { *m = GfSpGetStatusResponse{} } func (m *GfSpGetStatusResponse) String() string { return proto.CompactTextString(m) } func (*GfSpGetStatusResponse) ProtoMessage() {} func (*GfSpGetStatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{91} + return fileDescriptor_7cdcff708e247f22, []int{93} } func (m *GfSpGetStatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5633,7 +5742,7 @@ func (m *GfSpGetUserGroupsRequest) Reset() { *m = GfSpGetUserGroupsReque func (m *GfSpGetUserGroupsRequest) String() string { return proto.CompactTextString(m) } func (*GfSpGetUserGroupsRequest) ProtoMessage() {} func (*GfSpGetUserGroupsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{92} + return fileDescriptor_7cdcff708e247f22, []int{94} } func (m *GfSpGetUserGroupsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5693,7 +5802,7 @@ func (m *GfSpGetUserGroupsResponse) Reset() { *m = GfSpGetUserGroupsResp func (m *GfSpGetUserGroupsResponse) String() string { return proto.CompactTextString(m) } func (*GfSpGetUserGroupsResponse) ProtoMessage() {} func (*GfSpGetUserGroupsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{93} + return fileDescriptor_7cdcff708e247f22, []int{95} } func (m *GfSpGetUserGroupsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5743,7 +5852,7 @@ func (m *GfSpGetGroupMembersRequest) Reset() { *m = GfSpGetGroupMembersR func (m *GfSpGetGroupMembersRequest) String() string { return proto.CompactTextString(m) } func (*GfSpGetGroupMembersRequest) ProtoMessage() {} func (*GfSpGetGroupMembersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{94} + return fileDescriptor_7cdcff708e247f22, []int{96} } func (m *GfSpGetGroupMembersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5803,7 +5912,7 @@ func (m *GfSpGetGroupMembersResponse) Reset() { *m = GfSpGetGroupMembers func (m *GfSpGetGroupMembersResponse) String() string { return proto.CompactTextString(m) } func (*GfSpGetGroupMembersResponse) ProtoMessage() {} func (*GfSpGetGroupMembersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{95} + return fileDescriptor_7cdcff708e247f22, []int{97} } func (m *GfSpGetGroupMembersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5853,7 +5962,7 @@ func (m *GfSpGetUserOwnedGroupsRequest) Reset() { *m = GfSpGetUserOwnedG func (m *GfSpGetUserOwnedGroupsRequest) String() string { return proto.CompactTextString(m) } func (*GfSpGetUserOwnedGroupsRequest) ProtoMessage() {} func (*GfSpGetUserOwnedGroupsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{96} + return fileDescriptor_7cdcff708e247f22, []int{98} } func (m *GfSpGetUserOwnedGroupsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5913,7 +6022,7 @@ func (m *GfSpGetUserOwnedGroupsResponse) Reset() { *m = GfSpGetUserOwned func (m *GfSpGetUserOwnedGroupsResponse) String() string { return proto.CompactTextString(m) } func (*GfSpGetUserOwnedGroupsResponse) ProtoMessage() {} func (*GfSpGetUserOwnedGroupsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{97} + return fileDescriptor_7cdcff708e247f22, []int{99} } func (m *GfSpGetUserOwnedGroupsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5970,7 +6079,7 @@ func (m *Policy) Reset() { *m = Policy{} } func (m *Policy) String() string { return proto.CompactTextString(m) } func (*Policy) ProtoMessage() {} func (*Policy) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{98} + return fileDescriptor_7cdcff708e247f22, []int{100} } func (m *Policy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6066,7 +6175,7 @@ func (m *GfSpListObjectPoliciesRequest) Reset() { *m = GfSpListObjectPol func (m *GfSpListObjectPoliciesRequest) String() string { return proto.CompactTextString(m) } func (*GfSpListObjectPoliciesRequest) ProtoMessage() {} func (*GfSpListObjectPoliciesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{99} + return fileDescriptor_7cdcff708e247f22, []int{101} } func (m *GfSpListObjectPoliciesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6139,7 +6248,7 @@ func (m *GfSpListObjectPoliciesResponse) Reset() { *m = GfSpListObjectPo func (m *GfSpListObjectPoliciesResponse) String() string { return proto.CompactTextString(m) } func (*GfSpListObjectPoliciesResponse) ProtoMessage() {} func (*GfSpListObjectPoliciesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{100} + return fileDescriptor_7cdcff708e247f22, []int{102} } func (m *GfSpListObjectPoliciesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6185,7 +6294,7 @@ func (m *GfSpListPaymentAccountStreamsRequest) Reset() { *m = GfSpListPa func (m *GfSpListPaymentAccountStreamsRequest) String() string { return proto.CompactTextString(m) } func (*GfSpListPaymentAccountStreamsRequest) ProtoMessage() {} func (*GfSpListPaymentAccountStreamsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{101} + return fileDescriptor_7cdcff708e247f22, []int{103} } func (m *GfSpListPaymentAccountStreamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6231,7 +6340,7 @@ func (m *GfSpListPaymentAccountStreamsResponse) Reset() { *m = GfSpListP func (m *GfSpListPaymentAccountStreamsResponse) String() string { return proto.CompactTextString(m) } func (*GfSpListPaymentAccountStreamsResponse) ProtoMessage() {} func (*GfSpListPaymentAccountStreamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{102} + return fileDescriptor_7cdcff708e247f22, []int{104} } func (m *GfSpListPaymentAccountStreamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6277,7 +6386,7 @@ func (m *GfSpListUserPaymentAccountsRequest) Reset() { *m = GfSpListUser func (m *GfSpListUserPaymentAccountsRequest) String() string { return proto.CompactTextString(m) } func (*GfSpListUserPaymentAccountsRequest) ProtoMessage() {} func (*GfSpListUserPaymentAccountsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{103} + return fileDescriptor_7cdcff708e247f22, []int{105} } func (m *GfSpListUserPaymentAccountsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6323,7 +6432,7 @@ func (m *GfSpListUserPaymentAccountsResponse) Reset() { *m = GfSpListUse func (m *GfSpListUserPaymentAccountsResponse) String() string { return proto.CompactTextString(m) } func (*GfSpListUserPaymentAccountsResponse) ProtoMessage() {} func (*GfSpListUserPaymentAccountsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{104} + return fileDescriptor_7cdcff708e247f22, []int{106} } func (m *GfSpListUserPaymentAccountsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6369,7 +6478,7 @@ func (m *GfSpListGroupsByIDsRequest) Reset() { *m = GfSpListGroupsByIDsR func (m *GfSpListGroupsByIDsRequest) String() string { return proto.CompactTextString(m) } func (*GfSpListGroupsByIDsRequest) ProtoMessage() {} func (*GfSpListGroupsByIDsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{105} + return fileDescriptor_7cdcff708e247f22, []int{107} } func (m *GfSpListGroupsByIDsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6415,7 +6524,7 @@ func (m *GfSpListGroupsByIDsResponse) Reset() { *m = GfSpListGroupsByIDs func (m *GfSpListGroupsByIDsResponse) String() string { return proto.CompactTextString(m) } func (*GfSpListGroupsByIDsResponse) ProtoMessage() {} func (*GfSpListGroupsByIDsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{106} + return fileDescriptor_7cdcff708e247f22, []int{108} } func (m *GfSpListGroupsByIDsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6461,7 +6570,7 @@ func (m *GfSpGetSPMigratingBucketNumberRequest) Reset() { *m = GfSpGetSP func (m *GfSpGetSPMigratingBucketNumberRequest) String() string { return proto.CompactTextString(m) } func (*GfSpGetSPMigratingBucketNumberRequest) ProtoMessage() {} func (*GfSpGetSPMigratingBucketNumberRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{107} + return fileDescriptor_7cdcff708e247f22, []int{109} } func (m *GfSpGetSPMigratingBucketNumberRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6509,7 +6618,7 @@ func (m *GfSpGetSPMigratingBucketNumberResponse) Reset() { func (m *GfSpGetSPMigratingBucketNumberResponse) String() string { return proto.CompactTextString(m) } func (*GfSpGetSPMigratingBucketNumberResponse) ProtoMessage() {} func (*GfSpGetSPMigratingBucketNumberResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{108} + return fileDescriptor_7cdcff708e247f22, []int{110} } func (m *GfSpGetSPMigratingBucketNumberResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6559,7 +6668,7 @@ func (m *GfSpVerifyMigrateGVGPermissionRequest) Reset() { *m = GfSpVerif func (m *GfSpVerifyMigrateGVGPermissionRequest) String() string { return proto.CompactTextString(m) } func (*GfSpVerifyMigrateGVGPermissionRequest) ProtoMessage() {} func (*GfSpVerifyMigrateGVGPermissionRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{109} + return fileDescriptor_7cdcff708e247f22, []int{111} } func (m *GfSpVerifyMigrateGVGPermissionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6621,7 +6730,7 @@ func (m *GfSpVerifyMigrateGVGPermissionResponse) Reset() { func (m *GfSpVerifyMigrateGVGPermissionResponse) String() string { return proto.CompactTextString(m) } func (*GfSpVerifyMigrateGVGPermissionResponse) ProtoMessage() {} func (*GfSpVerifyMigrateGVGPermissionResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{110} + return fileDescriptor_7cdcff708e247f22, []int{112} } func (m *GfSpVerifyMigrateGVGPermissionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6667,7 +6776,7 @@ func (m *GfSpGetBucketSizeRequest) Reset() { *m = GfSpGetBucketSizeReque func (m *GfSpGetBucketSizeRequest) String() string { return proto.CompactTextString(m) } func (*GfSpGetBucketSizeRequest) ProtoMessage() {} func (*GfSpGetBucketSizeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{111} + return fileDescriptor_7cdcff708e247f22, []int{113} } func (m *GfSpGetBucketSizeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6713,7 +6822,7 @@ func (m *GfSpGetBucketSizeResponse) Reset() { *m = GfSpGetBucketSizeResp func (m *GfSpGetBucketSizeResponse) String() string { return proto.CompactTextString(m) } func (*GfSpGetBucketSizeResponse) ProtoMessage() {} func (*GfSpGetBucketSizeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{112} + return fileDescriptor_7cdcff708e247f22, []int{114} } func (m *GfSpGetBucketSizeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6757,7 +6866,7 @@ func (m *GfSpGetLatestObjectIDRequest) Reset() { *m = GfSpGetLatestObjec func (m *GfSpGetLatestObjectIDRequest) String() string { return proto.CompactTextString(m) } func (*GfSpGetLatestObjectIDRequest) ProtoMessage() {} func (*GfSpGetLatestObjectIDRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{113} + return fileDescriptor_7cdcff708e247f22, []int{115} } func (m *GfSpGetLatestObjectIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6796,7 +6905,7 @@ func (m *GfSpGetLatestObjectIDResponse) Reset() { *m = GfSpGetLatestObje func (m *GfSpGetLatestObjectIDResponse) String() string { return proto.CompactTextString(m) } func (*GfSpGetLatestObjectIDResponse) ProtoMessage() {} func (*GfSpGetLatestObjectIDResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_7cdcff708e247f22, []int{114} + return fileDescriptor_7cdcff708e247f22, []int{116} } func (m *GfSpGetLatestObjectIDResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6903,6 +7012,8 @@ func init() { proto.RegisterType((*GfSpListMigrateBucketEventsRequest)(nil), "modular.metadata.types.GfSpListMigrateBucketEventsRequest") proto.RegisterType((*ListMigrateBucketEvents)(nil), "modular.metadata.types.ListMigrateBucketEvents") proto.RegisterType((*GfSpListMigrateBucketEventsResponse)(nil), "modular.metadata.types.GfSpListMigrateBucketEventsResponse") + proto.RegisterType((*GfSpListCompleteMigrationBucketEventsRequest)(nil), "modular.metadata.types.GfSpListCompleteMigrationBucketEventsRequest") + proto.RegisterType((*GfSpListCompleteMigrationBucketEventsResponse)(nil), "modular.metadata.types.GfSpListCompleteMigrationBucketEventsResponse") proto.RegisterType((*GfSpListSwapOutEventsRequest)(nil), "modular.metadata.types.GfSpListSwapOutEventsRequest") proto.RegisterType((*ListSwapOutEvents)(nil), "modular.metadata.types.ListSwapOutEvents") proto.RegisterType((*GfSpListSwapOutEventsResponse)(nil), "modular.metadata.types.GfSpListSwapOutEventsResponse") @@ -6958,346 +7069,350 @@ func init() { } var fileDescriptor_7cdcff708e247f22 = []byte{ - // 5418 bytes of a gzipped FileDescriptorProto + // 5481 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7c, 0x4b, 0x6c, 0x1c, 0x47, - 0x7a, 0x30, 0x7b, 0x86, 0x8f, 0x99, 0x1a, 0x0e, 0x49, 0x95, 0x65, 0x89, 0x1a, 0x59, 0x94, 0xd4, - 0xb2, 0x2c, 0xca, 0xb2, 0x48, 0x5b, 0xf2, 0x43, 0xb2, 0x25, 0x5b, 0x24, 0x25, 0xd1, 0x84, 0x57, - 0x16, 0xdd, 0x23, 0xc9, 0xbb, 0xde, 0xdf, 0x7f, 0x6f, 0xcf, 0x74, 0xcd, 0xb0, 0xc3, 0x99, 0xee, - 0x76, 0x57, 0x0f, 0xa5, 0x11, 0xb2, 0xc8, 0x22, 0x2f, 0x60, 0x91, 0x00, 0x79, 0x07, 0xc1, 0x06, - 0x59, 0x60, 0x17, 0x01, 0x72, 0xd9, 0x04, 0x41, 0xb2, 0xc8, 0x21, 0xc9, 0x26, 0x01, 0x72, 0x31, - 0x10, 0x04, 0x30, 0xf6, 0x90, 0x04, 0x8b, 0xc0, 0x58, 0xd8, 0xf7, 0x5c, 0x72, 0xcd, 0x21, 0xa8, - 0x57, 0x77, 0xf5, 0x7b, 0x38, 0xe4, 0x06, 0x39, 0xe4, 0x22, 0x4d, 0x57, 0x7d, 0xf5, 0x55, 0xd5, - 0xf7, 0xaa, 0xaf, 0xbe, 0xef, 0x2b, 0x82, 0xf3, 0x7d, 0xc7, 0x1c, 0xf4, 0x0c, 0x6f, 0xb5, 0x8f, - 0x7c, 0xc3, 0x34, 0x7c, 0x63, 0xd5, 0x1f, 0xba, 0x08, 0x07, 0x9f, 0x2b, 0xae, 0xe7, 0xf8, 0x0e, - 0x3c, 0xc6, 0xc1, 0x56, 0x82, 0x76, 0x0a, 0xd6, 0x38, 0xdb, 0x32, 0x30, 0xe2, 0x43, 0xba, 0x1d, - 0xec, 0x22, 0xcf, 0x73, 0x3c, 0xbc, 0x4a, 0xff, 0x63, 0x43, 0x1b, 0x4b, 0x31, 0x10, 0xdf, 0xc0, - 0xbb, 0xab, 0xe4, 0x1f, 0xde, 0x7f, 0xa2, 0xed, 0xe0, 0xbe, 0x83, 0x75, 0xfa, 0xb5, 0xca, 0x3e, - 0x78, 0xd7, 0xd1, 0xae, 0xd3, 0x75, 0x58, 0x3b, 0xf9, 0xc5, 0x5b, 0x5f, 0xe8, 0x7a, 0x08, 0xd9, - 0x1d, 0x0b, 0xf5, 0xcc, 0x55, 0xd7, 0x18, 0xf6, 0x91, 0xed, 0xaf, 0x62, 0xdf, 0x43, 0x46, 0x5f, - 0xf7, 0x50, 0xdb, 0xf1, 0x4c, 0x0e, 0xa7, 0xca, 0x70, 0xc8, 0xeb, 0x5b, 0x18, 0x5b, 0x8e, 0xbd, - 0xda, 0x76, 0xfa, 0x7d, 0xc7, 0xe6, 0x30, 0xa7, 0x25, 0x18, 0x0f, 0x61, 0x67, 0xe0, 0xb5, 0xf9, - 0x5a, 0xc5, 0xea, 0x24, 0x00, 0xec, 0x46, 0xba, 0xe4, 0xb1, 0xd8, 0x77, 0x3c, 0xa3, 0x8b, 0x56, - 0xd1, 0x1e, 0xb2, 0x7d, 0x01, 0xb0, 0x94, 0x02, 0xf0, 0xc9, 0x00, 0x79, 0xc3, 0x9c, 0x7e, 0x79, - 0x82, 0xe7, 0xa5, 0xfe, 0x3d, 0xcb, 0xf3, 0x07, 0x46, 0xaf, 0xeb, 0x39, 0x03, 0x37, 0x3a, 0xcb, - 0xb9, 0x2c, 0x28, 0x19, 0xd5, 0x71, 0x82, 0x5f, 0x70, 0x81, 0xfe, 0x66, 0x1d, 0xea, 0x7f, 0x94, - 0xc0, 0xf4, 0xfa, 0xa0, 0xbd, 0x8b, 0x7c, 0xf8, 0x0e, 0xa8, 0xb5, 0xe8, 0x2f, 0xdd, 0xb2, 0x3b, - 0xce, 0xa2, 0x72, 0x46, 0x59, 0xae, 0x5d, 0x59, 0x5a, 0x09, 0xd1, 0xaf, 0xf0, 0x45, 0xae, 0xb0, - 0x01, 0x5b, 0x76, 0xc7, 0xd1, 0x40, 0x2b, 0xf8, 0x0d, 0x17, 0xc1, 0x8c, 0x87, 0xfa, 0xce, 0x1e, - 0x32, 0x17, 0x4b, 0x67, 0x94, 0xe5, 0x8a, 0x26, 0x3e, 0xe1, 0x49, 0x50, 0x35, 0x51, 0x0f, 0xf9, - 0x48, 0x37, 0xfc, 0xc5, 0xf2, 0x19, 0x65, 0xb9, 0xac, 0x55, 0x58, 0xc3, 0x9a, 0x0f, 0xcf, 0x81, - 0x3a, 0xef, 0xf4, 0x90, 0x81, 0x1d, 0x7b, 0x71, 0xf2, 0x8c, 0xb2, 0x5c, 0xd5, 0x66, 0x59, 0xa3, - 0x46, 0xdb, 0x60, 0x03, 0x54, 0x1c, 0x17, 0x79, 0x86, 0xef, 0x78, 0x8b, 0x53, 0xb4, 0x3f, 0xf8, - 0x86, 0xcf, 0x83, 0xb9, 0xb6, 0x87, 0x0c, 0x1f, 0xe9, 0xfe, 0x13, 0x7d, 0xc7, 0xc0, 0x3b, 0x8b, - 0xd3, 0x0c, 0x03, 0x6b, 0x7d, 0xf0, 0xe4, 0x5d, 0x03, 0xef, 0x10, 0xa8, 0x81, 0x6b, 0xca, 0x50, - 0x33, 0x0c, 0x8a, 0xb5, 0x72, 0xa8, 0x93, 0xa0, 0xca, 0xa1, 0x0c, 0x7f, 0xb1, 0xc2, 0x56, 0xca, - 0x1a, 0xd6, 0x7c, 0x78, 0x1a, 0xd4, 0x04, 0x0a, 0xab, 0x8f, 0x16, 0xab, 0xb4, 0x1b, 0xf0, 0xf1, - 0x56, 0x1f, 0xc1, 0xb3, 0x60, 0x96, 0xd3, 0x48, 0xc7, 0xd6, 0x53, 0xb4, 0x08, 0xe8, 0x0c, 0x35, - 0xde, 0xd6, 0xb4, 0x9e, 0x22, 0xf5, 0x3f, 0x4b, 0x60, 0xfa, 0x7e, 0xeb, 0xe7, 0x50, 0x9b, 0x12, - 0xdc, 0xa1, 0xbf, 0x0a, 0x09, 0xce, 0x06, 0x30, 0x82, 0x3b, 0xc1, 0x6f, 0x78, 0x1e, 0xcc, 0xf5, - 0x9c, 0xf6, 0x2e, 0x32, 0xf5, 0x96, 0xd1, 0x33, 0xec, 0x36, 0xa2, 0x74, 0xaf, 0x6a, 0x75, 0xd6, - 0xba, 0xce, 0x1a, 0x65, 0xbe, 0x94, 0x13, 0x7c, 0x09, 0x77, 0x3b, 0x19, 0xdb, 0x6d, 0x84, 0x69, - 0x53, 0x45, 0x4c, 0x9b, 0x2e, 0x60, 0xda, 0x4c, 0x21, 0xd3, 0x2a, 0x23, 0x31, 0xad, 0x9a, 0xc2, - 0xb4, 0x33, 0x60, 0x16, 0x23, 0xa3, 0x17, 0xc0, 0x30, 0xb2, 0x03, 0xd2, 0xc6, 0x20, 0xd4, 0xbf, - 0x53, 0x40, 0x9d, 0x11, 0xf1, 0x36, 0xf2, 0x0d, 0xab, 0x87, 0xe1, 0xeb, 0x60, 0x9a, 0x51, 0x32, - 0xa0, 0x7b, 0xba, 0x89, 0xe3, 0xb4, 0xd7, 0x38, 0x34, 0x19, 0xc7, 0x44, 0x9e, 0xd2, 0x3a, 0x67, - 0x1c, 0x53, 0x12, 0x8d, 0x43, 0xc3, 0x9b, 0xa0, 0xdc, 0xdd, 0xeb, 0x52, 0x06, 0xd4, 0xae, 0x5c, - 0x92, 0x99, 0x2c, 0x2b, 0xed, 0xca, 0x66, 0xcf, 0x69, 0x19, 0xbd, 0x47, 0xac, 0x69, 0x93, 0x34, - 0x69, 0x64, 0x9c, 0xfa, 0xd7, 0x65, 0x50, 0x7f, 0xb4, 0x79, 0x97, 0xb0, 0xfd, 0xff, 0xd4, 0xf5, - 0xb0, 0xd4, 0x75, 0x03, 0x94, 0xf7, 0xba, 0x1d, 0x2a, 0x2e, 0xb5, 0x2b, 0xaf, 0xec, 0x83, 0x27, - 0x77, 0x8d, 0xbe, 0xd5, 0x1b, 0x6a, 0x64, 0x74, 0x42, 0xe7, 0x6b, 0x49, 0x9d, 0xff, 0xae, 0x02, - 0xe6, 0xb6, 0xd9, 0x49, 0xb5, 0xd6, 0x6e, 0x3b, 0x03, 0xdb, 0x27, 0xc4, 0x37, 0x4c, 0xd3, 0x43, - 0x18, 0x53, 0xce, 0x55, 0x35, 0xf1, 0x09, 0x8f, 0x82, 0x29, 0xe7, 0xb1, 0x8d, 0x3c, 0xae, 0xcb, - 0xec, 0x03, 0x2e, 0x01, 0xe0, 0xa1, 0xce, 0xc0, 0x36, 0x8d, 0x56, 0x0f, 0x71, 0x35, 0x96, 0x5a, - 0xf2, 0x35, 0x39, 0x46, 0x88, 0xa9, 0x38, 0x21, 0xd4, 0x1f, 0x28, 0x00, 0x46, 0x17, 0x78, 0x0f, - 0xf9, 0x06, 0xbc, 0x0f, 0xe6, 0xf9, 0x01, 0xab, 0x1b, 0xac, 0x99, 0x8b, 0xd9, 0x0b, 0x59, 0x42, - 0x1f, 0x45, 0xa2, 0xcd, 0xb9, 0xd1, 0x5d, 0xdf, 0x01, 0xf5, 0xc8, 0x49, 0xcd, 0x75, 0xe8, 0x8c, - 0x4c, 0x7a, 0x3e, 0x64, 0xa5, 0x49, 0x01, 0x35, 0x0a, 0xa7, 0xcd, 0x62, 0xe9, 0x4b, 0x6d, 0x83, - 0x13, 0x9b, 0x9d, 0xa6, 0xbb, 0x89, 0xfc, 0x87, 0x18, 0x79, 0x4c, 0xbc, 0xb1, 0x86, 0x3e, 0x19, - 0x20, 0xec, 0xc3, 0x53, 0x00, 0xf0, 0xc5, 0xea, 0x96, 0xc9, 0x89, 0x5b, 0xe5, 0x2d, 0x5b, 0x26, - 0xbc, 0x00, 0xe6, 0x2d, 0xbb, 0xdd, 0x1b, 0x98, 0x44, 0x7e, 0x65, 0xe9, 0x9f, 0xe3, 0xcd, 0x1a, - 0x6b, 0x55, 0x3f, 0x06, 0x8d, 0xb4, 0x49, 0xb0, 0xeb, 0xd8, 0x18, 0xc1, 0x77, 0xc0, 0x0c, 0x53, - 0x25, 0xc2, 0xbf, 0xf2, 0x72, 0xed, 0xca, 0xf9, 0x2c, 0x92, 0x44, 0xb4, 0x56, 0x13, 0xa3, 0xd4, - 0x3f, 0x2b, 0x01, 0x95, 0xe0, 0xff, 0x8a, 0x85, 0x7d, 0x66, 0x62, 0xf0, 0xfa, 0x90, 0x01, 0xbd, - 0x6f, 0xf4, 0x91, 0xd8, 0xcd, 0xe9, 0x40, 0xcb, 0x6d, 0xa3, 0x8f, 0xf8, 0x76, 0xb8, 0x16, 0x13, - 0xb8, 0xd8, 0x76, 0x4b, 0xf1, 0xed, 0x9e, 0x00, 0x95, 0xbe, 0xf1, 0x44, 0xdf, 0x45, 0x43, 0x4c, - 0xa5, 0x66, 0x52, 0x9b, 0xe9, 0x1b, 0x4f, 0xde, 0x43, 0x43, 0x4c, 0x50, 0x63, 0xdf, 0xf0, 0x7c, - 0xdd, 0xe8, 0xf8, 0xc8, 0xe3, 0x6a, 0x0c, 0x68, 0xd3, 0x1a, 0x69, 0x81, 0x97, 0x01, 0x6c, 0x3b, - 0xb6, 0x6f, 0xd9, 0x03, 0xc3, 0xb7, 0x1c, 0x5b, 0xf7, 0x9d, 0x5d, 0x64, 0x73, 0x75, 0x3e, 0x22, - 0xf7, 0x3c, 0x20, 0x1d, 0xf0, 0x39, 0x6a, 0x35, 0xac, 0xbe, 0x45, 0xb0, 0x31, 0x95, 0x0e, 0x1b, - 0xe0, 0x31, 0x30, 0xed, 0x7a, 0xa8, 0x63, 0x3d, 0xe1, 0x7a, 0xcc, 0xbf, 0xd2, 0xf8, 0x51, 0x49, - 0xe5, 0xc7, 0xef, 0x96, 0xc1, 0xb9, 0x5c, 0x82, 0x71, 0xce, 0x5c, 0x03, 0x33, 0xcc, 0x54, 0x0b, - 0xce, 0x14, 0x59, 0x76, 0x01, 0x4e, 0x74, 0x68, 0x17, 0x0d, 0x75, 0x26, 0xe8, 0x25, 0x4a, 0xac, - 0xca, 0x2e, 0x1a, 0x6e, 0x50, 0xd1, 0xcd, 0x21, 0xe4, 0x59, 0x30, 0x6b, 0x61, 0xdd, 0xf7, 0x06, - 0x76, 0xdb, 0xf0, 0x91, 0x49, 0x29, 0x59, 0xd1, 0x6a, 0x16, 0x7e, 0x20, 0x9a, 0xe0, 0xeb, 0xe0, - 0xb8, 0x8d, 0x9e, 0xf8, 0x7a, 0x26, 0x3d, 0x9f, 0x25, 0xdd, 0x1b, 0x09, 0x9a, 0x42, 0x30, 0x49, - 0xf9, 0xce, 0xc8, 0x49, 0x7f, 0x67, 0x52, 0x32, 0x42, 0xff, 0x4a, 0x9c, 0xfe, 0x17, 0xc0, 0x3c, - 0xf3, 0x7c, 0x75, 0x06, 0x8e, 0xf0, 0x62, 0xf5, 0x4c, 0x79, 0xb9, 0xaa, 0xcd, 0xb1, 0xe6, 0x6d, - 0xde, 0x9a, 0xc1, 0x75, 0x90, 0xc1, 0x75, 0xb5, 0x07, 0xce, 0x70, 0x35, 0x61, 0xbc, 0x18, 0x4b, - 0x88, 0x25, 0x21, 0x70, 0x3d, 0x6b, 0xcf, 0xf0, 0x51, 0x4c, 0x29, 0xb7, 0x59, 0xab, 0xfa, 0x75, - 0x70, 0x36, 0x67, 0x36, 0x2e, 0x01, 0xe1, 0x11, 0xad, 0xec, 0xe7, 0x88, 0x56, 0x3b, 0x60, 0x29, - 0x15, 0xf9, 0xd6, 0x6d, 0xb1, 0x91, 0x93, 0xa0, 0x2a, 0xce, 0x5c, 0x66, 0x5a, 0xca, 0x5a, 0x85, - 0x9f, 0xa8, 0xe6, 0xe8, 0x9b, 0xf8, 0x1a, 0x38, 0x9d, 0x39, 0xcf, 0x01, 0xb7, 0xf0, 0x17, 0x0a, - 0x58, 0x15, 0x4a, 0x72, 0x9b, 0x1e, 0xc8, 0x66, 0xa8, 0x2b, 0xc4, 0x2b, 0x7c, 0x7f, 0xd0, 0x6f, - 0x21, 0x4f, 0x33, 0xec, 0x6e, 0xc0, 0x9d, 0x97, 0x00, 0x64, 0x76, 0xa0, 0x45, 0x00, 0x74, 0x9b, - 0x42, 0xf0, 0xdd, 0x2d, 0xd0, 0x1e, 0x69, 0x24, 0x5c, 0x06, 0x0b, 0xc8, 0x36, 0xa3, 0xb0, 0x25, - 0x0a, 0x3b, 0x87, 0x6c, 0x53, 0x86, 0x4c, 0xa1, 0x47, 0x39, 0x95, 0x1e, 0xbf, 0xaf, 0x80, 0x97, - 0x47, 0x5f, 0xf4, 0x81, 0xd5, 0x7c, 0xe4, 0x1d, 0xa8, 0x3b, 0x81, 0x40, 0x48, 0x47, 0x00, 0x35, - 0x07, 0x87, 0x7d, 0xd8, 0xbc, 0x11, 0x88, 0x44, 0x72, 0x26, 0xbe, 0xe1, 0xa3, 0x60, 0x2a, 0x3c, - 0x82, 0xcb, 0x1a, 0xfb, 0x50, 0x9f, 0x32, 0x85, 0x20, 0xa4, 0xbb, 0xf3, 0xc4, 0xb5, 0x3c, 0x64, - 0xf2, 0xc1, 0xeb, 0xc3, 0xa6, 0x2b, 0x89, 0x2d, 0xf7, 0xb8, 0x0c, 0x31, 0xbc, 0xc2, 0x1a, 0xd6, - 0x7c, 0xa8, 0x82, 0xba, 0xeb, 0x59, 0x7d, 0xc3, 0x1b, 0xea, 0xd8, 0x15, 0x67, 0x48, 0x5d, 0xab, - 0xf1, 0xc6, 0xa6, 0xbb, 0x65, 0x92, 0xb9, 0xa9, 0x1d, 0xe1, 0xce, 0x20, 0xfb, 0x50, 0xff, 0x7f, - 0x78, 0x82, 0xa5, 0xcd, 0x1d, 0x32, 0x2a, 0x7a, 0x52, 0x16, 0xc9, 0x72, 0x70, 0x44, 0xfe, 0x8a, - 0x02, 0x16, 0x39, 0x55, 0x18, 0x0f, 0x89, 0x53, 0x22, 0xd9, 0x14, 0x7e, 0x79, 0x92, 0x6d, 0x0a, - 0x6b, 0xa2, 0x36, 0x25, 0x66, 0x74, 0x4a, 0xa3, 0x18, 0x9d, 0x74, 0xf9, 0x6c, 0x06, 0xee, 0x86, - 0xbc, 0x8c, 0x50, 0x53, 0xc7, 0xb9, 0x47, 0xa8, 0xfd, 0xc0, 0x92, 0x71, 0x9f, 0xe9, 0x67, 0x6b, - 0x38, 0x77, 0x19, 0xaf, 0xb2, 0xa6, 0xe3, 0x9b, 0x49, 0xf8, 0x67, 0xca, 0x58, 0xfe, 0x59, 0x37, - 0x90, 0xe6, 0xd8, 0x64, 0x87, 0x6d, 0x49, 0xad, 0xe0, 0xf0, 0x49, 0x99, 0xe8, 0x70, 0xf7, 0x64, - 0x06, 0xb2, 0xc8, 0x66, 0x88, 0xc9, 0xe2, 0x21, 0xb1, 0xe9, 0x7b, 0x4a, 0x20, 0x6b, 0xf2, 0x34, - 0x7c, 0x2b, 0x37, 0x63, 0xa7, 0xc2, 0x88, 0x3e, 0xa7, 0xb8, 0x82, 0x1e, 0x92, 0xf7, 0x7d, 0x15, - 0x3c, 0xc7, 0x97, 0x78, 0xc7, 0x36, 0x5d, 0xc7, 0x22, 0x54, 0x6f, 0xba, 0x21, 0x6b, 0x9f, 0x01, - 0x53, 0xcc, 0x90, 0x28, 0xd4, 0x90, 0x4c, 0x62, 0x77, 0xcb, 0x54, 0xdf, 0x02, 0xa7, 0x32, 0x06, - 0xf1, 0xbd, 0x35, 0x40, 0x05, 0xf1, 0x1e, 0x4e, 0xc0, 0xe0, 0x5b, 0xfd, 0x85, 0x60, 0x30, 0xdf, - 0x11, 0x32, 0xcc, 0x0f, 0x06, 0x4e, 0xc8, 0x80, 0x03, 0xdf, 0x85, 0x4f, 0x01, 0x30, 0x44, 0x86, - 0xa7, 0xf7, 0x1d, 0xdb, 0xdf, 0x11, 0x5e, 0x34, 0x69, 0xb9, 0x47, 0x1a, 0xd4, 0x5f, 0x2b, 0xc5, - 0x5c, 0x03, 0x69, 0x05, 0x7c, 0xfd, 0x57, 0x40, 0x19, 0x79, 0x5e, 0x20, 0x5c, 0x2d, 0x03, 0x23, - 0xce, 0x8c, 0x30, 0x2e, 0xba, 0x42, 0x70, 0xdc, 0x21, 0x3f, 0x35, 0x02, 0x4c, 0x4e, 0xde, 0xf6, - 0x8e, 0xe1, 0x75, 0x91, 0xa9, 0x7f, 0x42, 0x90, 0xb1, 0x0b, 0x24, 0xf3, 0x3c, 0x17, 0x78, 0x0f, - 0x9d, 0x85, 0xdc, 0x22, 0xe1, 0x25, 0x00, 0xb1, 0xab, 0x77, 0x3c, 0x84, 0x64, 0x68, 0xe6, 0x8b, - 0xce, 0x63, 0xf7, 0xae, 0x87, 0x50, 0x08, 0x7c, 0x0e, 0xd4, 0xdb, 0x8e, 0x8d, 0x07, 0x7d, 0x64, - 0x32, 0xb8, 0x49, 0x0a, 0x37, 0x2b, 0x1a, 0x29, 0xd0, 0x6b, 0xe0, 0xb8, 0x84, 0x8e, 0x77, 0x31, - 0xf0, 0x29, 0x0a, 0x7e, 0xb4, 0x23, 0x90, 0x6e, 0xb0, 0x4e, 0x7a, 0x9d, 0x5d, 0x67, 0x8e, 0xf8, - 0x26, 0xf2, 0xbf, 0x62, 0xf8, 0x08, 0x67, 0x31, 0x25, 0xa1, 0xe2, 0x93, 0xa1, 0x8a, 0xab, 0xdf, - 0x51, 0xc0, 0xf3, 0xf9, 0x48, 0x0e, 0x40, 0xd7, 0xb7, 0xc1, 0x14, 0xdd, 0x12, 0x17, 0xf0, 0xe5, - 0xf8, 0x28, 0x1a, 0x7d, 0x26, 0x63, 0xd8, 0xa4, 0x74, 0x42, 0x2a, 0x12, 0x6c, 0x98, 0xfa, 0x53, - 0x85, 0x19, 0x30, 0x72, 0xb2, 0x85, 0xeb, 0xe2, 0xca, 0x70, 0x58, 0x22, 0x17, 0xb8, 0x5d, 0xe4, - 0x4e, 0x8e, 0x7d, 0xa3, 0xef, 0xea, 0x03, 0xcc, 0x1d, 0x11, 0xe6, 0x76, 0x3d, 0x10, 0x1d, 0x0f, - 0x03, 0xa7, 0x25, 0x02, 0x5b, 0x0e, 0x9c, 0x16, 0x19, 0xf2, 0x79, 0x30, 0x47, 0x2e, 0x2a, 0x4c, - 0xc5, 0x89, 0x7f, 0xc3, 0xc3, 0x01, 0xb3, 0x7d, 0xe3, 0x09, 0xdb, 0xc2, 0xfb, 0x83, 0xbe, 0xfa, - 0x97, 0x0a, 0x00, 0xe1, 0xa6, 0x8a, 0x4f, 0xd3, 0x93, 0xa0, 0x2a, 0x62, 0x95, 0xa6, 0xb8, 0x1b, - 0xf1, 0x48, 0x24, 0xb5, 0xd7, 0xc2, 0x0b, 0x12, 0x41, 0x8d, 0x32, 0xc5, 0x30, 0xc7, 0x9b, 0xd7, - 0x78, 0x6c, 0xe3, 0x2c, 0x98, 0x8d, 0xec, 0x80, 0xad, 0xac, 0xe6, 0x4b, 0xcb, 0x3f, 0x09, 0xaa, - 0x1e, 0x32, 0x4c, 0x59, 0x0a, 0x2b, 0xa4, 0x81, 0x4a, 0xde, 0x4f, 0x14, 0x66, 0xf0, 0xd3, 0x19, - 0x73, 0x00, 0x89, 0x79, 0x0f, 0xcc, 0xd2, 0x59, 0x19, 0xd5, 0x08, 0x1b, 0x88, 0xa7, 0xa2, 0x66, - 0xd9, 0xd7, 0x70, 0xd6, 0xf5, 0xc9, 0x4f, 0x3f, 0x3f, 0xad, 0x68, 0x35, 0x2f, 0x68, 0xc1, 0x44, - 0xad, 0xe8, 0x65, 0x2f, 0x85, 0xbd, 0x8c, 0x65, 0x47, 0x49, 0x77, 0x33, 0xc6, 0x62, 0xf5, 0x26, - 0xb3, 0x31, 0x1f, 0x0c, 0x90, 0x37, 0x7c, 0xe8, 0xf6, 0x1c, 0xc3, 0xdc, 0xf6, 0x9c, 0x2e, 0xa1, - 0x9b, 0xa4, 0x51, 0x21, 0x13, 0x94, 0x28, 0x13, 0xd4, 0x1f, 0x70, 0xa1, 0x4d, 0x1d, 0x7f, 0x20, - 0x23, 0x35, 0x85, 0x7d, 0x71, 0x62, 0xcd, 0x5d, 0x39, 0xb6, 0xc2, 0xd2, 0x07, 0x6c, 0xd8, 0x03, - 0x03, 0xef, 0x36, 0x49, 0xaf, 0xc6, 0x80, 0x88, 0x28, 0x20, 0xcf, 0xd3, 0x4d, 0x84, 0xdb, 0x9e, - 0xe5, 0x92, 0x6b, 0xa2, 0x10, 0x05, 0xe4, 0x79, 0xb7, 0xc3, 0x56, 0xf5, 0x0e, 0x78, 0x21, 0x58, - 0xad, 0x86, 0xf0, 0xa0, 0x6f, 0xb4, 0x7a, 0x88, 0x2d, 0xbb, 0x89, 0xba, 0xe4, 0x0c, 0x1a, 0x69, - 0xd7, 0xbf, 0xa8, 0x80, 0x0b, 0x85, 0x78, 0x0e, 0xb0, 0xfb, 0x73, 0xa0, 0x8e, 0x19, 0x1a, 0x29, - 0x2e, 0x50, 0xd7, 0x66, 0x79, 0x23, 0x75, 0xd1, 0xd5, 0xef, 0x94, 0xc0, 0x14, 0x8d, 0x0b, 0xc2, - 0xab, 0x60, 0x8a, 0xc6, 0x0c, 0xf9, 0x24, 0xa7, 0xd2, 0xec, 0x01, 0x85, 0x64, 0xe6, 0x86, 0xc2, - 0x46, 0x82, 0xa5, 0xa5, 0x58, 0xb0, 0x34, 0xe2, 0xba, 0x97, 0x63, 0xae, 0xfb, 0x69, 0x50, 0x13, - 0x91, 0x54, 0xab, 0x8f, 0xb8, 0x36, 0x01, 0x1e, 0x46, 0xb5, 0xfa, 0xb1, 0xa8, 0xe0, 0x54, 0x7e, - 0x54, 0x70, 0x3a, 0x11, 0x1e, 0x7d, 0x11, 0x1c, 0x61, 0xd7, 0x23, 0xdd, 0xe9, 0xe8, 0x7d, 0x44, - 0x7e, 0x61, 0x1a, 0x73, 0x28, 0x6b, 0xf3, 0xac, 0xe3, 0x7e, 0xe7, 0x1e, 0x6b, 0x96, 0x83, 0xc9, - 0x95, 0x48, 0x30, 0x59, 0xfd, 0xdb, 0x12, 0xa8, 0xd1, 0x2d, 0x33, 0xd0, 0xf1, 0x48, 0x54, 0x10, - 0xe5, 0x92, 0x29, 0x58, 0xce, 0xa3, 0xe0, 0x64, 0x3e, 0x05, 0xa7, 0xf2, 0x29, 0x38, 0x9d, 0x4f, - 0xc1, 0x99, 0x04, 0x05, 0x33, 0xa9, 0x42, 0xf5, 0x84, 0xdc, 0x99, 0x78, 0x8c, 0x25, 0x8c, 0x4f, - 0xcf, 0x85, 0xcd, 0x34, 0x34, 0xfb, 0x23, 0x05, 0x1c, 0xe7, 0x07, 0x25, 0xa5, 0x0a, 0x31, 0x7d, - 0x42, 0x33, 0x44, 0x74, 0x48, 0x49, 0x8d, 0x0e, 0x95, 0x22, 0xd1, 0xa1, 0xd3, 0xa0, 0xc6, 0xd2, - 0x9b, 0x3a, 0x11, 0x79, 0x4e, 0x25, 0xc0, 0x9a, 0x1e, 0x0c, 0x5d, 0x14, 0xde, 0xf1, 0x26, 0xa5, - 0x3b, 0x1e, 0x41, 0xe7, 0x74, 0x3a, 0x18, 0x09, 0xf1, 0xe1, 0x5f, 0x69, 0x37, 0xdb, 0xe9, 0xd4, - 0x9b, 0x6d, 0x37, 0xf0, 0x9b, 0xa5, 0xe5, 0x73, 0x85, 0x7c, 0x0d, 0x4c, 0x53, 0xf6, 0x8a, 0x9b, - 0xe1, 0xa9, 0x2c, 0x7b, 0xcb, 0x12, 0x21, 0x1c, 0x38, 0xbc, 0x09, 0x97, 0xe4, 0x9b, 0x30, 0x02, - 0x27, 0xa3, 0x47, 0x03, 0x5e, 0x1f, 0x6e, 0xdd, 0x96, 0xc3, 0xc2, 0x81, 0x37, 0xc2, 0xe6, 0x9b, - 0xd4, 0xaa, 0xc2, 0x1d, 0xc1, 0xa3, 0xdf, 0xd4, 0xff, 0x55, 0x61, 0xee, 0x6f, 0x72, 0x1e, 0xbe, - 0xa9, 0xaf, 0xc7, 0xef, 0xbb, 0x6b, 0x99, 0xbb, 0xca, 0x41, 0xc3, 0xbd, 0x06, 0x7c, 0xc7, 0xf6, - 0xbd, 0x61, 0x70, 0x25, 0x6e, 0x7c, 0x04, 0x66, 0xe5, 0x0e, 0xb8, 0x00, 0xca, 0xbb, 0x68, 0xc8, - 0xad, 0x22, 0xf9, 0x09, 0x5f, 0x05, 0x53, 0x7b, 0x46, 0x6f, 0x80, 0x46, 0x4c, 0x4f, 0x31, 0xe0, - 0x37, 0x4b, 0xd7, 0x14, 0x99, 0x80, 0x41, 0xf8, 0x25, 0x4a, 0xc0, 0xc0, 0x0c, 0x07, 0x04, 0x14, - 0x76, 0x78, 0x4c, 0x02, 0x46, 0xe7, 0x09, 0x09, 0x18, 0x8d, 0xec, 0x14, 0x12, 0x30, 0x0d, 0x0d, - 0xbf, 0x6f, 0x0b, 0x02, 0x72, 0x8c, 0x84, 0x80, 0x72, 0xc7, 0x01, 0x08, 0xc8, 0xef, 0xf3, 0x12, - 0x01, 0x7f, 0xb9, 0xc4, 0x4e, 0xe0, 0x47, 0xc8, 0xb3, 0x3a, 0xc3, 0xed, 0xa0, 0xe4, 0x80, 0xac, - 0x4b, 0x50, 0xf1, 0x55, 0xc9, 0x52, 0x51, 0xb5, 0x5d, 0x5f, 0xfc, 0xf1, 0x0f, 0x2f, 0x1f, 0xe5, - 0x65, 0x0f, 0xdc, 0x4f, 0x6a, 0xfa, 0x9e, 0x65, 0x77, 0x25, 0x1b, 0x76, 0x17, 0xd4, 0x45, 0x75, - 0x02, 0x53, 0x5f, 0x76, 0x16, 0x9f, 0x95, 0x6d, 0xa7, 0x00, 0x58, 0xd1, 0x50, 0xa8, 0xd5, 0xda, - 0xac, 0x27, 0x7d, 0x11, 0x23, 0x10, 0xe0, 0xb1, 0x4c, 0x7e, 0x77, 0x00, 0xa2, 0x69, 0xcb, 0x84, - 0xeb, 0xa0, 0x66, 0xb4, 0x99, 0x49, 0x22, 0xd3, 0x4c, 0x26, 0xa7, 0x09, 0x2b, 0x29, 0x56, 0xd6, - 0x28, 0x24, 0x9d, 0x06, 0x18, 0xc1, 0x6f, 0xf5, 0x6b, 0xcc, 0x47, 0x4b, 0xa7, 0x42, 0xa8, 0xf9, - 0xa8, 0xd3, 0x11, 0x51, 0x93, 0xb9, 0xe8, 0x29, 0x20, 0x4d, 0x71, 0x87, 0x02, 0x69, 0x1c, 0x58, - 0xbd, 0x05, 0x2e, 0x0a, 0x9e, 0x27, 0xd2, 0x71, 0x16, 0xc2, 0x23, 0xdc, 0x43, 0xbf, 0xaf, 0x80, - 0x17, 0x47, 0x41, 0xc1, 0xd7, 0xe9, 0x83, 0x53, 0x5d, 0x9a, 0xfd, 0xd3, 0x79, 0x46, 0x50, 0xa7, - 0x36, 0x48, 0xef, 0x70, 0x70, 0x2e, 0xa1, 0x63, 0xe4, 0x0e, 0x1b, 0xdd, 0xf4, 0x1e, 0x0b, 0x61, - 0xf5, 0x16, 0xf3, 0x69, 0x88, 0xcd, 0x4c, 0x00, 0xad, 0x0f, 0x37, 0xf7, 0xba, 0xe1, 0x26, 0x9f, - 0x05, 0xd3, 0xdd, 0xbd, 0x6e, 0xb8, 0xcb, 0xa9, 0xee, 0x5e, 0x77, 0xcb, 0x54, 0xbf, 0xad, 0x80, - 0xe5, 0x62, 0x14, 0x7c, 0x93, 0x1f, 0x83, 0xa3, 0x69, 0x9b, 0xe4, 0x07, 0xf4, 0xbe, 0x72, 0xd5, - 0x30, 0xb9, 0x2b, 0xf5, 0x7a, 0x10, 0xa4, 0x49, 0x21, 0x43, 0xb8, 0x8d, 0xbd, 0x6e, 0x47, 0xda, - 0xc6, 0x5e, 0xb7, 0xb3, 0x65, 0xaa, 0x3b, 0x41, 0x90, 0x2c, 0x6d, 0x28, 0x5f, 0x3e, 0xcf, 0xe2, - 0x2a, 0x07, 0xc9, 0xe2, 0xaa, 0x8f, 0x82, 0x45, 0xa6, 0xec, 0x6a, 0x84, 0x0b, 0x2d, 0xd9, 0x41, - 0x8f, 0x31, 0x82, 0x79, 0x88, 0x53, 0x3d, 0xca, 0x88, 0x56, 0xb0, 0x83, 0x34, 0xbc, 0x41, 0x5c, - 0x87, 0xd6, 0x06, 0x28, 0x63, 0xd6, 0x06, 0xec, 0x26, 0x0c, 0xf7, 0x96, 0xbd, 0xf9, 0x68, 0x33, - 0x5f, 0x44, 0xe2, 0xe9, 0x3f, 0x6e, 0x0b, 0xa4, 0xf4, 0x5f, 0xc4, 0x21, 0xa8, 0x8b, 0xa0, 0xaf, - 0x9e, 0xb0, 0xde, 0x7c, 0xb2, 0x30, 0x31, 0x1a, 0xb5, 0xde, 0xe7, 0xf3, 0x0d, 0x28, 0xaf, 0xc7, - 0x08, 0x2c, 0xb4, 0xfa, 0x5b, 0x3c, 0x32, 0x10, 0x9f, 0x61, 0xcd, 0x36, 0xc5, 0x95, 0x2f, 0x77, - 0x5f, 0x11, 0x2e, 0x95, 0x62, 0x5c, 0x1a, 0x73, 0xd3, 0x3b, 0xe0, 0x7c, 0xc1, 0x92, 0x0e, 0x6b, - 0xf7, 0x7f, 0xa4, 0x84, 0x26, 0x2e, 0x38, 0xd6, 0xe4, 0xa9, 0xee, 0x3a, 0xde, 0xe6, 0x86, 0x20, - 0xc1, 0x73, 0x00, 0x98, 0xd8, 0xd7, 0x23, 0x64, 0xa8, 0x98, 0xd8, 0xdf, 0xfc, 0x99, 0x51, 0xa2, - 0x1f, 0x9a, 0xcf, 0xbc, 0xe5, 0x1d, 0x16, 0x39, 0x1e, 0x84, 0x29, 0x86, 0x7b, 0x56, 0xd7, 0x33, - 0x7c, 0xc4, 0xa6, 0xb9, 0x43, 0x2b, 0xe0, 0x04, 0x19, 0x4e, 0x80, 0x0a, 0xcb, 0xe6, 0x04, 0x7a, - 0x39, 0x43, 0xbf, 0xb7, 0xcc, 0xf0, 0x10, 0x28, 0x49, 0x87, 0xc0, 0xbf, 0x94, 0xc0, 0xf1, 0x0c, - 0x94, 0xf0, 0x6d, 0x30, 0x45, 0xcb, 0xeb, 0xb8, 0x36, 0x2e, 0xa7, 0x5d, 0x4f, 0x28, 0x28, 0x1b, - 0x4c, 0x0e, 0x36, 0xee, 0x49, 0xd1, 0x61, 0xf0, 0x03, 0x30, 0xdb, 0x36, 0xec, 0x36, 0xea, 0xe9, - 0x0c, 0x0d, 0xf3, 0x22, 0x56, 0x32, 0xd1, 0x6c, 0x50, 0xe0, 0x38, 0xb2, 0x1a, 0xc3, 0x41, 0x21, - 0xe0, 0x87, 0x60, 0xae, 0xed, 0xf4, 0x5d, 0x5a, 0x73, 0xc3, 0x90, 0xb2, 0x2a, 0xa2, 0x97, 0xb3, - 0x91, 0x72, 0xf0, 0x38, 0xda, 0xba, 0xc0, 0xc3, 0x10, 0xdf, 0x07, 0xb3, 0x1e, 0xa2, 0x2e, 0x1d, - 0x43, 0x3b, 0x49, 0xd1, 0xbe, 0x94, 0x89, 0x56, 0xa3, 0xc0, 0x11, 0xaa, 0x69, 0x35, 0x86, 0x81, - 0xf6, 0xab, 0x76, 0x98, 0xa2, 0x4f, 0x65, 0x17, 0x17, 0x8b, 0x4d, 0x30, 0xcd, 0x4a, 0x18, 0xb9, - 0x54, 0xac, 0x66, 0x49, 0x45, 0x16, 0x22, 0x3e, 0x5c, 0x7d, 0x3f, 0x34, 0x46, 0xcd, 0xc7, 0x86, - 0x7b, 0x7f, 0x70, 0x40, 0xc1, 0xf8, 0x2f, 0x05, 0x1c, 0x49, 0x20, 0x83, 0x37, 0xa5, 0xe5, 0xb2, - 0xb0, 0x7b, 0x96, 0x85, 0xa6, 0x03, 0xf8, 0x60, 0xb1, 0x48, 0xb8, 0x0d, 0xea, 0xb2, 0x44, 0x60, - 0x2e, 0x12, 0x97, 0xf2, 0xb1, 0x30, 0xb9, 0x10, 0xb8, 0x66, 0x25, 0x79, 0xc0, 0xf0, 0x11, 0xcd, - 0xe5, 0x4b, 0x02, 0x81, 0xb9, 0x44, 0x5c, 0x2e, 0xc0, 0xc9, 0x07, 0x09, 0xac, 0x73, 0x11, 0x71, - 0xc0, 0x6a, 0x8b, 0xc5, 0xd9, 0x53, 0xc8, 0xc9, 0x19, 0xb7, 0x16, 0x63, 0xdc, 0xc5, 0x3c, 0xc6, - 0x45, 0x51, 0x08, 0x96, 0xdd, 0x0d, 0x13, 0xd4, 0xc9, 0xf3, 0x8c, 0xb8, 0x5f, 0xa8, 0xed, 0xd8, - 0xa6, 0xe1, 0x0d, 0x9b, 0xdb, 0xb9, 0x8e, 0xdc, 0xe3, 0x30, 0x67, 0x5c, 0x8c, 0x27, 0xf0, 0x14, - 0xa2, 0xf7, 0xcd, 0x7d, 0x1d, 0xb5, 0x7c, 0xa8, 0xba, 0x15, 0x5a, 0xc0, 0xd4, 0x89, 0xa3, 0x87, - 0x54, 0x6e, 0x10, 0xdc, 0x03, 0x97, 0x46, 0x42, 0x75, 0x98, 0xcb, 0xbf, 0x17, 0x3a, 0x0b, 0x4d, - 0xf7, 0xce, 0x13, 0xeb, 0x80, 0x1a, 0xf3, 0x23, 0x05, 0x2c, 0xc4, 0x71, 0xc1, 0xcd, 0xa8, 0x0d, - 0x7d, 0xa5, 0x40, 0x5f, 0x98, 0x89, 0xd9, 0xf6, 0x9c, 0x3d, 0xcb, 0x44, 0x1e, 0xc1, 0x23, 0x8c, - 0xe9, 0x37, 0x12, 0x96, 0x8f, 0xe9, 0xce, 0xf5, 0x11, 0xe5, 0x3c, 0x05, 0x73, 0xd4, 0x04, 0xaa, - 0xdf, 0x90, 0x2c, 0x48, 0x84, 0x1c, 0x9c, 0xe6, 0xb7, 0x62, 0xba, 0xbf, 0x9c, 0x2b, 0xf1, 0x32, - 0x06, 0x21, 0xf0, 0x6b, 0xe0, 0x28, 0xf7, 0x00, 0x9b, 0xdb, 0x34, 0xa4, 0xc5, 0x29, 0x7d, 0x11, - 0x2c, 0x88, 0xfb, 0x9d, 0x1e, 0x2d, 0x05, 0x9c, 0x17, 0xed, 0xfc, 0x3a, 0xa8, 0xb6, 0xc0, 0xb3, - 0x31, 0x14, 0x7c, 0x75, 0x5b, 0x60, 0x41, 0xd4, 0x1e, 0xba, 0x7c, 0x93, 0xa9, 0x99, 0x08, 0x77, - 0x25, 0x46, 0x0a, 0x6d, 0x1e, 0x47, 0x1b, 0xd4, 0x6b, 0xcc, 0x51, 0xdd, 0x0e, 0xb2, 0xfe, 0x76, - 0xdb, 0xe9, 0x23, 0x71, 0x20, 0xe7, 0x69, 0xe2, 0xdf, 0x28, 0xec, 0x90, 0xce, 0x1a, 0xca, 0xd7, - 0x7a, 0x09, 0x1c, 0x69, 0x0f, 0x3c, 0x0f, 0xd9, 0x52, 0x48, 0x5c, 0x54, 0x99, 0xf0, 0x8e, 0x20, - 0x1a, 0x0e, 0x77, 0xc0, 0x09, 0xb9, 0x28, 0x81, 0x22, 0xd4, 0x4d, 0x86, 0x91, 0x07, 0xe7, 0x2f, - 0x67, 0xd6, 0x20, 0xa6, 0xad, 0x43, 0x3b, 0xe6, 0xa6, 0x2e, 0x4f, 0xfd, 0x27, 0x05, 0x3c, 0x9b, - 0x3a, 0x22, 0xe3, 0x4e, 0x72, 0x48, 0x59, 0x54, 0xf8, 0x00, 0x4c, 0xb3, 0x6d, 0x51, 0xd3, 0x3d, - 0xbb, 0x7e, 0xe3, 0xd3, 0xcf, 0x4f, 0x4f, 0xfc, 0xe4, 0xf3, 0xd3, 0x2f, 0x74, 0x2d, 0x7f, 0x67, - 0xd0, 0x5a, 0x69, 0x3b, 0x7d, 0xfe, 0x18, 0x82, 0xff, 0x77, 0x19, 0x9b, 0xbb, 0xbc, 0xa6, 0x7f, - 0xcb, 0xf6, 0x7f, 0xfc, 0xc3, 0xcb, 0x80, 0x07, 0x0d, 0xb6, 0x6c, 0x5f, 0xe3, 0xb8, 0xd4, 0x37, - 0xd9, 0x01, 0x1c, 0x1a, 0xbf, 0x7d, 0xf0, 0xf1, 0x1f, 0xb9, 0xe3, 0x9d, 0x3d, 0x78, 0x1c, 0x4e, - 0xda, 0xe0, 0x24, 0x16, 0x08, 0x33, 0x79, 0x99, 0xe9, 0x00, 0x64, 0xac, 0x45, 0x5b, 0xc4, 0x19, - 0x8b, 0x54, 0xff, 0x59, 0x01, 0xc7, 0x33, 0x46, 0x65, 0xdd, 0x18, 0xfe, 0x57, 0x73, 0xf4, 0x5b, - 0x25, 0x30, 0xdd, 0xf4, 0x0d, 0x7f, 0x80, 0xa1, 0x0e, 0x9e, 0x8d, 0x6b, 0xbb, 0x9c, 0x7c, 0xbc, - 0x94, 0x49, 0xc4, 0xa8, 0xaa, 0x53, 0x0b, 0xf2, 0x0c, 0x4e, 0x36, 0xc2, 0x26, 0x38, 0xc2, 0x8c, - 0x3f, 0x1e, 0xda, 0x6d, 0x81, 0x9c, 0x11, 0xe3, 0x42, 0x66, 0x1c, 0x91, 0x0c, 0x68, 0x52, 0x78, - 0x8a, 0x78, 0xbe, 0x15, 0x6d, 0x80, 0xb7, 0x00, 0x68, 0xef, 0x18, 0x96, 0xcd, 0xb0, 0x31, 0x3f, - 0xe5, 0x6c, 0x16, 0xb6, 0x0d, 0x02, 0x49, 0xf1, 0x54, 0xdb, 0xe2, 0xa7, 0xfa, 0x3b, 0x65, 0x30, - 0x1f, 0x9b, 0x06, 0xbe, 0x00, 0xe6, 0x5b, 0x98, 0xd7, 0x70, 0xed, 0x20, 0xab, 0xbb, 0x23, 0x0a, - 0x9b, 0xea, 0x2d, 0x4c, 0x61, 0xdf, 0xa5, 0x8d, 0x50, 0x05, 0xf5, 0x10, 0xce, 0xc0, 0x22, 0xb7, - 0x5f, 0x13, 0x50, 0xbc, 0xd4, 0xbc, 0x85, 0x75, 0x39, 0x92, 0xcf, 0x12, 0x2d, 0xb3, 0x2d, 0xfc, - 0x30, 0x8c, 0xe5, 0x2f, 0x83, 0x85, 0x16, 0xd6, 0xfb, 0x43, 0xfc, 0x49, 0x4f, 0xdf, 0x43, 0x1e, - 0xb6, 0x82, 0xd2, 0xf7, 0xb9, 0x16, 0xbe, 0x47, 0x9a, 0x1f, 0xb1, 0x56, 0x78, 0x0b, 0x9c, 0x6a, - 0x61, 0xdd, 0x44, 0x1d, 0x63, 0xd0, 0xf3, 0xf5, 0xf6, 0x8e, 0xe1, 0x19, 0x6d, 0x1f, 0x79, 0x3a, - 0x16, 0x05, 0x22, 0xac, 0xe4, 0xf3, 0x44, 0x0b, 0xdf, 0x66, 0x30, 0x1b, 0x02, 0xa4, 0xc9, 0xeb, - 0x45, 0xae, 0x83, 0x13, 0x32, 0x06, 0xa7, 0xd7, 0x63, 0x79, 0x02, 0xa9, 0x16, 0xf4, 0x58, 0x38, - 0x5a, 0x74, 0x8b, 0x7a, 0x60, 0xb2, 0x4c, 0x42, 0x5e, 0x84, 0x17, 0x67, 0x68, 0x89, 0x67, 0xb5, - 0x85, 0xef, 0xb1, 0x06, 0xde, 0xfd, 0xd8, 0xf1, 0x76, 0x91, 0x87, 0x69, 0x52, 0xa2, 0x4e, 0xba, - 0x3f, 0x64, 0x0d, 0xf0, 0x22, 0x38, 0xd2, 0xc2, 0x3a, 0xb2, 0x8d, 0x56, 0x0f, 0xe9, 0xe6, 0xc0, - 0xe8, 0xe9, 0x66, 0x8b, 0x26, 0x26, 0x2a, 0x64, 0x97, 0x77, 0x68, 0xfb, 0xed, 0x81, 0xd1, 0xbb, - 0xdd, 0x52, 0xdf, 0x03, 0xd5, 0x80, 0x5b, 0xc4, 0x6d, 0xe0, 0x4c, 0x16, 0x55, 0x70, 0x33, 0x8c, - 0x7f, 0x26, 0xad, 0x44, 0xa0, 0x5d, 0xe2, 0x90, 0x2b, 0xd1, 0x35, 0xcd, 0xd2, 0x46, 0x71, 0xc2, - 0xfd, 0x55, 0x09, 0x3c, 0x93, 0x22, 0xa6, 0x84, 0xcd, 0xd8, 0xd5, 0xdb, 0x8e, 0x89, 0x02, 0x9a, - 0x33, 0xf4, 0x75, 0xec, 0x6e, 0x38, 0x26, 0x12, 0x24, 0x7f, 0x1e, 0xcc, 0x09, 0xb8, 0xb6, 0xd3, - 0x27, 0xb7, 0x56, 0xc6, 0xe7, 0x59, 0x06, 0xb6, 0x41, 0xdb, 0xe0, 0x05, 0x8a, 0xcd, 0xf0, 0xda, - 0x3b, 0x96, 0x8f, 0xda, 0xfe, 0xc0, 0x13, 0x79, 0x90, 0x39, 0xec, 0xae, 0x49, 0xad, 0x44, 0x6a, - 0xb0, 0xab, 0x77, 0x9d, 0x18, 0xa3, 0x6b, 0xd8, 0xdd, 0x74, 0xc4, 0x94, 0x2b, 0xe0, 0x19, 0xec, - 0xea, 0xec, 0xa8, 0xb6, 0xec, 0xae, 0x8e, 0x87, 0xd8, 0x47, 0x7d, 0x51, 0x1e, 0x8d, 0xdd, 0xfb, - 0xa2, 0xa7, 0x49, 0x3b, 0x22, 0xf0, 0xd2, 0x91, 0x3f, 0x1d, 0x85, 0x0f, 0x0e, 0x7d, 0xbe, 0x25, - 0xd3, 0xe9, 0x13, 0xda, 0x51, 0xc6, 0xcf, 0x88, 0x2d, 0xdd, 0xa6, 0x8d, 0x84, 0xdd, 0xea, 0xb1, - 0xd0, 0xbb, 0xa0, 0x46, 0x82, 0x5b, 0x78, 0xf5, 0x7e, 0xe8, 0x32, 0xf0, 0xf6, 0xb0, 0x5e, 0x0d, - 0xd3, 0x96, 0xa2, 0x7a, 0x35, 0x3e, 0x8e, 0x43, 0xab, 0x6e, 0x90, 0xc7, 0x79, 0x88, 0x91, 0xc7, - 0x3c, 0xd4, 0x11, 0xab, 0x20, 0x83, 0x48, 0x42, 0x49, 0x8a, 0x24, 0x14, 0x06, 0x20, 0xd4, 0xaf, - 0x46, 0xaa, 0xfc, 0xc5, 0x8c, 0x7c, 0x1b, 0x6f, 0xc5, 0x7c, 0xe1, 0x73, 0xb9, 0xa9, 0x23, 0x96, - 0x7a, 0x0c, 0x7c, 0x60, 0x3b, 0x28, 0xed, 0x97, 0x7a, 0x65, 0x17, 0x98, 0x05, 0x79, 0x43, 0x17, - 0x98, 0x7e, 0xef, 0x67, 0x27, 0x91, 0x42, 0x7a, 0xf5, 0x23, 0xe6, 0x73, 0x27, 0xe6, 0x3b, 0x8c, - 0xbd, 0x0c, 0x82, 0xda, 0x28, 0x42, 0xa5, 0xfb, 0x8f, 0x6d, 0x64, 0xfe, 0x4f, 0x30, 0xe7, 0xe3, - 0x48, 0x69, 0x6c, 0x64, 0xda, 0xc3, 0xd8, 0xd5, 0x3f, 0x94, 0xc0, 0xf4, 0xb6, 0xd3, 0xb3, 0xda, - 0x43, 0x78, 0x1e, 0xcc, 0xb9, 0x9e, 0x65, 0xb7, 0x2d, 0xd7, 0xe8, 0xb1, 0xac, 0x04, 0xd9, 0xc3, - 0x94, 0x56, 0x0f, 0x5a, 0x69, 0x6a, 0xe3, 0x02, 0x98, 0x0f, 0xc1, 0xc2, 0x04, 0x4e, 0x55, 0x0b, - 0x47, 0x3f, 0x22, 0xad, 0xc9, 0x5c, 0x4a, 0xf9, 0x50, 0x72, 0x29, 0xfc, 0xf9, 0x84, 0x94, 0x4b, - 0xb9, 0x08, 0x16, 0xa4, 0xdc, 0x32, 0xf3, 0x92, 0x58, 0x12, 0x75, 0x3e, 0x4c, 0x30, 0x33, 0x27, - 0xe9, 0x22, 0x58, 0x90, 0x8e, 0x1f, 0x06, 0xca, 0x92, 0xcd, 0xf3, 0x61, 0x36, 0x99, 0x81, 0xa6, - 0x24, 0x8e, 0x67, 0x52, 0x13, 0xc7, 0xff, 0xae, 0x84, 0xb7, 0x79, 0x16, 0x5d, 0xa3, 0x04, 0xb5, - 0x10, 0x3e, 0xbc, 0x12, 0xda, 0x58, 0xba, 0xa8, 0x3c, 0x46, 0xba, 0x28, 0x3d, 0xce, 0x18, 0x17, - 0xc0, 0xa9, 0x84, 0x00, 0xfe, 0x3f, 0x26, 0x80, 0x69, 0xbb, 0xe3, 0x02, 0xf8, 0x26, 0xa8, 0xb8, - 0xbc, 0xad, 0xa8, 0xf2, 0x98, 0x89, 0x9a, 0x16, 0xc0, 0xab, 0xf7, 0xc3, 0x18, 0x74, 0xf4, 0x49, - 0x13, 0xf3, 0xff, 0x02, 0x12, 0x5e, 0x48, 0x7f, 0x21, 0x55, 0x8d, 0xbf, 0x7c, 0x52, 0x8d, 0x30, - 0x82, 0x9c, 0x81, 0xf0, 0xc0, 0xe5, 0xd2, 0x1b, 0x61, 0xac, 0x94, 0xe8, 0x64, 0x74, 0x9a, 0x11, - 0xcd, 0x81, 0xfa, 0xf3, 0x61, 0x04, 0x2f, 0x15, 0x09, 0x5f, 0xe5, 0x43, 0xb0, 0x10, 0xdb, 0xb7, - 0x70, 0xe5, 0x5f, 0x1c, 0xed, 0x69, 0x18, 0xad, 0x6b, 0x9d, 0x8f, 0x12, 0x09, 0xab, 0xd7, 0x99, - 0x61, 0xa6, 0x01, 0x11, 0x1e, 0x03, 0x91, 0x32, 0xd0, 0x27, 0x41, 0x55, 0x18, 0x66, 0x91, 0x80, - 0xae, 0x70, 0xcb, 0x8c, 0xd5, 0xcf, 0x94, 0x30, 0xb0, 0x11, 0x19, 0xcb, 0x57, 0xfc, 0x61, 0xcc, - 0x1c, 0xbd, 0x53, 0x94, 0x54, 0x4e, 0x41, 0xc2, 0x4c, 0x15, 0x4f, 0x29, 0x73, 0x74, 0x8d, 0xaf, - 0xf2, 0xf2, 0x96, 0xcc, 0x84, 0xf2, 0xd5, 0x68, 0x42, 0xb9, 0xa0, 0xc8, 0x41, 0xca, 0x27, 0xdf, - 0x60, 0x32, 0x43, 0xaf, 0xfd, 0x3c, 0x92, 0x6b, 0x77, 0x79, 0xd5, 0x36, 0x7b, 0x11, 0x91, 0x77, - 0x9d, 0x7b, 0x9b, 0x15, 0x58, 0xe5, 0x8d, 0x4e, 0x7b, 0x59, 0x30, 0x29, 0xea, 0x29, 0x1e, 0xb3, - 0xd9, 0x59, 0x1a, 0x97, 0x07, 0x61, 0x37, 0x1f, 0x6d, 0x86, 0x09, 0xdd, 0x51, 0xd3, 0x62, 0xdd, - 0x48, 0x5a, 0x8c, 0x5d, 0xb9, 0x1a, 0xa0, 0x6a, 0x62, 0x9f, 0x3f, 0x38, 0x28, 0xd3, 0x9e, 0x19, - 0x13, 0xfb, 0x4d, 0xb2, 0x70, 0x9d, 0x2d, 0x3c, 0x6f, 0xe2, 0x83, 0x65, 0x91, 0xdf, 0x88, 0x95, - 0x72, 0x37, 0xad, 0xa7, 0x68, 0xa4, 0x78, 0xdd, 0x8d, 0x58, 0x71, 0x36, 0x1b, 0xc8, 0x17, 0x13, - 0x1a, 0x4b, 0x5a, 0xba, 0x18, 0x29, 0x02, 0xa7, 0xc5, 0x8b, 0x4b, 0x41, 0xdd, 0x34, 0xab, 0x78, - 0xe5, 0x8f, 0xba, 0x45, 0x2a, 0x57, 0xbd, 0x11, 0x9c, 0xe4, 0xf1, 0x7e, 0x3e, 0x43, 0x5e, 0x21, - 0xdc, 0x95, 0xef, 0x5f, 0x03, 0xcf, 0x90, 0xe1, 0xf7, 0xb8, 0x50, 0x35, 0x91, 0xb7, 0x67, 0xb5, - 0x11, 0xfc, 0x26, 0x80, 0xc9, 0x97, 0x25, 0xf0, 0x95, 0x3c, 0xe9, 0x4f, 0x7d, 0x57, 0xd9, 0xb8, - 0xb2, 0x9f, 0x21, 0x6c, 0xc5, 0xea, 0x04, 0xfc, 0x03, 0x25, 0xa5, 0xaa, 0x24, 0x7c, 0x79, 0x00, - 0xdf, 0x1c, 0xb9, 0xb6, 0x23, 0xf1, 0x3a, 0xa2, 0xf1, 0xd6, 0x58, 0x63, 0x83, 0xa5, 0xfd, 0x76, - 0xbc, 0xd6, 0x3e, 0xb2, 0xb0, 0x6b, 0x05, 0xdb, 0xcd, 0x7c, 0xed, 0xd6, 0xb8, 0x3e, 0xc6, 0xc8, - 0x60, 0x51, 0xbf, 0x1e, 0x96, 0x7b, 0xc5, 0x1f, 0x87, 0xc1, 0xd7, 0xf7, 0x85, 0x38, 0x10, 0xac, - 0xc6, 0x1b, 0xfb, 0x1e, 0x17, 0x2c, 0xe7, 0xef, 0x79, 0x1d, 0xc1, 0x28, 0x4f, 0xb3, 0xe0, 0x66, - 0x11, 0x3f, 0x46, 0x7c, 0x91, 0xd6, 0x78, 0xf7, 0xe0, 0x88, 0xd2, 0x08, 0x1a, 0x7f, 0x5a, 0x55, - 0x48, 0xd0, 0x8c, 0x57, 0x5f, 0x85, 0x04, 0xcd, 0x7a, 0xc3, 0xa5, 0x4e, 0xc0, 0xdf, 0x53, 0xc2, - 0x23, 0x2e, 0xf9, 0x68, 0x0a, 0x5e, 0x2f, 0xda, 0x79, 0xe6, 0x23, 0xaf, 0xc6, 0x9b, 0xe3, 0x0c, - 0x0d, 0xd6, 0xf5, 0x14, 0x1c, 0x49, 0xbc, 0x71, 0x82, 0x2f, 0x17, 0xec, 0x33, 0xf1, 0x2a, 0xab, - 0xf1, 0xca, 0x3e, 0x46, 0x04, 0x73, 0xff, 0xaa, 0x12, 0x5c, 0x56, 0xa3, 0x96, 0x0f, 0xbe, 0x5a, - 0x80, 0x2e, 0xd5, 0x90, 0x36, 0x5e, 0xdb, 0xe7, 0xa8, 0x04, 0x73, 0xd2, 0x5f, 0x49, 0xc1, 0x22, - 0xc5, 0xce, 0x7e, 0xc8, 0x95, 0xcf, 0x9c, 0xfc, 0x47, 0x59, 0xea, 0x04, 0xfc, 0x8d, 0xf0, 0x21, - 0x5c, 0xe2, 0x9d, 0x13, 0x7c, 0x63, 0x7f, 0xa8, 0x43, 0x32, 0x5d, 0xdb, 0xff, 0xc0, 0x60, 0x45, - 0xdf, 0x64, 0x61, 0x87, 0x78, 0x8d, 0x17, 0x4c, 0x4d, 0x49, 0xd3, 0xda, 0xec, 0x38, 0x68, 0x28, - 0x31, 0xa3, 0x8f, 0x48, 0x91, 0xd6, 0xf0, 0x95, 0x54, 0xa1, 0xb4, 0x26, 0xde, 0x6d, 0x15, 0x4a, - 0x6b, 0xf2, 0x09, 0x56, 0x54, 0x5a, 0xa3, 0x4f, 0x99, 0x0a, 0xa5, 0x35, 0xf5, 0xb9, 0x54, 0xa1, - 0xb4, 0xa6, 0xbf, 0x97, 0x52, 0x27, 0xe0, 0xb7, 0x15, 0x70, 0x2c, 0xfd, 0x51, 0x12, 0x7c, 0x6d, - 0xa4, 0x8d, 0xc5, 0x5f, 0xec, 0x34, 0x5e, 0xdf, 0xef, 0xb0, 0x60, 0x2d, 0x7f, 0xa8, 0xc4, 0x9c, - 0x9b, 0xf8, 0x8a, 0xde, 0x1a, 0x49, 0x27, 0x33, 0xd6, 0x75, 0x63, 0xbc, 0xc1, 0x09, 0xfd, 0x49, - 0x7b, 0x36, 0x92, 0xaf, 0x3f, 0x39, 0x2f, 0x80, 0xf2, 0xf5, 0x27, 0xef, 0x85, 0x8a, 0x74, 0x2a, - 0xa5, 0x3c, 0xd6, 0xc8, 0x3f, 0x95, 0xb2, 0x5f, 0x87, 0xe4, 0x9f, 0x4a, 0x39, 0xaf, 0x42, 0xd4, - 0x09, 0xf8, 0xc7, 0xf2, 0xdb, 0x91, 0xf4, 0x57, 0x14, 0xf0, 0xed, 0x42, 0xf4, 0xb9, 0xcf, 0x38, - 0x1a, 0xef, 0x8c, 0x3d, 0x3e, 0x58, 0xe6, 0x63, 0xb0, 0x10, 0xaf, 0x25, 0x87, 0xab, 0x05, 0xb2, - 0x11, 0x2f, 0x9a, 0x6f, 0xbc, 0x3c, 0xfa, 0x80, 0x60, 0xe2, 0x5f, 0x52, 0x98, 0xbd, 0x8b, 0x57, - 0x6b, 0xc3, 0xab, 0xfb, 0xab, 0xed, 0x66, 0x2b, 0x78, 0x75, 0x9c, 0x82, 0xf0, 0xd8, 0x2a, 0xe4, - 0x92, 0xe7, 0xe2, 0x55, 0xa4, 0xd4, 0x73, 0x17, 0xaf, 0x22, 0xad, 0xaa, 0x5a, 0x52, 0xa6, 0xb4, - 0xfa, 0xde, 0x7c, 0x65, 0xca, 0xa9, 0x8b, 0xce, 0x57, 0xa6, 0xbc, 0x52, 0x62, 0x75, 0x02, 0xfe, - 0xa9, 0x12, 0x46, 0x3e, 0xb2, 0x6b, 0x7a, 0x61, 0x61, 0x19, 0x79, 0x61, 0x49, 0x71, 0x63, 0xfd, - 0x20, 0x28, 0x82, 0xf5, 0xfe, 0x89, 0x92, 0x53, 0x6c, 0xca, 0x8b, 0x73, 0xe1, 0x3b, 0x45, 0x62, - 0x5a, 0x50, 0x19, 0xdc, 0xb8, 0x35, 0x3e, 0x82, 0xb4, 0x2b, 0x52, 0xb2, 0x70, 0xb6, 0xf0, 0x8a, - 0x94, 0x59, 0xee, 0x5b, 0x78, 0x45, 0xca, 0xae, 0xf6, 0x8d, 0x2e, 0x2a, 0xb9, 0x87, 0xc2, 0x45, - 0x65, 0x96, 0xf7, 0x16, 0x2e, 0x2a, 0xbb, 0x80, 0x37, 0x5d, 0x37, 0x69, 0x89, 0xe8, 0xc8, 0xba, - 0x29, 0x97, 0xec, 0x8e, 0xac, 0x9b, 0x91, 0xd2, 0x5b, 0x75, 0x02, 0x7e, 0x37, 0x11, 0xf3, 0x8d, - 0x15, 0xaa, 0xc2, 0x1b, 0xfb, 0xc1, 0x1c, 0x2f, 0xb9, 0x6d, 0xdc, 0x1c, 0x73, 0x74, 0xaa, 0xaa, - 0x66, 0xd7, 0x8f, 0xc2, 0xd1, 0x5f, 0x7c, 0x64, 0x95, 0xc6, 0x16, 0xab, 0x6a, 0x71, 0xf9, 0x6a, - 0xec, 0xfe, 0x5b, 0x54, 0x66, 0x56, 0x7c, 0xff, 0x1d, 0xb1, 0xe0, 0xad, 0xf8, 0xfe, 0x3b, 0x6a, - 0xc5, 0x9b, 0x3a, 0x01, 0xff, 0x5c, 0x09, 0x23, 0xba, 0x39, 0x45, 0x66, 0x70, 0x7d, 0xac, 0x39, - 0xa3, 0xe2, 0xb1, 0x71, 0x20, 0x1c, 0xa9, 0x31, 0xa3, 0xb4, 0x12, 0xdd, 0xc2, 0x9b, 0x6e, 0x76, - 0xa9, 0x70, 0x71, 0xcc, 0x28, 0xa7, 0x6e, 0x55, 0x72, 0xfe, 0x93, 0x45, 0xa2, 0x85, 0x2a, 0x9b, - 0x56, 0xa0, 0x9a, 0xef, 0xfc, 0x67, 0xd6, 0x61, 0xc6, 0xec, 0x4d, 0xa4, 0xf6, 0xae, 0xd0, 0xde, - 0xa4, 0x54, 0xfd, 0x15, 0xdb, 0x9b, 0xb4, 0xda, 0x38, 0x75, 0x02, 0xda, 0xa0, 0x1e, 0x29, 0x4c, - 0x83, 0x2f, 0x15, 0xd8, 0xd0, 0x48, 0x09, 0x5c, 0xe3, 0xf2, 0x88, 0xd0, 0x69, 0xf3, 0xb1, 0x92, - 0x98, 0xc2, 0xf9, 0xe4, 0xa4, 0x78, 0xf1, 0x7c, 0x91, 0x54, 0x79, 0xe4, 0x9e, 0x19, 0xa6, 0xa0, - 0x0b, 0xef, 0x99, 0x89, 0xfc, 0x78, 0xe3, 0x95, 0x7d, 0x8c, 0x08, 0xe6, 0xfe, 0x96, 0xc2, 0x02, - 0xba, 0xb1, 0xac, 0x31, 0xbc, 0x32, 0x8a, 0xff, 0x1a, 0x4d, 0x69, 0x37, 0xae, 0xee, 0x6b, 0x4c, - 0xda, 0x0d, 0x33, 0x96, 0xe5, 0x2d, 0xbc, 0x61, 0xa6, 0x27, 0xa3, 0x1b, 0xaf, 0xef, 0x77, 0x58, - 0x62, 0x2d, 0xc9, 0x84, 0x1f, 0x7c, 0x6d, 0x34, 0x53, 0x1f, 0x4b, 0x7f, 0xe6, 0xaf, 0x25, 0x3b, - 0xaf, 0x18, 0x3b, 0x66, 0x53, 0xb3, 0x79, 0xc5, 0xc7, 0x6c, 0x5e, 0x56, 0xb1, 0xf8, 0x98, 0xcd, - 0x4d, 0x21, 0xc6, 0x2c, 0x68, 0x4a, 0x1a, 0xaf, 0xd8, 0x82, 0x66, 0x27, 0x10, 0x8b, 0x2d, 0x68, - 0x4e, 0xde, 0x50, 0x12, 0xeb, 0x58, 0x8a, 0x2d, 0x5f, 0xac, 0xd3, 0x13, 0x82, 0x8d, 0xab, 0x63, - 0xe4, 0xf0, 0xd4, 0x09, 0xf8, 0x3d, 0x25, 0x28, 0x5e, 0xc8, 0x48, 0x8d, 0xc1, 0x9b, 0x85, 0x96, - 0x29, 0x2f, 0x21, 0xd7, 0x78, 0x7b, 0xdc, 0xe1, 0x89, 0x35, 0x66, 0x67, 0xc1, 0xf2, 0xd7, 0x58, - 0x98, 0xb6, 0xcb, 0x5f, 0x63, 0x71, 0xf2, 0x2d, 0x25, 0x0a, 0x47, 0xff, 0xa6, 0xcc, 0x68, 0x51, - 0x38, 0x29, 0xe5, 0x36, 0x62, 0x14, 0x4e, 0xce, 0xb5, 0x49, 0xa1, 0xda, 0xf4, 0xa2, 0xe3, 0xfc, - 0x50, 0x6d, 0x6e, 0x8d, 0x73, 0x7e, 0xa8, 0x36, 0xbf, 0xc6, 0x59, 0x0a, 0x84, 0x65, 0x15, 0xd1, - 0xe6, 0x07, 0xc2, 0x0a, 0xea, 0x76, 0xf3, 0x03, 0x61, 0x45, 0x75, 0xbb, 0xea, 0xc4, 0xba, 0xf1, - 0xe9, 0x17, 0x4b, 0xca, 0x67, 0x5f, 0x2c, 0x29, 0x3f, 0xfd, 0x62, 0x49, 0xf9, 0xcd, 0x2f, 0x97, - 0x26, 0x3e, 0xfb, 0x72, 0x69, 0xe2, 0xdf, 0xbe, 0x5c, 0x9a, 0xf8, 0x68, 0x53, 0x2a, 0x52, 0x6d, - 0xd9, 0xad, 0xcb, 0xb4, 0x3a, 0x6f, 0x35, 0x0c, 0xcd, 0x5e, 0xe6, 0xa1, 0xd9, 0xcb, 0xa2, 0xf2, - 0x74, 0x35, 0xfd, 0x0f, 0xc7, 0xb7, 0xa6, 0xe9, 0xdf, 0x15, 0xbf, 0xfa, 0xdf, 0x01, 0x00, 0x00, - 0xff, 0xff, 0x2e, 0x6b, 0xc5, 0x80, 0x59, 0x5e, 0x00, 0x00, + 0x7a, 0x30, 0x7b, 0x86, 0xaf, 0x29, 0x3e, 0x55, 0x96, 0x25, 0x6a, 0x64, 0x51, 0x52, 0xcb, 0xb2, + 0x28, 0xcb, 0x24, 0x6d, 0xc9, 0x2f, 0xd9, 0x92, 0x2d, 0x92, 0xa2, 0x68, 0xc2, 0x2b, 0x8b, 0xee, + 0x91, 0xe4, 0xb5, 0xf7, 0xf7, 0xdf, 0xdb, 0xd3, 0x5d, 0x33, 0xec, 0x70, 0xa6, 0xbb, 0xdd, 0xd5, + 0x43, 0x69, 0x84, 0x2c, 0xb2, 0xc8, 0x0b, 0xd8, 0x24, 0x40, 0xde, 0x41, 0xb0, 0x41, 0x16, 0xd8, + 0x20, 0x40, 0x2e, 0x9b, 0x20, 0x48, 0x16, 0x7b, 0x48, 0xb2, 0x49, 0x80, 0x5c, 0x0c, 0x04, 0x01, + 0x8c, 0x3d, 0x24, 0xc1, 0x26, 0x30, 0x16, 0xf6, 0x3d, 0x97, 0x5c, 0x73, 0x08, 0xea, 0xd5, 0x5d, + 0xfd, 0x1e, 0x0e, 0xb9, 0x41, 0x0e, 0xb9, 0x48, 0xd3, 0x55, 0x5f, 0x7d, 0x55, 0xf5, 0xbd, 0xea, + 0xab, 0xef, 0xfb, 0x8a, 0xe0, 0x62, 0xd7, 0xb5, 0x7a, 0x1d, 0xc3, 0x5f, 0xed, 0xa2, 0xc0, 0xb0, + 0x8c, 0xc0, 0x58, 0x0d, 0xfa, 0x1e, 0xc2, 0xe1, 0xe7, 0x8a, 0xe7, 0xbb, 0x81, 0x0b, 0x4f, 0x70, + 0xb0, 0x95, 0xb0, 0x9d, 0x82, 0xd5, 0xcf, 0x37, 0x0d, 0x8c, 0xf8, 0x90, 0x76, 0x0b, 0x7b, 0xc8, + 0xf7, 0x5d, 0x1f, 0xaf, 0xd2, 0xff, 0xd8, 0xd0, 0xfa, 0x62, 0x02, 0x24, 0x30, 0xf0, 0xde, 0x2a, + 0xf9, 0x87, 0xf7, 0x9f, 0x32, 0x5d, 0xdc, 0x75, 0xb1, 0x4e, 0xbf, 0x56, 0xd9, 0x07, 0xef, 0x3a, + 0xde, 0x76, 0xdb, 0x2e, 0x6b, 0x27, 0xbf, 0x78, 0xeb, 0x73, 0x6d, 0x1f, 0x21, 0xa7, 0x65, 0xa3, + 0x8e, 0xb5, 0xea, 0x19, 0xfd, 0x2e, 0x72, 0x82, 0x55, 0x1c, 0xf8, 0xc8, 0xe8, 0xea, 0x3e, 0x32, + 0x5d, 0xdf, 0xe2, 0x70, 0xaa, 0x0c, 0x87, 0xfc, 0xae, 0x8d, 0xb1, 0xed, 0x3a, 0xab, 0xa6, 0xdb, + 0xed, 0xba, 0x0e, 0x87, 0x39, 0x2b, 0xc1, 0xf8, 0x08, 0xbb, 0x3d, 0xdf, 0xe4, 0x6b, 0x15, 0xab, + 0x93, 0x00, 0xb0, 0x17, 0xeb, 0x92, 0xc7, 0xe2, 0xc0, 0xf5, 0x8d, 0x36, 0x5a, 0x45, 0xfb, 0xc8, + 0x09, 0x04, 0xc0, 0x62, 0x06, 0xc0, 0x27, 0x3d, 0xe4, 0xf7, 0x0b, 0xfa, 0xe5, 0x09, 0x9e, 0x95, + 0xfa, 0xf7, 0x6d, 0x3f, 0xe8, 0x19, 0x9d, 0xb6, 0xef, 0xf6, 0xbc, 0xf8, 0x2c, 0x17, 0xf2, 0xa0, + 0x64, 0x54, 0x27, 0x09, 0x7e, 0xc1, 0x05, 0xfa, 0x9b, 0x75, 0xa8, 0xff, 0x51, 0x01, 0xe3, 0xeb, + 0x3d, 0x73, 0x0f, 0x05, 0xf0, 0x6d, 0x30, 0xd5, 0xa4, 0xbf, 0x74, 0xdb, 0x69, 0xb9, 0x0b, 0xca, + 0x39, 0x65, 0x69, 0xea, 0xea, 0xe2, 0x4a, 0x84, 0x7e, 0x85, 0x2f, 0x72, 0x85, 0x0d, 0xd8, 0x76, + 0x5a, 0xae, 0x06, 0x9a, 0xe1, 0x6f, 0xb8, 0x00, 0x26, 0x7c, 0xd4, 0x75, 0xf7, 0x91, 0xb5, 0x50, + 0x39, 0xa7, 0x2c, 0x4d, 0x6a, 0xe2, 0x13, 0x9e, 0x06, 0x35, 0x0b, 0x75, 0x50, 0x80, 0x74, 0x23, + 0x58, 0xa8, 0x9e, 0x53, 0x96, 0xaa, 0xda, 0x24, 0x6b, 0x58, 0x0b, 0xe0, 0x05, 0x30, 0xc3, 0x3b, + 0x7d, 0x64, 0x60, 0xd7, 0x59, 0x18, 0x3d, 0xa7, 0x2c, 0xd5, 0xb4, 0x69, 0xd6, 0xa8, 0xd1, 0x36, + 0x58, 0x07, 0x93, 0xae, 0x87, 0x7c, 0x23, 0x70, 0xfd, 0x85, 0x31, 0xda, 0x1f, 0x7e, 0xc3, 0x67, + 0xc1, 0xac, 0xe9, 0x23, 0x23, 0x40, 0x7a, 0xf0, 0x58, 0xdf, 0x35, 0xf0, 0xee, 0xc2, 0x38, 0xc3, + 0xc0, 0x5a, 0xef, 0x3f, 0x7e, 0xc7, 0xc0, 0xbb, 0x04, 0xaa, 0xe7, 0x59, 0x32, 0xd4, 0x04, 0x83, + 0x62, 0xad, 0x1c, 0xea, 0x34, 0xa8, 0x71, 0x28, 0x23, 0x58, 0x98, 0x64, 0x2b, 0x65, 0x0d, 0x6b, + 0x01, 0x3c, 0x0b, 0xa6, 0x04, 0x0a, 0xbb, 0x8b, 0x16, 0x6a, 0xb4, 0x1b, 0xf0, 0xf1, 0x76, 0x17, + 0xc1, 0xf3, 0x60, 0x9a, 0xd3, 0x48, 0xc7, 0xf6, 0x13, 0xb4, 0x00, 0xe8, 0x0c, 0x53, 0xbc, 0xad, + 0x61, 0x3f, 0x41, 0xea, 0x7f, 0x56, 0xc0, 0xf8, 0xbd, 0xe6, 0xcf, 0x20, 0x93, 0x12, 0xdc, 0xa5, + 0xbf, 0x4a, 0x09, 0xce, 0x06, 0x30, 0x82, 0xbb, 0xe1, 0x6f, 0x78, 0x11, 0xcc, 0x76, 0x5c, 0x73, + 0x0f, 0x59, 0x7a, 0xd3, 0xe8, 0x18, 0x8e, 0x89, 0x28, 0xdd, 0x6b, 0xda, 0x0c, 0x6b, 0x5d, 0x67, + 0x8d, 0x32, 0x5f, 0xaa, 0x29, 0xbe, 0x44, 0xbb, 0x1d, 0x4d, 0xec, 0x36, 0xc6, 0xb4, 0xb1, 0x32, + 0xa6, 0x8d, 0x97, 0x30, 0x6d, 0xa2, 0x94, 0x69, 0x93, 0x03, 0x31, 0xad, 0x96, 0xc1, 0xb4, 0x73, + 0x60, 0x1a, 0x23, 0xa3, 0x13, 0xc2, 0x30, 0xb2, 0x03, 0xd2, 0xc6, 0x20, 0xd4, 0xbf, 0x55, 0xc0, + 0x0c, 0x23, 0xe2, 0x6d, 0x14, 0x18, 0x76, 0x07, 0xc3, 0x57, 0xc1, 0x38, 0xa3, 0x64, 0x48, 0xf7, + 0x6c, 0x13, 0xc7, 0x69, 0xaf, 0x71, 0x68, 0x32, 0x8e, 0x89, 0x3c, 0xa5, 0x75, 0xc1, 0x38, 0xa6, + 0x24, 0x1a, 0x87, 0x86, 0x37, 0x41, 0xb5, 0xbd, 0xdf, 0xa6, 0x0c, 0x98, 0xba, 0x7a, 0x45, 0x66, + 0xb2, 0xac, 0xb4, 0x2b, 0x5b, 0x1d, 0xb7, 0x69, 0x74, 0x1e, 0xb2, 0xa6, 0x2d, 0xd2, 0xa4, 0x91, + 0x71, 0xea, 0x5f, 0x55, 0xc1, 0xcc, 0xc3, 0xad, 0x3b, 0x84, 0xed, 0xff, 0xa7, 0xae, 0x47, 0xa5, + 0xae, 0x1b, 0xa0, 0xba, 0xdf, 0x6e, 0x51, 0x71, 0x99, 0xba, 0xfa, 0xd2, 0x01, 0x78, 0x72, 0xc7, + 0xe8, 0xda, 0x9d, 0xbe, 0x46, 0x46, 0xa7, 0x74, 0x7e, 0x2a, 0xad, 0xf3, 0xdf, 0x51, 0xc0, 0xec, + 0x0e, 0x3b, 0xa9, 0xd6, 0x4c, 0xd3, 0xed, 0x39, 0x01, 0x21, 0xbe, 0x61, 0x59, 0x3e, 0xc2, 0x98, + 0x72, 0xae, 0xa6, 0x89, 0x4f, 0x78, 0x1c, 0x8c, 0xb9, 0x8f, 0x1c, 0xe4, 0x73, 0x5d, 0x66, 0x1f, + 0x70, 0x11, 0x00, 0x1f, 0xb5, 0x7a, 0x8e, 0x65, 0x34, 0x3b, 0x88, 0xab, 0xb1, 0xd4, 0x52, 0xac, + 0xc9, 0x09, 0x42, 0x8c, 0x25, 0x09, 0xa1, 0x7e, 0x4f, 0x01, 0x30, 0xbe, 0xc0, 0xbb, 0x28, 0x30, + 0xe0, 0x3d, 0x30, 0xc7, 0x0f, 0x58, 0xdd, 0x60, 0xcd, 0x5c, 0xcc, 0x9e, 0xcb, 0x13, 0xfa, 0x38, + 0x12, 0x6d, 0xd6, 0x8b, 0xef, 0x7a, 0x13, 0xcc, 0xc4, 0x4e, 0x6a, 0xae, 0x43, 0xe7, 0x64, 0xd2, + 0xf3, 0x21, 0x2b, 0x0d, 0x0a, 0xa8, 0x51, 0x38, 0x6d, 0x1a, 0x4b, 0x5f, 0xaa, 0x09, 0x4e, 0x6d, + 0xb5, 0x1a, 0xde, 0x16, 0x0a, 0x1e, 0x60, 0xe4, 0x33, 0xf1, 0xc6, 0x1a, 0xfa, 0xa4, 0x87, 0x70, + 0x00, 0xcf, 0x00, 0xc0, 0x17, 0xab, 0xdb, 0x16, 0x27, 0x6e, 0x8d, 0xb7, 0x6c, 0x5b, 0xf0, 0x12, + 0x98, 0xb3, 0x1d, 0xb3, 0xd3, 0xb3, 0x88, 0xfc, 0xca, 0xd2, 0x3f, 0xcb, 0x9b, 0x35, 0xd6, 0xaa, + 0x7e, 0x0c, 0xea, 0x59, 0x93, 0x60, 0xcf, 0x75, 0x30, 0x82, 0x6f, 0x83, 0x09, 0xa6, 0x4a, 0x84, + 0x7f, 0xd5, 0xa5, 0xa9, 0xab, 0x17, 0xf3, 0x48, 0x12, 0xd3, 0x5a, 0x4d, 0x8c, 0x52, 0xff, 0xac, + 0x02, 0x54, 0x82, 0xff, 0x2b, 0x36, 0x0e, 0x98, 0x89, 0xc1, 0xeb, 0x7d, 0x06, 0xf4, 0x9e, 0xd1, + 0x45, 0x62, 0x37, 0x67, 0x43, 0x2d, 0x77, 0x8c, 0x2e, 0xe2, 0xdb, 0xe1, 0x5a, 0x4c, 0xe0, 0x12, + 0xdb, 0xad, 0x24, 0xb7, 0x7b, 0x0a, 0x4c, 0x76, 0x8d, 0xc7, 0xfa, 0x1e, 0xea, 0x63, 0x2a, 0x35, + 0xa3, 0xda, 0x44, 0xd7, 0x78, 0xfc, 0x2e, 0xea, 0x63, 0x82, 0x1a, 0x07, 0x86, 0x1f, 0xe8, 0x46, + 0x2b, 0x40, 0x3e, 0x57, 0x63, 0x40, 0x9b, 0xd6, 0x48, 0x0b, 0x5c, 0x06, 0xd0, 0x74, 0x9d, 0xc0, + 0x76, 0x7a, 0x46, 0x60, 0xbb, 0x8e, 0x1e, 0xb8, 0x7b, 0xc8, 0xe1, 0xea, 0x7c, 0x4c, 0xee, 0xb9, + 0x4f, 0x3a, 0xe0, 0x33, 0xd4, 0x6a, 0xd8, 0x5d, 0x9b, 0x60, 0x63, 0x2a, 0x1d, 0x35, 0xc0, 0x13, + 0x60, 0xdc, 0xf3, 0x51, 0xcb, 0x7e, 0xcc, 0xf5, 0x98, 0x7f, 0x65, 0xf1, 0x63, 0x32, 0x93, 0x1f, + 0xbf, 0x53, 0x05, 0x17, 0x0a, 0x09, 0xc6, 0x39, 0xf3, 0x3a, 0x98, 0x60, 0xa6, 0x5a, 0x70, 0xa6, + 0xcc, 0xb2, 0x0b, 0x70, 0xa2, 0x43, 0x7b, 0xa8, 0xaf, 0x33, 0x41, 0xaf, 0x50, 0x62, 0x4d, 0xee, + 0xa1, 0xfe, 0x06, 0x15, 0xdd, 0x02, 0x42, 0x9e, 0x07, 0xd3, 0x36, 0xd6, 0x03, 0xbf, 0xe7, 0x98, + 0x46, 0x80, 0x2c, 0x4a, 0xc9, 0x49, 0x6d, 0xca, 0xc6, 0xf7, 0x45, 0x13, 0x7c, 0x15, 0x9c, 0x74, + 0xd0, 0xe3, 0x40, 0xcf, 0xa5, 0xe7, 0xd3, 0xa4, 0x7b, 0x23, 0x45, 0x53, 0x08, 0x46, 0x29, 0xdf, + 0x19, 0x39, 0xe9, 0xef, 0x5c, 0x4a, 0xc6, 0xe8, 0x3f, 0x99, 0xa4, 0xff, 0x25, 0x30, 0xc7, 0x3c, + 0x5f, 0x9d, 0x81, 0x23, 0xbc, 0x50, 0x3b, 0x57, 0x5d, 0xaa, 0x69, 0xb3, 0xac, 0x79, 0x87, 0xb7, + 0xe6, 0x70, 0x1d, 0xe4, 0x70, 0x5d, 0xed, 0x80, 0x73, 0x5c, 0x4d, 0x18, 0x2f, 0x86, 0x12, 0x62, + 0x49, 0x08, 0x3c, 0xdf, 0xde, 0x37, 0x02, 0x94, 0x50, 0xca, 0x1d, 0xd6, 0xaa, 0x7e, 0x0d, 0x9c, + 0x2f, 0x98, 0x8d, 0x4b, 0x40, 0x74, 0x44, 0x2b, 0x07, 0x39, 0xa2, 0xd5, 0x16, 0x58, 0xcc, 0x44, + 0xbe, 0x7d, 0x5b, 0x6c, 0xe4, 0x34, 0xa8, 0x89, 0x33, 0x97, 0x99, 0x96, 0xaa, 0x36, 0xc9, 0x4f, + 0x54, 0x6b, 0xf0, 0x4d, 0x7c, 0x08, 0xce, 0xe6, 0xce, 0x73, 0xc8, 0x2d, 0xfc, 0x85, 0x02, 0x56, + 0x85, 0x92, 0xdc, 0xa6, 0x07, 0xb2, 0x15, 0xe9, 0x0a, 0xf1, 0x0a, 0xdf, 0xeb, 0x75, 0x9b, 0xc8, + 0xd7, 0x0c, 0xa7, 0x1d, 0x72, 0xe7, 0x05, 0x00, 0x99, 0x1d, 0x68, 0x12, 0x00, 0xdd, 0xa1, 0x10, + 0x7c, 0x77, 0xf3, 0xb4, 0x47, 0x1a, 0x09, 0x97, 0xc0, 0x3c, 0x72, 0xac, 0x38, 0x6c, 0x85, 0xc2, + 0xce, 0x22, 0xc7, 0x92, 0x21, 0x33, 0xe8, 0x51, 0xcd, 0xa4, 0xc7, 0xef, 0x29, 0xe0, 0xc5, 0xc1, + 0x17, 0x7d, 0x68, 0x35, 0x1f, 0x78, 0x07, 0xea, 0x6e, 0x28, 0x10, 0xd2, 0x11, 0x40, 0xcd, 0xc1, + 0x51, 0x1f, 0x36, 0xaf, 0x85, 0x22, 0x91, 0x9e, 0x89, 0x6f, 0xf8, 0x38, 0x18, 0x8b, 0x8e, 0xe0, + 0xaa, 0xc6, 0x3e, 0xd4, 0x27, 0x4c, 0x21, 0x08, 0xe9, 0x36, 0x1f, 0x7b, 0xb6, 0x8f, 0x2c, 0x3e, + 0x78, 0xbd, 0xdf, 0xf0, 0x24, 0xb1, 0xe5, 0x1e, 0x97, 0x21, 0x86, 0x4f, 0xb2, 0x86, 0xb5, 0x00, + 0xaa, 0x60, 0xc6, 0xf3, 0xed, 0xae, 0xe1, 0xf7, 0x75, 0xec, 0x89, 0x33, 0x64, 0x46, 0x9b, 0xe2, + 0x8d, 0x0d, 0x6f, 0xdb, 0x22, 0x73, 0x53, 0x3b, 0xc2, 0x9d, 0x41, 0xf6, 0xa1, 0xfe, 0xff, 0xe8, + 0x04, 0xcb, 0x9a, 0x3b, 0x62, 0x54, 0xfc, 0xa4, 0x2c, 0x93, 0xe5, 0xf0, 0x88, 0xfc, 0x25, 0x05, + 0x2c, 0x70, 0xaa, 0x30, 0x1e, 0x12, 0xa7, 0x44, 0xb2, 0x29, 0xfc, 0xf2, 0x24, 0xdb, 0x14, 0xd6, + 0x44, 0x6d, 0x4a, 0xc2, 0xe8, 0x54, 0x06, 0x31, 0x3a, 0xd9, 0xf2, 0xd9, 0x08, 0xdd, 0x0d, 0x79, + 0x19, 0x91, 0xa6, 0x0e, 0x73, 0x8f, 0x50, 0xbb, 0xa1, 0x25, 0xe3, 0x3e, 0xd3, 0x4f, 0xd7, 0x70, + 0xee, 0x31, 0x5e, 0xe5, 0x4d, 0xc7, 0x37, 0x93, 0xf2, 0xcf, 0x94, 0xa1, 0xfc, 0xb3, 0x76, 0x28, + 0xcd, 0x89, 0xc9, 0x8e, 0xda, 0x92, 0xda, 0xe1, 0xe1, 0x93, 0x31, 0xd1, 0xd1, 0xee, 0xc9, 0x0a, + 0x65, 0x91, 0xcd, 0x90, 0x90, 0xc5, 0x23, 0x62, 0xd3, 0x77, 0x95, 0x50, 0xd6, 0xe4, 0x69, 0xf8, + 0x56, 0x6e, 0x26, 0x4e, 0x85, 0x01, 0x7d, 0x4e, 0x71, 0x05, 0x3d, 0x22, 0xef, 0xfb, 0x1a, 0x78, + 0x86, 0x2f, 0x71, 0xd3, 0xb1, 0x3c, 0xd7, 0x26, 0x54, 0x6f, 0x78, 0x11, 0x6b, 0x9f, 0x02, 0x63, + 0xcc, 0x90, 0x28, 0xd4, 0x90, 0x8c, 0x62, 0x6f, 0xdb, 0x52, 0xdf, 0x04, 0x67, 0x72, 0x06, 0xf1, + 0xbd, 0xd5, 0xc1, 0x24, 0xe2, 0x3d, 0x9c, 0x80, 0xe1, 0xb7, 0xfa, 0x73, 0xe1, 0x60, 0xbe, 0x23, + 0x64, 0x58, 0xef, 0xf7, 0xdc, 0x88, 0x01, 0x87, 0xbe, 0x0b, 0x9f, 0x01, 0xa0, 0x8f, 0x0c, 0x5f, + 0xef, 0xba, 0x4e, 0xb0, 0x2b, 0xbc, 0x68, 0xd2, 0x72, 0x97, 0x34, 0xa8, 0xbf, 0x5a, 0x49, 0xb8, + 0x06, 0xd2, 0x0a, 0xf8, 0xfa, 0xaf, 0x82, 0x2a, 0xf2, 0xfd, 0x50, 0xb8, 0x9a, 0x06, 0x46, 0x9c, + 0x19, 0x51, 0x5c, 0x74, 0x85, 0xe0, 0xd8, 0x24, 0x3f, 0x35, 0x02, 0x4c, 0x4e, 0x5e, 0x73, 0xd7, + 0xf0, 0xdb, 0xc8, 0xd2, 0x3f, 0x21, 0xc8, 0xd8, 0x05, 0x92, 0x79, 0x9e, 0xf3, 0xbc, 0x87, 0xce, + 0x42, 0x6e, 0x91, 0xf0, 0x0a, 0x80, 0xd8, 0xd3, 0x5b, 0x3e, 0x42, 0x32, 0x34, 0xf3, 0x45, 0xe7, + 0xb0, 0x77, 0xc7, 0x47, 0x28, 0x02, 0xbe, 0x00, 0x66, 0x4c, 0xd7, 0xc1, 0xbd, 0x2e, 0xb2, 0x18, + 0xdc, 0x28, 0x85, 0x9b, 0x16, 0x8d, 0x14, 0xe8, 0x15, 0x70, 0x52, 0x42, 0xc7, 0xbb, 0x18, 0xf8, + 0x18, 0x05, 0x3f, 0xde, 0x12, 0x48, 0x37, 0x58, 0x27, 0xbd, 0xce, 0xae, 0x33, 0x47, 0x7c, 0x0b, + 0x05, 0x5f, 0x31, 0x02, 0x84, 0xf3, 0x98, 0x92, 0x52, 0xf1, 0xd1, 0x48, 0xc5, 0xd5, 0x6f, 0x2b, + 0xe0, 0xd9, 0x62, 0x24, 0x87, 0xa0, 0xeb, 0x5b, 0x60, 0x8c, 0x6e, 0x89, 0x0b, 0xf8, 0x52, 0x72, + 0x14, 0x8d, 0x3e, 0x93, 0x31, 0x6c, 0x52, 0x3a, 0x21, 0x15, 0x09, 0x36, 0x4c, 0xfd, 0x89, 0xc2, + 0x0c, 0x18, 0x39, 0xd9, 0xa2, 0x75, 0x71, 0x65, 0x38, 0x2a, 0x91, 0x0b, 0xdd, 0x2e, 0x72, 0x27, + 0xc7, 0x81, 0xd1, 0xf5, 0xf4, 0x1e, 0xe6, 0x8e, 0x08, 0x73, 0xbb, 0xee, 0x8b, 0x8e, 0x07, 0xa1, + 0xd3, 0x12, 0x83, 0xad, 0x86, 0x4e, 0x8b, 0x0c, 0xf9, 0x2c, 0x98, 0x25, 0x17, 0x15, 0xa6, 0xe2, + 0xc4, 0xbf, 0xe1, 0xe1, 0x80, 0xe9, 0xae, 0xf1, 0x98, 0x6d, 0xe1, 0xbd, 0x5e, 0x57, 0xfd, 0x4b, + 0x05, 0x80, 0x68, 0x53, 0xe5, 0xa7, 0xe9, 0x69, 0x50, 0x13, 0xb1, 0x4a, 0x4b, 0xdc, 0x8d, 0x78, + 0x24, 0x92, 0xda, 0x6b, 0xe1, 0x05, 0x89, 0xa0, 0x46, 0x95, 0x62, 0x98, 0xe5, 0xcd, 0x6b, 0x3c, + 0xb6, 0x71, 0x1e, 0x4c, 0xc7, 0x76, 0xc0, 0x56, 0x36, 0x15, 0x48, 0xcb, 0x3f, 0x0d, 0x6a, 0x3e, + 0x32, 0x2c, 0x59, 0x0a, 0x27, 0x49, 0x03, 0x95, 0xbc, 0x1f, 0x2b, 0xcc, 0xe0, 0x67, 0x33, 0xe6, + 0x10, 0x12, 0xf3, 0x2e, 0x98, 0xa6, 0xb3, 0x32, 0xaa, 0x11, 0x36, 0x10, 0x4f, 0x45, 0xcd, 0xb3, + 0xaf, 0xd1, 0xac, 0xeb, 0xa3, 0x9f, 0x7e, 0x7e, 0x56, 0xd1, 0xa6, 0xfc, 0xb0, 0x05, 0x13, 0xb5, + 0xa2, 0x97, 0xbd, 0x0c, 0xf6, 0x32, 0x96, 0x1d, 0x27, 0xdd, 0x8d, 0x04, 0x8b, 0xd5, 0x9b, 0xcc, + 0xc6, 0xbc, 0xdf, 0x43, 0x7e, 0xff, 0x81, 0xd7, 0x71, 0x0d, 0x6b, 0xc7, 0x77, 0xdb, 0x84, 0x6e, + 0x92, 0x46, 0x45, 0x4c, 0x50, 0xe2, 0x4c, 0x50, 0xbf, 0xc7, 0x85, 0x36, 0x73, 0xfc, 0xa1, 0x8c, + 0xd4, 0x18, 0x0e, 0xc4, 0x89, 0x35, 0x7b, 0xf5, 0xc4, 0x0a, 0x4b, 0x1f, 0xb0, 0x61, 0xf7, 0x0d, + 0xbc, 0xd7, 0x20, 0xbd, 0x1a, 0x03, 0x22, 0xa2, 0x80, 0x7c, 0x5f, 0xb7, 0x10, 0x36, 0x7d, 0xdb, + 0x23, 0xd7, 0x44, 0x21, 0x0a, 0xc8, 0xf7, 0x6f, 0x47, 0xad, 0xea, 0x26, 0x78, 0x2e, 0x5c, 0xad, + 0x86, 0x70, 0xaf, 0x6b, 0x34, 0x3b, 0x88, 0x2d, 0xbb, 0x81, 0xda, 0xe4, 0x0c, 0x1a, 0x68, 0xd7, + 0x3f, 0xaf, 0x80, 0x4b, 0xa5, 0x78, 0x0e, 0xb1, 0xfb, 0x0b, 0x60, 0x06, 0x33, 0x34, 0x52, 0x5c, + 0x60, 0x46, 0x9b, 0xe6, 0x8d, 0xd4, 0x45, 0x57, 0xbf, 0x5d, 0x01, 0x63, 0x34, 0x2e, 0x08, 0xaf, + 0x81, 0x31, 0x1a, 0x33, 0xe4, 0x93, 0x9c, 0xc9, 0xb2, 0x07, 0x14, 0x92, 0x99, 0x1b, 0x0a, 0x1b, + 0x0b, 0x96, 0x56, 0x12, 0xc1, 0xd2, 0x98, 0xeb, 0x5e, 0x4d, 0xb8, 0xee, 0x67, 0xc1, 0x94, 0x88, + 0xa4, 0xda, 0x5d, 0xc4, 0xb5, 0x09, 0xf0, 0x30, 0xaa, 0xdd, 0x4d, 0x44, 0x05, 0xc7, 0x8a, 0xa3, + 0x82, 0xe3, 0xa9, 0xf0, 0xe8, 0xf3, 0xe0, 0x18, 0xbb, 0x1e, 0xe9, 0x6e, 0x4b, 0xef, 0x22, 0xf2, + 0x0b, 0xd3, 0x98, 0x43, 0x55, 0x9b, 0x63, 0x1d, 0xf7, 0x5a, 0x77, 0x59, 0xb3, 0x1c, 0x4c, 0x9e, + 0x8c, 0x05, 0x93, 0xd5, 0xbf, 0xa9, 0x80, 0x29, 0xba, 0x65, 0x06, 0x3a, 0x1c, 0x89, 0x4a, 0xa2, + 0x5c, 0x32, 0x05, 0xab, 0x45, 0x14, 0x1c, 0x2d, 0xa6, 0xe0, 0x58, 0x31, 0x05, 0xc7, 0x8b, 0x29, + 0x38, 0x91, 0xa2, 0x60, 0x2e, 0x55, 0xa8, 0x9e, 0x90, 0x3b, 0x13, 0x8f, 0xb1, 0x44, 0xf1, 0xe9, + 0xd9, 0xa8, 0x99, 0x86, 0x66, 0x7f, 0xa8, 0x80, 0x93, 0xfc, 0xa0, 0xa4, 0x54, 0x21, 0xa6, 0x4f, + 0x68, 0x86, 0x88, 0x0e, 0x29, 0x99, 0xd1, 0xa1, 0x4a, 0x2c, 0x3a, 0x74, 0x16, 0x4c, 0xb1, 0xf4, + 0xa6, 0x4e, 0x44, 0x9e, 0x53, 0x09, 0xb0, 0xa6, 0xfb, 0x7d, 0x0f, 0x45, 0x77, 0xbc, 0x51, 0xe9, + 0x8e, 0x47, 0xd0, 0xb9, 0xad, 0x16, 0x46, 0x42, 0x7c, 0xf8, 0x57, 0xd6, 0xcd, 0x76, 0x3c, 0xf3, + 0x66, 0xdb, 0x0e, 0xfd, 0x66, 0x69, 0xf9, 0x5c, 0x21, 0x5f, 0x01, 0xe3, 0x94, 0xbd, 0xe2, 0x66, + 0x78, 0x26, 0xcf, 0xde, 0xb2, 0x44, 0x08, 0x07, 0x8e, 0x6e, 0xc2, 0x15, 0xf9, 0x26, 0x8c, 0xc0, + 0xe9, 0xf8, 0xd1, 0x80, 0xd7, 0xfb, 0xdb, 0xb7, 0xe5, 0xb0, 0x70, 0xe8, 0x8d, 0xb0, 0xf9, 0x46, + 0xb5, 0x9a, 0x70, 0x47, 0xf0, 0xe0, 0x37, 0xf5, 0x7f, 0x51, 0x98, 0xfb, 0x9b, 0x9e, 0x87, 0x6f, + 0xea, 0x6b, 0xc9, 0xfb, 0xee, 0x5a, 0xee, 0xae, 0x0a, 0xd0, 0x70, 0xaf, 0x01, 0x6f, 0x3a, 0x81, + 0xdf, 0x0f, 0xaf, 0xc4, 0xf5, 0x8f, 0xc0, 0xb4, 0xdc, 0x01, 0xe7, 0x41, 0x75, 0x0f, 0xf5, 0xb9, + 0x55, 0x24, 0x3f, 0xe1, 0xcb, 0x60, 0x6c, 0xdf, 0xe8, 0xf4, 0xd0, 0x80, 0xe9, 0x29, 0x06, 0xfc, + 0x46, 0xe5, 0x75, 0x45, 0x26, 0x60, 0x18, 0x7e, 0x89, 0x13, 0x30, 0x34, 0xc3, 0x21, 0x01, 0x85, + 0x1d, 0x1e, 0x92, 0x80, 0xf1, 0x79, 0x22, 0x02, 0xc6, 0x23, 0x3b, 0xa5, 0x04, 0xcc, 0x42, 0xc3, + 0xef, 0xdb, 0x82, 0x80, 0x1c, 0x23, 0x21, 0xa0, 0xdc, 0x71, 0x08, 0x02, 0xf2, 0xfb, 0xbc, 0x44, + 0xc0, 0x5f, 0xac, 0xb0, 0x13, 0xf8, 0x21, 0xf2, 0xed, 0x56, 0x7f, 0x27, 0x2c, 0x39, 0x20, 0xeb, + 0x12, 0x54, 0x7c, 0x59, 0xb2, 0x54, 0x54, 0x6d, 0xd7, 0x17, 0x7e, 0xf4, 0xfd, 0xe5, 0xe3, 0xbc, + 0xec, 0x81, 0xfb, 0x49, 0x8d, 0xc0, 0xb7, 0x9d, 0xb6, 0x64, 0xc3, 0xee, 0x80, 0x19, 0x51, 0x9d, + 0xc0, 0xd4, 0x97, 0x9d, 0xc5, 0xe7, 0x65, 0xdb, 0x29, 0x00, 0x56, 0x34, 0x14, 0x69, 0xb5, 0x36, + 0xed, 0x4b, 0x5f, 0xc4, 0x08, 0x84, 0x78, 0x6c, 0x8b, 0xdf, 0x1d, 0x80, 0x68, 0xda, 0xb6, 0xe0, + 0x3a, 0x98, 0x32, 0x4c, 0x66, 0x92, 0xc8, 0x34, 0xa3, 0xe9, 0x69, 0xa2, 0x4a, 0x8a, 0x95, 0x35, + 0x0a, 0x49, 0xa7, 0x01, 0x46, 0xf8, 0x5b, 0xfd, 0x90, 0xf9, 0x68, 0xd9, 0x54, 0x88, 0x34, 0x1f, + 0xb5, 0x5a, 0x22, 0x6a, 0x32, 0x1b, 0x3f, 0x05, 0xa4, 0x29, 0x36, 0x29, 0x90, 0xc6, 0x81, 0xd5, + 0x5b, 0xe0, 0xb2, 0xe0, 0x79, 0x2a, 0x1d, 0x67, 0x23, 0x3c, 0xc0, 0x3d, 0xf4, 0x8f, 0x14, 0xf0, + 0xfc, 0x20, 0x28, 0xf8, 0x3a, 0x03, 0x70, 0xa6, 0x4d, 0xb3, 0x7f, 0x3a, 0xcf, 0x08, 0xea, 0xd4, + 0x06, 0xe9, 0x2d, 0x0e, 0xce, 0x25, 0x74, 0x88, 0xdc, 0x61, 0xbd, 0x9d, 0xdd, 0x63, 0x23, 0xac, + 0xde, 0x62, 0x3e, 0x0d, 0xb1, 0x99, 0x29, 0xa0, 0xf5, 0xfe, 0xd6, 0x7e, 0x3b, 0xda, 0xe4, 0xd3, + 0x60, 0xbc, 0xbd, 0xdf, 0x8e, 0x76, 0x39, 0xd6, 0xde, 0x6f, 0x6f, 0x5b, 0xea, 0xb7, 0x14, 0xb0, + 0x54, 0x8e, 0x82, 0x6f, 0xf2, 0x63, 0x70, 0x3c, 0x6b, 0x93, 0xfc, 0x80, 0x3e, 0x50, 0xae, 0x1a, + 0xa6, 0x77, 0xa5, 0x5e, 0x0f, 0x83, 0x34, 0x19, 0x64, 0x88, 0xb6, 0xb1, 0xdf, 0x6e, 0x49, 0xdb, + 0xd8, 0x6f, 0xb7, 0xb6, 0x2d, 0x75, 0x37, 0x0c, 0x92, 0x65, 0x0d, 0xe5, 0xcb, 0xe7, 0x59, 0x5c, + 0xe5, 0x30, 0x59, 0x5c, 0xf5, 0x61, 0xb8, 0xc8, 0x8c, 0x5d, 0x0d, 0x70, 0xa1, 0x25, 0x3b, 0xe8, + 0x30, 0x46, 0x30, 0x0f, 0x71, 0xac, 0x43, 0x19, 0xd1, 0x0c, 0x77, 0x90, 0x85, 0x37, 0x8c, 0xeb, + 0xd0, 0xda, 0x00, 0x65, 0xc8, 0xda, 0x80, 0xbd, 0x94, 0xe1, 0xde, 0x76, 0xb6, 0x1e, 0x6e, 0x15, + 0x8b, 0x48, 0x32, 0xfd, 0xc7, 0x6d, 0x81, 0x94, 0xfe, 0x8b, 0x39, 0x04, 0x33, 0x22, 0xe8, 0xab, + 0xa7, 0xac, 0x37, 0x9f, 0x2c, 0x4a, 0x8c, 0xc6, 0xad, 0xf7, 0xc5, 0x62, 0x03, 0xca, 0xeb, 0x31, + 0x42, 0x0b, 0xad, 0xfe, 0x26, 0x8f, 0x0c, 0x24, 0x67, 0x58, 0x73, 0x2c, 0x71, 0xe5, 0x2b, 0xdc, + 0x57, 0x8c, 0x4b, 0x95, 0x04, 0x97, 0x86, 0xdc, 0xf4, 0x2e, 0xb8, 0x58, 0xb2, 0xa4, 0xa3, 0xda, + 0xfd, 0x1f, 0x2a, 0x91, 0x89, 0x0b, 0x8f, 0x35, 0x79, 0xaa, 0x3b, 0xae, 0xbf, 0xb5, 0x21, 0x48, + 0xf0, 0x0c, 0x00, 0x16, 0x0e, 0xf4, 0x18, 0x19, 0x26, 0x2d, 0x1c, 0x6c, 0xfd, 0xd4, 0x28, 0xd1, + 0x8d, 0xcc, 0x67, 0xd1, 0xf2, 0x8e, 0x8a, 0x1c, 0xf7, 0xa3, 0x14, 0xc3, 0x5d, 0xbb, 0xed, 0x1b, + 0x01, 0x62, 0xd3, 0x6c, 0xd2, 0x0a, 0x38, 0x41, 0x86, 0x53, 0x60, 0x92, 0x65, 0x73, 0x42, 0xbd, + 0x9c, 0xa0, 0xdf, 0xdb, 0x56, 0x74, 0x08, 0x54, 0xa4, 0x43, 0xe0, 0x9f, 0x2b, 0xe0, 0x64, 0x0e, + 0x4a, 0xf8, 0x16, 0x18, 0xa3, 0xe5, 0x75, 0x5c, 0x1b, 0x97, 0xb2, 0xae, 0x27, 0x14, 0x94, 0x0d, + 0x26, 0x07, 0x1b, 0xf7, 0xa4, 0xe8, 0x30, 0xf8, 0x3e, 0x98, 0x36, 0x0d, 0xc7, 0x44, 0x1d, 0x9d, + 0xa1, 0x61, 0x5e, 0xc4, 0x4a, 0x2e, 0x9a, 0x0d, 0x0a, 0x9c, 0x44, 0x36, 0xc5, 0x70, 0x50, 0x08, + 0xf8, 0x01, 0x98, 0x35, 0xdd, 0xae, 0x47, 0x6b, 0x6e, 0x18, 0x52, 0x56, 0x45, 0xf4, 0x62, 0x3e, + 0x52, 0x0e, 0x9e, 0x44, 0x3b, 0x23, 0xf0, 0x30, 0xc4, 0xf7, 0xc0, 0xb4, 0x8f, 0xa8, 0x4b, 0xc7, + 0xd0, 0x8e, 0x52, 0xb4, 0x2f, 0xe4, 0xa2, 0xd5, 0x28, 0x70, 0x8c, 0x6a, 0xda, 0x14, 0xc3, 0x40, + 0xfb, 0x55, 0x27, 0x4a, 0xd1, 0x67, 0xb2, 0x8b, 0x8b, 0xc5, 0x16, 0x18, 0x67, 0x25, 0x8c, 0x5c, + 0x2a, 0x56, 0xf3, 0xa4, 0x22, 0x0f, 0x11, 0x1f, 0xae, 0x22, 0xf0, 0x82, 0x98, 0x2f, 0x67, 0xcb, + 0x03, 0x0b, 0x4a, 0x1d, 0xd4, 0xb0, 0x6f, 0xc6, 0x52, 0x60, 0x13, 0xd8, 0x37, 0x1b, 0x44, 0x5e, + 0x7e, 0x45, 0x01, 0xcb, 0x03, 0xce, 0xc3, 0x77, 0xf8, 0x21, 0xcd, 0xb6, 0x4b, 0x2c, 0x13, 0x5b, + 0x3d, 0x38, 0xcf, 0x66, 0x63, 0x3c, 0xc3, 0xea, 0x7b, 0x91, 0x01, 0x6e, 0x3c, 0x32, 0xbc, 0x7b, + 0xbd, 0x43, 0x2a, 0xc3, 0x7f, 0x29, 0xe0, 0x58, 0x0a, 0x19, 0xbc, 0x29, 0xb1, 0x88, 0xa5, 0x1a, + 0xf2, 0x4e, 0x25, 0x3a, 0x80, 0x0f, 0x16, 0x8c, 0x81, 0x3b, 0x60, 0x46, 0xd6, 0x02, 0xcc, 0xd5, + 0xe0, 0x4a, 0x31, 0x16, 0xa6, 0x0b, 0x02, 0xd7, 0xb4, 0xa4, 0x03, 0x18, 0x3e, 0x4c, 0x53, 0x94, + 0x69, 0xc1, 0x72, 0x09, 0x4e, 0x3e, 0x48, 0x60, 0x4d, 0x92, 0xb3, 0xc9, 0x72, 0x0b, 0x19, 0xe4, + 0xe4, 0xac, 0x5c, 0x4b, 0x08, 0xeb, 0xe5, 0x22, 0x61, 0x8d, 0xa3, 0x10, 0x62, 0x7a, 0x27, 0x4a, + 0xca, 0xa7, 0xcf, 0x70, 0xe2, 0x72, 0x22, 0xd3, 0x75, 0x2c, 0xc3, 0xef, 0x37, 0x76, 0x0a, 0x9d, + 0xd7, 0x47, 0x51, 0x9e, 0xbc, 0x1c, 0x4f, 0xe8, 0x1d, 0xc5, 0xef, 0xd8, 0x07, 0x72, 0x2f, 0xf8, + 0x50, 0x75, 0x3b, 0xb2, 0xfa, 0x99, 0x13, 0xc7, 0x0f, 0xe6, 0xc2, 0xc0, 0xbf, 0x0f, 0xae, 0x0c, + 0x84, 0xea, 0x28, 0x97, 0x7f, 0x37, 0x72, 0x90, 0x1a, 0xde, 0xe6, 0x63, 0xfb, 0x90, 0x1a, 0xf3, + 0x43, 0x05, 0xcc, 0x27, 0x71, 0xc1, 0xad, 0xf8, 0xb9, 0xf1, 0x52, 0x89, 0xbe, 0x30, 0xcd, 0xdf, + 0xf1, 0xdd, 0x7d, 0xdb, 0x42, 0x3e, 0xc1, 0x23, 0x0e, 0x90, 0xaf, 0xa7, 0xac, 0x3d, 0xd3, 0x9d, + 0xeb, 0x03, 0xca, 0x79, 0x06, 0xe6, 0xb8, 0xd9, 0x57, 0xbf, 0x2e, 0x59, 0x90, 0x18, 0x39, 0x38, + 0xcd, 0x6f, 0x25, 0x74, 0x7f, 0xa9, 0x50, 0xe2, 0x65, 0x0c, 0x42, 0xe0, 0xd7, 0xc0, 0x71, 0xee, + 0xf5, 0x36, 0x76, 0x68, 0x18, 0x8f, 0x53, 0xfa, 0x32, 0x98, 0x17, 0x77, 0x5a, 0x3d, 0x5e, 0xfe, + 0x38, 0x27, 0xda, 0xf9, 0x15, 0x58, 0x6d, 0x82, 0xa7, 0x13, 0x28, 0xf8, 0xea, 0xb6, 0xc1, 0xbc, + 0xa8, 0xb7, 0xf4, 0xf8, 0x26, 0x33, 0xb3, 0x2f, 0xde, 0x4a, 0x82, 0x14, 0xda, 0x1c, 0x8e, 0x37, + 0xa8, 0xaf, 0x33, 0xe7, 0x7c, 0x27, 0xac, 0x74, 0x70, 0x4c, 0xb7, 0x8b, 0x84, 0x13, 0x52, 0xa4, + 0x89, 0x7f, 0xad, 0x30, 0xc7, 0x24, 0x6f, 0x28, 0x5f, 0xeb, 0x15, 0x70, 0xcc, 0xec, 0xf9, 0x3e, + 0x72, 0xa4, 0x34, 0x80, 0xa8, 0xac, 0xe1, 0x1d, 0x61, 0x06, 0x00, 0xee, 0x82, 0x53, 0x72, 0x21, + 0x06, 0x45, 0xa8, 0x5b, 0x0c, 0x23, 0x4f, 0x48, 0x2c, 0xe7, 0xd6, 0x5d, 0x66, 0xad, 0x43, 0x3b, + 0xe1, 0x65, 0x2e, 0x4f, 0xfd, 0x47, 0x05, 0x3c, 0x9d, 0x39, 0x22, 0xe7, 0x1e, 0x76, 0x44, 0x99, + 0x63, 0x78, 0x1f, 0x8c, 0xb3, 0x6d, 0x51, 0xd3, 0x3d, 0xbd, 0x7e, 0xe3, 0xd3, 0xcf, 0xcf, 0x8e, + 0xfc, 0xf8, 0xf3, 0xb3, 0xcf, 0xb5, 0xed, 0x60, 0xb7, 0xd7, 0x5c, 0x31, 0xdd, 0x2e, 0x7f, 0x00, + 0xc2, 0xff, 0x5b, 0xc6, 0xd6, 0x1e, 0x7f, 0xc7, 0xb0, 0xed, 0x04, 0x3f, 0xfa, 0xfe, 0x32, 0xe0, + 0x81, 0x92, 0x6d, 0x27, 0xd0, 0x38, 0x2e, 0xf5, 0x0d, 0xe6, 0x74, 0x44, 0xc6, 0xef, 0x00, 0x7c, + 0xfc, 0x07, 0x7e, 0xd9, 0xc8, 0x1f, 0x3c, 0x0c, 0x27, 0x1d, 0x70, 0x1a, 0x0b, 0x84, 0xb9, 0xbc, + 0xcc, 0x75, 0x7a, 0x72, 0xd6, 0xa2, 0x2d, 0xe0, 0x9c, 0x45, 0xaa, 0xff, 0xa4, 0x80, 0x93, 0x39, + 0xa3, 0xf2, 0x6e, 0x49, 0xff, 0xab, 0x39, 0xfa, 0xcd, 0x0a, 0x18, 0x6f, 0x04, 0x46, 0xd0, 0xc3, + 0x50, 0x07, 0x4f, 0x27, 0xb5, 0x5d, 0x4e, 0xb8, 0x5e, 0xc9, 0x25, 0x62, 0x5c, 0xd5, 0xa9, 0x05, + 0x79, 0x0a, 0xa7, 0x1b, 0x61, 0x03, 0x1c, 0x63, 0xc6, 0x1f, 0xf7, 0x1d, 0x53, 0x20, 0x67, 0xc4, + 0xb8, 0x94, 0x1b, 0x3b, 0x25, 0x03, 0x1a, 0x14, 0x9e, 0x22, 0x9e, 0x6b, 0xc6, 0x1b, 0xe0, 0x2d, + 0x00, 0xcc, 0x5d, 0xc3, 0x76, 0x18, 0x36, 0xe6, 0xa7, 0x9c, 0xcf, 0xc3, 0xb6, 0x41, 0x20, 0x29, + 0x9e, 0x9a, 0x29, 0x7e, 0xaa, 0xbf, 0x5d, 0x05, 0x73, 0x89, 0x69, 0xe0, 0x73, 0x60, 0xae, 0x89, + 0x79, 0xdd, 0xda, 0x2e, 0xb2, 0xdb, 0xbb, 0xa2, 0x98, 0x6b, 0xa6, 0x89, 0x29, 0xec, 0x3b, 0xb4, + 0x11, 0xaa, 0x60, 0x26, 0x82, 0x33, 0xb0, 0xa8, 0x67, 0x98, 0x12, 0x50, 0xbc, 0xbc, 0xbe, 0x89, + 0x75, 0x39, 0x7b, 0xc1, 0x92, 0x4b, 0xd3, 0x4d, 0xfc, 0x20, 0xca, 0x5f, 0x2c, 0x81, 0xf9, 0x26, + 0xd6, 0xbb, 0x7d, 0xfc, 0x49, 0x47, 0xdf, 0x47, 0x3e, 0xb6, 0xc3, 0x72, 0xff, 0xd9, 0x26, 0xbe, + 0x4b, 0x9a, 0x1f, 0xb2, 0x56, 0x78, 0x0b, 0x9c, 0x69, 0x62, 0xdd, 0x42, 0x2d, 0xa3, 0xd7, 0x09, + 0x74, 0x73, 0xd7, 0xf0, 0x0d, 0x33, 0x40, 0xbe, 0x8e, 0x45, 0x51, 0x0c, 0x2b, 0x73, 0x3d, 0xd5, + 0xc4, 0xb7, 0x19, 0xcc, 0x86, 0x00, 0x69, 0xf0, 0x1a, 0x99, 0xeb, 0xe0, 0x94, 0x8c, 0xc1, 0xed, + 0x74, 0x58, 0x6e, 0x44, 0xaa, 0x7f, 0x3d, 0x11, 0x8d, 0x16, 0xdd, 0xa2, 0x06, 0x9a, 0x2c, 0x93, + 0x90, 0x17, 0xe1, 0x85, 0x09, 0x5a, 0xd6, 0x5a, 0x6b, 0xe2, 0xbb, 0xac, 0x81, 0x77, 0x3f, 0x72, + 0xfd, 0x3d, 0xe4, 0x63, 0x9a, 0x88, 0x99, 0x21, 0xdd, 0x1f, 0xb0, 0x06, 0x78, 0x19, 0x1c, 0x6b, + 0x62, 0x1d, 0x39, 0x46, 0xb3, 0x83, 0x74, 0xab, 0x67, 0x74, 0x74, 0xab, 0x49, 0x93, 0x31, 0x93, + 0x64, 0x97, 0x9b, 0xb4, 0xfd, 0x76, 0xcf, 0xe8, 0xdc, 0x6e, 0xaa, 0xef, 0x82, 0x5a, 0xc8, 0x2d, + 0xe2, 0x36, 0x70, 0x26, 0x8b, 0xca, 0xbf, 0x09, 0xc6, 0x3f, 0x8b, 0x56, 0x5f, 0xd0, 0x2e, 0x71, + 0xc8, 0x55, 0xe8, 0x9a, 0xa6, 0x69, 0xa3, 0x38, 0xe1, 0x7e, 0x50, 0x01, 0x4f, 0x65, 0x88, 0x29, + 0x61, 0x33, 0xf6, 0x74, 0xd3, 0xb5, 0x50, 0x48, 0x73, 0x86, 0x7e, 0x06, 0x7b, 0x1b, 0xae, 0x85, + 0x04, 0xc9, 0x9f, 0x05, 0xb3, 0x02, 0xce, 0x74, 0xbb, 0xe4, 0xa6, 0xce, 0xf8, 0x3c, 0xcd, 0xc0, + 0x36, 0x68, 0x1b, 0xbc, 0x44, 0xb1, 0x19, 0xbe, 0xb9, 0x6b, 0x07, 0xc8, 0x0c, 0x7a, 0xbe, 0xc8, + 0xfd, 0xcc, 0x62, 0x6f, 0x4d, 0x6a, 0x25, 0x52, 0x83, 0x3d, 0xbd, 0xed, 0x26, 0x18, 0x3d, 0x85, + 0xbd, 0x2d, 0x57, 0x4c, 0xb9, 0x02, 0x9e, 0xc2, 0x9e, 0xce, 0x8e, 0x6a, 0xdb, 0x69, 0xeb, 0xb8, + 0x8f, 0x03, 0xd4, 0x15, 0x25, 0xe1, 0xd8, 0xbb, 0x27, 0x7a, 0x1a, 0xb4, 0x23, 0x06, 0x2f, 0x1d, + 0xf9, 0xe3, 0x71, 0xf8, 0xf0, 0xd0, 0xe7, 0x5b, 0xb2, 0xdc, 0x2e, 0xa1, 0x1d, 0x65, 0xfc, 0x84, + 0xd8, 0xd2, 0x6d, 0xda, 0x48, 0xd8, 0xad, 0x9e, 0x88, 0xbc, 0x0b, 0x6a, 0x24, 0xb8, 0x85, 0x57, + 0xef, 0x45, 0x2e, 0x03, 0x6f, 0x8f, 0x6a, 0xf4, 0x30, 0x6d, 0x29, 0xab, 0xd1, 0xe3, 0xe3, 0x38, + 0xb4, 0xea, 0x85, 0xb9, 0xab, 0x07, 0x18, 0xf9, 0xcc, 0x43, 0x1d, 0xb0, 0xf2, 0x33, 0x8c, 0x9e, + 0x54, 0xa4, 0xe8, 0x49, 0x69, 0xd0, 0x45, 0xfd, 0x6a, 0xec, 0x65, 0x83, 0x98, 0x91, 0x6f, 0xe3, + 0xcd, 0x84, 0x2f, 0x7c, 0xa1, 0x30, 0x5d, 0xc6, 0xd2, 0xad, 0xa1, 0x0f, 0xec, 0x84, 0xcf, 0x19, + 0xa4, 0x5e, 0xd9, 0x05, 0x66, 0x81, 0xed, 0xc8, 0x05, 0xa6, 0xdf, 0x07, 0xd9, 0x49, 0xec, 0xf1, + 0x80, 0xfa, 0x11, 0xf3, 0xb9, 0x53, 0xf3, 0x1d, 0xc5, 0x5e, 0x7a, 0x61, 0x3d, 0x18, 0xa1, 0xd2, + 0xbd, 0x47, 0x0e, 0xb2, 0xfe, 0x27, 0x98, 0xf3, 0x71, 0xac, 0x1c, 0x38, 0x36, 0xed, 0x51, 0xec, + 0xea, 0xef, 0x2b, 0x60, 0x7c, 0xc7, 0xed, 0xd8, 0x66, 0x1f, 0x5e, 0x04, 0xb3, 0x9e, 0x6f, 0x3b, + 0xa6, 0xed, 0x19, 0x1d, 0x96, 0x89, 0x21, 0x7b, 0x18, 0xd3, 0x66, 0xc2, 0x56, 0x9a, 0xce, 0xb9, + 0x04, 0xe6, 0x22, 0xb0, 0x28, 0x69, 0x55, 0xd3, 0xa2, 0xd1, 0x0f, 0x49, 0x6b, 0x3a, 0x7f, 0x54, + 0x3d, 0x92, 0xfc, 0x11, 0x7f, 0x32, 0x22, 0xe5, 0x8f, 0x2e, 0x83, 0x79, 0x29, 0x9f, 0xce, 0xbc, + 0x24, 0x96, 0x38, 0x9e, 0x8b, 0x92, 0xea, 0xcc, 0x49, 0xba, 0x0c, 0xe6, 0xa5, 0xe3, 0x87, 0x81, + 0xb2, 0x04, 0xfb, 0x5c, 0x94, 0x41, 0x67, 0xa0, 0x19, 0xc9, 0xf2, 0x89, 0xcc, 0x64, 0xf9, 0xbf, + 0x2b, 0xd1, 0x6d, 0x9e, 0x45, 0x14, 0x29, 0x41, 0x6d, 0x84, 0x8f, 0xae, 0x6c, 0x38, 0x91, 0x22, + 0xab, 0x0e, 0x91, 0x22, 0xcb, 0x8e, 0xad, 0x26, 0x05, 0x70, 0x2c, 0x25, 0x80, 0xff, 0x8f, 0x09, + 0x60, 0xd6, 0xee, 0xb8, 0x00, 0xbe, 0x01, 0x26, 0x3d, 0xde, 0x56, 0x56, 0x6d, 0xcd, 0x44, 0x4d, + 0x0b, 0xe1, 0xd5, 0x7b, 0x51, 0xdc, 0x3d, 0xfe, 0x8c, 0x8b, 0xf9, 0x7f, 0x21, 0x09, 0x2f, 0x65, + 0xbf, 0x0a, 0xab, 0x25, 0x5f, 0x7b, 0xa9, 0x46, 0x14, 0x35, 0xcf, 0x41, 0x78, 0xe8, 0x12, 0xf1, + 0x8d, 0x28, 0x3e, 0x4c, 0x74, 0x32, 0x3e, 0xcd, 0x80, 0xe6, 0x40, 0xfd, 0xd9, 0x28, 0x6a, 0x99, + 0x89, 0x84, 0xaf, 0xf2, 0x01, 0x98, 0x4f, 0xec, 0x5b, 0xb8, 0xf2, 0xcf, 0x0f, 0xf6, 0x1c, 0x8e, + 0xd6, 0xf2, 0xce, 0xc5, 0x89, 0x84, 0xd5, 0xeb, 0xcc, 0x30, 0xd3, 0x80, 0x08, 0x8f, 0x81, 0x48, + 0x59, 0xf7, 0xd3, 0xa0, 0x26, 0x0c, 0xb3, 0x48, 0xba, 0x4f, 0x72, 0xcb, 0x8c, 0xd5, 0xcf, 0x94, + 0x28, 0xb0, 0x11, 0x1b, 0xcb, 0x57, 0xfc, 0x41, 0xc2, 0x1c, 0xbd, 0x5d, 0x96, 0x48, 0xcf, 0x40, + 0xc2, 0x4c, 0x15, 0x4f, 0xa3, 0x73, 0x74, 0xf5, 0xaf, 0xf2, 0x92, 0x9e, 0xdc, 0x24, 0xfa, 0xb5, + 0x78, 0x12, 0xbd, 0xa4, 0xb0, 0x43, 0xca, 0xa1, 0xdf, 0x60, 0x32, 0x43, 0xaf, 0xfd, 0x3c, 0x12, + 0xea, 0xb4, 0x79, 0xa5, 0x3a, 0x7b, 0x05, 0x52, 0x74, 0x9d, 0x7b, 0x8b, 0x15, 0x95, 0x15, 0x8d, + 0xce, 0x7a, 0x4d, 0x31, 0x2a, 0x6a, 0x48, 0x1e, 0xb1, 0xd9, 0x59, 0xea, 0x9a, 0x07, 0x9e, 0xb7, + 0x1e, 0x6e, 0x45, 0x49, 0xec, 0x41, 0x53, 0x81, 0xed, 0x58, 0x2a, 0x90, 0x5d, 0xb9, 0xea, 0xa0, + 0x66, 0xe1, 0x80, 0x47, 0x98, 0xab, 0x2c, 0xc2, 0x6c, 0xe1, 0x80, 0x46, 0x98, 0x75, 0xb6, 0xf0, + 0xa2, 0x89, 0x0f, 0x97, 0x39, 0x7f, 0x2d, 0x51, 0xbe, 0xde, 0xb0, 0x9f, 0xa0, 0x81, 0xe2, 0x75, + 0x37, 0x12, 0x05, 0xe9, 0x6c, 0x20, 0x5f, 0x4c, 0x64, 0x2c, 0x69, 0xb9, 0x66, 0xac, 0xf0, 0x9d, + 0x16, 0x6c, 0x2e, 0x86, 0xb5, 0xe2, 0xac, 0xca, 0x97, 0x3f, 0x64, 0x17, 0xe9, 0x6b, 0xf5, 0x46, + 0x78, 0x92, 0x27, 0xfb, 0xf9, 0x0c, 0x45, 0xc5, 0x7f, 0x57, 0xff, 0xed, 0x3a, 0x78, 0x8a, 0x0c, + 0xbf, 0xcb, 0x85, 0xaa, 0x81, 0xfc, 0x7d, 0xdb, 0x44, 0xf0, 0x1b, 0x00, 0xa6, 0x5f, 0xd3, 0xc0, + 0x97, 0x8a, 0xa4, 0x3f, 0xf3, 0x2d, 0x69, 0xfd, 0xea, 0x41, 0x86, 0xb0, 0x15, 0xab, 0x23, 0xf0, + 0xf7, 0x95, 0x8c, 0x4a, 0x9a, 0xe8, 0xb5, 0x05, 0x7c, 0x63, 0xe0, 0x7a, 0x96, 0xd4, 0x8b, 0x90, + 0xfa, 0x9b, 0x43, 0x8d, 0x0d, 0x97, 0xf6, 0x5b, 0xc9, 0xf7, 0x05, 0xb1, 0x85, 0xbd, 0x5e, 0xb2, + 0xdd, 0xdc, 0x17, 0x7e, 0xf5, 0xeb, 0x43, 0x8c, 0x0c, 0x17, 0xf5, 0x6b, 0x51, 0x89, 0x5b, 0xf2, + 0x41, 0x1c, 0x7c, 0xf5, 0x40, 0x88, 0x43, 0xc1, 0xaa, 0xbf, 0x76, 0xe0, 0x71, 0xe1, 0x72, 0xfe, + 0x8e, 0xd7, 0x4e, 0x0c, 0xf2, 0x1c, 0x0d, 0x6e, 0x95, 0xf1, 0x63, 0xc0, 0x57, 0x78, 0xf5, 0x77, + 0x0e, 0x8f, 0x28, 0x8b, 0xa0, 0xc9, 0xe7, 0x64, 0xa5, 0x04, 0xcd, 0x79, 0xe9, 0x56, 0x4a, 0xd0, + 0xbc, 0x77, 0x6b, 0xea, 0x08, 0xfc, 0x5d, 0x25, 0x3a, 0xe2, 0xd2, 0x0f, 0xc5, 0xe0, 0xf5, 0xb2, + 0x9d, 0xe7, 0x3e, 0x6c, 0xab, 0xbf, 0x31, 0xcc, 0xd0, 0x70, 0x5d, 0x4f, 0xc0, 0xb1, 0xd4, 0xbb, + 0x2e, 0xf8, 0x62, 0xc9, 0x3e, 0x53, 0x2f, 0xd1, 0xea, 0x2f, 0x1d, 0x60, 0x44, 0x38, 0xf7, 0x2f, + 0x2b, 0xe1, 0x65, 0x35, 0x6e, 0xf9, 0xe0, 0xcb, 0x25, 0xe8, 0x32, 0x0d, 0x69, 0xfd, 0x95, 0x03, + 0x8e, 0x4a, 0x31, 0x27, 0xfb, 0x65, 0x18, 0x2c, 0x53, 0xec, 0xfc, 0xc7, 0x6b, 0xc5, 0xcc, 0x29, + 0x7e, 0x88, 0xa6, 0x8e, 0xc0, 0x5f, 0x8f, 0x1e, 0xff, 0xa5, 0xde, 0x76, 0xc1, 0xd7, 0x0e, 0x86, + 0x3a, 0x22, 0xd3, 0xeb, 0x07, 0x1f, 0x18, 0xae, 0xe8, 0x1b, 0x2c, 0xec, 0x90, 0xac, 0x6b, 0x83, + 0x99, 0x29, 0x5d, 0x5a, 0x8f, 0x9e, 0x04, 0x8d, 0x24, 0x66, 0xf0, 0x11, 0x19, 0xd2, 0x1a, 0xbd, + 0x0c, 0x2b, 0x95, 0xd6, 0xd4, 0x5b, 0xb5, 0x52, 0x69, 0x4d, 0x3f, 0x3b, 0x8b, 0x4b, 0x6b, 0xfc, + 0xf9, 0x56, 0xa9, 0xb4, 0x66, 0x3e, 0x11, 0x2b, 0x95, 0xd6, 0xec, 0x37, 0x62, 0xea, 0x08, 0xfc, + 0x96, 0x02, 0x4e, 0x64, 0x3f, 0xc4, 0x82, 0xaf, 0x0c, 0xb4, 0xb1, 0xe4, 0x2b, 0xa5, 0xfa, 0xab, + 0x07, 0x1d, 0x16, 0xae, 0xe5, 0x0f, 0x94, 0x84, 0x73, 0x93, 0x5c, 0xd1, 0x9b, 0x03, 0xe9, 0x64, + 0xce, 0xba, 0x6e, 0x0c, 0x37, 0x38, 0xa5, 0x3f, 0x59, 0x4f, 0x65, 0x8a, 0xf5, 0xa7, 0xe0, 0xd5, + 0x53, 0xb1, 0xfe, 0x14, 0xbd, 0xca, 0x91, 0x4e, 0xa5, 0x8c, 0x07, 0x2a, 0xc5, 0xa7, 0x52, 0xfe, + 0x8b, 0x98, 0xe2, 0x53, 0xa9, 0xe0, 0x25, 0x8c, 0x3a, 0x02, 0xff, 0x58, 0x7e, 0x2f, 0x93, 0xfd, + 0x72, 0x04, 0xbe, 0x55, 0x8a, 0xbe, 0xf0, 0xe9, 0x4a, 0xfd, 0xed, 0xa1, 0xc7, 0x87, 0xcb, 0x7c, + 0x04, 0xe6, 0x93, 0xf5, 0xf3, 0x70, 0xb5, 0x44, 0x36, 0x92, 0x0f, 0x05, 0xea, 0x2f, 0x0e, 0x3e, + 0x20, 0x9c, 0xf8, 0x17, 0x14, 0x66, 0xef, 0x92, 0x15, 0xea, 0xf0, 0xda, 0xc1, 0xea, 0xd9, 0xd9, + 0x0a, 0x5e, 0x1e, 0xa6, 0x08, 0x3e, 0xb1, 0x0a, 0xb9, 0xcc, 0xbb, 0x7c, 0x15, 0x19, 0x35, 0xec, + 0xe5, 0xab, 0xc8, 0xaa, 0x24, 0x97, 0x94, 0x29, 0xab, 0xa6, 0xb9, 0x58, 0x99, 0x0a, 0x6a, 0xc1, + 0x8b, 0x95, 0xa9, 0xa8, 0x7c, 0x5a, 0x1d, 0x81, 0x7f, 0xaa, 0x44, 0x91, 0x8f, 0xfc, 0x3a, 0x66, + 0x58, 0x5a, 0x3a, 0x5f, 0x5a, 0x46, 0x5d, 0x5f, 0x3f, 0x0c, 0x8a, 0x70, 0xbd, 0x7f, 0xa2, 0x14, + 0x14, 0xd8, 0xf2, 0x82, 0x64, 0xf8, 0x76, 0x99, 0x98, 0x96, 0x54, 0x43, 0xd7, 0x6f, 0x0d, 0x8f, + 0x20, 0xeb, 0x8a, 0x94, 0x2e, 0x16, 0x2e, 0xbd, 0x22, 0xe5, 0x96, 0x38, 0x97, 0x5e, 0x91, 0xf2, + 0x2b, 0x9c, 0xe3, 0x8b, 0x4a, 0xef, 0xa1, 0x74, 0x51, 0xb9, 0x25, 0xcd, 0xa5, 0x8b, 0xca, 0x2f, + 0x5a, 0xce, 0xd6, 0x4d, 0x5a, 0x16, 0x3b, 0xb0, 0x6e, 0xca, 0x65, 0xca, 0x03, 0xeb, 0x66, 0xac, + 0xdc, 0x58, 0x1d, 0x81, 0xdf, 0x49, 0xc5, 0x7c, 0x13, 0xc5, 0xb9, 0xf0, 0xc6, 0x41, 0x30, 0x27, + 0xcb, 0x8c, 0xeb, 0x37, 0x87, 0x1c, 0x9d, 0xa9, 0xaa, 0xf9, 0x35, 0xb3, 0x70, 0xf0, 0x57, 0x2e, + 0x79, 0xe5, 0xc0, 0xe5, 0xaa, 0x5a, 0x5e, 0xb2, 0x9b, 0xb8, 0xff, 0x96, 0x95, 0x99, 0x95, 0xdf, + 0x7f, 0x07, 0x2c, 0x78, 0x2b, 0xbf, 0xff, 0x0e, 0x5a, 0xf1, 0xa6, 0x8e, 0xc0, 0x3f, 0x57, 0xa2, + 0x88, 0x6e, 0x41, 0x91, 0x19, 0x5c, 0x1f, 0x6a, 0xce, 0xb8, 0x78, 0x6c, 0x1c, 0x0a, 0x47, 0x66, + 0xcc, 0x28, 0xab, 0x2c, 0xb9, 0xf4, 0xa6, 0x9b, 0x5f, 0x1e, 0x5d, 0x1e, 0x33, 0x2a, 0xa8, 0xd5, + 0x55, 0x47, 0xe0, 0x0f, 0x94, 0x28, 0x8e, 0x5f, 0x58, 0xfd, 0x0a, 0x6f, 0x97, 0x4d, 0x34, 0x48, + 0x91, 0x6e, 0x7d, 0xf3, 0x90, 0x58, 0x52, 0xb7, 0x96, 0x74, 0x75, 0x6b, 0xa9, 0xad, 0xc9, 0xaa, + 0xac, 0x2d, 0xbe, 0xb5, 0xe4, 0x16, 0x90, 0x26, 0x0c, 0x65, 0xac, 0x68, 0xb0, 0xd4, 0x50, 0x66, + 0x94, 0x2b, 0x96, 0x1b, 0xca, 0xac, 0xa2, 0x3e, 0x75, 0x04, 0x3a, 0x60, 0x26, 0x56, 0x51, 0x07, + 0x5f, 0x28, 0x31, 0xfe, 0xb1, 0xda, 0xbd, 0xfa, 0xf2, 0x80, 0xd0, 0x59, 0xf3, 0xb1, 0x5a, 0x9e, + 0xd2, 0xf9, 0xe4, 0x6c, 0x7e, 0xf9, 0x7c, 0xb1, 0x1c, 0x7f, 0xec, 0x82, 0x1c, 0xe5, 0xce, 0x4b, + 0x2f, 0xc8, 0xa9, 0xc4, 0x7e, 0xfd, 0xa5, 0x03, 0x8c, 0x08, 0xe7, 0xfe, 0xa6, 0xc2, 0x22, 0xd1, + 0x89, 0x74, 0x37, 0xbc, 0x3a, 0x88, 0xe3, 0x1d, 0xcf, 0xc5, 0xd7, 0xaf, 0x1d, 0x68, 0x4c, 0xd6, + 0xd5, 0x38, 0x91, 0x9e, 0x2e, 0xbd, 0x1a, 0x67, 0x67, 0xd1, 0xeb, 0xaf, 0x1e, 0x74, 0x58, 0x6a, + 0x2d, 0xe9, 0x4c, 0x25, 0x7c, 0x65, 0xb0, 0x33, 0x2a, 0x91, 0xb7, 0x2d, 0x5e, 0x4b, 0x7e, 0x42, + 0x34, 0xe1, 0x1f, 0x64, 0xa6, 0x21, 0xcb, 0xfd, 0x83, 0xa2, 0x74, 0x68, 0xb9, 0x7f, 0x50, 0x98, + 0xfb, 0x4c, 0x98, 0xfe, 0x8c, 0xfc, 0x63, 0xb9, 0xe9, 0xcf, 0xcf, 0x7c, 0x96, 0x9b, 0xfe, 0x82, + 0x84, 0xa7, 0x24, 0xd6, 0x89, 0xdc, 0x60, 0xb1, 0x58, 0x67, 0x67, 0x32, 0xeb, 0xd7, 0x86, 0x48, + 0x3e, 0xaa, 0x23, 0xf0, 0xbb, 0x4a, 0x58, 0x75, 0x91, 0x93, 0xd3, 0x83, 0x37, 0x4b, 0x2d, 0x53, + 0x51, 0x26, 0xb1, 0xfe, 0xd6, 0xb0, 0xc3, 0x53, 0x6b, 0xcc, 0x4f, 0xdf, 0x15, 0xaf, 0xb1, 0x34, + 0xdf, 0x58, 0xbc, 0xc6, 0xf2, 0xac, 0x61, 0x46, 0xf8, 0x90, 0xfe, 0x01, 0xa0, 0xc1, 0xc2, 0x87, + 0x52, 0xae, 0x70, 0xc0, 0xf0, 0xa1, 0x9c, 0x24, 0x94, 0x62, 0xcc, 0xd9, 0xd5, 0xd2, 0xc5, 0x31, + 0xe6, 0xc2, 0xe2, 0xec, 0xe2, 0x18, 0x73, 0x71, 0x71, 0xb6, 0x14, 0xc1, 0xcb, 0xab, 0xfe, 0x2d, + 0x8e, 0xe0, 0x95, 0x14, 0x1c, 0x17, 0x47, 0xf0, 0xca, 0x0a, 0x8e, 0xd5, 0x91, 0x75, 0xe3, 0xd3, + 0x2f, 0x16, 0x95, 0xcf, 0xbe, 0x58, 0x54, 0x7e, 0xf2, 0xc5, 0xa2, 0xf2, 0x1b, 0x5f, 0x2e, 0x8e, + 0x7c, 0xf6, 0xe5, 0xe2, 0xc8, 0xbf, 0x7e, 0xb9, 0x38, 0xf2, 0xd1, 0x96, 0x54, 0x5d, 0xdb, 0x74, + 0x9a, 0xcb, 0xb4, 0xac, 0x70, 0x35, 0x8a, 0x29, 0x2f, 0xf3, 0x98, 0xf2, 0xb2, 0x28, 0x99, 0x5d, + 0xcd, 0xfe, 0x2b, 0xff, 0xcd, 0x71, 0xfa, 0x47, 0xe0, 0xaf, 0xfd, 0x77, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x0d, 0xa0, 0x68, 0x62, 0x06, 0x60, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -7345,6 +7460,7 @@ type GfSpMetadataServiceClient interface { GfSpListGlobalVirtualGroupsBySecondarySP(ctx context.Context, in *GfSpListGlobalVirtualGroupsBySecondarySPRequest, opts ...grpc.CallOption) (*GfSpListGlobalVirtualGroupsBySecondarySPResponse, error) GfSpListGlobalVirtualGroupsByBucket(ctx context.Context, in *GfSpListGlobalVirtualGroupsByBucketRequest, opts ...grpc.CallOption) (*GfSpListGlobalVirtualGroupsByBucketResponse, error) GfSpListMigrateBucketEvents(ctx context.Context, in *GfSpListMigrateBucketEventsRequest, opts ...grpc.CallOption) (*GfSpListMigrateBucketEventsResponse, error) + GfSpListCompleteMigrationBucketEvents(ctx context.Context, in *GfSpListCompleteMigrationBucketEventsRequest, opts ...grpc.CallOption) (*GfSpListCompleteMigrationBucketEventsResponse, error) GfSpListSwapOutEvents(ctx context.Context, in *GfSpListSwapOutEventsRequest, opts ...grpc.CallOption) (*GfSpListSwapOutEventsResponse, error) GfSpListSpExitEvents(ctx context.Context, in *GfSpListSpExitEventsRequest, opts ...grpc.CallOption) (*GfSpListSpExitEventsResponse, error) GfSpGetSPInfo(ctx context.Context, in *GfSpGetSPInfoRequest, opts ...grpc.CallOption) (*GfSpGetSPInfoResponse, error) @@ -7668,6 +7784,15 @@ func (c *gfSpMetadataServiceClient) GfSpListMigrateBucketEvents(ctx context.Cont return out, nil } +func (c *gfSpMetadataServiceClient) GfSpListCompleteMigrationBucketEvents(ctx context.Context, in *GfSpListCompleteMigrationBucketEventsRequest, opts ...grpc.CallOption) (*GfSpListCompleteMigrationBucketEventsResponse, error) { + out := new(GfSpListCompleteMigrationBucketEventsResponse) + err := c.cc.Invoke(ctx, "/modular.metadata.types.GfSpMetadataService/GfSpListCompleteMigrationBucketEvents", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *gfSpMetadataServiceClient) GfSpListSwapOutEvents(ctx context.Context, in *GfSpListSwapOutEventsRequest, opts ...grpc.CallOption) (*GfSpListSwapOutEventsResponse, error) { out := new(GfSpListSwapOutEventsResponse) err := c.cc.Invoke(ctx, "/modular.metadata.types.GfSpMetadataService/GfSpListSwapOutEvents", in, out, opts...) @@ -7847,6 +7972,7 @@ type GfSpMetadataServiceServer interface { GfSpListGlobalVirtualGroupsBySecondarySP(context.Context, *GfSpListGlobalVirtualGroupsBySecondarySPRequest) (*GfSpListGlobalVirtualGroupsBySecondarySPResponse, error) GfSpListGlobalVirtualGroupsByBucket(context.Context, *GfSpListGlobalVirtualGroupsByBucketRequest) (*GfSpListGlobalVirtualGroupsByBucketResponse, error) GfSpListMigrateBucketEvents(context.Context, *GfSpListMigrateBucketEventsRequest) (*GfSpListMigrateBucketEventsResponse, error) + GfSpListCompleteMigrationBucketEvents(context.Context, *GfSpListCompleteMigrationBucketEventsRequest) (*GfSpListCompleteMigrationBucketEventsResponse, error) GfSpListSwapOutEvents(context.Context, *GfSpListSwapOutEventsRequest) (*GfSpListSwapOutEventsResponse, error) GfSpListSpExitEvents(context.Context, *GfSpListSpExitEventsRequest) (*GfSpListSpExitEventsResponse, error) GfSpGetSPInfo(context.Context, *GfSpGetSPInfoRequest) (*GfSpGetSPInfoResponse, error) @@ -7968,6 +8094,9 @@ func (*UnimplementedGfSpMetadataServiceServer) GfSpListGlobalVirtualGroupsByBuck func (*UnimplementedGfSpMetadataServiceServer) GfSpListMigrateBucketEvents(ctx context.Context, req *GfSpListMigrateBucketEventsRequest) (*GfSpListMigrateBucketEventsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GfSpListMigrateBucketEvents not implemented") } +func (*UnimplementedGfSpMetadataServiceServer) GfSpListCompleteMigrationBucketEvents(ctx context.Context, req *GfSpListCompleteMigrationBucketEventsRequest) (*GfSpListCompleteMigrationBucketEventsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GfSpListCompleteMigrationBucketEvents not implemented") +} func (*UnimplementedGfSpMetadataServiceServer) GfSpListSwapOutEvents(ctx context.Context, req *GfSpListSwapOutEventsRequest) (*GfSpListSwapOutEventsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GfSpListSwapOutEvents not implemented") } @@ -8615,6 +8744,24 @@ func _GfSpMetadataService_GfSpListMigrateBucketEvents_Handler(srv interface{}, c return interceptor(ctx, in, info, handler) } +func _GfSpMetadataService_GfSpListCompleteMigrationBucketEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GfSpListCompleteMigrationBucketEventsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GfSpMetadataServiceServer).GfSpListCompleteMigrationBucketEvents(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/modular.metadata.types.GfSpMetadataService/GfSpListCompleteMigrationBucketEvents", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GfSpMetadataServiceServer).GfSpListCompleteMigrationBucketEvents(ctx, req.(*GfSpListCompleteMigrationBucketEventsRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _GfSpMetadataService_GfSpListSwapOutEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GfSpListSwapOutEventsRequest) if err := dec(in); err != nil { @@ -9039,6 +9186,10 @@ var _GfSpMetadataService_serviceDesc = grpc.ServiceDesc{ MethodName: "GfSpListMigrateBucketEvents", Handler: _GfSpMetadataService_GfSpListMigrateBucketEvents_Handler, }, + { + MethodName: "GfSpListCompleteMigrationBucketEvents", + Handler: _GfSpMetadataService_GfSpListCompleteMigrationBucketEvents_Handler, + }, { MethodName: "GfSpListSwapOutEvents", Handler: _GfSpMetadataService_GfSpListSwapOutEvents_Handler, @@ -12221,6 +12372,76 @@ func (m *GfSpListMigrateBucketEventsResponse) MarshalToSizedBuffer(dAtA []byte) return len(dAtA) - i, nil } +func (m *GfSpListCompleteMigrationBucketEventsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GfSpListCompleteMigrationBucketEventsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpListCompleteMigrationBucketEventsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SrcSpId != 0 { + i = encodeVarintMetadata(dAtA, i, uint64(m.SrcSpId)) + i-- + dAtA[i] = 0x10 + } + if m.BlockId != 0 { + i = encodeVarintMetadata(dAtA, i, uint64(m.BlockId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GfSpListCompleteMigrationBucketEventsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GfSpListCompleteMigrationBucketEventsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpListCompleteMigrationBucketEventsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.CompleteEvents) > 0 { + for iNdEx := len(m.CompleteEvents) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.CompleteEvents[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintMetadata(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func (m *GfSpListSwapOutEventsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -15389,6 +15610,36 @@ func (m *GfSpListMigrateBucketEventsResponse) Size() (n int) { return n } +func (m *GfSpListCompleteMigrationBucketEventsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockId != 0 { + n += 1 + sovMetadata(uint64(m.BlockId)) + } + if m.SrcSpId != 0 { + n += 1 + sovMetadata(uint64(m.SrcSpId)) + } + return n +} + +func (m *GfSpListCompleteMigrationBucketEventsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.CompleteEvents) > 0 { + for _, e := range m.CompleteEvents { + l = e.Size() + n += 1 + l + sovMetadata(uint64(l)) + } + } + return n +} + func (m *GfSpListSwapOutEventsRequest) Size() (n int) { if m == nil { return 0 @@ -24896,6 +25147,178 @@ func (m *GfSpListMigrateBucketEventsResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *GfSpListCompleteMigrationBucketEventsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMetadata + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GfSpListCompleteMigrationBucketEventsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GfSpListCompleteMigrationBucketEventsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType) + } + m.BlockId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMetadata + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SrcSpId", wireType) + } + m.SrcSpId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMetadata + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SrcSpId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipMetadata(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthMetadata + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GfSpListCompleteMigrationBucketEventsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMetadata + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GfSpListCompleteMigrationBucketEventsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GfSpListCompleteMigrationBucketEventsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CompleteEvents", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMetadata + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMetadata + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthMetadata + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CompleteEvents = append(m.CompleteEvents, &types.EventCompleteMigrationBucket{}) + if err := m.CompleteEvents[len(m.CompleteEvents)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMetadata(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthMetadata + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *GfSpListSwapOutEventsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/proto/base/types/gfspserver/manage.proto b/proto/base/types/gfspserver/manage.proto index ea6924f71..7163da111 100644 --- a/proto/base/types/gfspserver/manage.proto +++ b/proto/base/types/gfspserver/manage.proto @@ -84,6 +84,7 @@ message GfSpNotifyPreMigrateBucketRequest { message GfSpNotifyPreMigrateBucketResponse { base.types.gfsperrors.GfSpError err = 1; + base.types.gfsptask.GfSpBucketQuotaInfo quota = 2; } message GfSpNotifyPostMigrateBucketRequest { @@ -94,6 +95,7 @@ message GfSpNotifyPostMigrateBucketRequest { message GfSpNotifyPostMigrateBucketResponse { base.types.gfsperrors.GfSpError err = 1; + base.types.gfsptask.GfSpBucketQuotaInfo quota = 2; } message GfSpQueryTasksStatsRequest {} @@ -113,6 +115,31 @@ message TasksStats { repeated string recovery_failed_list = 8; } +message GfSpQueryBucketMigrationProgressRequest { + uint64 bucket_id = 1; +} + +message GfSpQueryBucketMigrationProgressResponse { + MigrateBucketProgressMeta progress = 1; +} + +message MigrateBucketProgressMeta { + uint64 bucket_id = 1; + uint64 subscribed_block_height = 2; + uint32 migrate_state = 3; + + uint32 total_gvg_num = 4; // Total number of GVGs that need to be migrated + uint32 migrated_finished_gvg_num = 5; // Number of successfully migrated GVGs + uint32 gc_finished_gvg_num = 6; // Number of successfully gc finished GVGs + + uint64 pre_deducted_quota = 7; // Quota pre-deducted by the source sp in the pre-migrate bucket phase + uint64 recoup_quota = 8; // In case of migration failure, the dest sp recoup the quota for the source sp + + uint64 last_gc_object_id = 9; // After bucket migration is complete, the progress of GC, up to which object is GC performed. + uint64 last_gc_gvg_id = 10; // which GVG is GC performed. + uint64 migrated_bytes = 11; +} + message GfSpResetRecoveryFailedListRequest {} message GfSpResetRecoveryFailedListResponse { @@ -126,7 +153,8 @@ service GfSpManageService { rpc GfSpPickVirtualGroupFamily(GfSpPickVirtualGroupFamilyRequest) returns (GfSpPickVirtualGroupFamilyResponse) {} rpc GfSpNotifyMigrateSwapOut(GfSpNotifyMigrateSwapOutRequest) returns (GfSpNotifyMigrateSwapOutResponse) {} rpc GfSpQueryTasksStats(GfSpQueryTasksStatsRequest) returns (GfSpQueryTasksStatsResponse) {} - rpc GfSpNotifyPreMigrate(GfSpNotifyPreMigrateBucketRequest) returns (GfSpNotifyPreMigrateBucketResponse) {} - rpc GfSpNotifyPostMigrate(GfSpNotifyPostMigrateBucketRequest) returns (GfSpNotifyPostMigrateBucketResponse) {} + rpc GfSpQueryBucketMigrationProgress(GfSpQueryBucketMigrationProgressRequest) returns (GfSpQueryBucketMigrationProgressResponse) {} + rpc GfSpNotifyPreMigrateBucketAndDeductQuota(GfSpNotifyPreMigrateBucketRequest) returns (GfSpNotifyPreMigrateBucketResponse) {} + rpc GfSpNotifyPostMigrateAndRecoupQuota(GfSpNotifyPostMigrateBucketRequest) returns (GfSpNotifyPostMigrateBucketResponse) {} rpc GfSpResetRecoveryFailedList(GfSpResetRecoveryFailedListRequest) returns (GfSpResetRecoveryFailedListResponse) {} } diff --git a/proto/base/types/gfspserver/query_task.proto b/proto/base/types/gfspserver/query_task.proto index 172752ffd..215995973 100644 --- a/proto/base/types/gfspserver/query_task.proto +++ b/proto/base/types/gfspserver/query_task.proto @@ -21,6 +21,8 @@ message GfSpBucketMigrate { uint64 bucket_id = 2; uint32 finished = 3; repeated GfSpMigrateGVG gvg_task = 4; + uint32 state = 5; + uint64 migrated_bytes_size = 6; } message GfSpMigrateGVG { diff --git a/proto/base/types/gfsptask/task.proto b/proto/base/types/gfsptask/task.proto index b861fc236..d90bb7b27 100644 --- a/proto/base/types/gfsptask/task.proto +++ b/proto/base/types/gfsptask/task.proto @@ -201,6 +201,12 @@ message GfSpMigratePieceTask { message GfSpGCBucketMigrationTask { GfSpTask task = 1; uint64 bucket_id = 2; + uint64 last_gc_object_id = 3; + uint64 last_gc_gvg_id = 4; + // whether the gc of bucket migration succeed + bool finished = 5; + uint64 total_gvg_num = 6; // the bucket migration gc total gvg num + uint64 gc_finished_gvg_num = 7; // gc has finished gvg num } message GfSpBucketMigrationInfo { diff --git a/proto/modular/metadata/types/metadata.proto b/proto/modular/metadata/types/metadata.proto index 12c41b164..a6bd487c4 100644 --- a/proto/modular/metadata/types/metadata.proto +++ b/proto/modular/metadata/types/metadata.proto @@ -665,6 +665,20 @@ message GfSpListMigrateBucketEventsResponse { repeated ListMigrateBucketEvents events = 1; } +// GfSpListCompleteMigrationBucketEventsRequest is request type for the GfSpListCompleteMigrationBucketEvents RPC method +message GfSpListCompleteMigrationBucketEventsRequest { + // block_id is the unique identification for block + uint64 block_id = 1; + // src_sp_id is the unique identification for sp + uint32 src_sp_id = 2; +} + +// GfSpListCompleteMigrationBucketEventsResponse is response type for the GfSpListCompleteMigrationBucketEvents RPC method +message GfSpListCompleteMigrationBucketEventsResponse { + // complete_event defines the complete migration bucket event + repeated greenfield.storage.EventCompleteMigrationBucket complete_events = 1; +} + // GfSpListSwapOutEventsRequest is request type for the GfSpListSwapOutEvents RPC method message GfSpListSwapOutEventsRequest { // block_id is the unique identification for block @@ -1044,6 +1058,7 @@ service GfSpMetadataService { rpc GfSpListGlobalVirtualGroupsBySecondarySP(GfSpListGlobalVirtualGroupsBySecondarySPRequest) returns (GfSpListGlobalVirtualGroupsBySecondarySPResponse) {} rpc GfSpListGlobalVirtualGroupsByBucket(GfSpListGlobalVirtualGroupsByBucketRequest) returns (GfSpListGlobalVirtualGroupsByBucketResponse) {} rpc GfSpListMigrateBucketEvents(GfSpListMigrateBucketEventsRequest) returns (GfSpListMigrateBucketEventsResponse) {} + rpc GfSpListCompleteMigrationBucketEvents(GfSpListCompleteMigrationBucketEventsRequest) returns (GfSpListCompleteMigrationBucketEventsResponse) {} rpc GfSpListSwapOutEvents(GfSpListSwapOutEventsRequest) returns (GfSpListSwapOutEventsResponse) {} rpc GfSpListSpExitEvents(GfSpListSpExitEventsRequest) returns (GfSpListSpExitEventsResponse) {} rpc GfSpGetSPInfo(GfSpGetSPInfoRequest) returns (GfSpGetSPInfoResponse) {} diff --git a/proto/store/types/store.proto b/proto/store/types/store.proto index 6718373f6..34183da0f 100644 --- a/proto/store/types/store.proto +++ b/proto/store/types/store.proto @@ -28,3 +28,30 @@ enum TaskState { TASK_STATE_OBJECT_DISCONTINUED = 16; } + +enum BucketMigrationState { + BUCKET_MIGRATION_STATE_INIT_UNSPECIFIED = 0; + + // produced execute plan and pre deduct quota + BUCKET_MIGRATION_STATE_SRC_SP_PRE_DEDUCT_QUOTA_DONE = 1; + BUCKET_MIGRATION_STATE_DEST_SP_PRE_DEDUCT_QUOTA_DONE = 2; + + // migrating gvg task + BUCKET_MIGRATION_STATE_MIGRATE_GVG_DOING = 5; + BUCKET_MIGRATION_STATE_MIGRATE_GVG_DONE = 6; + BUCKET_MIGRATION_STATE_MIGRATE_QUOTA_INFO_DONE = 7; + + // confirm tx + BUCKET_MIGRATION_STATE_SEND_COMPLETE_TX_DONE = 10; + BUCKET_MIGRATION_STATE_WAIT_COMPLETE_TX_EVENT_DONE = 11; + BUCKET_MIGRATION_STATE_SEND_REJECT_TX_DONE = 12; + BUCKET_MIGRATION_STATE_WAIT_REJECT_TX_EVENT_DONE = 13; + BUCKET_MIGRATION_STATE_WAIT_CANCEL_TX_EVENT_DONE = 14; + + // gc + BUCKET_MIGRATION_STATE_SRC_SP_GC_DOING = 20; + BUCKET_MIGRATION_STATE_DEST_SP_GC_DOING = 21; + + BUCKET_MIGRATION_STATE_POST_SRC_SP_DONE = 30; + BUCKET_MIGRATION_STATE_MIGRATION_FINISHED = 31; +} diff --git a/store/bsdb/database.go b/store/bsdb/database.go index 95f6eac85..a64559eec 100644 --- a/store/bsdb/database.go +++ b/store/bsdb/database.go @@ -91,6 +91,8 @@ type Metadata interface { GetLvgByBucketAndLvgID(bucketID common.Hash, lvgID uint32) (*LocalVirtualGroup, error) // ListMigrateBucketEvents list migrate bucket events ListMigrateBucketEvents(spID uint32, filters ...func(*gorm.DB) *gorm.DB) ([]*EventMigrationBucket, []*EventCompleteMigrationBucket, []*EventCancelMigrationBucket, []*EventRejectMigrateBucket, error) + // ListCompleteMigrationBucket list complete migrate bucket events + ListCompleteMigrationBucket(srcSpID uint32, filters ...func(*gorm.DB) *gorm.DB) ([]*EventCompleteMigrationBucket, error) // GetMigrateBucketEventByBucketID get migrate bucket event by bucket id GetMigrateBucketEventByBucketID(bucketID common.Hash) (*EventCompleteMigrationBucket, error) // ListSwapOutEvents list swap out events diff --git a/store/bsdb/database_mock.go b/store/bsdb/database_mock.go index 09430dd9f..23011965f 100644 --- a/store/bsdb/database_mock.go +++ b/store/bsdb/database_mock.go @@ -1,6 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: store/bsdb/database.go - +// +// Generated by this command: +// +// mockgen -source=store/bsdb/database.go -destination=store/bsdb/database_mock.go -package=bsdb +// // Package bsdb is a generated GoMock package. package bsdb @@ -651,6 +655,26 @@ func (mr *MockMetadataMockRecorder) ListBucketsByVgfID(vgfIDs, startAfter, limit return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsByVgfID", reflect.TypeOf((*MockMetadata)(nil).ListBucketsByVgfID), vgfIDs, startAfter, limit) } +// ListCompleteMigrationBucket mocks base method. +func (m *MockMetadata) ListCompleteMigrationBucket(srcSpID uint32, filters ...func(*gorm.DB) *gorm.DB) ([]*EventCompleteMigrationBucket, error) { + m.ctrl.T.Helper() + varargs := []interface{}{srcSpID} + for _, a := range filters { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListCompleteMigrationBucket", varargs...) + ret0, _ := ret[0].([]*EventCompleteMigrationBucket) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCompleteMigrationBucket indicates an expected call of ListCompleteMigrationBucket. +func (mr *MockMetadataMockRecorder) ListCompleteMigrationBucket(srcSpID interface{}, filters ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{srcSpID}, filters...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompleteMigrationBucket", reflect.TypeOf((*MockMetadata)(nil).ListCompleteMigrationBucket), varargs...) +} + // ListDeletedObjectsByBlockNumberRange mocks base method. func (m *MockMetadata) ListDeletedObjectsByBlockNumberRange(startBlockNumber, endBlockNumber int64, includePrivate bool) ([]*Object, error) { m.ctrl.T.Helper() @@ -1669,6 +1693,26 @@ func (mr *MockBSDBMockRecorder) ListBucketsByVgfID(vgfIDs, startAfter, limit int return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsByVgfID", reflect.TypeOf((*MockBSDB)(nil).ListBucketsByVgfID), vgfIDs, startAfter, limit) } +// ListCompleteMigrationBucket mocks base method. +func (m *MockBSDB) ListCompleteMigrationBucket(srcSpID uint32, filters ...func(*gorm.DB) *gorm.DB) ([]*EventCompleteMigrationBucket, error) { + m.ctrl.T.Helper() + varargs := []interface{}{srcSpID} + for _, a := range filters { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListCompleteMigrationBucket", varargs...) + ret0, _ := ret[0].([]*EventCompleteMigrationBucket) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCompleteMigrationBucket indicates an expected call of ListCompleteMigrationBucket. +func (mr *MockBSDBMockRecorder) ListCompleteMigrationBucket(srcSpID interface{}, filters ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{srcSpID}, filters...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompleteMigrationBucket", reflect.TypeOf((*MockBSDB)(nil).ListCompleteMigrationBucket), varargs...) +} + // ListDeletedObjectsByBlockNumberRange mocks base method. func (m *MockBSDB) ListDeletedObjectsByBlockNumberRange(startBlockNumber, endBlockNumber int64, includePrivate bool) ([]*Object, error) { m.ctrl.T.Helper() diff --git a/store/bsdb/event_migration_bucket.go b/store/bsdb/event_migration_bucket.go index 02acf8a54..5d3385b01 100644 --- a/store/bsdb/event_migration_bucket.go +++ b/store/bsdb/event_migration_bucket.go @@ -63,6 +63,34 @@ func (b *BsDBImpl) ListMigrateBucketEvents(spID uint32, filters ...func(*gorm.DB return events, completeEvents, cancelEvents, rejectEvents, err } +// ListCompleteMigrationBucket list migrate bucket events +func (b *BsDBImpl) ListCompleteMigrationBucket(srcSpID uint32, filters ...func(*gorm.DB) *gorm.DB) ([]*EventCompleteMigrationBucket, error) { + var ( + completeEvents []*EventCompleteMigrationBucket + err error + ) + startTime := time.Now() + methodName := currentFunction() + defer func() { + if err != nil { + MetadataDatabaseFailureMetrics(err, startTime, methodName) + } else { + MetadataDatabaseSuccessMetrics(startTime, methodName) + } + }() + + err = b.db.Table((&EventCompleteMigrationBucket{}).TableName()). + Select("*"). + Where("src_primary_sp_id = ?", srcSpID). + Scopes(filters...). + Find(&completeEvents).Error + if err != nil { + return nil, err + } + + return completeEvents, err +} + // GetMigrateBucketEventByBucketID get migrate bucket event by bucket id func (b *BsDBImpl) GetMigrateBucketEventByBucketID(bucketID common.Hash) (*EventCompleteMigrationBucket, error) { var ( diff --git a/store/bsdb/filters.go b/store/bsdb/filters.go index 7eb238ccc..17322b48b 100644 --- a/store/bsdb/filters.go +++ b/store/bsdb/filters.go @@ -80,6 +80,12 @@ func CreateAtFilter(createAt int64) func(db *gorm.DB) *gorm.DB { } } +func CreateAtEqualFilter(createAt int64) func(db *gorm.DB) *gorm.DB { + return func(db *gorm.DB) *gorm.DB { + return db.Where("create_at = ?", createAt) + } +} + func WithLimit(limit int) func(*gorm.DB) *gorm.DB { return func(db *gorm.DB) *gorm.DB { return db.Limit(limit) diff --git a/store/sqldb/const.go b/store/sqldb/const.go index aecbe2a5c..d19a23a43 100644 --- a/store/sqldb/const.go +++ b/store/sqldb/const.go @@ -44,6 +44,8 @@ const ( SwapOutTableName = "swap_out_unit" // MigrateGVGTableName defines the progress of subscribe migrate event. MigrateGVGTableName = "migrate_gvg" + // MigrateBucketProgressTableName defines the progress of migrate bucket. + MigrateBucketProgressTableName = "migrate_bucket_progress" ) // define error name constant. diff --git a/store/sqldb/migrate.go b/store/sqldb/migrate.go index e00dc9574..54ba56dc1 100644 --- a/store/sqldb/migrate.go +++ b/store/sqldb/migrate.go @@ -9,14 +9,16 @@ import ( "gorm.io/gorm" "github.com/bnb-chain/greenfield-storage-provider/core/spdb" + "github.com/bnb-chain/greenfield-storage-provider/store/types" "github.com/bnb-chain/greenfield-storage-provider/util" virtualgrouptypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" ) const ( - SPExitProgressKey = "sp_exit_progress" - SwapOutProgressKey = "swap_out_progress" - BucketMigrateProgressKey = "bucket_migrate_progress" + SPExitProgressKey = "sp_exit_progress" + SwapOutProgressKey = "swap_out_progress" + BucketMigrateProgressKey = "bucket_migrate_progress" + BucketMigrateGCProgressKey = "bucket_migrate_gc_progress" ) // UpdateSPExitSubscribeProgress is used to update progress. @@ -158,6 +160,41 @@ func (s *SpDBImpl) UpdateBucketMigrateSubscribeProgress(blockHeight uint64) erro return nil } +func (s *SpDBImpl) UpdateBucketMigrateGCSubscribeProgress(blockHeight uint64) error { + var ( + result *gorm.DB + queryReturn *MigrateSubscribeProgressTable + updateRecord *MigrateSubscribeProgressTable + needInsert = false + ) + queryReturn = &MigrateSubscribeProgressTable{} + result = s.db.First(queryReturn, "event_name = ?", BucketMigrateGCProgressKey) + if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) { + return result.Error + } + if result.Error != nil { + needInsert = errors.Is(result.Error, gorm.ErrRecordNotFound) + } + updateRecord = &MigrateSubscribeProgressTable{ + EventName: BucketMigrateGCProgressKey, + LastSubscribedBlockHeight: blockHeight, + } + + if needInsert { + result = s.db.Create(updateRecord) + if result.Error != nil || result.RowsAffected != 1 { + return fmt.Errorf("failed to insert record in subscribe progress table: %s", result.Error) + } + } else { // update + result = s.db.Model(&MigrateSubscribeProgressTable{}). + Where("event_name = ?", BucketMigrateGCProgressKey).Updates(updateRecord) + if result.Error != nil { + return fmt.Errorf("failed to update record in subscribe progress table: %s", result.Error) + } + } + return nil +} + func (s *SpDBImpl) QueryBucketMigrateSubscribeProgress() (uint64, error) { var ( result *gorm.DB @@ -363,6 +400,15 @@ func (s *SpDBImpl) UpdateMigrateGVGRetryCount(migrateKey string, retryTime int) return nil } +func (s *SpDBImpl) UpdateMigrateGVGMigratedBytesSize(migrateKey string, migrateBytes uint64) error { + if result := s.db.Model(&MigrateGVGTable{}).Where("migrate_key = ?", migrateKey).Updates(&MigrateGVGTable{ + MigratedBytesSize: migrateBytes, + }); result.Error != nil { + return fmt.Errorf("failed to update migrate gvg migrated bytes size: %s", result.Error) + } + return nil +} + func (s *SpDBImpl) QueryMigrateGVGUnit(migrateKey string) (*spdb.MigrateGVGUnitMeta, error) { var ( result *gorm.DB @@ -418,3 +464,273 @@ func (s *SpDBImpl) DeleteMigrateGVGUnitsByBucketID(bucketID uint64) error { } return nil } + +func (s *SpDBImpl) UpdateBucketMigrationProgress(bucketID uint64, migrateState int) error { + var ( + result *gorm.DB + insertMigrateBucket *MigrateBucketProgressTable + queryReturn *MigrateBucketProgressTable + needInsert bool + ) + queryReturn = &MigrateBucketProgressTable{} + insertMigrateBucket = &MigrateBucketProgressTable{ + BucketID: bucketID, + MigrationState: migrateState, + } + result = s.db.First(queryReturn, "bucket_id = ?", bucketID) + if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) { + return result.Error + } + if result.Error != nil { + needInsert = errors.Is(result.Error, gorm.ErrRecordNotFound) + } + + if needInsert { + result = s.db.Create(insertMigrateBucket) + if result.Error != nil || result.RowsAffected != 1 { + return fmt.Errorf("failed to insert record in migrate bucket table: %s", result.Error) + } + } else { // update + result = s.db.Model(&MigrateBucketProgressTable{}). + Where("bucket_id = ?", bucketID).Updates(insertMigrateBucket) + if result.Error != nil { + return fmt.Errorf("failed to update record in migrate bucket table: %s", result.Error) + } + } + + return nil +} + +func (s *SpDBImpl) QueryMigrateBucketState(bucketID uint64) (int, error) { + var ( + result *gorm.DB + insertMigrateBucket *MigrateBucketProgressTable + queryReturn *MigrateBucketProgressTable + needInsert bool + state = int(types.BucketMigrationState_BUCKET_MIGRATION_STATE_INIT_UNSPECIFIED) + ) + queryReturn = &MigrateBucketProgressTable{} + insertMigrateBucket = &MigrateBucketProgressTable{ + BucketID: bucketID, + MigrationState: state, + } + result = s.db.First(queryReturn, "bucket_id = ?", bucketID) + if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) { + return state, result.Error + } + if result.Error != nil { + needInsert = errors.Is(result.Error, gorm.ErrRecordNotFound) + } + + if needInsert { + result = s.db.Create(insertMigrateBucket) + if result.Error != nil || result.RowsAffected != 1 { + return 0, fmt.Errorf("failed to insert record in migrate bucket table: %s", result.Error) + } + } else { + state = queryReturn.MigrationState + } + + return state, nil +} + +func (s *SpDBImpl) QueryMigrateBucketProgress(bucketID uint64) (*spdb.MigrateBucketProgressMeta, error) { + var ( + result *gorm.DB + queryReturn *MigrateBucketProgressTable + ) + + progress := &spdb.MigrateBucketProgressMeta{} + queryReturn = &MigrateBucketProgressTable{} + result = s.db.First(queryReturn, "bucket_id = ?", bucketID) + if result.Error != nil { + return &spdb.MigrateBucketProgressMeta{}, result.Error + } + + progress.BucketID = queryReturn.BucketID + progress.SubscribedBlockHeight = queryReturn.SubscribedBlockHeight + progress.LastGcObjectID = queryReturn.LastGcObjectID + progress.LastGcGvgID = queryReturn.LastGcGvgID + progress.RecoupQuota = queryReturn.RecoupQuota + progress.MigrateState = queryReturn.MigrationState + + return progress, nil +} + +func (s *SpDBImpl) ListBucketMigrationToConfirm(migrationStates []int) ([]*spdb.MigrateBucketProgressMeta, error) { + var queryReturns []MigrateBucketProgressTable + result := s.db.Where("migration_state IN (?)", migrationStates).Find(&queryReturns) + if result.Error != nil { + return nil, fmt.Errorf("failed to list bucket migration progress table: %s", result.Error) + } + returns := make([]*spdb.MigrateBucketProgressMeta, 0) + for _, queryReturn := range queryReturns { + returns = append(returns, &spdb.MigrateBucketProgressMeta{ + BucketID: queryReturn.BucketID, + SubscribedBlockHeight: queryReturn.SubscribedBlockHeight, + MigrateState: queryReturn.MigrationState, + }) + } + return returns, nil +} + +func (s *SpDBImpl) UpdateBucketMigrationPreDeductedQuota(bucketID uint64, deductedQuota uint64, state int) error { + var ( + result *gorm.DB + insertMigrateBucket *MigrateBucketProgressTable + queryReturn *MigrateBucketProgressTable + needInsert bool + ) + queryReturn = &MigrateBucketProgressTable{} + insertMigrateBucket = &MigrateBucketProgressTable{ + BucketID: bucketID, + MigrationState: state, + PreDeductedQuota: deductedQuota, + } + result = s.db.First(queryReturn, "bucket_id = ?", bucketID) + if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) { + return result.Error + } + if result.Error != nil { + needInsert = errors.Is(result.Error, gorm.ErrRecordNotFound) + } + + if needInsert { + result = s.db.Create(insertMigrateBucket) + if result.Error != nil || result.RowsAffected != 1 { + return fmt.Errorf("failed to insert record in migrate bucket table: %s", result.Error) + } + } else { // update + result = s.db.Model(&MigrateBucketProgressTable{}). + Where("bucket_id = ?", bucketID).Updates(insertMigrateBucket) + if result.Error != nil { + return fmt.Errorf("failed to update record in migrate bucket table: %s", result.Error) + } + } + + return nil +} + +func (s *SpDBImpl) UpdateBucketMigrationRecoupQuota(bucketID uint64, recoupQuota uint64, state int) error { + var ( + result *gorm.DB + insertMigrateBucket *MigrateBucketProgressTable + queryReturn *MigrateBucketProgressTable + needInsert bool + ) + queryReturn = &MigrateBucketProgressTable{} + insertMigrateBucket = &MigrateBucketProgressTable{ + BucketID: bucketID, + RecoupQuota: recoupQuota, + MigrationState: state, + } + result = s.db.First(queryReturn, "bucket_id = ?", bucketID) + if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) { + return result.Error + } + if result.Error != nil { + needInsert = errors.Is(result.Error, gorm.ErrRecordNotFound) + } + + if needInsert { + result = s.db.Create(insertMigrateBucket) + if result.Error != nil || result.RowsAffected != 1 { + return fmt.Errorf("failed to insert record in migrate bucket table: %s", result.Error) + } + } else { // update + result = s.db.Model(&MigrateBucketProgressTable{}). + Where("bucket_id = ?", bucketID).Updates(insertMigrateBucket) + if result.Error != nil { + return fmt.Errorf("failed to update record in migrate bucket table: %s", result.Error) + } + } + + return nil +} + +func (s *SpDBImpl) UpdateBucketMigrationGCProgress(progressMeta spdb.MigrateBucketProgressMeta) error { + var ( + result *gorm.DB + insertMigrateBucket *MigrateBucketProgressTable + queryReturn *MigrateBucketProgressTable + needInsert bool + ) + bucketID := progressMeta.BucketID + queryReturn = &MigrateBucketProgressTable{} + insertMigrateBucket = &MigrateBucketProgressTable{ + BucketID: bucketID, + MigrationState: progressMeta.MigrateState, + TotalGvgNum: progressMeta.TotalGvgNum, + GcFinishedGvgNum: progressMeta.GcFinishedGvgNum, + LastGcGvgID: progressMeta.LastGcGvgID, + LastGcObjectID: progressMeta.LastGcObjectID, + } + result = s.db.First(queryReturn, "bucket_id = ?", bucketID) + if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) { + return result.Error + } + if result.Error != nil { + needInsert = errors.Is(result.Error, gorm.ErrRecordNotFound) + } + + if needInsert { + result = s.db.Create(insertMigrateBucket) + if result.Error != nil || result.RowsAffected != 1 { + return fmt.Errorf("failed to insert record in migrate bucket table: %s", result.Error) + } + } else { // update + result = s.db.Model(&MigrateBucketProgressTable{}). + Where("bucket_id = ?", bucketID).Updates(insertMigrateBucket) + if result.Error != nil { + return fmt.Errorf("failed to update record in migrate bucket table: %s", result.Error) + } + } + + return nil +} + +func (s *SpDBImpl) UpdateBucketMigrationMigratingProgress(bucketID uint64, gvgUnits uint32, gvgUnitsFinished uint32) error { + var ( + result *gorm.DB + insertMigrateBucket *MigrateBucketProgressTable + queryReturn *MigrateBucketProgressTable + needInsert bool + ) + queryReturn = &MigrateBucketProgressTable{} + insertMigrateBucket = &MigrateBucketProgressTable{ + BucketID: bucketID, + TotalGvgNum: gvgUnits, + MigratedFinishedGvgNum: gvgUnitsFinished, + } + result = s.db.First(queryReturn, "bucket_id = ?", bucketID) + if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) { + return result.Error + } + if result.Error != nil { + needInsert = errors.Is(result.Error, gorm.ErrRecordNotFound) + } + + if needInsert { + result = s.db.Create(insertMigrateBucket) + if result.Error != nil || result.RowsAffected != 1 { + return fmt.Errorf("failed to insert record in migrate bucket table: %s", result.Error) + } + } else { // update + result = s.db.Model(&MigrateBucketProgressTable{}). + Where("bucket_id = ?", bucketID).Updates(insertMigrateBucket) + if result.Error != nil { + return fmt.Errorf("failed to update record in migrate bucket table: %s", result.Error) + } + } + + return nil +} + +func (s *SpDBImpl) DeleteMigrateBucket(bucketID uint64) error { + var results []MigrateBucketProgressTable + result := s.db.Where("bucket_id = ?", bucketID).Find(&results).Delete(&results) + if result.Error != nil { + return fmt.Errorf("failed to delete migrate bucket table: %s", result.Error) + } + return nil +} diff --git a/store/sqldb/migrate_schema.go b/store/sqldb/migrate_schema.go index 11dddfb3f..7ae6d3571 100644 --- a/store/sqldb/migrate_schema.go +++ b/store/sqldb/migrate_schema.go @@ -38,9 +38,33 @@ type MigrateGVGTable struct { LastMigratedObjectID uint64 MigrateStatus int `gorm:"index:migrate_status_index"` RetryTime int `gorm:"comment:retry_time"` + MigratedBytesSize uint64 } // TableName is used to set MigrateGVGTable Schema's table name in database. func (MigrateGVGTable) TableName() string { return MigrateGVGTableName } + +// MigrateBucketProgressTable table schema. +// used by persist bucket migration progress and meta +type MigrateBucketProgressTable struct { + BucketID uint64 `gorm:"primary_key"` + SubscribedBlockHeight uint64 `gorm:"primary_key"` + MigrationState int `gorm:"migration_state"` + + TotalGvgNum uint32 // Total number of GVGs that need to be migrated + MigratedFinishedGvgNum uint32 // Number of successfully migrated GVGs + GcFinishedGvgNum uint32 // Number of successfully gc finished GVGs + + PreDeductedQuota uint64 // Quota pre-deducted by the source sp in the pre-migrate bucket phase + RecoupQuota uint64 // In case of migration failure, the dest sp recoup the quota for the source sp + + LastGcObjectID uint64 // After bucket migration is complete, the progress of GC, up to which object is GC performed. + LastGcGvgID uint64 // which GVG is GC performed. +} + +// TableName is used to set MigrateBucketProgressTable Schema's table name in database. +func (MigrateBucketProgressTable) TableName() string { + return MigrateBucketProgressTableName +} diff --git a/store/sqldb/migrate_test.go b/store/sqldb/migrate_test.go index 25f2016d4..5e52ae94e 100644 --- a/store/sqldb/migrate_test.go +++ b/store/sqldb/migrate_test.go @@ -533,6 +533,7 @@ func TestSpDBImpl_InsertMigrateGVGUnitSuccess(t *testing.T) { LastMigratedObjectID: 8, MigrateStatus: 9, RetryTime: 10, + MigratedBytesSize: 11, } m := &MigrateGVGTable{ MigrateKey: meta.MigrateGVGKey, @@ -550,8 +551,8 @@ func TestSpDBImpl_InsertMigrateGVGUnitSuccess(t *testing.T) { } mock.ExpectQuery(mockMigrateGVGQuerySQL).WithArgs(meta.MigrateGVGKey).WillReturnError(gorm.ErrRecordNotFound) mock.ExpectBegin() - mock.ExpectExec("INSERT INTO `migrate_gvg` (`migrate_key`,`swap_out_key`,`global_virtual_group_id`,`dest_global_virtual_group_id`,`virtual_group_family_id`,`bucket_id`,`redundancy_index`,`src_sp_id`,`dest_sp_id`,`last_migrated_object_id`,`migrate_status`,`retry_time`) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)"). - WithArgs(m.MigrateKey, m.SwapOutKey, m.GlobalVirtualGroupID, m.DestGlobalVirtualGroupID, m.VirtualGroupFamilyID, m.BucketID, m.RedundancyIndex, m.SrcSPID, m.DestSPID, m.LastMigratedObjectID, m.MigrateStatus, m.RetryTime). + mock.ExpectExec("INSERT INTO `migrate_gvg` (`migrate_key`,`swap_out_key`,`global_virtual_group_id`,`dest_global_virtual_group_id`,`virtual_group_family_id`,`bucket_id`,`redundancy_index`,`src_sp_id`,`dest_sp_id`,`last_migrated_object_id`,`migrate_status`,`retry_time`,`migrated_bytes_size`) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)"). + WithArgs(m.MigrateKey, m.SwapOutKey, m.GlobalVirtualGroupID, m.DestGlobalVirtualGroupID, m.VirtualGroupFamilyID, m.BucketID, m.RedundancyIndex, m.SrcSPID, m.DestSPID, m.LastMigratedObjectID, m.MigrateStatus, m.RetryTime, m.MigratedBytesSize). WillReturnResult(sqlmock.NewResult(1, 1)) mock.ExpectCommit() err := s.InsertMigrateGVGUnit(meta) @@ -575,7 +576,7 @@ func TestSpDBImpl_InsertMigrateGVGUnitFailure(t *testing.T) { } mock.ExpectQuery(mockMigrateGVGQuerySQL).WithArgs(meta.MigrateGVGKey).WillReturnError(gorm.ErrRecordNotFound) mock.ExpectBegin() - mock.ExpectExec("INSERT INTO `migrate_gvg` (`migrate_key`,`swap_out_key`,`global_virtual_group_id`,`dest_global_virtual_group_id`,`virtual_group_family_id`,`bucket_id`,`redundancy_index`,`src_sp_id`,`dest_sp_id`,`last_migrated_object_id`,`migrate_status`) VALUES (?,?,?,?,?,?,?,?,?,?,?)"). + mock.ExpectExec("INSERT INTO `migrate_gvg` (`migrate_key`,`swap_out_key`,`global_virtual_group_id`,`dest_global_virtual_group_id`,`virtual_group_family_id`,`bucket_id`,`redundancy_index`,`src_sp_id`,`dest_sp_id`,`last_migrated_object_id`,`migrate_status`, `migrated_bytes_size`) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)"). WillReturnError(mockDBInternalError) mock.ExpectRollback() mock.ExpectCommit() diff --git a/store/sqldb/store.go b/store/sqldb/store.go index 4d040fbd4..c79e7cedd 100644 --- a/store/sqldb/store.go +++ b/store/sqldb/store.go @@ -165,6 +165,10 @@ func InitDB(config *config.SQLDBConfig) (*gorm.DB, error) { log.Errorw("failed to migrate gvg table", "error", err) return nil, err } + if err = db.AutoMigrate(&MigrateBucketProgressTable{}); err != nil && !isAlreadyExists(err) { + log.Errorw("failed to migrate bucket table", "error", err) + return nil, err + } return db, nil } diff --git a/store/types/store.pb.go b/store/types/store.pb.go index 306394bb4..abe73b227 100644 --- a/store/types/store.pb.go +++ b/store/types/store.pb.go @@ -90,35 +90,118 @@ func (TaskState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_adc82498be3fc479, []int{0} } +type BucketMigrationState int32 + +const ( + BucketMigrationState_BUCKET_MIGRATION_STATE_INIT_UNSPECIFIED BucketMigrationState = 0 + // produced execute plan and pre deduct quota + BucketMigrationState_BUCKET_MIGRATION_STATE_SRC_SP_PRE_DEDUCT_QUOTA_DONE BucketMigrationState = 1 + BucketMigrationState_BUCKET_MIGRATION_STATE_DEST_SP_PRE_DEDUCT_QUOTA_DONE BucketMigrationState = 2 + // migrating gvg task + BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATE_GVG_DOING BucketMigrationState = 5 + BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATE_GVG_DONE BucketMigrationState = 6 + BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATE_QUOTA_INFO_DONE BucketMigrationState = 7 + // confirm tx + BucketMigrationState_BUCKET_MIGRATION_STATE_SEND_COMPLETE_TX_DONE BucketMigrationState = 10 + BucketMigrationState_BUCKET_MIGRATION_STATE_WAIT_COMPLETE_TX_EVENT_DONE BucketMigrationState = 11 + BucketMigrationState_BUCKET_MIGRATION_STATE_SEND_REJECT_TX_DONE BucketMigrationState = 12 + BucketMigrationState_BUCKET_MIGRATION_STATE_WAIT_REJECT_TX_EVENT_DONE BucketMigrationState = 13 + BucketMigrationState_BUCKET_MIGRATION_STATE_WAIT_CANCEL_TX_EVENT_DONE BucketMigrationState = 14 + // gc + BucketMigrationState_BUCKET_MIGRATION_STATE_SRC_SP_GC_DOING BucketMigrationState = 20 + BucketMigrationState_BUCKET_MIGRATION_STATE_DEST_SP_GC_DOING BucketMigrationState = 21 + BucketMigrationState_BUCKET_MIGRATION_STATE_POST_SRC_SP_DONE BucketMigrationState = 30 + BucketMigrationState_BUCKET_MIGRATION_STATE_MIGRATION_FINISHED BucketMigrationState = 31 +) + +var BucketMigrationState_name = map[int32]string{ + 0: "BUCKET_MIGRATION_STATE_INIT_UNSPECIFIED", + 1: "BUCKET_MIGRATION_STATE_SRC_SP_PRE_DEDUCT_QUOTA_DONE", + 2: "BUCKET_MIGRATION_STATE_DEST_SP_PRE_DEDUCT_QUOTA_DONE", + 5: "BUCKET_MIGRATION_STATE_MIGRATE_GVG_DOING", + 6: "BUCKET_MIGRATION_STATE_MIGRATE_GVG_DONE", + 7: "BUCKET_MIGRATION_STATE_MIGRATE_QUOTA_INFO_DONE", + 10: "BUCKET_MIGRATION_STATE_SEND_COMPLETE_TX_DONE", + 11: "BUCKET_MIGRATION_STATE_WAIT_COMPLETE_TX_EVENT_DONE", + 12: "BUCKET_MIGRATION_STATE_SEND_REJECT_TX_DONE", + 13: "BUCKET_MIGRATION_STATE_WAIT_REJECT_TX_EVENT_DONE", + 14: "BUCKET_MIGRATION_STATE_WAIT_CANCEL_TX_EVENT_DONE", + 20: "BUCKET_MIGRATION_STATE_SRC_SP_GC_DOING", + 21: "BUCKET_MIGRATION_STATE_DEST_SP_GC_DOING", + 30: "BUCKET_MIGRATION_STATE_POST_SRC_SP_DONE", + 31: "BUCKET_MIGRATION_STATE_MIGRATION_FINISHED", +} + +var BucketMigrationState_value = map[string]int32{ + "BUCKET_MIGRATION_STATE_INIT_UNSPECIFIED": 0, + "BUCKET_MIGRATION_STATE_SRC_SP_PRE_DEDUCT_QUOTA_DONE": 1, + "BUCKET_MIGRATION_STATE_DEST_SP_PRE_DEDUCT_QUOTA_DONE": 2, + "BUCKET_MIGRATION_STATE_MIGRATE_GVG_DOING": 5, + "BUCKET_MIGRATION_STATE_MIGRATE_GVG_DONE": 6, + "BUCKET_MIGRATION_STATE_MIGRATE_QUOTA_INFO_DONE": 7, + "BUCKET_MIGRATION_STATE_SEND_COMPLETE_TX_DONE": 10, + "BUCKET_MIGRATION_STATE_WAIT_COMPLETE_TX_EVENT_DONE": 11, + "BUCKET_MIGRATION_STATE_SEND_REJECT_TX_DONE": 12, + "BUCKET_MIGRATION_STATE_WAIT_REJECT_TX_EVENT_DONE": 13, + "BUCKET_MIGRATION_STATE_WAIT_CANCEL_TX_EVENT_DONE": 14, + "BUCKET_MIGRATION_STATE_SRC_SP_GC_DOING": 20, + "BUCKET_MIGRATION_STATE_DEST_SP_GC_DOING": 21, + "BUCKET_MIGRATION_STATE_POST_SRC_SP_DONE": 30, + "BUCKET_MIGRATION_STATE_MIGRATION_FINISHED": 31, +} + +func (x BucketMigrationState) String() string { + return proto.EnumName(BucketMigrationState_name, int32(x)) +} + +func (BucketMigrationState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_adc82498be3fc479, []int{1} +} + func init() { proto.RegisterEnum("store.types.TaskState", TaskState_name, TaskState_value) + proto.RegisterEnum("store.types.BucketMigrationState", BucketMigrationState_name, BucketMigrationState_value) } func init() { proto.RegisterFile("store/types/store.proto", fileDescriptor_adc82498be3fc479) } var fileDescriptor_adc82498be3fc479 = []byte{ - // 363 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0xcd, 0x4e, 0xea, 0x40, - 0x18, 0x86, 0xdb, 0x73, 0x38, 0x1c, 0x19, 0xfc, 0x99, 0xcc, 0xc6, 0x85, 0x5a, 0xc0, 0x9f, 0x8d, - 0x09, 0x74, 0xe1, 0xd6, 0x4d, 0x69, 0x3f, 0xc9, 0x68, 0x33, 0x25, 0xed, 0x60, 0xa2, 0x9b, 0xa6, - 0x85, 0x11, 0x1a, 0x95, 0x92, 0x52, 0x4d, 0xbc, 0x0b, 0x2f, 0xcb, 0x25, 0x4b, 0x97, 0x06, 0x76, - 0x5e, 0x85, 0x81, 0x6a, 0xd2, 0x36, 0xa6, 0xec, 0xbe, 0xc9, 0x3c, 0xf3, 0x3e, 0x99, 0x7c, 0x2f, - 0xda, 0x9d, 0xc6, 0x61, 0x24, 0xd4, 0xf8, 0x65, 0x22, 0xa6, 0xea, 0x6a, 0x6e, 0x4d, 0xa2, 0x30, - 0x0e, 0x49, 0x35, 0x39, 0xac, 0x2e, 0x4e, 0x3f, 0x4b, 0xa8, 0xc2, 0xbd, 0xe9, 0xbd, 0x13, 0x7b, - 0xb1, 0x20, 0x35, 0xb4, 0xc7, 0x35, 0xe7, 0xca, 0x75, 0xb8, 0xc6, 0xc1, 0xa5, 0x8c, 0x72, 0xb7, - 0xc7, 0x9c, 0x2e, 0xe8, 0xf4, 0x82, 0x82, 0x81, 0x25, 0x72, 0x88, 0x94, 0x14, 0xd0, 0xeb, 0x9a, - 0x96, 0x66, 0xb8, 0x56, 0xfb, 0x12, 0x74, 0xee, 0x1a, 0x16, 0x65, 0x1d, 0x2c, 0x93, 0x06, 0x3a, - 0x28, 0x60, 0x18, 0xe0, 0x3f, 0x85, 0x31, 0x60, 0xdb, 0x96, 0x8d, 0xff, 0x92, 0x63, 0x54, 0x4f, - 0x31, 0x9a, 0x69, 0x5a, 0xba, 0xeb, 0x80, 0x6e, 0x31, 0x43, 0xb3, 0x6f, 0xbe, 0x65, 0x25, 0x72, - 0x84, 0x6a, 0x85, 0x14, 0x03, 0xfc, 0x6f, 0x4d, 0x54, 0x22, 0x2c, 0x93, 0x13, 0xd4, 0x48, 0x51, - 0x36, 0x74, 0x4d, 0xaa, 0x2f, 0xa7, 0xcc, 0xf7, 0xfe, 0xe7, 0xc2, 0x7e, 0xc1, 0x18, 0xe0, 0x8d, - 0x75, 0x61, 0x89, 0xb3, 0x42, 0xea, 0x68, 0x3f, 0x85, 0x39, 0xb4, 0xc3, 0xb2, 0x3a, 0x94, 0x5b, - 0x49, 0x96, 0x60, 0x80, 0xab, 0x05, 0x11, 0x89, 0x64, 0x33, 0x4f, 0x80, 0x66, 0x66, 0x25, 0x5b, - 0x79, 0x49, 0x86, 0x60, 0x80, 0xb7, 0x0b, 0x22, 0x12, 0xc9, 0x4e, 0x6e, 0xa5, 0x3f, 0xaf, 0xa9, - 0xa3, 0x5b, 0x8c, 0x53, 0xd6, 0x03, 0x03, 0xe3, 0xf6, 0xf5, 0xdb, 0x5c, 0x91, 0x67, 0x73, 0x45, - 0xfe, 0x98, 0x2b, 0xf2, 0xeb, 0x42, 0x91, 0x66, 0x0b, 0x45, 0x7a, 0x5f, 0x28, 0xd2, 0xed, 0xf9, - 0x30, 0x88, 0x47, 0x4f, 0x7e, 0xab, 0x1f, 0x3e, 0xaa, 0xfe, 0xd8, 0x6f, 0xf6, 0x47, 0x5e, 0x30, - 0x56, 0x87, 0x91, 0x10, 0xe3, 0xbb, 0x40, 0x3c, 0x0c, 0x9a, 0xcb, 0xce, 0x7a, 0x43, 0xd1, 0x9c, - 0x44, 0xe1, 0x73, 0x30, 0x10, 0x91, 0x9a, 0x6a, 0xb7, 0x5f, 0x5e, 0x15, 0xfb, 0xec, 0x2b, 0x00, - 0x00, 0xff, 0xff, 0xed, 0x75, 0x6e, 0xb5, 0xf3, 0x02, 0x00, 0x00, + // 586 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x94, 0x4d, 0x53, 0xd3, 0x40, + 0x1c, 0xc6, 0x5b, 0x84, 0x22, 0xcb, 0x8b, 0x3b, 0x3b, 0x38, 0x1e, 0xd4, 0x00, 0xbe, 0x5b, 0x69, + 0xcb, 0x00, 0xa3, 0x1e, 0xbc, 0xa4, 0x9b, 0x3f, 0x75, 0x25, 0xec, 0xc6, 0x64, 0x8b, 0x2f, 0x97, + 0x9d, 0x16, 0x62, 0xe9, 0xa0, 0x0d, 0x13, 0x82, 0x33, 0xde, 0xfc, 0x08, 0x7e, 0x2c, 0x8f, 0x1c, + 0x3d, 0x3a, 0x70, 0xf3, 0x53, 0x38, 0xed, 0x02, 0x26, 0x19, 0xb3, 0xbd, 0x65, 0x27, 0xbf, 0xe7, + 0x79, 0x76, 0xf7, 0xf9, 0xcf, 0xa2, 0x5b, 0xc7, 0x49, 0x14, 0x87, 0x8d, 0xe4, 0xdb, 0x51, 0x78, + 0xdc, 0x18, 0x7d, 0xd7, 0x8f, 0xe2, 0x28, 0x89, 0xc8, 0xac, 0x5e, 0x8c, 0x7e, 0x54, 0xff, 0x4c, + 0xa2, 0x19, 0xd9, 0x39, 0x3e, 0x0c, 0x92, 0x4e, 0x12, 0x92, 0x25, 0x74, 0x5b, 0xda, 0xc1, 0xb6, + 0x0a, 0xa4, 0x2d, 0x41, 0x31, 0xce, 0xa4, 0x6a, 0xf3, 0xc0, 0x03, 0xca, 0xb6, 0x18, 0x38, 0xb8, + 0x44, 0xee, 0x21, 0x2b, 0x05, 0xb4, 0x3d, 0x57, 0xd8, 0x8e, 0x12, 0xcd, 0x37, 0x40, 0xa5, 0x72, + 0x04, 0xe3, 0x2d, 0x5c, 0x26, 0x2b, 0xe8, 0xae, 0x81, 0xe1, 0x80, 0x27, 0x8c, 0x36, 0xe0, 0xfb, + 0xc2, 0xc7, 0xd7, 0xc8, 0x03, 0xb4, 0x9c, 0x62, 0x6c, 0xd7, 0x15, 0x54, 0x05, 0x40, 0x05, 0x77, + 0x6c, 0xff, 0xc3, 0x45, 0xd8, 0x24, 0xb9, 0x8f, 0x96, 0x8c, 0x14, 0x07, 0x3c, 0x35, 0xc6, 0x4a, + 0x07, 0x56, 0xc8, 0x43, 0xb4, 0x92, 0xa2, 0x7c, 0xf0, 0x5c, 0x46, 0x87, 0x5f, 0x99, 0xe3, 0x4d, + 0xe7, 0xcc, 0xfe, 0x83, 0x71, 0xc0, 0xd7, 0xc7, 0x99, 0xe9, 0xcc, 0x19, 0xb2, 0x8c, 0xee, 0xa4, + 0xb0, 0x80, 0xb5, 0x78, 0x36, 0x0e, 0xe5, 0x2a, 0xc9, 0x12, 0x1c, 0xf0, 0xac, 0xc1, 0x42, 0x87, + 0xcc, 0xe5, 0x09, 0xb0, 0xdd, 0x6c, 0xc8, 0x7c, 0x3e, 0x24, 0x43, 0x70, 0xc0, 0x0b, 0x06, 0x0b, + 0x1d, 0x72, 0x23, 0x57, 0xe9, 0xa5, 0x9a, 0x05, 0x54, 0x70, 0xc9, 0x78, 0x1b, 0x1c, 0x8c, 0xab, + 0xdf, 0x2b, 0x68, 0xb1, 0x79, 0xb2, 0x77, 0x18, 0x26, 0x3b, 0xfd, 0x5e, 0xdc, 0x49, 0xfa, 0xd1, + 0x40, 0xcf, 0xdd, 0x33, 0xf4, 0xb8, 0xd9, 0xa6, 0xdb, 0x20, 0xd5, 0x0e, 0x6b, 0xf9, 0xb6, 0x64, + 0x82, 0x17, 0xcf, 0xe0, 0x0b, 0xb4, 0x51, 0x00, 0x07, 0x3e, 0x55, 0x81, 0xa7, 0x3c, 0x1f, 0x94, + 0x03, 0x4e, 0x9b, 0x4a, 0xf5, 0xb6, 0x2d, 0xa4, 0xad, 0x0f, 0x51, 0x26, 0x2f, 0xd1, 0x66, 0x81, + 0xd0, 0x81, 0x40, 0x16, 0x2b, 0x27, 0xc8, 0x2a, 0x7a, 0x52, 0xa0, 0xd4, 0x6b, 0x50, 0xad, 0xdd, + 0xd6, 0xc5, 0x6d, 0x4e, 0x19, 0x4e, 0x93, 0xa5, 0x39, 0xe0, 0x0a, 0x59, 0x47, 0xf5, 0x31, 0xb0, + 0xde, 0x09, 0xe3, 0x5b, 0x42, 0x6b, 0xa6, 0xc9, 0x1a, 0x5a, 0x2d, 0xba, 0x01, 0xe0, 0x8e, 0xa2, + 0x62, 0xc7, 0x73, 0x41, 0x82, 0x92, 0xef, 0xb5, 0x02, 0x91, 0xe7, 0x68, 0xbd, 0x40, 0xf1, 0xce, + 0x66, 0x32, 0xa3, 0x80, 0x5d, 0xe0, 0x57, 0xc3, 0x55, 0x47, 0x55, 0x53, 0x92, 0x0f, 0xa3, 0x9a, + 0x2f, 0x73, 0xe6, 0xc8, 0x26, 0x5a, 0x33, 0xe5, 0xfc, 0xe3, 0x53, 0x29, 0xf3, 0xe3, 0x54, 0xd4, + 0xe6, 0x14, 0xdc, 0x9c, 0x6a, 0x81, 0x54, 0xd1, 0x23, 0xf3, 0x1c, 0xb4, 0xe8, 0x45, 0x25, 0x8b, + 0x86, 0x4a, 0x2e, 0xab, 0xbf, 0x82, 0x6f, 0x1a, 0x60, 0x4f, 0x0c, 0x61, 0xed, 0x3e, 0xda, 0x85, + 0x45, 0x6a, 0xe8, 0xa9, 0xb1, 0xbf, 0xe1, 0x7a, 0x8b, 0x71, 0x16, 0xbc, 0x06, 0x07, 0x2f, 0x35, + 0x77, 0x7f, 0x9e, 0x59, 0xe5, 0xd3, 0x33, 0xab, 0xfc, 0xfb, 0xcc, 0x2a, 0xff, 0x38, 0xb7, 0x4a, + 0xa7, 0xe7, 0x56, 0xe9, 0xd7, 0xb9, 0x55, 0xfa, 0xf8, 0xaa, 0xd7, 0x4f, 0x0e, 0x4e, 0xba, 0xf5, + 0xbd, 0xe8, 0x4b, 0xa3, 0x3b, 0xe8, 0xd6, 0xf6, 0x0e, 0x3a, 0xfd, 0x41, 0xa3, 0x17, 0x87, 0xe1, + 0xe0, 0x53, 0x3f, 0xfc, 0xbc, 0x5f, 0x1b, 0x3e, 0xdb, 0x9d, 0x5e, 0x58, 0x3b, 0x8a, 0xa3, 0xaf, + 0xfd, 0xfd, 0x30, 0x6e, 0xa4, 0x1e, 0xf8, 0x6e, 0x65, 0xf4, 0xb6, 0x6f, 0xfc, 0x0d, 0x00, 0x00, + 0xff, 0xff, 0x4e, 0x01, 0x1f, 0x36, 0xf6, 0x05, 0x00, 0x00, } From 71d5341395fc7b118c932f572b68c10029ebbd6d Mon Sep 17 00:00:00 2001 From: Alan W Date: Mon, 18 Dec 2023 17:46:47 +0800 Subject: [PATCH 04/27] chore: switch develop image to distroless --- .github/workflows/docker-develop.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/docker-develop.yml b/.github/workflows/docker-develop.yml index 04d89c8ce..461bcf8b4 100644 --- a/.github/workflows/docker-develop.yml +++ b/.github/workflows/docker-develop.yml @@ -40,7 +40,7 @@ jobs: --label "org.opencontainers.image.source=${IMAGE_SOURCE}" \ --label "org.opencontainers.image.revision=$(git rev-parse HEAD)" \ --label "org.opencontainers.image.licenses=LGPL-3.0,GPL-3.0" \ - -f ./Dockerfile -t "${IMAGE_NAME}" + -f ./Dockerfile.distroless -t "${IMAGE_NAME}" - name: Log into registry run: echo "${{ secrets.GH_SECRET }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin From 8413e1a6a46f4f4c156da2a862bd65b31cd3485e Mon Sep 17 00:00:00 2001 From: Alan <134836984+dangerousidea@users.noreply.github.com> Date: Mon, 18 Dec 2023 21:35:13 +0800 Subject: [PATCH 05/27] Update docker-develop.yml --- .github/workflows/docker-develop.yml | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/.github/workflows/docker-develop.yml b/.github/workflows/docker-develop.yml index 461bcf8b4..237e65006 100644 --- a/.github/workflows/docker-develop.yml +++ b/.github/workflows/docker-develop.yml @@ -40,7 +40,14 @@ jobs: --label "org.opencontainers.image.source=${IMAGE_SOURCE}" \ --label "org.opencontainers.image.revision=$(git rev-parse HEAD)" \ --label "org.opencontainers.image.licenses=LGPL-3.0,GPL-3.0" \ - -f ./Dockerfile.distroless -t "${IMAGE_NAME}" + -f ./Dockerfile -t "${IMAGE_NAME}" + + docker build . \ + --build-arg "GH_TOKEN=${{ secrets.GH_SECRET }}" \ + --label "org.opencontainers.image.source=${IMAGE_SOURCE}" \ + --label "org.opencontainers.image.revision=$(git rev-parse HEAD)" \ + --label "org.opencontainers.image.licenses=LGPL-3.0,GPL-3.0" \ + -f ./Dockerfile.distroless -t "${IMAGE_NAME}:distroless" - name: Log into registry run: echo "${{ secrets.GH_SECRET }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin @@ -49,4 +56,6 @@ jobs: run: | VERSION=$(echo "${{ github.sha }}" | sed -e 's,.*/\(.*\),\1,') docker tag $IMAGE_NAME $IMAGE_NAME:$VERSION + docker tag ${IMAGE_NAME}:distroless $IMAGE_NAME:$VERSION-distroless docker push $IMAGE_NAME:$VERSION + docker push $IMAGE_NAME:$VERSION-distroless From 1818b8bb26587cb27b278bded37a1b173e113363 Mon Sep 17 00:00:00 2001 From: constwz <122766871+constwz@users.noreply.github.com> Date: Tue, 26 Dec 2023 10:52:14 +0800 Subject: [PATCH 06/27] feat: re-implementation of sp exit (#1279) * feat: SP exit recover scheduler --------- Co-authored-by: Alexgao001 --- base/gfspapp/app_options.go | 6 + base/gfspapp/manage_server.go | 20 + base/gfspapp/sign_server.go | 30 + base/gfspclient/helper_test.go | 8 + base/gfspclient/interface.go | 2 + base/gfspclient/interface_mock.go | 1146 +++++++------ base/gfspclient/manager.go | 40 + base/gfspclient/signer.go | 111 ++ base/gnfd/gnfd_service.go | 37 + base/types/gfspserver/manage.pb.go | 1935 ++++++++++++++++++++-- base/types/gfspserver/sign.pb.go | 419 ++++- base/types/gfsptask/recovery.go | 16 + base/types/gfsptask/task.pb.go | 346 ++-- cmd/command/recovery.go | 32 +- cmd/command/sp_exit.go | 77 + cmd/command/swap_in.go | 422 +++++ cmd/storage_provider/main.go | 11 + core/consensus/consensus.go | 6 + core/consensus/consensus_mock.go | 15 + core/module/modular.go | 10 + core/module/modular_mock.go | 359 ++-- core/module/null_modular.go | 16 + core/spdb/entity.go | 25 + core/spdb/spdb.go | 32 + core/spdb/spdb_mock.go | 713 ++++++-- core/task/null_task.go | 2 + core/task/task.go | 4 + core/task/task_mock.go | 840 ++++++---- core/vgmgr/virtual_group_manager_mock.go | 24 +- go.mod | 6 +- go.sum | 8 +- modular/executor/execute_gc.go | 20 + modular/executor/execute_task.go | 122 +- modular/executor/executor_task_test.go | 21 +- modular/gater/admin_handler.go | 52 +- modular/gater/admin_handler_test.go | 1 + modular/manager/manage_task.go | 42 +- modular/manager/manager.go | 119 +- modular/manager/manager_options.go | 4 +- modular/manager/recover_scheduler.go | 737 ++++++++ modular/signer/signer.go | 15 + modular/signer/signer_client.go | 175 +- proto/base/types/gfspserver/manage.proto | 42 + proto/base/types/gfspserver/sign.proto | 3 + proto/base/types/gfsptask/task.proto | 2 + proto/buf.lock | 4 +- store/bsdb/database_mock.go | 12 +- store/sqldb/const.go | 4 + store/sqldb/exit_recover.go | 200 +++ store/sqldb/exit_recover_schema.go | 26 + store/sqldb/store.go | 7 + 51 files changed, 6709 insertions(+), 1617 deletions(-) create mode 100644 cmd/command/sp_exit.go create mode 100644 cmd/command/swap_in.go create mode 100644 modular/manager/recover_scheduler.go create mode 100644 store/sqldb/exit_recover.go create mode 100644 store/sqldb/exit_recover_schema.go diff --git a/base/gfspapp/app_options.go b/base/gfspapp/app_options.go index eb4a4e83d..e7a443b94 100644 --- a/base/gfspapp/app_options.go +++ b/base/gfspapp/app_options.go @@ -153,6 +153,12 @@ const ( SignerFailureGfSpBucketMigrateInfo = "signer_gfsp_bucket_migrate_info_failure" SignerSuccessRejectMigrateBucket = "signer_reject_migrate_bucket_success" SignerFailureRejectMigrateBucket = "signer_reject_migrate_bucket_failure" + SignerSuccessSwapIn = "signer_swap_in_success" + SignerFailureSwapIn = "signer_swap_in_failure" + SignerSuccessCompleteSwapIn = "signer_complete_swap_in_success" + SignerFailureCompleteSwapIn = "signer_complete_swap_in_failure" + SignerSuccessCancelSwapIn = "signer_cancel_swap_in_success" + SignerFailureCancelSwapIn = "signer_cancel_swap_in_failure" SignerSuccessDeposit = "signer_deposit_success" SignerFailureDeposit = "signer_deposit_failure" diff --git a/base/gfspapp/manage_server.go b/base/gfspapp/manage_server.go index 4740231cb..6f6ea604a 100644 --- a/base/gfspapp/manage_server.go +++ b/base/gfspapp/manage_server.go @@ -411,3 +411,23 @@ func (g *GfSpBaseApp) GfSpResetRecoveryFailedList(ctx context.Context, _ *gfspse RecoveryFailedList: recoveryFailedList, }, nil } + +func (g *GfSpBaseApp) GfSpTriggerRecoverForSuccessorSP(ctx context.Context, req *gfspserver.GfSpTriggerRecoverForSuccessorSPRequest) ( + *gfspserver.GfSpTriggerRecoverForSuccessorSPResponse, error) { + err := g.manager.TriggerRecoverForSuccessorSP(ctx, req.GetVgfId(), req.GetGvgId(), req.ReplicateIndex) + if err != nil { + return nil, err + } + return &gfspserver.GfSpTriggerRecoverForSuccessorSPResponse{}, nil +} + +func (g *GfSpBaseApp) GfSpQueryRecoverProcess(ctx context.Context, req *gfspserver.GfSpQueryRecoverProcessRequest) (*gfspserver.GfSpQueryRecoverProcessResponse, error) { + gvgStats, flag, err := g.manager.QueryRecoverProcess(ctx, req.GetVgfId(), req.GetGvgId()) + if err != nil { + return nil, err + } + return &gfspserver.GfSpQueryRecoverProcessResponse{ + RecoverProcesses: gvgStats, + Executing: flag, + }, nil +} diff --git a/base/gfspapp/sign_server.go b/base/gfspapp/sign_server.go index 518251a3a..02938981b 100644 --- a/base/gfspapp/sign_server.go +++ b/base/gfspapp/sign_server.go @@ -291,6 +291,36 @@ func (g *GfSpBaseApp) GfSpSign(ctx context.Context, req *gfspserver.GfSpSignRequ metrics.ReqCounter.WithLabelValues(SignerSuccessRejectMigrateBucket).Inc() metrics.ReqTime.WithLabelValues(SignerSuccessRejectMigrateBucket).Observe(time.Since(startTime).Seconds()) } + case *gfspserver.GfSpSignRequest_ReserveSwapIn: + txHash, err = g.signer.ReserveSwapIn(ctx, t.ReserveSwapIn) + if err != nil { + log.CtxErrorw(ctx, "failed to reserve swap in", "error", err) + metrics.ReqCounter.WithLabelValues(SignerFailureSwapIn).Inc() + metrics.ReqTime.WithLabelValues(SignerFailureSwapIn).Observe(time.Since(startTime).Seconds()) + } else { + metrics.ReqCounter.WithLabelValues(SignerSuccessSwapIn).Inc() + metrics.ReqTime.WithLabelValues(SignerSuccessSwapIn).Observe(time.Since(startTime).Seconds()) + } + case *gfspserver.GfSpSignRequest_CompleteSwapIn: + txHash, err = g.signer.CompleteSwapIn(ctx, t.CompleteSwapIn) + if err != nil { + log.CtxErrorw(ctx, "failed to complete swap in", "error", err) + metrics.ReqCounter.WithLabelValues(SignerFailureCompleteSwapIn).Inc() + metrics.ReqTime.WithLabelValues(SignerFailureCompleteSwapIn).Observe(time.Since(startTime).Seconds()) + } else { + metrics.ReqCounter.WithLabelValues(SignerSuccessCompleteSwapIn).Inc() + metrics.ReqTime.WithLabelValues(SignerSuccessCompleteSwapIn).Observe(time.Since(startTime).Seconds()) + } + case *gfspserver.GfSpSignRequest_CancelSwapIn: + txHash, err = g.signer.CancelSwapIn(ctx, t.CancelSwapIn) + if err != nil { + log.CtxErrorw(ctx, "failed to cancel swap in", "error", err) + metrics.ReqCounter.WithLabelValues(SignerFailureCancelSwapIn).Inc() + metrics.ReqTime.WithLabelValues(SignerFailureCancelSwapIn).Observe(time.Since(startTime).Seconds()) + } else { + metrics.ReqCounter.WithLabelValues(SignerSuccessCancelSwapIn).Inc() + metrics.ReqTime.WithLabelValues(SignerSuccessCancelSwapIn).Observe(time.Since(startTime).Seconds()) + } case *gfspserver.GfSpSignRequest_Deposit: txHash, err = g.signer.Deposit(ctx, t.Deposit) if err != nil { diff --git a/base/gfspclient/helper_test.go b/base/gfspclient/helper_test.go index edd52cb94..4fb20a5d7 100644 --- a/base/gfspclient/helper_test.go +++ b/base/gfspclient/helper_test.go @@ -236,6 +236,14 @@ func (mockDownloaderServer) GfSpDeductQuotaForBucketMigrate(ctx context.Context, type mockManagerServer struct{} +func (s mockManagerServer) GfSpTriggerRecoverForSuccessorSP(ctx context.Context, request *gfspserver.GfSpTriggerRecoverForSuccessorSPRequest) (*gfspserver.GfSpTriggerRecoverForSuccessorSPResponse, error) { + return &gfspserver.GfSpTriggerRecoverForSuccessorSPResponse{Err: ErrExceptionsStream}, nil +} + +func (s mockManagerServer) GfSpQueryRecoverProcess(ctx context.Context, request *gfspserver.GfSpQueryRecoverProcessRequest) (*gfspserver.GfSpQueryRecoverProcessResponse, error) { + return &gfspserver.GfSpQueryRecoverProcessResponse{Err: ErrExceptionsStream}, nil +} + func (mockManagerServer) GfSpBeginTask(ctx context.Context, req *gfspserver.GfSpBeginTaskRequest) ( *gfspserver.GfSpBeginTaskResponse, error) { switch req.Request.(type) { diff --git a/base/gfspclient/interface.go b/base/gfspclient/interface.go index 52a6dc425..df9eca783 100644 --- a/base/gfspclient/interface.go +++ b/base/gfspclient/interface.go @@ -194,6 +194,8 @@ type SignerAPI interface { SignMigrateGVG(ctx context.Context, task *gfsptask.GfSpMigrateGVGTask) ([]byte, error) SignBucketMigrationInfo(ctx context.Context, task *gfsptask.GfSpBucketMigrationInfo) ([]byte, error) RejectMigrateBucket(ctx context.Context, rejectMigrateBucket *storagetypes.MsgRejectMigrateBucket) (string, error) + ReserveSwapIn(ctx context.Context, reserveSwapIn *virtualgrouptypes.MsgReserveSwapIn) (string, error) + CompleteSwapIn(ctx context.Context, completeSwpIn *virtualgrouptypes.MsgCompleteSwapIn) (string, error) Deposit(ctx context.Context, deposit *virtualgrouptypes.MsgDeposit) (string, error) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG *virtualgrouptypes.MsgDeleteGlobalVirtualGroup) (string, error) } diff --git a/base/gfspclient/interface_mock.go b/base/gfspclient/interface_mock.go index 94570be84..b408ff492 100644 --- a/base/gfspclient/interface_mock.go +++ b/base/gfspclient/interface_mock.go @@ -1,6 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: base/gfspclient/interface.go - +// Source: ./interface.go +// +// Generated by this command: +// +// mockgen -source=./interface.go -destination=./interface_mock.go -package=gfspclient +// // Package gfspclient is a generated GoMock package. package gfspclient @@ -53,7 +57,7 @@ func (m *MockGfSpClientAPI) EXPECT() *MockGfSpClientAPIMockRecorder { // ApproverConn mocks base method. func (m *MockGfSpClientAPI) ApproverConn(ctx context.Context, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -64,9 +68,9 @@ func (m *MockGfSpClientAPI) ApproverConn(ctx context.Context, opts ...grpc.DialO } // ApproverConn indicates an expected call of ApproverConn. -func (mr *MockGfSpClientAPIMockRecorder) ApproverConn(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ApproverConn(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproverConn", reflect.TypeOf((*MockGfSpClientAPI)(nil).ApproverConn), varargs...) } @@ -81,7 +85,7 @@ func (m *MockGfSpClientAPI) AskCreateBucketApproval(ctx context.Context, t task. } // AskCreateBucketApproval indicates an expected call of AskCreateBucketApproval. -func (mr *MockGfSpClientAPIMockRecorder) AskCreateBucketApproval(ctx, t interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) AskCreateBucketApproval(ctx, t any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskCreateBucketApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).AskCreateBucketApproval), ctx, t) } @@ -97,7 +101,7 @@ func (m *MockGfSpClientAPI) AskCreateObjectApproval(ctx context.Context, t task. } // AskCreateObjectApproval indicates an expected call of AskCreateObjectApproval. -func (mr *MockGfSpClientAPIMockRecorder) AskCreateObjectApproval(ctx, t interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) AskCreateObjectApproval(ctx, t any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskCreateObjectApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).AskCreateObjectApproval), ctx, t) } @@ -113,7 +117,7 @@ func (m *MockGfSpClientAPI) AskMigrateBucketApproval(ctx context.Context, t task } // AskMigrateBucketApproval indicates an expected call of AskMigrateBucketApproval. -func (mr *MockGfSpClientAPIMockRecorder) AskMigrateBucketApproval(ctx, t interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) AskMigrateBucketApproval(ctx, t any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskMigrateBucketApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).AskMigrateBucketApproval), ctx, t) } @@ -128,7 +132,7 @@ func (m *MockGfSpClientAPI) AskSecondaryReplicatePieceApproval(ctx context.Conte } // AskSecondaryReplicatePieceApproval indicates an expected call of AskSecondaryReplicatePieceApproval. -func (mr *MockGfSpClientAPIMockRecorder) AskSecondaryReplicatePieceApproval(ctx, task, low, high, timeout interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) AskSecondaryReplicatePieceApproval(ctx, task, low, high, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskSecondaryReplicatePieceApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).AskSecondaryReplicatePieceApproval), ctx, task, low, high, timeout) } @@ -143,7 +147,7 @@ func (m *MockGfSpClientAPI) AskTask(ctx context.Context, limit rcmgr.Limit) (tas } // AskTask indicates an expected call of AskTask. -func (mr *MockGfSpClientAPIMockRecorder) AskTask(ctx, limit interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) AskTask(ctx, limit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskTask", reflect.TypeOf((*MockGfSpClientAPI)(nil).AskTask), ctx, limit) } @@ -172,7 +176,7 @@ func (m *MockGfSpClientAPI) CompleteMigrateBucket(ctx context.Context, migrateBu } // CompleteMigrateBucket indicates an expected call of CompleteMigrateBucket. -func (mr *MockGfSpClientAPIMockRecorder) CompleteMigrateBucket(ctx, migrateBucket interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) CompleteMigrateBucket(ctx, migrateBucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).CompleteMigrateBucket), ctx, migrateBucket) } @@ -187,11 +191,26 @@ func (m *MockGfSpClientAPI) CompleteSPExit(ctx context.Context, completeSPExit * } // CompleteSPExit indicates an expected call of CompleteSPExit. -func (mr *MockGfSpClientAPIMockRecorder) CompleteSPExit(ctx, completeSPExit interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) CompleteSPExit(ctx, completeSPExit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSPExit", reflect.TypeOf((*MockGfSpClientAPI)(nil).CompleteSPExit), ctx, completeSPExit) } +// CompleteSwapIn mocks base method. +func (m *MockGfSpClientAPI) CompleteSwapIn(ctx context.Context, completeSwpIn *types4.MsgCompleteSwapIn) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CompleteSwapIn", ctx, completeSwpIn) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CompleteSwapIn indicates an expected call of CompleteSwapIn. +func (mr *MockGfSpClientAPIMockRecorder) CompleteSwapIn(ctx, completeSwpIn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapIn", reflect.TypeOf((*MockGfSpClientAPI)(nil).CompleteSwapIn), ctx, completeSwpIn) +} + // CompleteSwapOut mocks base method. func (m *MockGfSpClientAPI) CompleteSwapOut(ctx context.Context, completeSwapOut *types4.MsgCompleteSwapOut) (string, error) { m.ctrl.T.Helper() @@ -202,7 +221,7 @@ func (m *MockGfSpClientAPI) CompleteSwapOut(ctx context.Context, completeSwapOut } // CompleteSwapOut indicates an expected call of CompleteSwapOut. -func (mr *MockGfSpClientAPIMockRecorder) CompleteSwapOut(ctx, completeSwapOut interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) CompleteSwapOut(ctx, completeSwapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).CompleteSwapOut), ctx, completeSwapOut) } @@ -210,7 +229,7 @@ func (mr *MockGfSpClientAPIMockRecorder) CompleteSwapOut(ctx, completeSwapOut in // Connection mocks base method. func (m *MockGfSpClientAPI) Connection(ctx context.Context, address string, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, address} + varargs := []any{ctx, address} for _, a := range opts { varargs = append(varargs, a) } @@ -221,9 +240,9 @@ func (m *MockGfSpClientAPI) Connection(ctx context.Context, address string, opts } // Connection indicates an expected call of Connection. -func (mr *MockGfSpClientAPIMockRecorder) Connection(ctx, address interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) Connection(ctx, address any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, address}, opts...) + varargs := append([]any{ctx, address}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connection", reflect.TypeOf((*MockGfSpClientAPI)(nil).Connection), varargs...) } @@ -236,7 +255,7 @@ func (m *MockGfSpClientAPI) CreateGlobalVirtualGroup(ctx context.Context, group } // CreateGlobalVirtualGroup indicates an expected call of CreateGlobalVirtualGroup. -func (mr *MockGfSpClientAPIMockRecorder) CreateGlobalVirtualGroup(ctx, group interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) CreateGlobalVirtualGroup(ctx, group any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalVirtualGroup", reflect.TypeOf((*MockGfSpClientAPI)(nil).CreateGlobalVirtualGroup), ctx, group) } @@ -250,7 +269,7 @@ func (m *MockGfSpClientAPI) CreateResumableUploadObject(ctx context.Context, tas } // CreateResumableUploadObject indicates an expected call of CreateResumableUploadObject. -func (mr *MockGfSpClientAPIMockRecorder) CreateResumableUploadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) CreateResumableUploadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResumableUploadObject", reflect.TypeOf((*MockGfSpClientAPI)(nil).CreateResumableUploadObject), ctx, task) } @@ -264,7 +283,7 @@ func (m *MockGfSpClientAPI) CreateUploadObject(ctx context.Context, task task.Up } // CreateUploadObject indicates an expected call of CreateUploadObject. -func (mr *MockGfSpClientAPIMockRecorder) CreateUploadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) CreateUploadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUploadObject", reflect.TypeOf((*MockGfSpClientAPI)(nil).CreateUploadObject), ctx, task) } @@ -272,7 +291,7 @@ func (mr *MockGfSpClientAPIMockRecorder) CreateUploadObject(ctx, task interface{ // DeductQuotaForBucketMigrate mocks base method. func (m *MockGfSpClientAPI) DeductQuotaForBucketMigrate(ctx context.Context, bucketID, deductQuota uint64, yearMonth string, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, deductQuota, yearMonth} + varargs := []any{ctx, bucketID, deductQuota, yearMonth} for _, a := range opts { varargs = append(varargs, a) } @@ -282,9 +301,9 @@ func (m *MockGfSpClientAPI) DeductQuotaForBucketMigrate(ctx context.Context, buc } // DeductQuotaForBucketMigrate indicates an expected call of DeductQuotaForBucketMigrate. -func (mr *MockGfSpClientAPIMockRecorder) DeductQuotaForBucketMigrate(ctx, bucketID, deductQuota, yearMonth interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) DeductQuotaForBucketMigrate(ctx, bucketID, deductQuota, yearMonth any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, deductQuota, yearMonth}, opts...) + varargs := append([]any{ctx, bucketID, deductQuota, yearMonth}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeductQuotaForBucketMigrate", reflect.TypeOf((*MockGfSpClientAPI)(nil).DeductQuotaForBucketMigrate), varargs...) } @@ -298,7 +317,7 @@ func (m *MockGfSpClientAPI) DeleteGlobalVirtualGroup(ctx context.Context, delete } // DeleteGlobalVirtualGroup indicates an expected call of DeleteGlobalVirtualGroup. -func (mr *MockGfSpClientAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalVirtualGroup", reflect.TypeOf((*MockGfSpClientAPI)(nil).DeleteGlobalVirtualGroup), ctx, deleteGVG) } @@ -313,7 +332,7 @@ func (m *MockGfSpClientAPI) Deposit(ctx context.Context, deposit *types4.MsgDepo } // Deposit indicates an expected call of Deposit. -func (mr *MockGfSpClientAPIMockRecorder) Deposit(ctx, deposit interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) Deposit(ctx, deposit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deposit", reflect.TypeOf((*MockGfSpClientAPI)(nil).Deposit), ctx, deposit) } @@ -328,7 +347,7 @@ func (m *MockGfSpClientAPI) DiscontinueBucket(ctx context.Context, bucket *types } // DiscontinueBucket indicates an expected call of DiscontinueBucket. -func (mr *MockGfSpClientAPIMockRecorder) DiscontinueBucket(ctx, bucket interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) DiscontinueBucket(ctx, bucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscontinueBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).DiscontinueBucket), ctx, bucket) } @@ -336,7 +355,7 @@ func (mr *MockGfSpClientAPIMockRecorder) DiscontinueBucket(ctx, bucket interface // DoneReplicatePiece mocks base method. func (m *MockGfSpClientAPI) DoneReplicatePiece(ctx context.Context, task task.ReceivePieceTask, opts ...grpc.DialOption) ([]byte, []byte, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, task} + varargs := []any{ctx, task} for _, a := range opts { varargs = append(varargs, a) } @@ -348,9 +367,9 @@ func (m *MockGfSpClientAPI) DoneReplicatePiece(ctx context.Context, task task.Re } // DoneReplicatePiece indicates an expected call of DoneReplicatePiece. -func (mr *MockGfSpClientAPIMockRecorder) DoneReplicatePiece(ctx, task interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) DoneReplicatePiece(ctx, task any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, task}, opts...) + varargs := append([]any{ctx, task}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoneReplicatePiece", reflect.TypeOf((*MockGfSpClientAPI)(nil).DoneReplicatePiece), varargs...) } @@ -364,7 +383,7 @@ func (m *MockGfSpClientAPI) DoneReplicatePieceToSecondary(ctx context.Context, e } // DoneReplicatePieceToSecondary indicates an expected call of DoneReplicatePieceToSecondary. -func (mr *MockGfSpClientAPIMockRecorder) DoneReplicatePieceToSecondary(ctx, endpoint, receive interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) DoneReplicatePieceToSecondary(ctx, endpoint, receive any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoneReplicatePieceToSecondary", reflect.TypeOf((*MockGfSpClientAPI)(nil).DoneReplicatePieceToSecondary), ctx, endpoint, receive) } @@ -372,7 +391,7 @@ func (mr *MockGfSpClientAPIMockRecorder) DoneReplicatePieceToSecondary(ctx, endp // GetAuthNonce mocks base method. func (m *MockGfSpClientAPI) GetAuthNonce(ctx context.Context, account, domain string, opts ...grpc.DialOption) (int32, int32, string, int64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, domain} + varargs := []any{ctx, account, domain} for _, a := range opts { varargs = append(varargs, a) } @@ -386,16 +405,16 @@ func (m *MockGfSpClientAPI) GetAuthNonce(ctx context.Context, account, domain st } // GetAuthNonce indicates an expected call of GetAuthNonce. -func (mr *MockGfSpClientAPIMockRecorder) GetAuthNonce(ctx, account, domain interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetAuthNonce(ctx, account, domain any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, domain}, opts...) + varargs := append([]any{ctx, account, domain}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthNonce", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetAuthNonce), varargs...) } // GetBucketByBucketID mocks base method. func (m *MockGfSpClientAPI) GetBucketByBucketID(ctx context.Context, bucketID int64, includePrivate bool, opts ...grpc.DialOption) (*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, includePrivate} + varargs := []any{ctx, bucketID, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -406,16 +425,16 @@ func (m *MockGfSpClientAPI) GetBucketByBucketID(ctx context.Context, bucketID in } // GetBucketByBucketID indicates an expected call of GetBucketByBucketID. -func (mr *MockGfSpClientAPIMockRecorder) GetBucketByBucketID(ctx, bucketID, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetBucketByBucketID(ctx, bucketID, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, includePrivate}, opts...) + varargs := append([]any{ctx, bucketID, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketByBucketID", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetBucketByBucketID), varargs...) } // GetBucketByBucketName mocks base method. func (m *MockGfSpClientAPI) GetBucketByBucketName(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketName, includePrivate} + varargs := []any{ctx, bucketName, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -426,16 +445,16 @@ func (m *MockGfSpClientAPI) GetBucketByBucketName(ctx context.Context, bucketNam } // GetBucketByBucketName indicates an expected call of GetBucketByBucketName. -func (mr *MockGfSpClientAPIMockRecorder) GetBucketByBucketName(ctx, bucketName, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetBucketByBucketName(ctx, bucketName, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketName, includePrivate}, opts...) + varargs := append([]any{ctx, bucketName, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketByBucketName", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetBucketByBucketName), varargs...) } // GetBucketMeta mocks base method. func (m *MockGfSpClientAPI) GetBucketMeta(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.VGFInfoBucket, *types0.StreamRecord, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketName, includePrivate} + varargs := []any{ctx, bucketName, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -447,16 +466,16 @@ func (m *MockGfSpClientAPI) GetBucketMeta(ctx context.Context, bucketName string } // GetBucketMeta indicates an expected call of GetBucketMeta. -func (mr *MockGfSpClientAPIMockRecorder) GetBucketMeta(ctx, bucketName, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetBucketMeta(ctx, bucketName, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketName, includePrivate}, opts...) + varargs := append([]any{ctx, bucketName, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMeta", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetBucketMeta), varargs...) } // GetBucketReadQuota mocks base method. func (m *MockGfSpClientAPI) GetBucketReadQuota(ctx context.Context, bucket *types3.BucketInfo, yearMonth string, opts ...grpc.DialOption) (uint64, uint64, uint64, uint64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucket, yearMonth} + varargs := []any{ctx, bucket, yearMonth} for _, a := range opts { varargs = append(varargs, a) } @@ -470,16 +489,16 @@ func (m *MockGfSpClientAPI) GetBucketReadQuota(ctx context.Context, bucket *type } // GetBucketReadQuota indicates an expected call of GetBucketReadQuota. -func (mr *MockGfSpClientAPIMockRecorder) GetBucketReadQuota(ctx, bucket, yearMonth interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetBucketReadQuota(ctx, bucket, yearMonth any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucket, yearMonth}, opts...) + varargs := append([]any{ctx, bucket, yearMonth}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReadQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetBucketReadQuota), varargs...) } // GetBucketSize mocks base method. func (m *MockGfSpClientAPI) GetBucketSize(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID} + varargs := []any{ctx, bucketID} for _, a := range opts { varargs = append(varargs, a) } @@ -490,16 +509,16 @@ func (m *MockGfSpClientAPI) GetBucketSize(ctx context.Context, bucketID uint64, } // GetBucketSize indicates an expected call of GetBucketSize. -func (mr *MockGfSpClientAPIMockRecorder) GetBucketSize(ctx, bucketID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetBucketSize(ctx, bucketID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID}, opts...) + varargs := append([]any{ctx, bucketID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketSize", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetBucketSize), varargs...) } // GetChallengeInfo mocks base method. func (m *MockGfSpClientAPI) GetChallengeInfo(ctx context.Context, challengePieceTask task.ChallengePieceTask, opts ...grpc.DialOption) ([]byte, [][]byte, []byte, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, challengePieceTask} + varargs := []any{ctx, challengePieceTask} for _, a := range opts { varargs = append(varargs, a) } @@ -512,16 +531,16 @@ func (m *MockGfSpClientAPI) GetChallengeInfo(ctx context.Context, challengePiece } // GetChallengeInfo indicates an expected call of GetChallengeInfo. -func (mr *MockGfSpClientAPIMockRecorder) GetChallengeInfo(ctx, challengePieceTask interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetChallengeInfo(ctx, challengePieceTask any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, challengePieceTask}, opts...) + varargs := append([]any{ctx, challengePieceTask}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChallengeInfo", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetChallengeInfo), varargs...) } // GetEndpointBySpID mocks base method. func (m *MockGfSpClientAPI) GetEndpointBySpID(ctx context.Context, spID uint32, opts ...grpc.DialOption) (string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -532,16 +551,16 @@ func (m *MockGfSpClientAPI) GetEndpointBySpID(ctx context.Context, spID uint32, } // GetEndpointBySpID indicates an expected call of GetEndpointBySpID. -func (mr *MockGfSpClientAPIMockRecorder) GetEndpointBySpID(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetEndpointBySpID(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEndpointBySpID", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetEndpointBySpID), varargs...) } // GetGlobalVirtualGroup mocks base method. func (m *MockGfSpClientAPI) GetGlobalVirtualGroup(ctx context.Context, bucketID uint64, lvgID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroup, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, lvgID} + varargs := []any{ctx, bucketID, lvgID} for _, a := range opts { varargs = append(varargs, a) } @@ -552,16 +571,16 @@ func (m *MockGfSpClientAPI) GetGlobalVirtualGroup(ctx context.Context, bucketID } // GetGlobalVirtualGroup indicates an expected call of GetGlobalVirtualGroup. -func (mr *MockGfSpClientAPIMockRecorder) GetGlobalVirtualGroup(ctx, bucketID, lvgID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetGlobalVirtualGroup(ctx, bucketID, lvgID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, lvgID}, opts...) + varargs := append([]any{ctx, bucketID, lvgID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGlobalVirtualGroup", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetGlobalVirtualGroup), varargs...) } // GetGlobalVirtualGroupByGvgID mocks base method. func (m *MockGfSpClientAPI) GetGlobalVirtualGroupByGvgID(ctx context.Context, gvgID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroup, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, gvgID} + varargs := []any{ctx, gvgID} for _, a := range opts { varargs = append(varargs, a) } @@ -572,16 +591,16 @@ func (m *MockGfSpClientAPI) GetGlobalVirtualGroupByGvgID(ctx context.Context, gv } // GetGlobalVirtualGroupByGvgID indicates an expected call of GetGlobalVirtualGroupByGvgID. -func (mr *MockGfSpClientAPIMockRecorder) GetGlobalVirtualGroupByGvgID(ctx, gvgID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetGlobalVirtualGroupByGvgID(ctx, gvgID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, gvgID}, opts...) + varargs := append([]any{ctx, gvgID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGlobalVirtualGroupByGvgID", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetGlobalVirtualGroupByGvgID), varargs...) } // GetGroupList mocks base method. func (m *MockGfSpClientAPI) GetGroupList(ctx context.Context, name, prefix, sourceType string, limit, offset int64, includeRemoved bool, opts ...grpc.DialOption) ([]*types.Group, int64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, name, prefix, sourceType, limit, offset, includeRemoved} + varargs := []any{ctx, name, prefix, sourceType, limit, offset, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -593,16 +612,16 @@ func (m *MockGfSpClientAPI) GetGroupList(ctx context.Context, name, prefix, sour } // GetGroupList indicates an expected call of GetGroupList. -func (mr *MockGfSpClientAPIMockRecorder) GetGroupList(ctx, name, prefix, sourceType, limit, offset, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetGroupList(ctx, name, prefix, sourceType, limit, offset, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, name, prefix, sourceType, limit, offset, includeRemoved}, opts...) + varargs := append([]any{ctx, name, prefix, sourceType, limit, offset, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupList", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetGroupList), varargs...) } // GetGroupMembers mocks base method. func (m *MockGfSpClientAPI) GetGroupMembers(ctx context.Context, groupID uint64, startAfter string, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, groupID, startAfter, limit} + varargs := []any{ctx, groupID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -613,16 +632,16 @@ func (m *MockGfSpClientAPI) GetGroupMembers(ctx context.Context, groupID uint64, } // GetGroupMembers indicates an expected call of GetGroupMembers. -func (mr *MockGfSpClientAPIMockRecorder) GetGroupMembers(ctx, groupID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetGroupMembers(ctx, groupID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, groupID, startAfter, limit}, opts...) + varargs := append([]any{ctx, groupID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMembers", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetGroupMembers), varargs...) } // GetLatestBucketReadQuota mocks base method. func (m *MockGfSpClientAPI) GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID} + varargs := []any{ctx, bucketID} for _, a := range opts { varargs = append(varargs, a) } @@ -633,16 +652,16 @@ func (m *MockGfSpClientAPI) GetLatestBucketReadQuota(ctx context.Context, bucket } // GetLatestBucketReadQuota indicates an expected call of GetLatestBucketReadQuota. -func (mr *MockGfSpClientAPIMockRecorder) GetLatestBucketReadQuota(ctx, bucketID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetLatestBucketReadQuota(ctx, bucketID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID}, opts...) + varargs := append([]any{ctx, bucketID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestBucketReadQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetLatestBucketReadQuota), varargs...) } // GetLatestObjectID mocks base method. func (m *MockGfSpClientAPI) GetLatestObjectID(ctx context.Context, opts ...grpc.DialOption) (uint64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -653,9 +672,9 @@ func (m *MockGfSpClientAPI) GetLatestObjectID(ctx context.Context, opts ...grpc. } // GetLatestObjectID indicates an expected call of GetLatestObjectID. -func (mr *MockGfSpClientAPIMockRecorder) GetLatestObjectID(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetLatestObjectID(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestObjectID", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetLatestObjectID), varargs...) } @@ -669,7 +688,7 @@ func (m *MockGfSpClientAPI) GetMigrateBucketProgress(ctx context.Context, bucket } // GetMigrateBucketProgress indicates an expected call of GetMigrateBucketProgress. -func (mr *MockGfSpClientAPIMockRecorder) GetMigrateBucketProgress(ctx, bucketID interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetMigrateBucketProgress(ctx, bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMigrateBucketProgress", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetMigrateBucketProgress), ctx, bucketID) } @@ -677,7 +696,7 @@ func (mr *MockGfSpClientAPIMockRecorder) GetMigrateBucketProgress(ctx, bucketID // GetObject mocks base method. func (m *MockGfSpClientAPI) GetObject(ctx context.Context, downloadObjectTask task.DownloadObjectTask, opts ...grpc.DialOption) ([]byte, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, downloadObjectTask} + varargs := []any{ctx, downloadObjectTask} for _, a := range opts { varargs = append(varargs, a) } @@ -688,16 +707,16 @@ func (m *MockGfSpClientAPI) GetObject(ctx context.Context, downloadObjectTask ta } // GetObject indicates an expected call of GetObject. -func (mr *MockGfSpClientAPIMockRecorder) GetObject(ctx, downloadObjectTask interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetObject(ctx, downloadObjectTask any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, downloadObjectTask}, opts...) + varargs := append([]any{ctx, downloadObjectTask}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetObject), varargs...) } // GetObjectByID mocks base method. func (m *MockGfSpClientAPI) GetObjectByID(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (*types3.ObjectInfo, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectID} + varargs := []any{ctx, objectID} for _, a := range opts { varargs = append(varargs, a) } @@ -708,16 +727,16 @@ func (m *MockGfSpClientAPI) GetObjectByID(ctx context.Context, objectID uint64, } // GetObjectByID indicates an expected call of GetObjectByID. -func (mr *MockGfSpClientAPIMockRecorder) GetObjectByID(ctx, objectID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetObjectByID(ctx, objectID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectID}, opts...) + varargs := append([]any{ctx, objectID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectByID", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetObjectByID), varargs...) } // GetObjectMeta mocks base method. func (m *MockGfSpClientAPI) GetObjectMeta(ctx context.Context, objectName, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.Object, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectName, bucketName, includePrivate} + varargs := []any{ctx, objectName, bucketName, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -728,16 +747,16 @@ func (m *MockGfSpClientAPI) GetObjectMeta(ctx context.Context, objectName, bucke } // GetObjectMeta indicates an expected call of GetObjectMeta. -func (mr *MockGfSpClientAPIMockRecorder) GetObjectMeta(ctx, objectName, bucketName, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetObjectMeta(ctx, objectName, bucketName, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectName, bucketName, includePrivate}, opts...) + varargs := append([]any{ctx, objectName, bucketName, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectMeta", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetObjectMeta), varargs...) } // GetPaymentByBucketID mocks base method. func (m *MockGfSpClientAPI) GetPaymentByBucketID(ctx context.Context, bucketID int64, includePrivate bool, opts ...grpc.DialOption) (*types0.StreamRecord, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, includePrivate} + varargs := []any{ctx, bucketID, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -748,16 +767,16 @@ func (m *MockGfSpClientAPI) GetPaymentByBucketID(ctx context.Context, bucketID i } // GetPaymentByBucketID indicates an expected call of GetPaymentByBucketID. -func (mr *MockGfSpClientAPIMockRecorder) GetPaymentByBucketID(ctx, bucketID, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetPaymentByBucketID(ctx, bucketID, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, includePrivate}, opts...) + varargs := append([]any{ctx, bucketID, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPaymentByBucketID", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetPaymentByBucketID), varargs...) } // GetPaymentByBucketName mocks base method. func (m *MockGfSpClientAPI) GetPaymentByBucketName(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types0.StreamRecord, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketName, includePrivate} + varargs := []any{ctx, bucketName, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -768,16 +787,16 @@ func (m *MockGfSpClientAPI) GetPaymentByBucketName(ctx context.Context, bucketNa } // GetPaymentByBucketName indicates an expected call of GetPaymentByBucketName. -func (mr *MockGfSpClientAPIMockRecorder) GetPaymentByBucketName(ctx, bucketName, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetPaymentByBucketName(ctx, bucketName, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketName, includePrivate}, opts...) + varargs := append([]any{ctx, bucketName, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPaymentByBucketName", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetPaymentByBucketName), varargs...) } // GetPiece mocks base method. func (m *MockGfSpClientAPI) GetPiece(ctx context.Context, downloadPieceTask task.DownloadPieceTask, opts ...grpc.DialOption) ([]byte, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, downloadPieceTask} + varargs := []any{ctx, downloadPieceTask} for _, a := range opts { varargs = append(varargs, a) } @@ -788,9 +807,9 @@ func (m *MockGfSpClientAPI) GetPiece(ctx context.Context, downloadPieceTask task } // GetPiece indicates an expected call of GetPiece. -func (mr *MockGfSpClientAPIMockRecorder) GetPiece(ctx, downloadPieceTask interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetPiece(ctx, downloadPieceTask any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, downloadPieceTask}, opts...) + varargs := append([]any{ctx, downloadPieceTask}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPiece", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetPiece), varargs...) } @@ -804,7 +823,7 @@ func (m *MockGfSpClientAPI) GetPieceFromECChunks(ctx context.Context, endpoint s } // GetPieceFromECChunks indicates an expected call of GetPieceFromECChunks. -func (mr *MockGfSpClientAPIMockRecorder) GetPieceFromECChunks(ctx, endpoint, task interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetPieceFromECChunks(ctx, endpoint, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPieceFromECChunks", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetPieceFromECChunks), ctx, endpoint, task) } @@ -812,7 +831,7 @@ func (mr *MockGfSpClientAPIMockRecorder) GetPieceFromECChunks(ctx, endpoint, tas // GetSPInfo mocks base method. func (m *MockGfSpClientAPI) GetSPInfo(ctx context.Context, operatorAddress string, opts ...grpc.DialOption) (*types2.StorageProvider, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, operatorAddress} + varargs := []any{ctx, operatorAddress} for _, a := range opts { varargs = append(varargs, a) } @@ -823,16 +842,16 @@ func (m *MockGfSpClientAPI) GetSPInfo(ctx context.Context, operatorAddress strin } // GetSPInfo indicates an expected call of GetSPInfo. -func (mr *MockGfSpClientAPIMockRecorder) GetSPInfo(ctx, operatorAddress interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetSPInfo(ctx, operatorAddress any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, operatorAddress}, opts...) + varargs := append([]any{ctx, operatorAddress}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSPInfo", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetSPInfo), varargs...) } // GetSPMigratingBucketNumber mocks base method. func (m *MockGfSpClientAPI) GetSPMigratingBucketNumber(ctx context.Context, spID uint32, opts ...grpc.DialOption) (uint64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -843,9 +862,9 @@ func (m *MockGfSpClientAPI) GetSPMigratingBucketNumber(ctx context.Context, spID } // GetSPMigratingBucketNumber indicates an expected call of GetSPMigratingBucketNumber. -func (mr *MockGfSpClientAPIMockRecorder) GetSPMigratingBucketNumber(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetSPMigratingBucketNumber(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSPMigratingBucketNumber", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetSPMigratingBucketNumber), varargs...) } @@ -859,7 +878,7 @@ func (m *MockGfSpClientAPI) GetSecondarySPMigrationBucketApproval(ctx context.Co } // GetSecondarySPMigrationBucketApproval indicates an expected call of GetSecondarySPMigrationBucketApproval. -func (mr *MockGfSpClientAPIMockRecorder) GetSecondarySPMigrationBucketApproval(ctx, secondarySPEndpoint, signDoc interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetSecondarySPMigrationBucketApproval(ctx, secondarySPEndpoint, signDoc any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecondarySPMigrationBucketApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetSecondarySPMigrationBucketApproval), ctx, secondarySPEndpoint, signDoc) } @@ -867,7 +886,7 @@ func (mr *MockGfSpClientAPIMockRecorder) GetSecondarySPMigrationBucketApproval(c // GetStatus mocks base method. func (m *MockGfSpClientAPI) GetStatus(ctx context.Context, opts ...grpc.DialOption) (*types.Status, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -878,9 +897,9 @@ func (m *MockGfSpClientAPI) GetStatus(ctx context.Context, opts ...grpc.DialOpti } // GetStatus indicates an expected call of GetStatus. -func (mr *MockGfSpClientAPIMockRecorder) GetStatus(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetStatus(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatus", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetStatus), varargs...) } @@ -894,7 +913,7 @@ func (m *MockGfSpClientAPI) GetSwapOutApproval(ctx context.Context, destSPEndpoi } // GetSwapOutApproval indicates an expected call of GetSwapOutApproval. -func (mr *MockGfSpClientAPIMockRecorder) GetSwapOutApproval(ctx, destSPEndpoint, swapOutApproval interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetSwapOutApproval(ctx, destSPEndpoint, swapOutApproval any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSwapOutApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetSwapOutApproval), ctx, destSPEndpoint, swapOutApproval) } @@ -909,7 +928,7 @@ func (m *MockGfSpClientAPI) GetTasksStats(ctx context.Context) (*gfspserver.Task } // GetTasksStats indicates an expected call of GetTasksStats. -func (mr *MockGfSpClientAPIMockRecorder) GetTasksStats(ctx interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetTasksStats(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTasksStats", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetTasksStats), ctx) } @@ -917,7 +936,7 @@ func (mr *MockGfSpClientAPIMockRecorder) GetTasksStats(ctx interface{}) *gomock. // GetUploadObjectSegment mocks base method. func (m *MockGfSpClientAPI) GetUploadObjectSegment(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (uint32, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectID} + varargs := []any{ctx, objectID} for _, a := range opts { varargs = append(varargs, a) } @@ -928,16 +947,16 @@ func (m *MockGfSpClientAPI) GetUploadObjectSegment(ctx context.Context, objectID } // GetUploadObjectSegment indicates an expected call of GetUploadObjectSegment. -func (mr *MockGfSpClientAPIMockRecorder) GetUploadObjectSegment(ctx, objectID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetUploadObjectSegment(ctx, objectID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectID}, opts...) + varargs := append([]any{ctx, objectID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadObjectSegment", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetUploadObjectSegment), varargs...) } // GetUploadObjectState mocks base method. func (m *MockGfSpClientAPI) GetUploadObjectState(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (int32, string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectID} + varargs := []any{ctx, objectID} for _, a := range opts { varargs = append(varargs, a) } @@ -949,16 +968,16 @@ func (m *MockGfSpClientAPI) GetUploadObjectState(ctx context.Context, objectID u } // GetUploadObjectState indicates an expected call of GetUploadObjectState. -func (mr *MockGfSpClientAPIMockRecorder) GetUploadObjectState(ctx, objectID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetUploadObjectState(ctx, objectID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectID}, opts...) + varargs := append([]any{ctx, objectID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadObjectState", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetUploadObjectState), varargs...) } // GetUserBuckets mocks base method. func (m *MockGfSpClientAPI) GetUserBuckets(ctx context.Context, account string, includeRemoved bool, opts ...grpc.DialOption) ([]*types.VGFInfoBucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, includeRemoved} + varargs := []any{ctx, account, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -969,16 +988,16 @@ func (m *MockGfSpClientAPI) GetUserBuckets(ctx context.Context, account string, } // GetUserBuckets indicates an expected call of GetUserBuckets. -func (mr *MockGfSpClientAPIMockRecorder) GetUserBuckets(ctx, account, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetUserBuckets(ctx, account, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, includeRemoved}, opts...) + varargs := append([]any{ctx, account, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserBuckets", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetUserBuckets), varargs...) } // GetUserBucketsCount mocks base method. func (m *MockGfSpClientAPI) GetUserBucketsCount(ctx context.Context, account string, includeRemoved bool, opts ...grpc.DialOption) (int64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, includeRemoved} + varargs := []any{ctx, account, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -989,16 +1008,16 @@ func (m *MockGfSpClientAPI) GetUserBucketsCount(ctx context.Context, account str } // GetUserBucketsCount indicates an expected call of GetUserBucketsCount. -func (mr *MockGfSpClientAPIMockRecorder) GetUserBucketsCount(ctx, account, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetUserBucketsCount(ctx, account, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, includeRemoved}, opts...) + varargs := append([]any{ctx, account, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserBucketsCount", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetUserBucketsCount), varargs...) } // GetUserGroups mocks base method. func (m *MockGfSpClientAPI) GetUserGroups(ctx context.Context, accountID string, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, accountID, startAfter, limit} + varargs := []any{ctx, accountID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -1009,16 +1028,16 @@ func (m *MockGfSpClientAPI) GetUserGroups(ctx context.Context, accountID string, } // GetUserGroups indicates an expected call of GetUserGroups. -func (mr *MockGfSpClientAPIMockRecorder) GetUserGroups(ctx, accountID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetUserGroups(ctx, accountID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, accountID, startAfter, limit}, opts...) + varargs := append([]any{ctx, accountID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserGroups", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetUserGroups), varargs...) } // GetUserOwnedGroups mocks base method. func (m *MockGfSpClientAPI) GetUserOwnedGroups(ctx context.Context, accountID string, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, accountID, startAfter, limit} + varargs := []any{ctx, accountID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -1029,16 +1048,16 @@ func (m *MockGfSpClientAPI) GetUserOwnedGroups(ctx context.Context, accountID st } // GetUserOwnedGroups indicates an expected call of GetUserOwnedGroups. -func (mr *MockGfSpClientAPIMockRecorder) GetUserOwnedGroups(ctx, accountID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetUserOwnedGroups(ctx, accountID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, accountID, startAfter, limit}, opts...) + varargs := append([]any{ctx, accountID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserOwnedGroups", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetUserOwnedGroups), varargs...) } // GetVirtualGroupFamily mocks base method. func (m *MockGfSpClientAPI) GetVirtualGroupFamily(ctx context.Context, vgfID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroupFamily, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, vgfID} + varargs := []any{ctx, vgfID} for _, a := range opts { varargs = append(varargs, a) } @@ -1049,9 +1068,9 @@ func (m *MockGfSpClientAPI) GetVirtualGroupFamily(ctx context.Context, vgfID uin } // GetVirtualGroupFamily indicates an expected call of GetVirtualGroupFamily. -func (mr *MockGfSpClientAPIMockRecorder) GetVirtualGroupFamily(ctx, vgfID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) GetVirtualGroupFamily(ctx, vgfID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, vgfID}, opts...) + varargs := append([]any{ctx, vgfID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualGroupFamily", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetVirtualGroupFamily), varargs...) } @@ -1064,7 +1083,7 @@ func (m *MockGfSpClientAPI) HTTPClient(ctx context.Context) *http.Client { } // HTTPClient indicates an expected call of HTTPClient. -func (mr *MockGfSpClientAPIMockRecorder) HTTPClient(ctx interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) HTTPClient(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTPClient", reflect.TypeOf((*MockGfSpClientAPI)(nil).HTTPClient), ctx) } @@ -1072,7 +1091,7 @@ func (mr *MockGfSpClientAPIMockRecorder) HTTPClient(ctx interface{}) *gomock.Cal // ListBucketReadRecord mocks base method. func (m *MockGfSpClientAPI) ListBucketReadRecord(ctx context.Context, bucket *types3.BucketInfo, startTimestampUs, endTimestampUs, maxRecordNum int64, opts ...grpc.DialOption) ([]*types.ReadRecord, int64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum} + varargs := []any{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum} for _, a := range opts { varargs = append(varargs, a) } @@ -1084,16 +1103,16 @@ func (m *MockGfSpClientAPI) ListBucketReadRecord(ctx context.Context, bucket *ty } // ListBucketReadRecord indicates an expected call of ListBucketReadRecord. -func (mr *MockGfSpClientAPIMockRecorder) ListBucketReadRecord(ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListBucketReadRecord(ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum}, opts...) + varargs := append([]any{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketReadRecord", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListBucketReadRecord), varargs...) } // ListBucketsByIDs mocks base method. func (m *MockGfSpClientAPI) ListBucketsByIDs(ctx context.Context, bucketIDs []uint64, includeRemoved bool, opts ...grpc.DialOption) (map[uint64]*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketIDs, includeRemoved} + varargs := []any{ctx, bucketIDs, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -1104,16 +1123,16 @@ func (m *MockGfSpClientAPI) ListBucketsByIDs(ctx context.Context, bucketIDs []ui } // ListBucketsByIDs indicates an expected call of ListBucketsByIDs. -func (mr *MockGfSpClientAPIMockRecorder) ListBucketsByIDs(ctx, bucketIDs, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListBucketsByIDs(ctx, bucketIDs, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketIDs, includeRemoved}, opts...) + varargs := append([]any{ctx, bucketIDs, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsByIDs", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListBucketsByIDs), varargs...) } // ListCompleteMigrationBucketEvents mocks base method. func (m *MockGfSpClientAPI) ListCompleteMigrationBucketEvents(ctx context.Context, blockID uint64, srcSpID uint32, opts ...grpc.DialOption) ([]*types3.EventCompleteMigrationBucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, blockID, srcSpID} + varargs := []any{ctx, blockID, srcSpID} for _, a := range opts { varargs = append(varargs, a) } @@ -1124,16 +1143,16 @@ func (m *MockGfSpClientAPI) ListCompleteMigrationBucketEvents(ctx context.Contex } // ListCompleteMigrationBucketEvents indicates an expected call of ListCompleteMigrationBucketEvents. -func (mr *MockGfSpClientAPIMockRecorder) ListCompleteMigrationBucketEvents(ctx, blockID, srcSpID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListCompleteMigrationBucketEvents(ctx, blockID, srcSpID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, blockID, srcSpID}, opts...) + varargs := append([]any{ctx, blockID, srcSpID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompleteMigrationBucketEvents", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListCompleteMigrationBucketEvents), varargs...) } // ListDeletedObjectsByBlockNumberRange mocks base method. func (m *MockGfSpClientAPI) ListDeletedObjectsByBlockNumberRange(ctx context.Context, spOperatorAddress string, startBlockNumber, endBlockNumber uint64, includePrivate bool, opts ...grpc.DialOption) ([]*types.Object, uint64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate} + varargs := []any{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -1145,16 +1164,16 @@ func (m *MockGfSpClientAPI) ListDeletedObjectsByBlockNumberRange(ctx context.Con } // ListDeletedObjectsByBlockNumberRange indicates an expected call of ListDeletedObjectsByBlockNumberRange. -func (mr *MockGfSpClientAPIMockRecorder) ListDeletedObjectsByBlockNumberRange(ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListDeletedObjectsByBlockNumberRange(ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate}, opts...) + varargs := append([]any{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeletedObjectsByBlockNumberRange", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListDeletedObjectsByBlockNumberRange), varargs...) } // ListExpiredBucketsBySp mocks base method. func (m *MockGfSpClientAPI) ListExpiredBucketsBySp(ctx context.Context, createAt int64, primarySpID uint32, limit int64, opts ...grpc.DialOption) ([]*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, createAt, primarySpID, limit} + varargs := []any{ctx, createAt, primarySpID, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -1165,16 +1184,16 @@ func (m *MockGfSpClientAPI) ListExpiredBucketsBySp(ctx context.Context, createAt } // ListExpiredBucketsBySp indicates an expected call of ListExpiredBucketsBySp. -func (mr *MockGfSpClientAPIMockRecorder) ListExpiredBucketsBySp(ctx, createAt, primarySpID, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListExpiredBucketsBySp(ctx, createAt, primarySpID, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, createAt, primarySpID, limit}, opts...) + varargs := append([]any{ctx, createAt, primarySpID, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExpiredBucketsBySp", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListExpiredBucketsBySp), varargs...) } // ListGlobalVirtualGroupsByBucket mocks base method. func (m *MockGfSpClientAPI) ListGlobalVirtualGroupsByBucket(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroup, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID} + varargs := []any{ctx, bucketID} for _, a := range opts { varargs = append(varargs, a) } @@ -1185,16 +1204,16 @@ func (m *MockGfSpClientAPI) ListGlobalVirtualGroupsByBucket(ctx context.Context, } // ListGlobalVirtualGroupsByBucket indicates an expected call of ListGlobalVirtualGroupsByBucket. -func (mr *MockGfSpClientAPIMockRecorder) ListGlobalVirtualGroupsByBucket(ctx, bucketID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListGlobalVirtualGroupsByBucket(ctx, bucketID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID}, opts...) + varargs := append([]any{ctx, bucketID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalVirtualGroupsByBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListGlobalVirtualGroupsByBucket), varargs...) } // ListGlobalVirtualGroupsBySecondarySP mocks base method. func (m *MockGfSpClientAPI) ListGlobalVirtualGroupsBySecondarySP(ctx context.Context, spID uint32, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroup, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -1205,16 +1224,16 @@ func (m *MockGfSpClientAPI) ListGlobalVirtualGroupsBySecondarySP(ctx context.Con } // ListGlobalVirtualGroupsBySecondarySP indicates an expected call of ListGlobalVirtualGroupsBySecondarySP. -func (mr *MockGfSpClientAPIMockRecorder) ListGlobalVirtualGroupsBySecondarySP(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListGlobalVirtualGroupsBySecondarySP(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalVirtualGroupsBySecondarySP", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListGlobalVirtualGroupsBySecondarySP), varargs...) } // ListGroupsByIDs mocks base method. func (m *MockGfSpClientAPI) ListGroupsByIDs(ctx context.Context, groupIDs []uint64, opts ...grpc.DialOption) (map[uint64]*types.Group, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, groupIDs} + varargs := []any{ctx, groupIDs} for _, a := range opts { varargs = append(varargs, a) } @@ -1225,16 +1244,16 @@ func (m *MockGfSpClientAPI) ListGroupsByIDs(ctx context.Context, groupIDs []uint } // ListGroupsByIDs indicates an expected call of ListGroupsByIDs. -func (mr *MockGfSpClientAPIMockRecorder) ListGroupsByIDs(ctx, groupIDs interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListGroupsByIDs(ctx, groupIDs any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, groupIDs}, opts...) + varargs := append([]any{ctx, groupIDs}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsByIDs", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListGroupsByIDs), varargs...) } // ListMigrateBucketEvents mocks base method. func (m *MockGfSpClientAPI) ListMigrateBucketEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListMigrateBucketEvents, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, blockID, spID} + varargs := []any{ctx, blockID, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -1245,16 +1264,16 @@ func (m *MockGfSpClientAPI) ListMigrateBucketEvents(ctx context.Context, blockID } // ListMigrateBucketEvents indicates an expected call of ListMigrateBucketEvents. -func (mr *MockGfSpClientAPIMockRecorder) ListMigrateBucketEvents(ctx, blockID, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListMigrateBucketEvents(ctx, blockID, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, blockID, spID}, opts...) + varargs := append([]any{ctx, blockID, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMigrateBucketEvents", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListMigrateBucketEvents), varargs...) } // ListObjectPolicies mocks base method. func (m *MockGfSpClientAPI) ListObjectPolicies(ctx context.Context, objectName, bucketName string, startAfter uint64, actionType int32, limit uint32, opts ...grpc.DialOption) ([]*types.Policy, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectName, bucketName, startAfter, actionType, limit} + varargs := []any{ctx, objectName, bucketName, startAfter, actionType, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -1265,16 +1284,16 @@ func (m *MockGfSpClientAPI) ListObjectPolicies(ctx context.Context, objectName, } // ListObjectPolicies indicates an expected call of ListObjectPolicies. -func (mr *MockGfSpClientAPIMockRecorder) ListObjectPolicies(ctx, objectName, bucketName, startAfter, actionType, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListObjectPolicies(ctx, objectName, bucketName, startAfter, actionType, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectName, bucketName, startAfter, actionType, limit}, opts...) + varargs := append([]any{ctx, objectName, bucketName, startAfter, actionType, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectPolicies", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectPolicies), varargs...) } // ListObjectsByBucketName mocks base method. func (m *MockGfSpClientAPI) ListObjectsByBucketName(ctx context.Context, bucketName, accountID string, maxKeys uint64, startAfter, continuationToken, delimiter, prefix string, includeRemoved bool, opts ...grpc.DialOption) ([]*types.Object, uint64, uint64, bool, string, string, string, string, []string, string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved} + varargs := []any{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -1294,16 +1313,16 @@ func (m *MockGfSpClientAPI) ListObjectsByBucketName(ctx context.Context, bucketN } // ListObjectsByBucketName indicates an expected call of ListObjectsByBucketName. -func (mr *MockGfSpClientAPIMockRecorder) ListObjectsByBucketName(ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListObjectsByBucketName(ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved}, opts...) + varargs := append([]any{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByBucketName", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectsByBucketName), varargs...) } // ListObjectsByGVGAndBucketForGC mocks base method. func (m *MockGfSpClientAPI) ListObjectsByGVGAndBucketForGC(ctx context.Context, gvgID uint32, bucketID, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, gvgID, bucketID, startAfter, limit} + varargs := []any{ctx, gvgID, bucketID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -1314,16 +1333,16 @@ func (m *MockGfSpClientAPI) ListObjectsByGVGAndBucketForGC(ctx context.Context, } // ListObjectsByGVGAndBucketForGC indicates an expected call of ListObjectsByGVGAndBucketForGC. -func (mr *MockGfSpClientAPIMockRecorder) ListObjectsByGVGAndBucketForGC(ctx, gvgID, bucketID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListObjectsByGVGAndBucketForGC(ctx, gvgID, bucketID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, gvgID, bucketID, startAfter, limit}, opts...) + varargs := append([]any{ctx, gvgID, bucketID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByGVGAndBucketForGC", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectsByGVGAndBucketForGC), varargs...) } // ListObjectsByIDs mocks base method. func (m *MockGfSpClientAPI) ListObjectsByIDs(ctx context.Context, objectIDs []uint64, includeRemoved bool, opts ...grpc.DialOption) (map[uint64]*types.Object, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectIDs, includeRemoved} + varargs := []any{ctx, objectIDs, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -1334,16 +1353,16 @@ func (m *MockGfSpClientAPI) ListObjectsByIDs(ctx context.Context, objectIDs []ui } // ListObjectsByIDs indicates an expected call of ListObjectsByIDs. -func (mr *MockGfSpClientAPIMockRecorder) ListObjectsByIDs(ctx, objectIDs, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListObjectsByIDs(ctx, objectIDs, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectIDs, includeRemoved}, opts...) + varargs := append([]any{ctx, objectIDs, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByIDs", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectsByIDs), varargs...) } // ListObjectsInGVG mocks base method. func (m *MockGfSpClientAPI) ListObjectsInGVG(ctx context.Context, gvgID uint32, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, gvgID, startAfter, limit} + varargs := []any{ctx, gvgID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -1354,16 +1373,16 @@ func (m *MockGfSpClientAPI) ListObjectsInGVG(ctx context.Context, gvgID uint32, } // ListObjectsInGVG indicates an expected call of ListObjectsInGVG. -func (mr *MockGfSpClientAPIMockRecorder) ListObjectsInGVG(ctx, gvgID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListObjectsInGVG(ctx, gvgID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, gvgID, startAfter, limit}, opts...) + varargs := append([]any{ctx, gvgID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsInGVG", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectsInGVG), varargs...) } // ListObjectsInGVGAndBucket mocks base method. func (m *MockGfSpClientAPI) ListObjectsInGVGAndBucket(ctx context.Context, gvgID uint32, bucketID, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, gvgID, bucketID, startAfter, limit} + varargs := []any{ctx, gvgID, bucketID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -1374,16 +1393,16 @@ func (m *MockGfSpClientAPI) ListObjectsInGVGAndBucket(ctx context.Context, gvgID } // ListObjectsInGVGAndBucket indicates an expected call of ListObjectsInGVGAndBucket. -func (mr *MockGfSpClientAPIMockRecorder) ListObjectsInGVGAndBucket(ctx, gvgID, bucketID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListObjectsInGVGAndBucket(ctx, gvgID, bucketID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, gvgID, bucketID, startAfter, limit}, opts...) + varargs := append([]any{ctx, gvgID, bucketID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsInGVGAndBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectsInGVGAndBucket), varargs...) } // ListPaymentAccountStreams mocks base method. func (m *MockGfSpClientAPI) ListPaymentAccountStreams(ctx context.Context, paymentAccount string, opts ...grpc.DialOption) ([]*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, paymentAccount} + varargs := []any{ctx, paymentAccount} for _, a := range opts { varargs = append(varargs, a) } @@ -1394,16 +1413,16 @@ func (m *MockGfSpClientAPI) ListPaymentAccountStreams(ctx context.Context, payme } // ListPaymentAccountStreams indicates an expected call of ListPaymentAccountStreams. -func (mr *MockGfSpClientAPIMockRecorder) ListPaymentAccountStreams(ctx, paymentAccount interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListPaymentAccountStreams(ctx, paymentAccount any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, paymentAccount}, opts...) + varargs := append([]any{ctx, paymentAccount}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPaymentAccountStreams", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListPaymentAccountStreams), varargs...) } // ListSpExitEvents mocks base method. func (m *MockGfSpClientAPI) ListSpExitEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) (*types.ListSpExitEvents, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, blockID, spID} + varargs := []any{ctx, blockID, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -1414,16 +1433,16 @@ func (m *MockGfSpClientAPI) ListSpExitEvents(ctx context.Context, blockID uint64 } // ListSpExitEvents indicates an expected call of ListSpExitEvents. -func (mr *MockGfSpClientAPIMockRecorder) ListSpExitEvents(ctx, blockID, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListSpExitEvents(ctx, blockID, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, blockID, spID}, opts...) + varargs := append([]any{ctx, blockID, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSpExitEvents", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListSpExitEvents), varargs...) } // ListSwapOutEvents mocks base method. func (m *MockGfSpClientAPI) ListSwapOutEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListSwapOutEvents, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, blockID, spID} + varargs := []any{ctx, blockID, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -1434,16 +1453,16 @@ func (m *MockGfSpClientAPI) ListSwapOutEvents(ctx context.Context, blockID uint6 } // ListSwapOutEvents indicates an expected call of ListSwapOutEvents. -func (mr *MockGfSpClientAPIMockRecorder) ListSwapOutEvents(ctx, blockID, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListSwapOutEvents(ctx, blockID, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, blockID, spID}, opts...) + varargs := append([]any{ctx, blockID, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSwapOutEvents", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListSwapOutEvents), varargs...) } // ListUserPaymentAccounts mocks base method. func (m *MockGfSpClientAPI) ListUserPaymentAccounts(ctx context.Context, accountID string, opts ...grpc.DialOption) ([]*types.PaymentAccountMeta, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, accountID} + varargs := []any{ctx, accountID} for _, a := range opts { varargs = append(varargs, a) } @@ -1454,16 +1473,16 @@ func (m *MockGfSpClientAPI) ListUserPaymentAccounts(ctx context.Context, account } // ListUserPaymentAccounts indicates an expected call of ListUserPaymentAccounts. -func (mr *MockGfSpClientAPIMockRecorder) ListUserPaymentAccounts(ctx, accountID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListUserPaymentAccounts(ctx, accountID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, accountID}, opts...) + varargs := append([]any{ctx, accountID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPaymentAccounts", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListUserPaymentAccounts), varargs...) } // ListVirtualGroupFamiliesSpID mocks base method. func (m *MockGfSpClientAPI) ListVirtualGroupFamiliesSpID(ctx context.Context, spID uint32, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroupFamily, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -1474,16 +1493,16 @@ func (m *MockGfSpClientAPI) ListVirtualGroupFamiliesSpID(ctx context.Context, sp } // ListVirtualGroupFamiliesSpID indicates an expected call of ListVirtualGroupFamiliesSpID. -func (mr *MockGfSpClientAPIMockRecorder) ListVirtualGroupFamiliesSpID(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ListVirtualGroupFamiliesSpID(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVirtualGroupFamiliesSpID", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListVirtualGroupFamiliesSpID), varargs...) } // ManagerConn mocks base method. func (m *MockGfSpClientAPI) ManagerConn(ctx context.Context, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -1494,9 +1513,9 @@ func (m *MockGfSpClientAPI) ManagerConn(ctx context.Context, opts ...grpc.DialOp } // ManagerConn indicates an expected call of ManagerConn. -func (mr *MockGfSpClientAPIMockRecorder) ManagerConn(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ManagerConn(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManagerConn", reflect.TypeOf((*MockGfSpClientAPI)(nil).ManagerConn), varargs...) } @@ -1510,7 +1529,7 @@ func (m *MockGfSpClientAPI) MigratePiece(ctx context.Context, gvgTask *gfsptask. } // MigratePiece indicates an expected call of MigratePiece. -func (mr *MockGfSpClientAPIMockRecorder) MigratePiece(ctx, gvgTask, pieceTask interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) MigratePiece(ctx, gvgTask, pieceTask any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigratePiece", reflect.TypeOf((*MockGfSpClientAPI)(nil).MigratePiece), ctx, gvgTask, pieceTask) } @@ -1524,7 +1543,7 @@ func (m *MockGfSpClientAPI) NotifyDestSPMigrateSwapOut(ctx context.Context, dest } // NotifyDestSPMigrateSwapOut indicates an expected call of NotifyDestSPMigrateSwapOut. -func (mr *MockGfSpClientAPIMockRecorder) NotifyDestSPMigrateSwapOut(ctx, destEndpoint, swapOut interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) NotifyDestSPMigrateSwapOut(ctx, destEndpoint, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyDestSPMigrateSwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyDestSPMigrateSwapOut), ctx, destEndpoint, swapOut) } @@ -1538,7 +1557,7 @@ func (m *MockGfSpClientAPI) NotifyMigrateSwapOut(ctx context.Context, swapOut *t } // NotifyMigrateSwapOut indicates an expected call of NotifyMigrateSwapOut. -func (mr *MockGfSpClientAPIMockRecorder) NotifyMigrateSwapOut(ctx, swapOut interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) NotifyMigrateSwapOut(ctx, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyMigrateSwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyMigrateSwapOut), ctx, swapOut) } @@ -1553,7 +1572,7 @@ func (m *MockGfSpClientAPI) NotifyPostMigrateBucketAndRecoupQuota(ctx context.Co } // NotifyPostMigrateBucketAndRecoupQuota indicates an expected call of NotifyPostMigrateBucketAndRecoupQuota. -func (mr *MockGfSpClientAPIMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmInfo interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmInfo any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucketAndRecoupQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyPostMigrateBucketAndRecoupQuota), ctx, bmInfo) } @@ -1568,7 +1587,7 @@ func (m *MockGfSpClientAPI) NotifyPreMigrateBucketAndDeductQuota(ctx context.Con } // NotifyPreMigrateBucketAndDeductQuota indicates an expected call of NotifyPreMigrateBucketAndDeductQuota. -func (mr *MockGfSpClientAPIMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucketAndDeductQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyPreMigrateBucketAndDeductQuota), ctx, bucketID) } @@ -1576,7 +1595,7 @@ func (mr *MockGfSpClientAPIMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ct // P2PConn mocks base method. func (m *MockGfSpClientAPI) P2PConn(ctx context.Context, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -1587,9 +1606,9 @@ func (m *MockGfSpClientAPI) P2PConn(ctx context.Context, opts ...grpc.DialOption } // P2PConn indicates an expected call of P2PConn. -func (mr *MockGfSpClientAPIMockRecorder) P2PConn(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) P2PConn(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "P2PConn", reflect.TypeOf((*MockGfSpClientAPI)(nil).P2PConn), varargs...) } @@ -1603,7 +1622,7 @@ func (m *MockGfSpClientAPI) PickVirtualGroupFamilyID(ctx context.Context, task t } // PickVirtualGroupFamilyID indicates an expected call of PickVirtualGroupFamilyID. -func (mr *MockGfSpClientAPIMockRecorder) PickVirtualGroupFamilyID(ctx, task interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) PickVirtualGroupFamilyID(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickVirtualGroupFamilyID", reflect.TypeOf((*MockGfSpClientAPI)(nil).PickVirtualGroupFamilyID), ctx, task) } @@ -1618,7 +1637,7 @@ func (m *MockGfSpClientAPI) PostMigrateBucket(ctx context.Context, srcSPEndpoint } // PostMigrateBucket indicates an expected call of PostMigrateBucket. -func (mr *MockGfSpClientAPIMockRecorder) PostMigrateBucket(ctx, srcSPEndpoint, postMsg interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) PostMigrateBucket(ctx, srcSPEndpoint, postMsg any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).PostMigrateBucket), ctx, srcSPEndpoint, postMsg) } @@ -1633,7 +1652,7 @@ func (m *MockGfSpClientAPI) PreMigrateBucket(ctx context.Context, srcSPEndpoint } // PreMigrateBucket indicates an expected call of PreMigrateBucket. -func (mr *MockGfSpClientAPIMockRecorder) PreMigrateBucket(ctx, srcSPEndpoint, preMsg interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) PreMigrateBucket(ctx, srcSPEndpoint, preMsg any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).PreMigrateBucket), ctx, srcSPEndpoint, preMsg) } @@ -1641,7 +1660,7 @@ func (mr *MockGfSpClientAPIMockRecorder) PreMigrateBucket(ctx, srcSPEndpoint, pr // PrimarySpIncomeDetails mocks base method. func (m *MockGfSpClientAPI) PrimarySpIncomeDetails(ctx context.Context, spID uint32, opts ...grpc.DialOption) (int64, []*types.PrimarySpIncomeDetail, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -1653,16 +1672,16 @@ func (m *MockGfSpClientAPI) PrimarySpIncomeDetails(ctx context.Context, spID uin } // PrimarySpIncomeDetails indicates an expected call of PrimarySpIncomeDetails. -func (mr *MockGfSpClientAPIMockRecorder) PrimarySpIncomeDetails(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) PrimarySpIncomeDetails(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimarySpIncomeDetails", reflect.TypeOf((*MockGfSpClientAPI)(nil).PrimarySpIncomeDetails), varargs...) } // QueryBucketMigrate mocks base method. func (m *MockGfSpClientAPI) QueryBucketMigrate(ctx context.Context, endpoint string, opts ...grpc.DialOption) (string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, endpoint} + varargs := []any{ctx, endpoint} for _, a := range opts { varargs = append(varargs, a) } @@ -1673,9 +1692,9 @@ func (m *MockGfSpClientAPI) QueryBucketMigrate(ctx context.Context, endpoint str } // QueryBucketMigrate indicates an expected call of QueryBucketMigrate. -func (mr *MockGfSpClientAPIMockRecorder) QueryBucketMigrate(ctx, endpoint interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) QueryBucketMigrate(ctx, endpoint any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, endpoint}, opts...) + varargs := append([]any{ctx, endpoint}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBucketMigrate", reflect.TypeOf((*MockGfSpClientAPI)(nil).QueryBucketMigrate), varargs...) } @@ -1689,7 +1708,7 @@ func (m *MockGfSpClientAPI) QueryLatestBucketQuota(ctx context.Context, endpoint } // QueryLatestBucketQuota indicates an expected call of QueryLatestBucketQuota. -func (mr *MockGfSpClientAPIMockRecorder) QueryLatestBucketQuota(ctx, endpoint, queryMsg interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) QueryLatestBucketQuota(ctx, endpoint, queryMsg any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryLatestBucketQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).QueryLatestBucketQuota), ctx, endpoint, queryMsg) } @@ -1704,7 +1723,7 @@ func (m *MockGfSpClientAPI) QueryP2PBootstrap(ctx context.Context) ([]string, er } // QueryP2PBootstrap indicates an expected call of QueryP2PBootstrap. -func (mr *MockGfSpClientAPIMockRecorder) QueryP2PBootstrap(ctx interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) QueryP2PBootstrap(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryP2PBootstrap", reflect.TypeOf((*MockGfSpClientAPI)(nil).QueryP2PBootstrap), ctx) } @@ -1712,7 +1731,7 @@ func (mr *MockGfSpClientAPIMockRecorder) QueryP2PBootstrap(ctx interface{}) *gom // QuerySPExit mocks base method. func (m *MockGfSpClientAPI) QuerySPExit(ctx context.Context, endpoint string, opts ...grpc.DialOption) (string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, endpoint} + varargs := []any{ctx, endpoint} for _, a := range opts { varargs = append(varargs, a) } @@ -1723,9 +1742,9 @@ func (m *MockGfSpClientAPI) QuerySPExit(ctx context.Context, endpoint string, op } // QuerySPExit indicates an expected call of QuerySPExit. -func (mr *MockGfSpClientAPIMockRecorder) QuerySPExit(ctx, endpoint interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) QuerySPExit(ctx, endpoint any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, endpoint}, opts...) + varargs := append([]any{ctx, endpoint}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySPExit", reflect.TypeOf((*MockGfSpClientAPI)(nil).QuerySPExit), varargs...) } @@ -1738,7 +1757,7 @@ func (m *MockGfSpClientAPI) QuerySPHasEnoughQuotaForMigrateBucket(ctx context.Co } // QuerySPHasEnoughQuotaForMigrateBucket indicates an expected call of QuerySPHasEnoughQuotaForMigrateBucket. -func (mr *MockGfSpClientAPIMockRecorder) QuerySPHasEnoughQuotaForMigrateBucket(ctx, srcSPEndpoint, queryMsg interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) QuerySPHasEnoughQuotaForMigrateBucket(ctx, srcSPEndpoint, queryMsg any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySPHasEnoughQuotaForMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).QuerySPHasEnoughQuotaForMigrateBucket), ctx, srcSPEndpoint, queryMsg) } @@ -1746,7 +1765,7 @@ func (mr *MockGfSpClientAPIMockRecorder) QuerySPHasEnoughQuotaForMigrateBucket(c // QueryTasks mocks base method. func (m *MockGfSpClientAPI) QueryTasks(ctx context.Context, endpoint, subKey string, opts ...grpc.DialOption) ([]string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, endpoint, subKey} + varargs := []any{ctx, endpoint, subKey} for _, a := range opts { varargs = append(varargs, a) } @@ -1757,16 +1776,16 @@ func (m *MockGfSpClientAPI) QueryTasks(ctx context.Context, endpoint, subKey str } // QueryTasks indicates an expected call of QueryTasks. -func (mr *MockGfSpClientAPIMockRecorder) QueryTasks(ctx, endpoint, subKey interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) QueryTasks(ctx, endpoint, subKey any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, endpoint, subKey}, opts...) + varargs := append([]any{ctx, endpoint, subKey}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockGfSpClientAPI)(nil).QueryTasks), varargs...) } // RecoupQuota mocks base method. func (m *MockGfSpClientAPI) RecoupQuota(ctx context.Context, bucketID, extraQuota uint64, yearMonth string, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, extraQuota, yearMonth} + varargs := []any{ctx, bucketID, extraQuota, yearMonth} for _, a := range opts { varargs = append(varargs, a) } @@ -1776,9 +1795,9 @@ func (m *MockGfSpClientAPI) RecoupQuota(ctx context.Context, bucketID, extraQuot } // RecoupQuota indicates an expected call of RecoupQuota. -func (mr *MockGfSpClientAPIMockRecorder) RecoupQuota(ctx, bucketID, extraQuota, yearMonth interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) RecoupQuota(ctx, bucketID, extraQuota, yearMonth any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, extraQuota, yearMonth}, opts...) + varargs := append([]any{ctx, bucketID, extraQuota, yearMonth}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecoupQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).RecoupQuota), varargs...) } @@ -1792,7 +1811,7 @@ func (m *MockGfSpClientAPI) RejectMigrateBucket(ctx context.Context, rejectMigra } // RejectMigrateBucket indicates an expected call of RejectMigrateBucket. -func (mr *MockGfSpClientAPIMockRecorder) RejectMigrateBucket(ctx, rejectMigrateBucket interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) RejectMigrateBucket(ctx, rejectMigrateBucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).RejectMigrateBucket), ctx, rejectMigrateBucket) } @@ -1807,7 +1826,7 @@ func (m *MockGfSpClientAPI) RejectUnSealObject(ctx context.Context, object *type } // RejectUnSealObject indicates an expected call of RejectUnSealObject. -func (mr *MockGfSpClientAPIMockRecorder) RejectUnSealObject(ctx, object interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) RejectUnSealObject(ctx, object any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectUnSealObject", reflect.TypeOf((*MockGfSpClientAPI)(nil).RejectUnSealObject), ctx, object) } @@ -1815,7 +1834,7 @@ func (mr *MockGfSpClientAPIMockRecorder) RejectUnSealObject(ctx, object interfac // ReplicatePiece mocks base method. func (m *MockGfSpClientAPI) ReplicatePiece(ctx context.Context, task task.ReceivePieceTask, data []byte, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, task, data} + varargs := []any{ctx, task, data} for _, a := range opts { varargs = append(varargs, a) } @@ -1825,9 +1844,9 @@ func (m *MockGfSpClientAPI) ReplicatePiece(ctx context.Context, task task.Receiv } // ReplicatePiece indicates an expected call of ReplicatePiece. -func (mr *MockGfSpClientAPIMockRecorder) ReplicatePiece(ctx, task, data interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ReplicatePiece(ctx, task, data any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, task, data}, opts...) + varargs := append([]any{ctx, task, data}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicatePiece", reflect.TypeOf((*MockGfSpClientAPI)(nil).ReplicatePiece), varargs...) } @@ -1840,7 +1859,7 @@ func (m *MockGfSpClientAPI) ReplicatePieceToSecondary(ctx context.Context, endpo } // ReplicatePieceToSecondary indicates an expected call of ReplicatePieceToSecondary. -func (mr *MockGfSpClientAPIMockRecorder) ReplicatePieceToSecondary(ctx, endpoint, receive, data interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ReplicatePieceToSecondary(ctx, endpoint, receive, data any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicatePieceToSecondary", reflect.TypeOf((*MockGfSpClientAPI)(nil).ReplicatePieceToSecondary), ctx, endpoint, receive, data) } @@ -1854,15 +1873,30 @@ func (m *MockGfSpClientAPI) ReportTask(ctx context.Context, report task.Task) er } // ReportTask indicates an expected call of ReportTask. -func (mr *MockGfSpClientAPIMockRecorder) ReportTask(ctx, report interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ReportTask(ctx, report any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportTask", reflect.TypeOf((*MockGfSpClientAPI)(nil).ReportTask), ctx, report) } +// ReserveSwapIn mocks base method. +func (m *MockGfSpClientAPI) ReserveSwapIn(ctx context.Context, reserveSwapIn *types4.MsgReserveSwapIn) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReserveSwapIn", ctx, reserveSwapIn) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReserveSwapIn indicates an expected call of ReserveSwapIn. +func (mr *MockGfSpClientAPIMockRecorder) ReserveSwapIn(ctx, reserveSwapIn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveSwapIn", reflect.TypeOf((*MockGfSpClientAPI)(nil).ReserveSwapIn), ctx, reserveSwapIn) +} + // ResumableUploadObject mocks base method. func (m *MockGfSpClientAPI) ResumableUploadObject(ctx context.Context, task task.ResumableUploadObjectTask, stream io.Reader, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, task, stream} + varargs := []any{ctx, task, stream} for _, a := range opts { varargs = append(varargs, a) } @@ -1872,9 +1906,9 @@ func (m *MockGfSpClientAPI) ResumableUploadObject(ctx context.Context, task task } // ResumableUploadObject indicates an expected call of ResumableUploadObject. -func (mr *MockGfSpClientAPIMockRecorder) ResumableUploadObject(ctx, task, stream interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) ResumableUploadObject(ctx, task, stream any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, task, stream}, opts...) + varargs := append([]any{ctx, task, stream}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumableUploadObject", reflect.TypeOf((*MockGfSpClientAPI)(nil).ResumableUploadObject), varargs...) } @@ -1888,7 +1922,7 @@ func (m *MockGfSpClientAPI) SPExit(ctx context.Context, spExit *types4.MsgStorag } // SPExit indicates an expected call of SPExit. -func (mr *MockGfSpClientAPIMockRecorder) SPExit(ctx, spExit interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SPExit(ctx, spExit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPExit", reflect.TypeOf((*MockGfSpClientAPI)(nil).SPExit), ctx, spExit) } @@ -1903,7 +1937,7 @@ func (m *MockGfSpClientAPI) SealObject(ctx context.Context, object *types3.MsgSe } // SealObject indicates an expected call of SealObject. -func (mr *MockGfSpClientAPIMockRecorder) SealObject(ctx, object interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SealObject(ctx, object any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealObject", reflect.TypeOf((*MockGfSpClientAPI)(nil).SealObject), ctx, object) } @@ -1911,7 +1945,7 @@ func (mr *MockGfSpClientAPIMockRecorder) SealObject(ctx, object interface{}) *go // SecondarySpIncomeDetails mocks base method. func (m *MockGfSpClientAPI) SecondarySpIncomeDetails(ctx context.Context, spID uint32, opts ...grpc.DialOption) (int64, []*types.SecondarySpIncomeDetail, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -1923,9 +1957,9 @@ func (m *MockGfSpClientAPI) SecondarySpIncomeDetails(ctx context.Context, spID u } // SecondarySpIncomeDetails indicates an expected call of SecondarySpIncomeDetails. -func (mr *MockGfSpClientAPIMockRecorder) SecondarySpIncomeDetails(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SecondarySpIncomeDetails(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecondarySpIncomeDetails", reflect.TypeOf((*MockGfSpClientAPI)(nil).SecondarySpIncomeDetails), varargs...) } @@ -1939,7 +1973,7 @@ func (m *MockGfSpClientAPI) SignBucketMigrationInfo(ctx context.Context, task *g } // SignBucketMigrationInfo indicates an expected call of SignBucketMigrationInfo. -func (mr *MockGfSpClientAPIMockRecorder) SignBucketMigrationInfo(ctx, task interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignBucketMigrationInfo(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignBucketMigrationInfo", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignBucketMigrationInfo), ctx, task) } @@ -1954,7 +1988,7 @@ func (m *MockGfSpClientAPI) SignCreateBucketApproval(ctx context.Context, bucket } // SignCreateBucketApproval indicates an expected call of SignCreateBucketApproval. -func (mr *MockGfSpClientAPIMockRecorder) SignCreateBucketApproval(ctx, bucket interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignCreateBucketApproval(ctx, bucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateBucketApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignCreateBucketApproval), ctx, bucket) } @@ -1969,7 +2003,7 @@ func (m *MockGfSpClientAPI) SignCreateObjectApproval(ctx context.Context, object } // SignCreateObjectApproval indicates an expected call of SignCreateObjectApproval. -func (mr *MockGfSpClientAPIMockRecorder) SignCreateObjectApproval(ctx, object interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignCreateObjectApproval(ctx, object any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateObjectApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignCreateObjectApproval), ctx, object) } @@ -1984,7 +2018,7 @@ func (m *MockGfSpClientAPI) SignMigrateBucketApproval(ctx context.Context, bucke } // SignMigrateBucketApproval indicates an expected call of SignMigrateBucketApproval. -func (mr *MockGfSpClientAPIMockRecorder) SignMigrateBucketApproval(ctx, bucket interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignMigrateBucketApproval(ctx, bucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateBucketApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignMigrateBucketApproval), ctx, bucket) } @@ -1999,7 +2033,7 @@ func (m *MockGfSpClientAPI) SignMigrateGVG(ctx context.Context, task *gfsptask.G } // SignMigrateGVG indicates an expected call of SignMigrateGVG. -func (mr *MockGfSpClientAPIMockRecorder) SignMigrateGVG(ctx, task interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignMigrateGVG(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateGVG", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignMigrateGVG), ctx, task) } @@ -2014,7 +2048,7 @@ func (m *MockGfSpClientAPI) SignP2PPingMsg(ctx context.Context, ping *gfspp2p.Gf } // SignP2PPingMsg indicates an expected call of SignP2PPingMsg. -func (mr *MockGfSpClientAPIMockRecorder) SignP2PPingMsg(ctx, ping interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignP2PPingMsg(ctx, ping any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPingMsg", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignP2PPingMsg), ctx, ping) } @@ -2029,7 +2063,7 @@ func (m *MockGfSpClientAPI) SignP2PPongMsg(ctx context.Context, pong *gfspp2p.Gf } // SignP2PPongMsg indicates an expected call of SignP2PPongMsg. -func (mr *MockGfSpClientAPIMockRecorder) SignP2PPongMsg(ctx, pong interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignP2PPongMsg(ctx, pong any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPongMsg", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignP2PPongMsg), ctx, pong) } @@ -2044,7 +2078,7 @@ func (m *MockGfSpClientAPI) SignReceiveTask(ctx context.Context, receiveTask tas } // SignReceiveTask indicates an expected call of SignReceiveTask. -func (mr *MockGfSpClientAPIMockRecorder) SignReceiveTask(ctx, receiveTask interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignReceiveTask(ctx, receiveTask any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReceiveTask", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignReceiveTask), ctx, receiveTask) } @@ -2059,7 +2093,7 @@ func (m *MockGfSpClientAPI) SignRecoveryTask(ctx context.Context, recoveryTask t } // SignRecoveryTask indicates an expected call of SignRecoveryTask. -func (mr *MockGfSpClientAPIMockRecorder) SignRecoveryTask(ctx, recoveryTask interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignRecoveryTask(ctx, recoveryTask any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignRecoveryTask", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignRecoveryTask), ctx, recoveryTask) } @@ -2074,7 +2108,7 @@ func (m *MockGfSpClientAPI) SignReplicatePieceApproval(ctx context.Context, task } // SignReplicatePieceApproval indicates an expected call of SignReplicatePieceApproval. -func (mr *MockGfSpClientAPIMockRecorder) SignReplicatePieceApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignReplicatePieceApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReplicatePieceApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignReplicatePieceApproval), ctx, task) } @@ -2089,7 +2123,7 @@ func (m *MockGfSpClientAPI) SignSecondarySPMigrationBucket(ctx context.Context, } // SignSecondarySPMigrationBucket indicates an expected call of SignSecondarySPMigrationBucket. -func (mr *MockGfSpClientAPIMockRecorder) SignSecondarySPMigrationBucket(ctx, signDoc interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignSecondarySPMigrationBucket(ctx, signDoc any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySPMigrationBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignSecondarySPMigrationBucket), ctx, signDoc) } @@ -2104,7 +2138,7 @@ func (m *MockGfSpClientAPI) SignSecondarySealBls(ctx context.Context, objectID u } // SignSecondarySealBls indicates an expected call of SignSecondarySealBls. -func (mr *MockGfSpClientAPIMockRecorder) SignSecondarySealBls(ctx, objectID, gvgId, checksums interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignSecondarySealBls(ctx, objectID, gvgId, checksums any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySealBls", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignSecondarySealBls), ctx, objectID, gvgId, checksums) } @@ -2119,7 +2153,7 @@ func (m *MockGfSpClientAPI) SignSwapOut(ctx context.Context, swapOut *types4.Msg } // SignSwapOut indicates an expected call of SignSwapOut. -func (mr *MockGfSpClientAPIMockRecorder) SignSwapOut(ctx, swapOut interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignSwapOut(ctx, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignSwapOut), ctx, swapOut) } @@ -2127,7 +2161,7 @@ func (mr *MockGfSpClientAPIMockRecorder) SignSwapOut(ctx, swapOut interface{}) * // SignerConn mocks base method. func (m *MockGfSpClientAPI) SignerConn(ctx context.Context, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -2138,9 +2172,9 @@ func (m *MockGfSpClientAPI) SignerConn(ctx context.Context, opts ...grpc.DialOpt } // SignerConn indicates an expected call of SignerConn. -func (mr *MockGfSpClientAPIMockRecorder) SignerConn(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SignerConn(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignerConn", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignerConn), varargs...) } @@ -2154,7 +2188,7 @@ func (m *MockGfSpClientAPI) SwapOut(ctx context.Context, swapOut *types4.MsgSwap } // SwapOut indicates an expected call of SwapOut. -func (mr *MockGfSpClientAPIMockRecorder) SwapOut(ctx, swapOut interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) SwapOut(ctx, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).SwapOut), ctx, swapOut) } @@ -2169,7 +2203,7 @@ func (m *MockGfSpClientAPI) UpdateSPPrice(ctx context.Context, price *types2.Msg } // UpdateSPPrice indicates an expected call of UpdateSPPrice. -func (mr *MockGfSpClientAPIMockRecorder) UpdateSPPrice(ctx, price interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) UpdateSPPrice(ctx, price any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSPPrice", reflect.TypeOf((*MockGfSpClientAPI)(nil).UpdateSPPrice), ctx, price) } @@ -2177,7 +2211,7 @@ func (mr *MockGfSpClientAPIMockRecorder) UpdateSPPrice(ctx, price interface{}) * // UpdateUserPublicKey mocks base method. func (m *MockGfSpClientAPI) UpdateUserPublicKey(ctx context.Context, account, domain string, currentNonce, nonce int32, userPublicKey string, expiryDate int64, opts ...grpc.DialOption) (bool, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate} + varargs := []any{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate} for _, a := range opts { varargs = append(varargs, a) } @@ -2188,16 +2222,16 @@ func (m *MockGfSpClientAPI) UpdateUserPublicKey(ctx context.Context, account, do } // UpdateUserPublicKey indicates an expected call of UpdateUserPublicKey. -func (mr *MockGfSpClientAPIMockRecorder) UpdateUserPublicKey(ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) UpdateUserPublicKey(ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate}, opts...) + varargs := append([]any{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPublicKey", reflect.TypeOf((*MockGfSpClientAPI)(nil).UpdateUserPublicKey), varargs...) } // UploadObject mocks base method. func (m *MockGfSpClientAPI) UploadObject(ctx context.Context, task task.UploadObjectTask, stream io.Reader, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, task, stream} + varargs := []any{ctx, task, stream} for _, a := range opts { varargs = append(varargs, a) } @@ -2207,16 +2241,16 @@ func (m *MockGfSpClientAPI) UploadObject(ctx context.Context, task task.UploadOb } // UploadObject indicates an expected call of UploadObject. -func (mr *MockGfSpClientAPIMockRecorder) UploadObject(ctx, task, stream interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) UploadObject(ctx, task, stream any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, task, stream}, opts...) + varargs := append([]any{ctx, task, stream}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadObject", reflect.TypeOf((*MockGfSpClientAPI)(nil).UploadObject), varargs...) } // VerifyAuthentication mocks base method. func (m *MockGfSpClientAPI) VerifyAuthentication(ctx context.Context, auth module.AuthOpType, account, bucket, object string, opts ...grpc.DialOption) (bool, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, auth, account, bucket, object} + varargs := []any{ctx, auth, account, bucket, object} for _, a := range opts { varargs = append(varargs, a) } @@ -2227,16 +2261,16 @@ func (m *MockGfSpClientAPI) VerifyAuthentication(ctx context.Context, auth modul } // VerifyAuthentication indicates an expected call of VerifyAuthentication. -func (mr *MockGfSpClientAPIMockRecorder) VerifyAuthentication(ctx, auth, account, bucket, object interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) VerifyAuthentication(ctx, auth, account, bucket, object any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, auth, account, bucket, object}, opts...) + varargs := append([]any{ctx, auth, account, bucket, object}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyAuthentication", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyAuthentication), varargs...) } // VerifyGNFD1EddsaSignature mocks base method. func (m *MockGfSpClientAPI) VerifyGNFD1EddsaSignature(ctx context.Context, account, domain, offChainSig string, realMsgToSign []byte, opts ...grpc.DialOption) (bool, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, domain, offChainSig, realMsgToSign} + varargs := []any{ctx, account, domain, offChainSig, realMsgToSign} for _, a := range opts { varargs = append(varargs, a) } @@ -2247,16 +2281,16 @@ func (m *MockGfSpClientAPI) VerifyGNFD1EddsaSignature(ctx context.Context, accou } // VerifyGNFD1EddsaSignature indicates an expected call of VerifyGNFD1EddsaSignature. -func (mr *MockGfSpClientAPIMockRecorder) VerifyGNFD1EddsaSignature(ctx, account, domain, offChainSig, realMsgToSign interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) VerifyGNFD1EddsaSignature(ctx, account, domain, offChainSig, realMsgToSign any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, domain, offChainSig, realMsgToSign}, opts...) + varargs := append([]any{ctx, account, domain, offChainSig, realMsgToSign}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGNFD1EddsaSignature", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyGNFD1EddsaSignature), varargs...) } // VerifyMigrateGVGPermission mocks base method. func (m *MockGfSpClientAPI) VerifyMigrateGVGPermission(ctx context.Context, bucketID uint64, gvgID, dstSpID uint32, opts ...grpc.DialOption) (*types1.Effect, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, gvgID, dstSpID} + varargs := []any{ctx, bucketID, gvgID, dstSpID} for _, a := range opts { varargs = append(varargs, a) } @@ -2267,16 +2301,16 @@ func (m *MockGfSpClientAPI) VerifyMigrateGVGPermission(ctx context.Context, buck } // VerifyMigrateGVGPermission indicates an expected call of VerifyMigrateGVGPermission. -func (mr *MockGfSpClientAPIMockRecorder) VerifyMigrateGVGPermission(ctx, bucketID, gvgID, dstSpID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) VerifyMigrateGVGPermission(ctx, bucketID, gvgID, dstSpID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, gvgID, dstSpID}, opts...) + varargs := append([]any{ctx, bucketID, gvgID, dstSpID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyMigrateGVGPermission", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyMigrateGVGPermission), varargs...) } // VerifyPermission mocks base method. func (m *MockGfSpClientAPI) VerifyPermission(ctx context.Context, Operator, bucketName, objectName string, actionType types1.ActionType, opts ...grpc.DialOption) (*types1.Effect, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, Operator, bucketName, objectName, actionType} + varargs := []any{ctx, Operator, bucketName, objectName, actionType} for _, a := range opts { varargs = append(varargs, a) } @@ -2287,16 +2321,16 @@ func (m *MockGfSpClientAPI) VerifyPermission(ctx context.Context, Operator, buck } // VerifyPermission indicates an expected call of VerifyPermission. -func (mr *MockGfSpClientAPIMockRecorder) VerifyPermission(ctx, Operator, bucketName, objectName, actionType interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) VerifyPermission(ctx, Operator, bucketName, objectName, actionType any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, Operator, bucketName, objectName, actionType}, opts...) + varargs := append([]any{ctx, Operator, bucketName, objectName, actionType}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyPermission", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyPermission), varargs...) } // VerifyPermissionByID mocks base method. func (m *MockGfSpClientAPI) VerifyPermissionByID(ctx context.Context, Operator string, resourceType resource.ResourceType, resourceID uint64, actionType types1.ActionType, opts ...grpc.DialOption) (*types1.Effect, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, Operator, resourceType, resourceID, actionType} + varargs := []any{ctx, Operator, resourceType, resourceID, actionType} for _, a := range opts { varargs = append(varargs, a) } @@ -2307,9 +2341,9 @@ func (m *MockGfSpClientAPI) VerifyPermissionByID(ctx context.Context, Operator s } // VerifyPermissionByID indicates an expected call of VerifyPermissionByID. -func (mr *MockGfSpClientAPIMockRecorder) VerifyPermissionByID(ctx, Operator, resourceType, resourceID, actionType interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpClientAPIMockRecorder) VerifyPermissionByID(ctx, Operator, resourceType, resourceID, actionType any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, Operator, resourceType, resourceID, actionType}, opts...) + varargs := append([]any{ctx, Operator, resourceType, resourceID, actionType}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyPermissionByID", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyPermissionByID), varargs...) } @@ -2347,7 +2381,7 @@ func (m *MockApproverAPI) AskCreateBucketApproval(ctx context.Context, t task.Ap } // AskCreateBucketApproval indicates an expected call of AskCreateBucketApproval. -func (mr *MockApproverAPIMockRecorder) AskCreateBucketApproval(ctx, t interface{}) *gomock.Call { +func (mr *MockApproverAPIMockRecorder) AskCreateBucketApproval(ctx, t any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskCreateBucketApproval", reflect.TypeOf((*MockApproverAPI)(nil).AskCreateBucketApproval), ctx, t) } @@ -2363,7 +2397,7 @@ func (m *MockApproverAPI) AskCreateObjectApproval(ctx context.Context, t task.Ap } // AskCreateObjectApproval indicates an expected call of AskCreateObjectApproval. -func (mr *MockApproverAPIMockRecorder) AskCreateObjectApproval(ctx, t interface{}) *gomock.Call { +func (mr *MockApproverAPIMockRecorder) AskCreateObjectApproval(ctx, t any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskCreateObjectApproval", reflect.TypeOf((*MockApproverAPI)(nil).AskCreateObjectApproval), ctx, t) } @@ -2379,7 +2413,7 @@ func (m *MockApproverAPI) AskMigrateBucketApproval(ctx context.Context, t task.A } // AskMigrateBucketApproval indicates an expected call of AskMigrateBucketApproval. -func (mr *MockApproverAPIMockRecorder) AskMigrateBucketApproval(ctx, t interface{}) *gomock.Call { +func (mr *MockApproverAPIMockRecorder) AskMigrateBucketApproval(ctx, t any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskMigrateBucketApproval", reflect.TypeOf((*MockApproverAPI)(nil).AskMigrateBucketApproval), ctx, t) } @@ -2410,7 +2444,7 @@ func (m *MockAuthenticatorAPI) EXPECT() *MockAuthenticatorAPIMockRecorder { // GetAuthNonce mocks base method. func (m *MockAuthenticatorAPI) GetAuthNonce(ctx context.Context, account, domain string, opts ...grpc.DialOption) (int32, int32, string, int64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, domain} + varargs := []any{ctx, account, domain} for _, a := range opts { varargs = append(varargs, a) } @@ -2424,16 +2458,16 @@ func (m *MockAuthenticatorAPI) GetAuthNonce(ctx context.Context, account, domain } // GetAuthNonce indicates an expected call of GetAuthNonce. -func (mr *MockAuthenticatorAPIMockRecorder) GetAuthNonce(ctx, account, domain interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockAuthenticatorAPIMockRecorder) GetAuthNonce(ctx, account, domain any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, domain}, opts...) + varargs := append([]any{ctx, account, domain}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthNonce", reflect.TypeOf((*MockAuthenticatorAPI)(nil).GetAuthNonce), varargs...) } // UpdateUserPublicKey mocks base method. func (m *MockAuthenticatorAPI) UpdateUserPublicKey(ctx context.Context, account, domain string, currentNonce, nonce int32, userPublicKey string, expiryDate int64, opts ...grpc.DialOption) (bool, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate} + varargs := []any{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate} for _, a := range opts { varargs = append(varargs, a) } @@ -2444,16 +2478,16 @@ func (m *MockAuthenticatorAPI) UpdateUserPublicKey(ctx context.Context, account, } // UpdateUserPublicKey indicates an expected call of UpdateUserPublicKey. -func (mr *MockAuthenticatorAPIMockRecorder) UpdateUserPublicKey(ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockAuthenticatorAPIMockRecorder) UpdateUserPublicKey(ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate}, opts...) + varargs := append([]any{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPublicKey", reflect.TypeOf((*MockAuthenticatorAPI)(nil).UpdateUserPublicKey), varargs...) } // VerifyAuthentication mocks base method. func (m *MockAuthenticatorAPI) VerifyAuthentication(ctx context.Context, auth module.AuthOpType, account, bucket, object string, opts ...grpc.DialOption) (bool, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, auth, account, bucket, object} + varargs := []any{ctx, auth, account, bucket, object} for _, a := range opts { varargs = append(varargs, a) } @@ -2464,16 +2498,16 @@ func (m *MockAuthenticatorAPI) VerifyAuthentication(ctx context.Context, auth mo } // VerifyAuthentication indicates an expected call of VerifyAuthentication. -func (mr *MockAuthenticatorAPIMockRecorder) VerifyAuthentication(ctx, auth, account, bucket, object interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockAuthenticatorAPIMockRecorder) VerifyAuthentication(ctx, auth, account, bucket, object any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, auth, account, bucket, object}, opts...) + varargs := append([]any{ctx, auth, account, bucket, object}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyAuthentication", reflect.TypeOf((*MockAuthenticatorAPI)(nil).VerifyAuthentication), varargs...) } // VerifyGNFD1EddsaSignature mocks base method. func (m *MockAuthenticatorAPI) VerifyGNFD1EddsaSignature(ctx context.Context, account, domain, offChainSig string, realMsgToSign []byte, opts ...grpc.DialOption) (bool, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, domain, offChainSig, realMsgToSign} + varargs := []any{ctx, account, domain, offChainSig, realMsgToSign} for _, a := range opts { varargs = append(varargs, a) } @@ -2484,9 +2518,9 @@ func (m *MockAuthenticatorAPI) VerifyGNFD1EddsaSignature(ctx context.Context, ac } // VerifyGNFD1EddsaSignature indicates an expected call of VerifyGNFD1EddsaSignature. -func (mr *MockAuthenticatorAPIMockRecorder) VerifyGNFD1EddsaSignature(ctx, account, domain, offChainSig, realMsgToSign interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockAuthenticatorAPIMockRecorder) VerifyGNFD1EddsaSignature(ctx, account, domain, offChainSig, realMsgToSign any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, domain, offChainSig, realMsgToSign}, opts...) + varargs := append([]any{ctx, account, domain, offChainSig, realMsgToSign}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGNFD1EddsaSignature", reflect.TypeOf((*MockAuthenticatorAPI)(nil).VerifyGNFD1EddsaSignature), varargs...) } @@ -2516,7 +2550,7 @@ func (m *MockDownloaderAPI) EXPECT() *MockDownloaderAPIMockRecorder { // DeductQuotaForBucketMigrate mocks base method. func (m *MockDownloaderAPI) DeductQuotaForBucketMigrate(ctx context.Context, bucketID, deductQuota uint64, yearMonth string, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, deductQuota, yearMonth} + varargs := []any{ctx, bucketID, deductQuota, yearMonth} for _, a := range opts { varargs = append(varargs, a) } @@ -2526,16 +2560,16 @@ func (m *MockDownloaderAPI) DeductQuotaForBucketMigrate(ctx context.Context, buc } // DeductQuotaForBucketMigrate indicates an expected call of DeductQuotaForBucketMigrate. -func (mr *MockDownloaderAPIMockRecorder) DeductQuotaForBucketMigrate(ctx, bucketID, deductQuota, yearMonth interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockDownloaderAPIMockRecorder) DeductQuotaForBucketMigrate(ctx, bucketID, deductQuota, yearMonth any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, deductQuota, yearMonth}, opts...) + varargs := append([]any{ctx, bucketID, deductQuota, yearMonth}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeductQuotaForBucketMigrate", reflect.TypeOf((*MockDownloaderAPI)(nil).DeductQuotaForBucketMigrate), varargs...) } // GetChallengeInfo mocks base method. func (m *MockDownloaderAPI) GetChallengeInfo(ctx context.Context, challengePieceTask task.ChallengePieceTask, opts ...grpc.DialOption) ([]byte, [][]byte, []byte, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, challengePieceTask} + varargs := []any{ctx, challengePieceTask} for _, a := range opts { varargs = append(varargs, a) } @@ -2548,16 +2582,16 @@ func (m *MockDownloaderAPI) GetChallengeInfo(ctx context.Context, challengePiece } // GetChallengeInfo indicates an expected call of GetChallengeInfo. -func (mr *MockDownloaderAPIMockRecorder) GetChallengeInfo(ctx, challengePieceTask interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockDownloaderAPIMockRecorder) GetChallengeInfo(ctx, challengePieceTask any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, challengePieceTask}, opts...) + varargs := append([]any{ctx, challengePieceTask}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChallengeInfo", reflect.TypeOf((*MockDownloaderAPI)(nil).GetChallengeInfo), varargs...) } // GetObject mocks base method. func (m *MockDownloaderAPI) GetObject(ctx context.Context, downloadObjectTask task.DownloadObjectTask, opts ...grpc.DialOption) ([]byte, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, downloadObjectTask} + varargs := []any{ctx, downloadObjectTask} for _, a := range opts { varargs = append(varargs, a) } @@ -2568,16 +2602,16 @@ func (m *MockDownloaderAPI) GetObject(ctx context.Context, downloadObjectTask ta } // GetObject indicates an expected call of GetObject. -func (mr *MockDownloaderAPIMockRecorder) GetObject(ctx, downloadObjectTask interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockDownloaderAPIMockRecorder) GetObject(ctx, downloadObjectTask any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, downloadObjectTask}, opts...) + varargs := append([]any{ctx, downloadObjectTask}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockDownloaderAPI)(nil).GetObject), varargs...) } // GetPiece mocks base method. func (m *MockDownloaderAPI) GetPiece(ctx context.Context, downloadPieceTask task.DownloadPieceTask, opts ...grpc.DialOption) ([]byte, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, downloadPieceTask} + varargs := []any{ctx, downloadPieceTask} for _, a := range opts { varargs = append(varargs, a) } @@ -2588,16 +2622,16 @@ func (m *MockDownloaderAPI) GetPiece(ctx context.Context, downloadPieceTask task } // GetPiece indicates an expected call of GetPiece. -func (mr *MockDownloaderAPIMockRecorder) GetPiece(ctx, downloadPieceTask interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockDownloaderAPIMockRecorder) GetPiece(ctx, downloadPieceTask any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, downloadPieceTask}, opts...) + varargs := append([]any{ctx, downloadPieceTask}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPiece", reflect.TypeOf((*MockDownloaderAPI)(nil).GetPiece), varargs...) } // RecoupQuota mocks base method. func (m *MockDownloaderAPI) RecoupQuota(ctx context.Context, bucketID, extraQuota uint64, yearMonth string, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, extraQuota, yearMonth} + varargs := []any{ctx, bucketID, extraQuota, yearMonth} for _, a := range opts { varargs = append(varargs, a) } @@ -2607,9 +2641,9 @@ func (m *MockDownloaderAPI) RecoupQuota(ctx context.Context, bucketID, extraQuot } // RecoupQuota indicates an expected call of RecoupQuota. -func (mr *MockDownloaderAPIMockRecorder) RecoupQuota(ctx, bucketID, extraQuota, yearMonth interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockDownloaderAPIMockRecorder) RecoupQuota(ctx, bucketID, extraQuota, yearMonth any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, extraQuota, yearMonth}, opts...) + varargs := append([]any{ctx, bucketID, extraQuota, yearMonth}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecoupQuota", reflect.TypeOf((*MockDownloaderAPI)(nil).RecoupQuota), varargs...) } @@ -2646,7 +2680,7 @@ func (m *MockGaterAPI) DoneReplicatePieceToSecondary(ctx context.Context, endpoi } // DoneReplicatePieceToSecondary indicates an expected call of DoneReplicatePieceToSecondary. -func (mr *MockGaterAPIMockRecorder) DoneReplicatePieceToSecondary(ctx, endpoint, receive interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) DoneReplicatePieceToSecondary(ctx, endpoint, receive any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoneReplicatePieceToSecondary", reflect.TypeOf((*MockGaterAPI)(nil).DoneReplicatePieceToSecondary), ctx, endpoint, receive) } @@ -2661,7 +2695,7 @@ func (m *MockGaterAPI) GetPieceFromECChunks(ctx context.Context, endpoint string } // GetPieceFromECChunks indicates an expected call of GetPieceFromECChunks. -func (mr *MockGaterAPIMockRecorder) GetPieceFromECChunks(ctx, endpoint, task interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) GetPieceFromECChunks(ctx, endpoint, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPieceFromECChunks", reflect.TypeOf((*MockGaterAPI)(nil).GetPieceFromECChunks), ctx, endpoint, task) } @@ -2676,7 +2710,7 @@ func (m *MockGaterAPI) GetSecondarySPMigrationBucketApproval(ctx context.Context } // GetSecondarySPMigrationBucketApproval indicates an expected call of GetSecondarySPMigrationBucketApproval. -func (mr *MockGaterAPIMockRecorder) GetSecondarySPMigrationBucketApproval(ctx, secondarySPEndpoint, signDoc interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) GetSecondarySPMigrationBucketApproval(ctx, secondarySPEndpoint, signDoc any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecondarySPMigrationBucketApproval", reflect.TypeOf((*MockGaterAPI)(nil).GetSecondarySPMigrationBucketApproval), ctx, secondarySPEndpoint, signDoc) } @@ -2691,7 +2725,7 @@ func (m *MockGaterAPI) GetSwapOutApproval(ctx context.Context, destSPEndpoint st } // GetSwapOutApproval indicates an expected call of GetSwapOutApproval. -func (mr *MockGaterAPIMockRecorder) GetSwapOutApproval(ctx, destSPEndpoint, swapOutApproval interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) GetSwapOutApproval(ctx, destSPEndpoint, swapOutApproval any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSwapOutApproval", reflect.TypeOf((*MockGaterAPI)(nil).GetSwapOutApproval), ctx, destSPEndpoint, swapOutApproval) } @@ -2706,7 +2740,7 @@ func (m *MockGaterAPI) MigratePiece(ctx context.Context, gvgTask *gfsptask.GfSpM } // MigratePiece indicates an expected call of MigratePiece. -func (mr *MockGaterAPIMockRecorder) MigratePiece(ctx, gvgTask, pieceTask interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) MigratePiece(ctx, gvgTask, pieceTask any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigratePiece", reflect.TypeOf((*MockGaterAPI)(nil).MigratePiece), ctx, gvgTask, pieceTask) } @@ -2720,7 +2754,7 @@ func (m *MockGaterAPI) NotifyDestSPMigrateSwapOut(ctx context.Context, destEndpo } // NotifyDestSPMigrateSwapOut indicates an expected call of NotifyDestSPMigrateSwapOut. -func (mr *MockGaterAPIMockRecorder) NotifyDestSPMigrateSwapOut(ctx, destEndpoint, swapOut interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) NotifyDestSPMigrateSwapOut(ctx, destEndpoint, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyDestSPMigrateSwapOut", reflect.TypeOf((*MockGaterAPI)(nil).NotifyDestSPMigrateSwapOut), ctx, destEndpoint, swapOut) } @@ -2735,7 +2769,7 @@ func (m *MockGaterAPI) PostMigrateBucket(ctx context.Context, srcSPEndpoint stri } // PostMigrateBucket indicates an expected call of PostMigrateBucket. -func (mr *MockGaterAPIMockRecorder) PostMigrateBucket(ctx, srcSPEndpoint, postMsg interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) PostMigrateBucket(ctx, srcSPEndpoint, postMsg any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMigrateBucket", reflect.TypeOf((*MockGaterAPI)(nil).PostMigrateBucket), ctx, srcSPEndpoint, postMsg) } @@ -2750,7 +2784,7 @@ func (m *MockGaterAPI) PreMigrateBucket(ctx context.Context, srcSPEndpoint strin } // PreMigrateBucket indicates an expected call of PreMigrateBucket. -func (mr *MockGaterAPIMockRecorder) PreMigrateBucket(ctx, srcSPEndpoint, preMsg interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) PreMigrateBucket(ctx, srcSPEndpoint, preMsg any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreMigrateBucket", reflect.TypeOf((*MockGaterAPI)(nil).PreMigrateBucket), ctx, srcSPEndpoint, preMsg) } @@ -2765,7 +2799,7 @@ func (m *MockGaterAPI) QueryLatestBucketQuota(ctx context.Context, endpoint stri } // QueryLatestBucketQuota indicates an expected call of QueryLatestBucketQuota. -func (mr *MockGaterAPIMockRecorder) QueryLatestBucketQuota(ctx, endpoint, queryMsg interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) QueryLatestBucketQuota(ctx, endpoint, queryMsg any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryLatestBucketQuota", reflect.TypeOf((*MockGaterAPI)(nil).QueryLatestBucketQuota), ctx, endpoint, queryMsg) } @@ -2779,7 +2813,7 @@ func (m *MockGaterAPI) QuerySPHasEnoughQuotaForMigrateBucket(ctx context.Context } // QuerySPHasEnoughQuotaForMigrateBucket indicates an expected call of QuerySPHasEnoughQuotaForMigrateBucket. -func (mr *MockGaterAPIMockRecorder) QuerySPHasEnoughQuotaForMigrateBucket(ctx, srcSPEndpoint, queryMsg interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) QuerySPHasEnoughQuotaForMigrateBucket(ctx, srcSPEndpoint, queryMsg any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySPHasEnoughQuotaForMigrateBucket", reflect.TypeOf((*MockGaterAPI)(nil).QuerySPHasEnoughQuotaForMigrateBucket), ctx, srcSPEndpoint, queryMsg) } @@ -2793,7 +2827,7 @@ func (m *MockGaterAPI) ReplicatePieceToSecondary(ctx context.Context, endpoint s } // ReplicatePieceToSecondary indicates an expected call of ReplicatePieceToSecondary. -func (mr *MockGaterAPIMockRecorder) ReplicatePieceToSecondary(ctx, endpoint, receive, data interface{}) *gomock.Call { +func (mr *MockGaterAPIMockRecorder) ReplicatePieceToSecondary(ctx, endpoint, receive, data any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicatePieceToSecondary", reflect.TypeOf((*MockGaterAPI)(nil).ReplicatePieceToSecondary), ctx, endpoint, receive, data) } @@ -2831,7 +2865,7 @@ func (m *MockManagerAPI) AskTask(ctx context.Context, limit rcmgr.Limit) (task.T } // AskTask indicates an expected call of AskTask. -func (mr *MockManagerAPIMockRecorder) AskTask(ctx, limit interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) AskTask(ctx, limit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskTask", reflect.TypeOf((*MockManagerAPI)(nil).AskTask), ctx, limit) } @@ -2845,7 +2879,7 @@ func (m *MockManagerAPI) CreateResumableUploadObject(ctx context.Context, task t } // CreateResumableUploadObject indicates an expected call of CreateResumableUploadObject. -func (mr *MockManagerAPIMockRecorder) CreateResumableUploadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) CreateResumableUploadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResumableUploadObject", reflect.TypeOf((*MockManagerAPI)(nil).CreateResumableUploadObject), ctx, task) } @@ -2859,7 +2893,7 @@ func (m *MockManagerAPI) CreateUploadObject(ctx context.Context, task task.Uploa } // CreateUploadObject indicates an expected call of CreateUploadObject. -func (mr *MockManagerAPIMockRecorder) CreateUploadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) CreateUploadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUploadObject", reflect.TypeOf((*MockManagerAPI)(nil).CreateUploadObject), ctx, task) } @@ -2874,7 +2908,7 @@ func (m *MockManagerAPI) GetMigrateBucketProgress(ctx context.Context, bucketID } // GetMigrateBucketProgress indicates an expected call of GetMigrateBucketProgress. -func (mr *MockManagerAPIMockRecorder) GetMigrateBucketProgress(ctx, bucketID interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) GetMigrateBucketProgress(ctx, bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMigrateBucketProgress", reflect.TypeOf((*MockManagerAPI)(nil).GetMigrateBucketProgress), ctx, bucketID) } @@ -2889,7 +2923,7 @@ func (m *MockManagerAPI) GetTasksStats(ctx context.Context) (*gfspserver.TasksSt } // GetTasksStats indicates an expected call of GetTasksStats. -func (mr *MockManagerAPIMockRecorder) GetTasksStats(ctx interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) GetTasksStats(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTasksStats", reflect.TypeOf((*MockManagerAPI)(nil).GetTasksStats), ctx) } @@ -2903,7 +2937,7 @@ func (m *MockManagerAPI) NotifyMigrateSwapOut(ctx context.Context, swapOut *type } // NotifyMigrateSwapOut indicates an expected call of NotifyMigrateSwapOut. -func (mr *MockManagerAPIMockRecorder) NotifyMigrateSwapOut(ctx, swapOut interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) NotifyMigrateSwapOut(ctx, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyMigrateSwapOut", reflect.TypeOf((*MockManagerAPI)(nil).NotifyMigrateSwapOut), ctx, swapOut) } @@ -2918,7 +2952,7 @@ func (m *MockManagerAPI) NotifyPostMigrateBucketAndRecoupQuota(ctx context.Conte } // NotifyPostMigrateBucketAndRecoupQuota indicates an expected call of NotifyPostMigrateBucketAndRecoupQuota. -func (mr *MockManagerAPIMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmInfo interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmInfo any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucketAndRecoupQuota", reflect.TypeOf((*MockManagerAPI)(nil).NotifyPostMigrateBucketAndRecoupQuota), ctx, bmInfo) } @@ -2933,7 +2967,7 @@ func (m *MockManagerAPI) NotifyPreMigrateBucketAndDeductQuota(ctx context.Contex } // NotifyPreMigrateBucketAndDeductQuota indicates an expected call of NotifyPreMigrateBucketAndDeductQuota. -func (mr *MockManagerAPIMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucketAndDeductQuota", reflect.TypeOf((*MockManagerAPI)(nil).NotifyPreMigrateBucketAndDeductQuota), ctx, bucketID) } @@ -2948,7 +2982,7 @@ func (m *MockManagerAPI) PickVirtualGroupFamilyID(ctx context.Context, task task } // PickVirtualGroupFamilyID indicates an expected call of PickVirtualGroupFamilyID. -func (mr *MockManagerAPIMockRecorder) PickVirtualGroupFamilyID(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) PickVirtualGroupFamilyID(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickVirtualGroupFamilyID", reflect.TypeOf((*MockManagerAPI)(nil).PickVirtualGroupFamilyID), ctx, task) } @@ -2962,7 +2996,7 @@ func (m *MockManagerAPI) ReportTask(ctx context.Context, report task.Task) error } // ReportTask indicates an expected call of ReportTask. -func (mr *MockManagerAPIMockRecorder) ReportTask(ctx, report interface{}) *gomock.Call { +func (mr *MockManagerAPIMockRecorder) ReportTask(ctx, report any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportTask", reflect.TypeOf((*MockManagerAPI)(nil).ReportTask), ctx, report) } @@ -2993,7 +3027,7 @@ func (m *MockMetadataAPI) EXPECT() *MockMetadataAPIMockRecorder { // GetBucketByBucketID mocks base method. func (m *MockMetadataAPI) GetBucketByBucketID(ctx context.Context, bucketID int64, includePrivate bool, opts ...grpc.DialOption) (*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, includePrivate} + varargs := []any{ctx, bucketID, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -3004,16 +3038,16 @@ func (m *MockMetadataAPI) GetBucketByBucketID(ctx context.Context, bucketID int6 } // GetBucketByBucketID indicates an expected call of GetBucketByBucketID. -func (mr *MockMetadataAPIMockRecorder) GetBucketByBucketID(ctx, bucketID, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetBucketByBucketID(ctx, bucketID, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, includePrivate}, opts...) + varargs := append([]any{ctx, bucketID, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketByBucketID", reflect.TypeOf((*MockMetadataAPI)(nil).GetBucketByBucketID), varargs...) } // GetBucketByBucketName mocks base method. func (m *MockMetadataAPI) GetBucketByBucketName(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketName, includePrivate} + varargs := []any{ctx, bucketName, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -3024,16 +3058,16 @@ func (m *MockMetadataAPI) GetBucketByBucketName(ctx context.Context, bucketName } // GetBucketByBucketName indicates an expected call of GetBucketByBucketName. -func (mr *MockMetadataAPIMockRecorder) GetBucketByBucketName(ctx, bucketName, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetBucketByBucketName(ctx, bucketName, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketName, includePrivate}, opts...) + varargs := append([]any{ctx, bucketName, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketByBucketName", reflect.TypeOf((*MockMetadataAPI)(nil).GetBucketByBucketName), varargs...) } // GetBucketMeta mocks base method. func (m *MockMetadataAPI) GetBucketMeta(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.VGFInfoBucket, *types0.StreamRecord, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketName, includePrivate} + varargs := []any{ctx, bucketName, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -3045,16 +3079,16 @@ func (m *MockMetadataAPI) GetBucketMeta(ctx context.Context, bucketName string, } // GetBucketMeta indicates an expected call of GetBucketMeta. -func (mr *MockMetadataAPIMockRecorder) GetBucketMeta(ctx, bucketName, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetBucketMeta(ctx, bucketName, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketName, includePrivate}, opts...) + varargs := append([]any{ctx, bucketName, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMeta", reflect.TypeOf((*MockMetadataAPI)(nil).GetBucketMeta), varargs...) } // GetBucketReadQuota mocks base method. func (m *MockMetadataAPI) GetBucketReadQuota(ctx context.Context, bucket *types3.BucketInfo, yearMonth string, opts ...grpc.DialOption) (uint64, uint64, uint64, uint64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucket, yearMonth} + varargs := []any{ctx, bucket, yearMonth} for _, a := range opts { varargs = append(varargs, a) } @@ -3068,16 +3102,16 @@ func (m *MockMetadataAPI) GetBucketReadQuota(ctx context.Context, bucket *types3 } // GetBucketReadQuota indicates an expected call of GetBucketReadQuota. -func (mr *MockMetadataAPIMockRecorder) GetBucketReadQuota(ctx, bucket, yearMonth interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetBucketReadQuota(ctx, bucket, yearMonth any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucket, yearMonth}, opts...) + varargs := append([]any{ctx, bucket, yearMonth}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReadQuota", reflect.TypeOf((*MockMetadataAPI)(nil).GetBucketReadQuota), varargs...) } // GetBucketSize mocks base method. func (m *MockMetadataAPI) GetBucketSize(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID} + varargs := []any{ctx, bucketID} for _, a := range opts { varargs = append(varargs, a) } @@ -3088,16 +3122,16 @@ func (m *MockMetadataAPI) GetBucketSize(ctx context.Context, bucketID uint64, op } // GetBucketSize indicates an expected call of GetBucketSize. -func (mr *MockMetadataAPIMockRecorder) GetBucketSize(ctx, bucketID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetBucketSize(ctx, bucketID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID}, opts...) + varargs := append([]any{ctx, bucketID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketSize", reflect.TypeOf((*MockMetadataAPI)(nil).GetBucketSize), varargs...) } // GetEndpointBySpID mocks base method. func (m *MockMetadataAPI) GetEndpointBySpID(ctx context.Context, spID uint32, opts ...grpc.DialOption) (string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -3108,16 +3142,16 @@ func (m *MockMetadataAPI) GetEndpointBySpID(ctx context.Context, spID uint32, op } // GetEndpointBySpID indicates an expected call of GetEndpointBySpID. -func (mr *MockMetadataAPIMockRecorder) GetEndpointBySpID(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetEndpointBySpID(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEndpointBySpID", reflect.TypeOf((*MockMetadataAPI)(nil).GetEndpointBySpID), varargs...) } // GetGlobalVirtualGroup mocks base method. func (m *MockMetadataAPI) GetGlobalVirtualGroup(ctx context.Context, bucketID uint64, lvgID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroup, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, lvgID} + varargs := []any{ctx, bucketID, lvgID} for _, a := range opts { varargs = append(varargs, a) } @@ -3128,16 +3162,16 @@ func (m *MockMetadataAPI) GetGlobalVirtualGroup(ctx context.Context, bucketID ui } // GetGlobalVirtualGroup indicates an expected call of GetGlobalVirtualGroup. -func (mr *MockMetadataAPIMockRecorder) GetGlobalVirtualGroup(ctx, bucketID, lvgID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetGlobalVirtualGroup(ctx, bucketID, lvgID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, lvgID}, opts...) + varargs := append([]any{ctx, bucketID, lvgID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGlobalVirtualGroup", reflect.TypeOf((*MockMetadataAPI)(nil).GetGlobalVirtualGroup), varargs...) } // GetGlobalVirtualGroupByGvgID mocks base method. func (m *MockMetadataAPI) GetGlobalVirtualGroupByGvgID(ctx context.Context, gvgID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroup, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, gvgID} + varargs := []any{ctx, gvgID} for _, a := range opts { varargs = append(varargs, a) } @@ -3148,16 +3182,16 @@ func (m *MockMetadataAPI) GetGlobalVirtualGroupByGvgID(ctx context.Context, gvgI } // GetGlobalVirtualGroupByGvgID indicates an expected call of GetGlobalVirtualGroupByGvgID. -func (mr *MockMetadataAPIMockRecorder) GetGlobalVirtualGroupByGvgID(ctx, gvgID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetGlobalVirtualGroupByGvgID(ctx, gvgID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, gvgID}, opts...) + varargs := append([]any{ctx, gvgID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGlobalVirtualGroupByGvgID", reflect.TypeOf((*MockMetadataAPI)(nil).GetGlobalVirtualGroupByGvgID), varargs...) } // GetGroupList mocks base method. func (m *MockMetadataAPI) GetGroupList(ctx context.Context, name, prefix, sourceType string, limit, offset int64, includeRemoved bool, opts ...grpc.DialOption) ([]*types.Group, int64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, name, prefix, sourceType, limit, offset, includeRemoved} + varargs := []any{ctx, name, prefix, sourceType, limit, offset, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -3169,16 +3203,16 @@ func (m *MockMetadataAPI) GetGroupList(ctx context.Context, name, prefix, source } // GetGroupList indicates an expected call of GetGroupList. -func (mr *MockMetadataAPIMockRecorder) GetGroupList(ctx, name, prefix, sourceType, limit, offset, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetGroupList(ctx, name, prefix, sourceType, limit, offset, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, name, prefix, sourceType, limit, offset, includeRemoved}, opts...) + varargs := append([]any{ctx, name, prefix, sourceType, limit, offset, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupList", reflect.TypeOf((*MockMetadataAPI)(nil).GetGroupList), varargs...) } // GetGroupMembers mocks base method. func (m *MockMetadataAPI) GetGroupMembers(ctx context.Context, groupID uint64, startAfter string, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, groupID, startAfter, limit} + varargs := []any{ctx, groupID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -3189,16 +3223,16 @@ func (m *MockMetadataAPI) GetGroupMembers(ctx context.Context, groupID uint64, s } // GetGroupMembers indicates an expected call of GetGroupMembers. -func (mr *MockMetadataAPIMockRecorder) GetGroupMembers(ctx, groupID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetGroupMembers(ctx, groupID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, groupID, startAfter, limit}, opts...) + varargs := append([]any{ctx, groupID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMembers", reflect.TypeOf((*MockMetadataAPI)(nil).GetGroupMembers), varargs...) } // GetLatestBucketReadQuota mocks base method. func (m *MockMetadataAPI) GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (*gfsptask.GfSpBucketQuotaInfo, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID} + varargs := []any{ctx, bucketID} for _, a := range opts { varargs = append(varargs, a) } @@ -3209,16 +3243,16 @@ func (m *MockMetadataAPI) GetLatestBucketReadQuota(ctx context.Context, bucketID } // GetLatestBucketReadQuota indicates an expected call of GetLatestBucketReadQuota. -func (mr *MockMetadataAPIMockRecorder) GetLatestBucketReadQuota(ctx, bucketID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetLatestBucketReadQuota(ctx, bucketID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID}, opts...) + varargs := append([]any{ctx, bucketID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestBucketReadQuota", reflect.TypeOf((*MockMetadataAPI)(nil).GetLatestBucketReadQuota), varargs...) } // GetLatestObjectID mocks base method. func (m *MockMetadataAPI) GetLatestObjectID(ctx context.Context, opts ...grpc.DialOption) (uint64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -3229,16 +3263,16 @@ func (m *MockMetadataAPI) GetLatestObjectID(ctx context.Context, opts ...grpc.Di } // GetLatestObjectID indicates an expected call of GetLatestObjectID. -func (mr *MockMetadataAPIMockRecorder) GetLatestObjectID(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetLatestObjectID(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestObjectID", reflect.TypeOf((*MockMetadataAPI)(nil).GetLatestObjectID), varargs...) } // GetObjectByID mocks base method. func (m *MockMetadataAPI) GetObjectByID(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (*types3.ObjectInfo, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectID} + varargs := []any{ctx, objectID} for _, a := range opts { varargs = append(varargs, a) } @@ -3249,16 +3283,16 @@ func (m *MockMetadataAPI) GetObjectByID(ctx context.Context, objectID uint64, op } // GetObjectByID indicates an expected call of GetObjectByID. -func (mr *MockMetadataAPIMockRecorder) GetObjectByID(ctx, objectID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetObjectByID(ctx, objectID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectID}, opts...) + varargs := append([]any{ctx, objectID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectByID", reflect.TypeOf((*MockMetadataAPI)(nil).GetObjectByID), varargs...) } // GetObjectMeta mocks base method. func (m *MockMetadataAPI) GetObjectMeta(ctx context.Context, objectName, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.Object, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectName, bucketName, includePrivate} + varargs := []any{ctx, objectName, bucketName, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -3269,16 +3303,16 @@ func (m *MockMetadataAPI) GetObjectMeta(ctx context.Context, objectName, bucketN } // GetObjectMeta indicates an expected call of GetObjectMeta. -func (mr *MockMetadataAPIMockRecorder) GetObjectMeta(ctx, objectName, bucketName, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetObjectMeta(ctx, objectName, bucketName, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectName, bucketName, includePrivate}, opts...) + varargs := append([]any{ctx, objectName, bucketName, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectMeta", reflect.TypeOf((*MockMetadataAPI)(nil).GetObjectMeta), varargs...) } // GetPaymentByBucketID mocks base method. func (m *MockMetadataAPI) GetPaymentByBucketID(ctx context.Context, bucketID int64, includePrivate bool, opts ...grpc.DialOption) (*types0.StreamRecord, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, includePrivate} + varargs := []any{ctx, bucketID, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -3289,16 +3323,16 @@ func (m *MockMetadataAPI) GetPaymentByBucketID(ctx context.Context, bucketID int } // GetPaymentByBucketID indicates an expected call of GetPaymentByBucketID. -func (mr *MockMetadataAPIMockRecorder) GetPaymentByBucketID(ctx, bucketID, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetPaymentByBucketID(ctx, bucketID, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, includePrivate}, opts...) + varargs := append([]any{ctx, bucketID, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPaymentByBucketID", reflect.TypeOf((*MockMetadataAPI)(nil).GetPaymentByBucketID), varargs...) } // GetPaymentByBucketName mocks base method. func (m *MockMetadataAPI) GetPaymentByBucketName(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types0.StreamRecord, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketName, includePrivate} + varargs := []any{ctx, bucketName, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -3309,16 +3343,16 @@ func (m *MockMetadataAPI) GetPaymentByBucketName(ctx context.Context, bucketName } // GetPaymentByBucketName indicates an expected call of GetPaymentByBucketName. -func (mr *MockMetadataAPIMockRecorder) GetPaymentByBucketName(ctx, bucketName, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetPaymentByBucketName(ctx, bucketName, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketName, includePrivate}, opts...) + varargs := append([]any{ctx, bucketName, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPaymentByBucketName", reflect.TypeOf((*MockMetadataAPI)(nil).GetPaymentByBucketName), varargs...) } // GetSPInfo mocks base method. func (m *MockMetadataAPI) GetSPInfo(ctx context.Context, operatorAddress string, opts ...grpc.DialOption) (*types2.StorageProvider, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, operatorAddress} + varargs := []any{ctx, operatorAddress} for _, a := range opts { varargs = append(varargs, a) } @@ -3329,16 +3363,16 @@ func (m *MockMetadataAPI) GetSPInfo(ctx context.Context, operatorAddress string, } // GetSPInfo indicates an expected call of GetSPInfo. -func (mr *MockMetadataAPIMockRecorder) GetSPInfo(ctx, operatorAddress interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetSPInfo(ctx, operatorAddress any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, operatorAddress}, opts...) + varargs := append([]any{ctx, operatorAddress}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSPInfo", reflect.TypeOf((*MockMetadataAPI)(nil).GetSPInfo), varargs...) } // GetSPMigratingBucketNumber mocks base method. func (m *MockMetadataAPI) GetSPMigratingBucketNumber(ctx context.Context, spID uint32, opts ...grpc.DialOption) (uint64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -3349,16 +3383,16 @@ func (m *MockMetadataAPI) GetSPMigratingBucketNumber(ctx context.Context, spID u } // GetSPMigratingBucketNumber indicates an expected call of GetSPMigratingBucketNumber. -func (mr *MockMetadataAPIMockRecorder) GetSPMigratingBucketNumber(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetSPMigratingBucketNumber(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSPMigratingBucketNumber", reflect.TypeOf((*MockMetadataAPI)(nil).GetSPMigratingBucketNumber), varargs...) } // GetStatus mocks base method. func (m *MockMetadataAPI) GetStatus(ctx context.Context, opts ...grpc.DialOption) (*types.Status, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -3369,16 +3403,16 @@ func (m *MockMetadataAPI) GetStatus(ctx context.Context, opts ...grpc.DialOption } // GetStatus indicates an expected call of GetStatus. -func (mr *MockMetadataAPIMockRecorder) GetStatus(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetStatus(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatus", reflect.TypeOf((*MockMetadataAPI)(nil).GetStatus), varargs...) } // GetUploadObjectSegment mocks base method. func (m *MockMetadataAPI) GetUploadObjectSegment(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (uint32, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectID} + varargs := []any{ctx, objectID} for _, a := range opts { varargs = append(varargs, a) } @@ -3389,16 +3423,16 @@ func (m *MockMetadataAPI) GetUploadObjectSegment(ctx context.Context, objectID u } // GetUploadObjectSegment indicates an expected call of GetUploadObjectSegment. -func (mr *MockMetadataAPIMockRecorder) GetUploadObjectSegment(ctx, objectID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetUploadObjectSegment(ctx, objectID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectID}, opts...) + varargs := append([]any{ctx, objectID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadObjectSegment", reflect.TypeOf((*MockMetadataAPI)(nil).GetUploadObjectSegment), varargs...) } // GetUploadObjectState mocks base method. func (m *MockMetadataAPI) GetUploadObjectState(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (int32, string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectID} + varargs := []any{ctx, objectID} for _, a := range opts { varargs = append(varargs, a) } @@ -3410,16 +3444,16 @@ func (m *MockMetadataAPI) GetUploadObjectState(ctx context.Context, objectID uin } // GetUploadObjectState indicates an expected call of GetUploadObjectState. -func (mr *MockMetadataAPIMockRecorder) GetUploadObjectState(ctx, objectID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetUploadObjectState(ctx, objectID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectID}, opts...) + varargs := append([]any{ctx, objectID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadObjectState", reflect.TypeOf((*MockMetadataAPI)(nil).GetUploadObjectState), varargs...) } // GetUserBuckets mocks base method. func (m *MockMetadataAPI) GetUserBuckets(ctx context.Context, account string, includeRemoved bool, opts ...grpc.DialOption) ([]*types.VGFInfoBucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, includeRemoved} + varargs := []any{ctx, account, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -3430,16 +3464,16 @@ func (m *MockMetadataAPI) GetUserBuckets(ctx context.Context, account string, in } // GetUserBuckets indicates an expected call of GetUserBuckets. -func (mr *MockMetadataAPIMockRecorder) GetUserBuckets(ctx, account, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetUserBuckets(ctx, account, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, includeRemoved}, opts...) + varargs := append([]any{ctx, account, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserBuckets", reflect.TypeOf((*MockMetadataAPI)(nil).GetUserBuckets), varargs...) } // GetUserBucketsCount mocks base method. func (m *MockMetadataAPI) GetUserBucketsCount(ctx context.Context, account string, includeRemoved bool, opts ...grpc.DialOption) (int64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, account, includeRemoved} + varargs := []any{ctx, account, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -3450,16 +3484,16 @@ func (m *MockMetadataAPI) GetUserBucketsCount(ctx context.Context, account strin } // GetUserBucketsCount indicates an expected call of GetUserBucketsCount. -func (mr *MockMetadataAPIMockRecorder) GetUserBucketsCount(ctx, account, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetUserBucketsCount(ctx, account, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, account, includeRemoved}, opts...) + varargs := append([]any{ctx, account, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserBucketsCount", reflect.TypeOf((*MockMetadataAPI)(nil).GetUserBucketsCount), varargs...) } // GetUserGroups mocks base method. func (m *MockMetadataAPI) GetUserGroups(ctx context.Context, accountID string, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, accountID, startAfter, limit} + varargs := []any{ctx, accountID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -3470,16 +3504,16 @@ func (m *MockMetadataAPI) GetUserGroups(ctx context.Context, accountID string, s } // GetUserGroups indicates an expected call of GetUserGroups. -func (mr *MockMetadataAPIMockRecorder) GetUserGroups(ctx, accountID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetUserGroups(ctx, accountID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, accountID, startAfter, limit}, opts...) + varargs := append([]any{ctx, accountID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserGroups", reflect.TypeOf((*MockMetadataAPI)(nil).GetUserGroups), varargs...) } // GetUserOwnedGroups mocks base method. func (m *MockMetadataAPI) GetUserOwnedGroups(ctx context.Context, accountID string, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, accountID, startAfter, limit} + varargs := []any{ctx, accountID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -3490,16 +3524,16 @@ func (m *MockMetadataAPI) GetUserOwnedGroups(ctx context.Context, accountID stri } // GetUserOwnedGroups indicates an expected call of GetUserOwnedGroups. -func (mr *MockMetadataAPIMockRecorder) GetUserOwnedGroups(ctx, accountID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetUserOwnedGroups(ctx, accountID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, accountID, startAfter, limit}, opts...) + varargs := append([]any{ctx, accountID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserOwnedGroups", reflect.TypeOf((*MockMetadataAPI)(nil).GetUserOwnedGroups), varargs...) } // GetVirtualGroupFamily mocks base method. func (m *MockMetadataAPI) GetVirtualGroupFamily(ctx context.Context, vgfID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroupFamily, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, vgfID} + varargs := []any{ctx, vgfID} for _, a := range opts { varargs = append(varargs, a) } @@ -3510,16 +3544,16 @@ func (m *MockMetadataAPI) GetVirtualGroupFamily(ctx context.Context, vgfID uint3 } // GetVirtualGroupFamily indicates an expected call of GetVirtualGroupFamily. -func (mr *MockMetadataAPIMockRecorder) GetVirtualGroupFamily(ctx, vgfID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) GetVirtualGroupFamily(ctx, vgfID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, vgfID}, opts...) + varargs := append([]any{ctx, vgfID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualGroupFamily", reflect.TypeOf((*MockMetadataAPI)(nil).GetVirtualGroupFamily), varargs...) } // ListBucketReadRecord mocks base method. func (m *MockMetadataAPI) ListBucketReadRecord(ctx context.Context, bucket *types3.BucketInfo, startTimestampUs, endTimestampUs, maxRecordNum int64, opts ...grpc.DialOption) ([]*types.ReadRecord, int64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum} + varargs := []any{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum} for _, a := range opts { varargs = append(varargs, a) } @@ -3531,16 +3565,16 @@ func (m *MockMetadataAPI) ListBucketReadRecord(ctx context.Context, bucket *type } // ListBucketReadRecord indicates an expected call of ListBucketReadRecord. -func (mr *MockMetadataAPIMockRecorder) ListBucketReadRecord(ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListBucketReadRecord(ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum}, opts...) + varargs := append([]any{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketReadRecord", reflect.TypeOf((*MockMetadataAPI)(nil).ListBucketReadRecord), varargs...) } // ListBucketsByIDs mocks base method. func (m *MockMetadataAPI) ListBucketsByIDs(ctx context.Context, bucketIDs []uint64, includeRemoved bool, opts ...grpc.DialOption) (map[uint64]*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketIDs, includeRemoved} + varargs := []any{ctx, bucketIDs, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -3551,16 +3585,16 @@ func (m *MockMetadataAPI) ListBucketsByIDs(ctx context.Context, bucketIDs []uint } // ListBucketsByIDs indicates an expected call of ListBucketsByIDs. -func (mr *MockMetadataAPIMockRecorder) ListBucketsByIDs(ctx, bucketIDs, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListBucketsByIDs(ctx, bucketIDs, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketIDs, includeRemoved}, opts...) + varargs := append([]any{ctx, bucketIDs, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsByIDs", reflect.TypeOf((*MockMetadataAPI)(nil).ListBucketsByIDs), varargs...) } // ListCompleteMigrationBucketEvents mocks base method. func (m *MockMetadataAPI) ListCompleteMigrationBucketEvents(ctx context.Context, blockID uint64, srcSpID uint32, opts ...grpc.DialOption) ([]*types3.EventCompleteMigrationBucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, blockID, srcSpID} + varargs := []any{ctx, blockID, srcSpID} for _, a := range opts { varargs = append(varargs, a) } @@ -3571,16 +3605,16 @@ func (m *MockMetadataAPI) ListCompleteMigrationBucketEvents(ctx context.Context, } // ListCompleteMigrationBucketEvents indicates an expected call of ListCompleteMigrationBucketEvents. -func (mr *MockMetadataAPIMockRecorder) ListCompleteMigrationBucketEvents(ctx, blockID, srcSpID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListCompleteMigrationBucketEvents(ctx, blockID, srcSpID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, blockID, srcSpID}, opts...) + varargs := append([]any{ctx, blockID, srcSpID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompleteMigrationBucketEvents", reflect.TypeOf((*MockMetadataAPI)(nil).ListCompleteMigrationBucketEvents), varargs...) } // ListDeletedObjectsByBlockNumberRange mocks base method. func (m *MockMetadataAPI) ListDeletedObjectsByBlockNumberRange(ctx context.Context, spOperatorAddress string, startBlockNumber, endBlockNumber uint64, includePrivate bool, opts ...grpc.DialOption) ([]*types.Object, uint64, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate} + varargs := []any{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate} for _, a := range opts { varargs = append(varargs, a) } @@ -3592,16 +3626,16 @@ func (m *MockMetadataAPI) ListDeletedObjectsByBlockNumberRange(ctx context.Conte } // ListDeletedObjectsByBlockNumberRange indicates an expected call of ListDeletedObjectsByBlockNumberRange. -func (mr *MockMetadataAPIMockRecorder) ListDeletedObjectsByBlockNumberRange(ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListDeletedObjectsByBlockNumberRange(ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate}, opts...) + varargs := append([]any{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeletedObjectsByBlockNumberRange", reflect.TypeOf((*MockMetadataAPI)(nil).ListDeletedObjectsByBlockNumberRange), varargs...) } // ListExpiredBucketsBySp mocks base method. func (m *MockMetadataAPI) ListExpiredBucketsBySp(ctx context.Context, createAt int64, primarySpID uint32, limit int64, opts ...grpc.DialOption) ([]*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, createAt, primarySpID, limit} + varargs := []any{ctx, createAt, primarySpID, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -3612,16 +3646,16 @@ func (m *MockMetadataAPI) ListExpiredBucketsBySp(ctx context.Context, createAt i } // ListExpiredBucketsBySp indicates an expected call of ListExpiredBucketsBySp. -func (mr *MockMetadataAPIMockRecorder) ListExpiredBucketsBySp(ctx, createAt, primarySpID, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListExpiredBucketsBySp(ctx, createAt, primarySpID, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, createAt, primarySpID, limit}, opts...) + varargs := append([]any{ctx, createAt, primarySpID, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExpiredBucketsBySp", reflect.TypeOf((*MockMetadataAPI)(nil).ListExpiredBucketsBySp), varargs...) } // ListGlobalVirtualGroupsByBucket mocks base method. func (m *MockMetadataAPI) ListGlobalVirtualGroupsByBucket(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroup, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID} + varargs := []any{ctx, bucketID} for _, a := range opts { varargs = append(varargs, a) } @@ -3632,16 +3666,16 @@ func (m *MockMetadataAPI) ListGlobalVirtualGroupsByBucket(ctx context.Context, b } // ListGlobalVirtualGroupsByBucket indicates an expected call of ListGlobalVirtualGroupsByBucket. -func (mr *MockMetadataAPIMockRecorder) ListGlobalVirtualGroupsByBucket(ctx, bucketID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListGlobalVirtualGroupsByBucket(ctx, bucketID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID}, opts...) + varargs := append([]any{ctx, bucketID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalVirtualGroupsByBucket", reflect.TypeOf((*MockMetadataAPI)(nil).ListGlobalVirtualGroupsByBucket), varargs...) } // ListGlobalVirtualGroupsBySecondarySP mocks base method. func (m *MockMetadataAPI) ListGlobalVirtualGroupsBySecondarySP(ctx context.Context, spID uint32, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroup, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -3652,16 +3686,16 @@ func (m *MockMetadataAPI) ListGlobalVirtualGroupsBySecondarySP(ctx context.Conte } // ListGlobalVirtualGroupsBySecondarySP indicates an expected call of ListGlobalVirtualGroupsBySecondarySP. -func (mr *MockMetadataAPIMockRecorder) ListGlobalVirtualGroupsBySecondarySP(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListGlobalVirtualGroupsBySecondarySP(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalVirtualGroupsBySecondarySP", reflect.TypeOf((*MockMetadataAPI)(nil).ListGlobalVirtualGroupsBySecondarySP), varargs...) } // ListGroupsByIDs mocks base method. func (m *MockMetadataAPI) ListGroupsByIDs(ctx context.Context, groupIDs []uint64, opts ...grpc.DialOption) (map[uint64]*types.Group, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, groupIDs} + varargs := []any{ctx, groupIDs} for _, a := range opts { varargs = append(varargs, a) } @@ -3672,16 +3706,16 @@ func (m *MockMetadataAPI) ListGroupsByIDs(ctx context.Context, groupIDs []uint64 } // ListGroupsByIDs indicates an expected call of ListGroupsByIDs. -func (mr *MockMetadataAPIMockRecorder) ListGroupsByIDs(ctx, groupIDs interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListGroupsByIDs(ctx, groupIDs any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, groupIDs}, opts...) + varargs := append([]any{ctx, groupIDs}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsByIDs", reflect.TypeOf((*MockMetadataAPI)(nil).ListGroupsByIDs), varargs...) } // ListMigrateBucketEvents mocks base method. func (m *MockMetadataAPI) ListMigrateBucketEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListMigrateBucketEvents, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, blockID, spID} + varargs := []any{ctx, blockID, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -3692,16 +3726,16 @@ func (m *MockMetadataAPI) ListMigrateBucketEvents(ctx context.Context, blockID u } // ListMigrateBucketEvents indicates an expected call of ListMigrateBucketEvents. -func (mr *MockMetadataAPIMockRecorder) ListMigrateBucketEvents(ctx, blockID, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListMigrateBucketEvents(ctx, blockID, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, blockID, spID}, opts...) + varargs := append([]any{ctx, blockID, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMigrateBucketEvents", reflect.TypeOf((*MockMetadataAPI)(nil).ListMigrateBucketEvents), varargs...) } // ListObjectPolicies mocks base method. func (m *MockMetadataAPI) ListObjectPolicies(ctx context.Context, objectName, bucketName string, startAfter uint64, actionType int32, limit uint32, opts ...grpc.DialOption) ([]*types.Policy, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectName, bucketName, startAfter, actionType, limit} + varargs := []any{ctx, objectName, bucketName, startAfter, actionType, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -3712,16 +3746,16 @@ func (m *MockMetadataAPI) ListObjectPolicies(ctx context.Context, objectName, bu } // ListObjectPolicies indicates an expected call of ListObjectPolicies. -func (mr *MockMetadataAPIMockRecorder) ListObjectPolicies(ctx, objectName, bucketName, startAfter, actionType, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListObjectPolicies(ctx, objectName, bucketName, startAfter, actionType, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectName, bucketName, startAfter, actionType, limit}, opts...) + varargs := append([]any{ctx, objectName, bucketName, startAfter, actionType, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectPolicies", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectPolicies), varargs...) } // ListObjectsByBucketName mocks base method. func (m *MockMetadataAPI) ListObjectsByBucketName(ctx context.Context, bucketName, accountID string, maxKeys uint64, startAfter, continuationToken, delimiter, prefix string, includeRemoved bool, opts ...grpc.DialOption) ([]*types.Object, uint64, uint64, bool, string, string, string, string, []string, string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved} + varargs := []any{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -3741,16 +3775,16 @@ func (m *MockMetadataAPI) ListObjectsByBucketName(ctx context.Context, bucketNam } // ListObjectsByBucketName indicates an expected call of ListObjectsByBucketName. -func (mr *MockMetadataAPIMockRecorder) ListObjectsByBucketName(ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListObjectsByBucketName(ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved}, opts...) + varargs := append([]any{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByBucketName", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectsByBucketName), varargs...) } // ListObjectsByGVGAndBucketForGC mocks base method. func (m *MockMetadataAPI) ListObjectsByGVGAndBucketForGC(ctx context.Context, gvgID uint32, bucketID, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, gvgID, bucketID, startAfter, limit} + varargs := []any{ctx, gvgID, bucketID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -3761,16 +3795,16 @@ func (m *MockMetadataAPI) ListObjectsByGVGAndBucketForGC(ctx context.Context, gv } // ListObjectsByGVGAndBucketForGC indicates an expected call of ListObjectsByGVGAndBucketForGC. -func (mr *MockMetadataAPIMockRecorder) ListObjectsByGVGAndBucketForGC(ctx, gvgID, bucketID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListObjectsByGVGAndBucketForGC(ctx, gvgID, bucketID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, gvgID, bucketID, startAfter, limit}, opts...) + varargs := append([]any{ctx, gvgID, bucketID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByGVGAndBucketForGC", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectsByGVGAndBucketForGC), varargs...) } // ListObjectsByIDs mocks base method. func (m *MockMetadataAPI) ListObjectsByIDs(ctx context.Context, objectIDs []uint64, includeRemoved bool, opts ...grpc.DialOption) (map[uint64]*types.Object, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, objectIDs, includeRemoved} + varargs := []any{ctx, objectIDs, includeRemoved} for _, a := range opts { varargs = append(varargs, a) } @@ -3781,16 +3815,16 @@ func (m *MockMetadataAPI) ListObjectsByIDs(ctx context.Context, objectIDs []uint } // ListObjectsByIDs indicates an expected call of ListObjectsByIDs. -func (mr *MockMetadataAPIMockRecorder) ListObjectsByIDs(ctx, objectIDs, includeRemoved interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListObjectsByIDs(ctx, objectIDs, includeRemoved any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, objectIDs, includeRemoved}, opts...) + varargs := append([]any{ctx, objectIDs, includeRemoved}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByIDs", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectsByIDs), varargs...) } // ListObjectsInGVG mocks base method. func (m *MockMetadataAPI) ListObjectsInGVG(ctx context.Context, gvgID uint32, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, gvgID, startAfter, limit} + varargs := []any{ctx, gvgID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -3801,16 +3835,16 @@ func (m *MockMetadataAPI) ListObjectsInGVG(ctx context.Context, gvgID uint32, st } // ListObjectsInGVG indicates an expected call of ListObjectsInGVG. -func (mr *MockMetadataAPIMockRecorder) ListObjectsInGVG(ctx, gvgID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListObjectsInGVG(ctx, gvgID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, gvgID, startAfter, limit}, opts...) + varargs := append([]any{ctx, gvgID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsInGVG", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectsInGVG), varargs...) } // ListObjectsInGVGAndBucket mocks base method. func (m *MockMetadataAPI) ListObjectsInGVGAndBucket(ctx context.Context, gvgID uint32, bucketID, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, gvgID, bucketID, startAfter, limit} + varargs := []any{ctx, gvgID, bucketID, startAfter, limit} for _, a := range opts { varargs = append(varargs, a) } @@ -3821,16 +3855,16 @@ func (m *MockMetadataAPI) ListObjectsInGVGAndBucket(ctx context.Context, gvgID u } // ListObjectsInGVGAndBucket indicates an expected call of ListObjectsInGVGAndBucket. -func (mr *MockMetadataAPIMockRecorder) ListObjectsInGVGAndBucket(ctx, gvgID, bucketID, startAfter, limit interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListObjectsInGVGAndBucket(ctx, gvgID, bucketID, startAfter, limit any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, gvgID, bucketID, startAfter, limit}, opts...) + varargs := append([]any{ctx, gvgID, bucketID, startAfter, limit}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsInGVGAndBucket", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectsInGVGAndBucket), varargs...) } // ListPaymentAccountStreams mocks base method. func (m *MockMetadataAPI) ListPaymentAccountStreams(ctx context.Context, paymentAccount string, opts ...grpc.DialOption) ([]*types.Bucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, paymentAccount} + varargs := []any{ctx, paymentAccount} for _, a := range opts { varargs = append(varargs, a) } @@ -3841,16 +3875,16 @@ func (m *MockMetadataAPI) ListPaymentAccountStreams(ctx context.Context, payment } // ListPaymentAccountStreams indicates an expected call of ListPaymentAccountStreams. -func (mr *MockMetadataAPIMockRecorder) ListPaymentAccountStreams(ctx, paymentAccount interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListPaymentAccountStreams(ctx, paymentAccount any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, paymentAccount}, opts...) + varargs := append([]any{ctx, paymentAccount}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPaymentAccountStreams", reflect.TypeOf((*MockMetadataAPI)(nil).ListPaymentAccountStreams), varargs...) } // ListSpExitEvents mocks base method. func (m *MockMetadataAPI) ListSpExitEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) (*types.ListSpExitEvents, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, blockID, spID} + varargs := []any{ctx, blockID, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -3861,16 +3895,16 @@ func (m *MockMetadataAPI) ListSpExitEvents(ctx context.Context, blockID uint64, } // ListSpExitEvents indicates an expected call of ListSpExitEvents. -func (mr *MockMetadataAPIMockRecorder) ListSpExitEvents(ctx, blockID, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListSpExitEvents(ctx, blockID, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, blockID, spID}, opts...) + varargs := append([]any{ctx, blockID, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSpExitEvents", reflect.TypeOf((*MockMetadataAPI)(nil).ListSpExitEvents), varargs...) } // ListSwapOutEvents mocks base method. func (m *MockMetadataAPI) ListSwapOutEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListSwapOutEvents, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, blockID, spID} + varargs := []any{ctx, blockID, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -3881,16 +3915,16 @@ func (m *MockMetadataAPI) ListSwapOutEvents(ctx context.Context, blockID uint64, } // ListSwapOutEvents indicates an expected call of ListSwapOutEvents. -func (mr *MockMetadataAPIMockRecorder) ListSwapOutEvents(ctx, blockID, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListSwapOutEvents(ctx, blockID, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, blockID, spID}, opts...) + varargs := append([]any{ctx, blockID, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSwapOutEvents", reflect.TypeOf((*MockMetadataAPI)(nil).ListSwapOutEvents), varargs...) } // ListUserPaymentAccounts mocks base method. func (m *MockMetadataAPI) ListUserPaymentAccounts(ctx context.Context, accountID string, opts ...grpc.DialOption) ([]*types.PaymentAccountMeta, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, accountID} + varargs := []any{ctx, accountID} for _, a := range opts { varargs = append(varargs, a) } @@ -3901,16 +3935,16 @@ func (m *MockMetadataAPI) ListUserPaymentAccounts(ctx context.Context, accountID } // ListUserPaymentAccounts indicates an expected call of ListUserPaymentAccounts. -func (mr *MockMetadataAPIMockRecorder) ListUserPaymentAccounts(ctx, accountID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListUserPaymentAccounts(ctx, accountID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, accountID}, opts...) + varargs := append([]any{ctx, accountID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPaymentAccounts", reflect.TypeOf((*MockMetadataAPI)(nil).ListUserPaymentAccounts), varargs...) } // ListVirtualGroupFamiliesSpID mocks base method. func (m *MockMetadataAPI) ListVirtualGroupFamiliesSpID(ctx context.Context, spID uint32, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroupFamily, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -3921,16 +3955,16 @@ func (m *MockMetadataAPI) ListVirtualGroupFamiliesSpID(ctx context.Context, spID } // ListVirtualGroupFamiliesSpID indicates an expected call of ListVirtualGroupFamiliesSpID. -func (mr *MockMetadataAPIMockRecorder) ListVirtualGroupFamiliesSpID(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) ListVirtualGroupFamiliesSpID(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVirtualGroupFamiliesSpID", reflect.TypeOf((*MockMetadataAPI)(nil).ListVirtualGroupFamiliesSpID), varargs...) } // PrimarySpIncomeDetails mocks base method. func (m *MockMetadataAPI) PrimarySpIncomeDetails(ctx context.Context, spID uint32, opts ...grpc.DialOption) (int64, []*types.PrimarySpIncomeDetail, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -3942,16 +3976,16 @@ func (m *MockMetadataAPI) PrimarySpIncomeDetails(ctx context.Context, spID uint3 } // PrimarySpIncomeDetails indicates an expected call of PrimarySpIncomeDetails. -func (mr *MockMetadataAPIMockRecorder) PrimarySpIncomeDetails(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) PrimarySpIncomeDetails(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimarySpIncomeDetails", reflect.TypeOf((*MockMetadataAPI)(nil).PrimarySpIncomeDetails), varargs...) } // SecondarySpIncomeDetails mocks base method. func (m *MockMetadataAPI) SecondarySpIncomeDetails(ctx context.Context, spID uint32, opts ...grpc.DialOption) (int64, []*types.SecondarySpIncomeDetail, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, spID} + varargs := []any{ctx, spID} for _, a := range opts { varargs = append(varargs, a) } @@ -3963,16 +3997,16 @@ func (m *MockMetadataAPI) SecondarySpIncomeDetails(ctx context.Context, spID uin } // SecondarySpIncomeDetails indicates an expected call of SecondarySpIncomeDetails. -func (mr *MockMetadataAPIMockRecorder) SecondarySpIncomeDetails(ctx, spID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) SecondarySpIncomeDetails(ctx, spID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, spID}, opts...) + varargs := append([]any{ctx, spID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecondarySpIncomeDetails", reflect.TypeOf((*MockMetadataAPI)(nil).SecondarySpIncomeDetails), varargs...) } // VerifyMigrateGVGPermission mocks base method. func (m *MockMetadataAPI) VerifyMigrateGVGPermission(ctx context.Context, bucketID uint64, gvgID, dstSpID uint32, opts ...grpc.DialOption) (*types1.Effect, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, bucketID, gvgID, dstSpID} + varargs := []any{ctx, bucketID, gvgID, dstSpID} for _, a := range opts { varargs = append(varargs, a) } @@ -3983,16 +4017,16 @@ func (m *MockMetadataAPI) VerifyMigrateGVGPermission(ctx context.Context, bucket } // VerifyMigrateGVGPermission indicates an expected call of VerifyMigrateGVGPermission. -func (mr *MockMetadataAPIMockRecorder) VerifyMigrateGVGPermission(ctx, bucketID, gvgID, dstSpID interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) VerifyMigrateGVGPermission(ctx, bucketID, gvgID, dstSpID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, bucketID, gvgID, dstSpID}, opts...) + varargs := append([]any{ctx, bucketID, gvgID, dstSpID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyMigrateGVGPermission", reflect.TypeOf((*MockMetadataAPI)(nil).VerifyMigrateGVGPermission), varargs...) } // VerifyPermission mocks base method. func (m *MockMetadataAPI) VerifyPermission(ctx context.Context, Operator, bucketName, objectName string, actionType types1.ActionType, opts ...grpc.DialOption) (*types1.Effect, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, Operator, bucketName, objectName, actionType} + varargs := []any{ctx, Operator, bucketName, objectName, actionType} for _, a := range opts { varargs = append(varargs, a) } @@ -4003,16 +4037,16 @@ func (m *MockMetadataAPI) VerifyPermission(ctx context.Context, Operator, bucket } // VerifyPermission indicates an expected call of VerifyPermission. -func (mr *MockMetadataAPIMockRecorder) VerifyPermission(ctx, Operator, bucketName, objectName, actionType interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) VerifyPermission(ctx, Operator, bucketName, objectName, actionType any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, Operator, bucketName, objectName, actionType}, opts...) + varargs := append([]any{ctx, Operator, bucketName, objectName, actionType}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyPermission", reflect.TypeOf((*MockMetadataAPI)(nil).VerifyPermission), varargs...) } // VerifyPermissionByID mocks base method. func (m *MockMetadataAPI) VerifyPermissionByID(ctx context.Context, Operator string, resourceType resource.ResourceType, resourceID uint64, actionType types1.ActionType, opts ...grpc.DialOption) (*types1.Effect, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, Operator, resourceType, resourceID, actionType} + varargs := []any{ctx, Operator, resourceType, resourceID, actionType} for _, a := range opts { varargs = append(varargs, a) } @@ -4023,9 +4057,9 @@ func (m *MockMetadataAPI) VerifyPermissionByID(ctx context.Context, Operator str } // VerifyPermissionByID indicates an expected call of VerifyPermissionByID. -func (mr *MockMetadataAPIMockRecorder) VerifyPermissionByID(ctx, Operator, resourceType, resourceID, actionType interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockMetadataAPIMockRecorder) VerifyPermissionByID(ctx, Operator, resourceType, resourceID, actionType any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, Operator, resourceType, resourceID, actionType}, opts...) + varargs := append([]any{ctx, Operator, resourceType, resourceID, actionType}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyPermissionByID", reflect.TypeOf((*MockMetadataAPI)(nil).VerifyPermissionByID), varargs...) } @@ -4062,7 +4096,7 @@ func (m *MockP2PAPI) AskSecondaryReplicatePieceApproval(ctx context.Context, tas } // AskSecondaryReplicatePieceApproval indicates an expected call of AskSecondaryReplicatePieceApproval. -func (mr *MockP2PAPIMockRecorder) AskSecondaryReplicatePieceApproval(ctx, task, low, high, timeout interface{}) *gomock.Call { +func (mr *MockP2PAPIMockRecorder) AskSecondaryReplicatePieceApproval(ctx, task, low, high, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskSecondaryReplicatePieceApproval", reflect.TypeOf((*MockP2PAPI)(nil).AskSecondaryReplicatePieceApproval), ctx, task, low, high, timeout) } @@ -4077,7 +4111,7 @@ func (m *MockP2PAPI) QueryP2PBootstrap(ctx context.Context) ([]string, error) { } // QueryP2PBootstrap indicates an expected call of QueryP2PBootstrap. -func (mr *MockP2PAPIMockRecorder) QueryP2PBootstrap(ctx interface{}) *gomock.Call { +func (mr *MockP2PAPIMockRecorder) QueryP2PBootstrap(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryP2PBootstrap", reflect.TypeOf((*MockP2PAPI)(nil).QueryP2PBootstrap), ctx) } @@ -4108,7 +4142,7 @@ func (m *MockQueryAPI) EXPECT() *MockQueryAPIMockRecorder { // QueryBucketMigrate mocks base method. func (m *MockQueryAPI) QueryBucketMigrate(ctx context.Context, endpoint string, opts ...grpc.DialOption) (string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, endpoint} + varargs := []any{ctx, endpoint} for _, a := range opts { varargs = append(varargs, a) } @@ -4119,16 +4153,16 @@ func (m *MockQueryAPI) QueryBucketMigrate(ctx context.Context, endpoint string, } // QueryBucketMigrate indicates an expected call of QueryBucketMigrate. -func (mr *MockQueryAPIMockRecorder) QueryBucketMigrate(ctx, endpoint interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockQueryAPIMockRecorder) QueryBucketMigrate(ctx, endpoint any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, endpoint}, opts...) + varargs := append([]any{ctx, endpoint}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBucketMigrate", reflect.TypeOf((*MockQueryAPI)(nil).QueryBucketMigrate), varargs...) } // QuerySPExit mocks base method. func (m *MockQueryAPI) QuerySPExit(ctx context.Context, endpoint string, opts ...grpc.DialOption) (string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, endpoint} + varargs := []any{ctx, endpoint} for _, a := range opts { varargs = append(varargs, a) } @@ -4139,16 +4173,16 @@ func (m *MockQueryAPI) QuerySPExit(ctx context.Context, endpoint string, opts .. } // QuerySPExit indicates an expected call of QuerySPExit. -func (mr *MockQueryAPIMockRecorder) QuerySPExit(ctx, endpoint interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockQueryAPIMockRecorder) QuerySPExit(ctx, endpoint any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, endpoint}, opts...) + varargs := append([]any{ctx, endpoint}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySPExit", reflect.TypeOf((*MockQueryAPI)(nil).QuerySPExit), varargs...) } // QueryTasks mocks base method. func (m *MockQueryAPI) QueryTasks(ctx context.Context, endpoint, subKey string, opts ...grpc.DialOption) ([]string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, endpoint, subKey} + varargs := []any{ctx, endpoint, subKey} for _, a := range opts { varargs = append(varargs, a) } @@ -4159,9 +4193,9 @@ func (m *MockQueryAPI) QueryTasks(ctx context.Context, endpoint, subKey string, } // QueryTasks indicates an expected call of QueryTasks. -func (mr *MockQueryAPIMockRecorder) QueryTasks(ctx, endpoint, subKey interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockQueryAPIMockRecorder) QueryTasks(ctx, endpoint, subKey any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, endpoint, subKey}, opts...) + varargs := append([]any{ctx, endpoint, subKey}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockQueryAPI)(nil).QueryTasks), varargs...) } @@ -4191,7 +4225,7 @@ func (m *MockReceiverAPI) EXPECT() *MockReceiverAPIMockRecorder { // DoneReplicatePiece mocks base method. func (m *MockReceiverAPI) DoneReplicatePiece(ctx context.Context, task task.ReceivePieceTask, opts ...grpc.DialOption) ([]byte, []byte, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, task} + varargs := []any{ctx, task} for _, a := range opts { varargs = append(varargs, a) } @@ -4203,16 +4237,16 @@ func (m *MockReceiverAPI) DoneReplicatePiece(ctx context.Context, task task.Rece } // DoneReplicatePiece indicates an expected call of DoneReplicatePiece. -func (mr *MockReceiverAPIMockRecorder) DoneReplicatePiece(ctx, task interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockReceiverAPIMockRecorder) DoneReplicatePiece(ctx, task any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, task}, opts...) + varargs := append([]any{ctx, task}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoneReplicatePiece", reflect.TypeOf((*MockReceiverAPI)(nil).DoneReplicatePiece), varargs...) } // ReplicatePiece mocks base method. func (m *MockReceiverAPI) ReplicatePiece(ctx context.Context, task task.ReceivePieceTask, data []byte, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, task, data} + varargs := []any{ctx, task, data} for _, a := range opts { varargs = append(varargs, a) } @@ -4222,9 +4256,9 @@ func (m *MockReceiverAPI) ReplicatePiece(ctx context.Context, task task.ReceiveP } // ReplicatePiece indicates an expected call of ReplicatePiece. -func (mr *MockReceiverAPIMockRecorder) ReplicatePiece(ctx, task, data interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockReceiverAPIMockRecorder) ReplicatePiece(ctx, task, data any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, task, data}, opts...) + varargs := append([]any{ctx, task, data}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicatePiece", reflect.TypeOf((*MockReceiverAPI)(nil).ReplicatePiece), varargs...) } @@ -4261,7 +4295,7 @@ func (m *MockSignerAPI) CompleteMigrateBucket(ctx context.Context, migrateBucket } // CompleteMigrateBucket indicates an expected call of CompleteMigrateBucket. -func (mr *MockSignerAPIMockRecorder) CompleteMigrateBucket(ctx, migrateBucket interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) CompleteMigrateBucket(ctx, migrateBucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMigrateBucket", reflect.TypeOf((*MockSignerAPI)(nil).CompleteMigrateBucket), ctx, migrateBucket) } @@ -4276,11 +4310,26 @@ func (m *MockSignerAPI) CompleteSPExit(ctx context.Context, completeSPExit *type } // CompleteSPExit indicates an expected call of CompleteSPExit. -func (mr *MockSignerAPIMockRecorder) CompleteSPExit(ctx, completeSPExit interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) CompleteSPExit(ctx, completeSPExit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSPExit", reflect.TypeOf((*MockSignerAPI)(nil).CompleteSPExit), ctx, completeSPExit) } +// CompleteSwapIn mocks base method. +func (m *MockSignerAPI) CompleteSwapIn(ctx context.Context, completeSwpIn *types4.MsgCompleteSwapIn) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CompleteSwapIn", ctx, completeSwpIn) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CompleteSwapIn indicates an expected call of CompleteSwapIn. +func (mr *MockSignerAPIMockRecorder) CompleteSwapIn(ctx, completeSwpIn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapIn", reflect.TypeOf((*MockSignerAPI)(nil).CompleteSwapIn), ctx, completeSwpIn) +} + // CompleteSwapOut mocks base method. func (m *MockSignerAPI) CompleteSwapOut(ctx context.Context, completeSwapOut *types4.MsgCompleteSwapOut) (string, error) { m.ctrl.T.Helper() @@ -4291,7 +4340,7 @@ func (m *MockSignerAPI) CompleteSwapOut(ctx context.Context, completeSwapOut *ty } // CompleteSwapOut indicates an expected call of CompleteSwapOut. -func (mr *MockSignerAPIMockRecorder) CompleteSwapOut(ctx, completeSwapOut interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) CompleteSwapOut(ctx, completeSwapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapOut", reflect.TypeOf((*MockSignerAPI)(nil).CompleteSwapOut), ctx, completeSwapOut) } @@ -4305,7 +4354,7 @@ func (m *MockSignerAPI) CreateGlobalVirtualGroup(ctx context.Context, group *gfs } // CreateGlobalVirtualGroup indicates an expected call of CreateGlobalVirtualGroup. -func (mr *MockSignerAPIMockRecorder) CreateGlobalVirtualGroup(ctx, group interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) CreateGlobalVirtualGroup(ctx, group any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalVirtualGroup", reflect.TypeOf((*MockSignerAPI)(nil).CreateGlobalVirtualGroup), ctx, group) } @@ -4320,7 +4369,7 @@ func (m *MockSignerAPI) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG } // DeleteGlobalVirtualGroup indicates an expected call of DeleteGlobalVirtualGroup. -func (mr *MockSignerAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalVirtualGroup", reflect.TypeOf((*MockSignerAPI)(nil).DeleteGlobalVirtualGroup), ctx, deleteGVG) } @@ -4335,7 +4384,7 @@ func (m *MockSignerAPI) Deposit(ctx context.Context, deposit *types4.MsgDeposit) } // Deposit indicates an expected call of Deposit. -func (mr *MockSignerAPIMockRecorder) Deposit(ctx, deposit interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) Deposit(ctx, deposit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deposit", reflect.TypeOf((*MockSignerAPI)(nil).Deposit), ctx, deposit) } @@ -4350,7 +4399,7 @@ func (m *MockSignerAPI) DiscontinueBucket(ctx context.Context, bucket *types3.Ms } // DiscontinueBucket indicates an expected call of DiscontinueBucket. -func (mr *MockSignerAPIMockRecorder) DiscontinueBucket(ctx, bucket interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) DiscontinueBucket(ctx, bucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscontinueBucket", reflect.TypeOf((*MockSignerAPI)(nil).DiscontinueBucket), ctx, bucket) } @@ -4365,7 +4414,7 @@ func (m *MockSignerAPI) RejectMigrateBucket(ctx context.Context, rejectMigrateBu } // RejectMigrateBucket indicates an expected call of RejectMigrateBucket. -func (mr *MockSignerAPIMockRecorder) RejectMigrateBucket(ctx, rejectMigrateBucket interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) RejectMigrateBucket(ctx, rejectMigrateBucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectMigrateBucket", reflect.TypeOf((*MockSignerAPI)(nil).RejectMigrateBucket), ctx, rejectMigrateBucket) } @@ -4380,11 +4429,26 @@ func (m *MockSignerAPI) RejectUnSealObject(ctx context.Context, object *types3.M } // RejectUnSealObject indicates an expected call of RejectUnSealObject. -func (mr *MockSignerAPIMockRecorder) RejectUnSealObject(ctx, object interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) RejectUnSealObject(ctx, object any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectUnSealObject", reflect.TypeOf((*MockSignerAPI)(nil).RejectUnSealObject), ctx, object) } +// ReserveSwapIn mocks base method. +func (m *MockSignerAPI) ReserveSwapIn(ctx context.Context, reserveSwapIn *types4.MsgReserveSwapIn) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReserveSwapIn", ctx, reserveSwapIn) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReserveSwapIn indicates an expected call of ReserveSwapIn. +func (mr *MockSignerAPIMockRecorder) ReserveSwapIn(ctx, reserveSwapIn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveSwapIn", reflect.TypeOf((*MockSignerAPI)(nil).ReserveSwapIn), ctx, reserveSwapIn) +} + // SPExit mocks base method. func (m *MockSignerAPI) SPExit(ctx context.Context, spExit *types4.MsgStorageProviderExit) (string, error) { m.ctrl.T.Helper() @@ -4395,7 +4459,7 @@ func (m *MockSignerAPI) SPExit(ctx context.Context, spExit *types4.MsgStoragePro } // SPExit indicates an expected call of SPExit. -func (mr *MockSignerAPIMockRecorder) SPExit(ctx, spExit interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SPExit(ctx, spExit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPExit", reflect.TypeOf((*MockSignerAPI)(nil).SPExit), ctx, spExit) } @@ -4410,7 +4474,7 @@ func (m *MockSignerAPI) SealObject(ctx context.Context, object *types3.MsgSealOb } // SealObject indicates an expected call of SealObject. -func (mr *MockSignerAPIMockRecorder) SealObject(ctx, object interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SealObject(ctx, object any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealObject", reflect.TypeOf((*MockSignerAPI)(nil).SealObject), ctx, object) } @@ -4425,7 +4489,7 @@ func (m *MockSignerAPI) SignBucketMigrationInfo(ctx context.Context, task *gfspt } // SignBucketMigrationInfo indicates an expected call of SignBucketMigrationInfo. -func (mr *MockSignerAPIMockRecorder) SignBucketMigrationInfo(ctx, task interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignBucketMigrationInfo(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignBucketMigrationInfo", reflect.TypeOf((*MockSignerAPI)(nil).SignBucketMigrationInfo), ctx, task) } @@ -4440,7 +4504,7 @@ func (m *MockSignerAPI) SignCreateBucketApproval(ctx context.Context, bucket *ty } // SignCreateBucketApproval indicates an expected call of SignCreateBucketApproval. -func (mr *MockSignerAPIMockRecorder) SignCreateBucketApproval(ctx, bucket interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignCreateBucketApproval(ctx, bucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateBucketApproval", reflect.TypeOf((*MockSignerAPI)(nil).SignCreateBucketApproval), ctx, bucket) } @@ -4455,7 +4519,7 @@ func (m *MockSignerAPI) SignCreateObjectApproval(ctx context.Context, object *ty } // SignCreateObjectApproval indicates an expected call of SignCreateObjectApproval. -func (mr *MockSignerAPIMockRecorder) SignCreateObjectApproval(ctx, object interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignCreateObjectApproval(ctx, object any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateObjectApproval", reflect.TypeOf((*MockSignerAPI)(nil).SignCreateObjectApproval), ctx, object) } @@ -4470,7 +4534,7 @@ func (m *MockSignerAPI) SignMigrateBucketApproval(ctx context.Context, bucket *t } // SignMigrateBucketApproval indicates an expected call of SignMigrateBucketApproval. -func (mr *MockSignerAPIMockRecorder) SignMigrateBucketApproval(ctx, bucket interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignMigrateBucketApproval(ctx, bucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateBucketApproval", reflect.TypeOf((*MockSignerAPI)(nil).SignMigrateBucketApproval), ctx, bucket) } @@ -4485,7 +4549,7 @@ func (m *MockSignerAPI) SignMigrateGVG(ctx context.Context, task *gfsptask.GfSpM } // SignMigrateGVG indicates an expected call of SignMigrateGVG. -func (mr *MockSignerAPIMockRecorder) SignMigrateGVG(ctx, task interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignMigrateGVG(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateGVG", reflect.TypeOf((*MockSignerAPI)(nil).SignMigrateGVG), ctx, task) } @@ -4500,7 +4564,7 @@ func (m *MockSignerAPI) SignP2PPingMsg(ctx context.Context, ping *gfspp2p.GfSpPi } // SignP2PPingMsg indicates an expected call of SignP2PPingMsg. -func (mr *MockSignerAPIMockRecorder) SignP2PPingMsg(ctx, ping interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignP2PPingMsg(ctx, ping any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPingMsg", reflect.TypeOf((*MockSignerAPI)(nil).SignP2PPingMsg), ctx, ping) } @@ -4515,7 +4579,7 @@ func (m *MockSignerAPI) SignP2PPongMsg(ctx context.Context, pong *gfspp2p.GfSpPo } // SignP2PPongMsg indicates an expected call of SignP2PPongMsg. -func (mr *MockSignerAPIMockRecorder) SignP2PPongMsg(ctx, pong interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignP2PPongMsg(ctx, pong any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPongMsg", reflect.TypeOf((*MockSignerAPI)(nil).SignP2PPongMsg), ctx, pong) } @@ -4530,7 +4594,7 @@ func (m *MockSignerAPI) SignReceiveTask(ctx context.Context, receiveTask task.Re } // SignReceiveTask indicates an expected call of SignReceiveTask. -func (mr *MockSignerAPIMockRecorder) SignReceiveTask(ctx, receiveTask interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignReceiveTask(ctx, receiveTask any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReceiveTask", reflect.TypeOf((*MockSignerAPI)(nil).SignReceiveTask), ctx, receiveTask) } @@ -4545,7 +4609,7 @@ func (m *MockSignerAPI) SignRecoveryTask(ctx context.Context, recoveryTask task. } // SignRecoveryTask indicates an expected call of SignRecoveryTask. -func (mr *MockSignerAPIMockRecorder) SignRecoveryTask(ctx, recoveryTask interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignRecoveryTask(ctx, recoveryTask any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignRecoveryTask", reflect.TypeOf((*MockSignerAPI)(nil).SignRecoveryTask), ctx, recoveryTask) } @@ -4560,7 +4624,7 @@ func (m *MockSignerAPI) SignReplicatePieceApproval(ctx context.Context, task tas } // SignReplicatePieceApproval indicates an expected call of SignReplicatePieceApproval. -func (mr *MockSignerAPIMockRecorder) SignReplicatePieceApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignReplicatePieceApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReplicatePieceApproval", reflect.TypeOf((*MockSignerAPI)(nil).SignReplicatePieceApproval), ctx, task) } @@ -4575,7 +4639,7 @@ func (m *MockSignerAPI) SignSecondarySPMigrationBucket(ctx context.Context, sign } // SignSecondarySPMigrationBucket indicates an expected call of SignSecondarySPMigrationBucket. -func (mr *MockSignerAPIMockRecorder) SignSecondarySPMigrationBucket(ctx, signDoc interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignSecondarySPMigrationBucket(ctx, signDoc any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySPMigrationBucket", reflect.TypeOf((*MockSignerAPI)(nil).SignSecondarySPMigrationBucket), ctx, signDoc) } @@ -4590,7 +4654,7 @@ func (m *MockSignerAPI) SignSecondarySealBls(ctx context.Context, objectID uint6 } // SignSecondarySealBls indicates an expected call of SignSecondarySealBls. -func (mr *MockSignerAPIMockRecorder) SignSecondarySealBls(ctx, objectID, gvgId, checksums interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignSecondarySealBls(ctx, objectID, gvgId, checksums any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySealBls", reflect.TypeOf((*MockSignerAPI)(nil).SignSecondarySealBls), ctx, objectID, gvgId, checksums) } @@ -4605,7 +4669,7 @@ func (m *MockSignerAPI) SignSwapOut(ctx context.Context, swapOut *types4.MsgSwap } // SignSwapOut indicates an expected call of SignSwapOut. -func (mr *MockSignerAPIMockRecorder) SignSwapOut(ctx, swapOut interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SignSwapOut(ctx, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSwapOut", reflect.TypeOf((*MockSignerAPI)(nil).SignSwapOut), ctx, swapOut) } @@ -4620,7 +4684,7 @@ func (m *MockSignerAPI) SwapOut(ctx context.Context, swapOut *types4.MsgSwapOut) } // SwapOut indicates an expected call of SwapOut. -func (mr *MockSignerAPIMockRecorder) SwapOut(ctx, swapOut interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) SwapOut(ctx, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapOut", reflect.TypeOf((*MockSignerAPI)(nil).SwapOut), ctx, swapOut) } @@ -4635,7 +4699,7 @@ func (m *MockSignerAPI) UpdateSPPrice(ctx context.Context, price *types2.MsgUpda } // UpdateSPPrice indicates an expected call of UpdateSPPrice. -func (mr *MockSignerAPIMockRecorder) UpdateSPPrice(ctx, price interface{}) *gomock.Call { +func (mr *MockSignerAPIMockRecorder) UpdateSPPrice(ctx, price any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSPPrice", reflect.TypeOf((*MockSignerAPI)(nil).UpdateSPPrice), ctx, price) } @@ -4666,7 +4730,7 @@ func (m *MockUploaderAPI) EXPECT() *MockUploaderAPIMockRecorder { // ResumableUploadObject mocks base method. func (m *MockUploaderAPI) ResumableUploadObject(ctx context.Context, task task.ResumableUploadObjectTask, stream io.Reader, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, task, stream} + varargs := []any{ctx, task, stream} for _, a := range opts { varargs = append(varargs, a) } @@ -4676,16 +4740,16 @@ func (m *MockUploaderAPI) ResumableUploadObject(ctx context.Context, task task.R } // ResumableUploadObject indicates an expected call of ResumableUploadObject. -func (mr *MockUploaderAPIMockRecorder) ResumableUploadObject(ctx, task, stream interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockUploaderAPIMockRecorder) ResumableUploadObject(ctx, task, stream any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, task, stream}, opts...) + varargs := append([]any{ctx, task, stream}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumableUploadObject", reflect.TypeOf((*MockUploaderAPI)(nil).ResumableUploadObject), varargs...) } // UploadObject mocks base method. func (m *MockUploaderAPI) UploadObject(ctx context.Context, task task.UploadObjectTask, stream io.Reader, opts ...grpc.DialOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, task, stream} + varargs := []any{ctx, task, stream} for _, a := range opts { varargs = append(varargs, a) } @@ -4695,9 +4759,9 @@ func (m *MockUploaderAPI) UploadObject(ctx context.Context, task task.UploadObje } // UploadObject indicates an expected call of UploadObject. -func (mr *MockUploaderAPIMockRecorder) UploadObject(ctx, task, stream interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockUploaderAPIMockRecorder) UploadObject(ctx, task, stream any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, task, stream}, opts...) + varargs := append([]any{ctx, task, stream}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadObject", reflect.TypeOf((*MockUploaderAPI)(nil).UploadObject), varargs...) } @@ -4727,7 +4791,7 @@ func (m *MockGfSpConnAPI) EXPECT() *MockGfSpConnAPIMockRecorder { // ApproverConn mocks base method. func (m *MockGfSpConnAPI) ApproverConn(ctx context.Context, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -4738,9 +4802,9 @@ func (m *MockGfSpConnAPI) ApproverConn(ctx context.Context, opts ...grpc.DialOpt } // ApproverConn indicates an expected call of ApproverConn. -func (mr *MockGfSpConnAPIMockRecorder) ApproverConn(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpConnAPIMockRecorder) ApproverConn(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproverConn", reflect.TypeOf((*MockGfSpConnAPI)(nil).ApproverConn), varargs...) } @@ -4761,7 +4825,7 @@ func (mr *MockGfSpConnAPIMockRecorder) Close() *gomock.Call { // Connection mocks base method. func (m *MockGfSpConnAPI) Connection(ctx context.Context, address string, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, address} + varargs := []any{ctx, address} for _, a := range opts { varargs = append(varargs, a) } @@ -4772,9 +4836,9 @@ func (m *MockGfSpConnAPI) Connection(ctx context.Context, address string, opts . } // Connection indicates an expected call of Connection. -func (mr *MockGfSpConnAPIMockRecorder) Connection(ctx, address interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpConnAPIMockRecorder) Connection(ctx, address any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, address}, opts...) + varargs := append([]any{ctx, address}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connection", reflect.TypeOf((*MockGfSpConnAPI)(nil).Connection), varargs...) } @@ -4787,7 +4851,7 @@ func (m *MockGfSpConnAPI) HTTPClient(ctx context.Context) *http.Client { } // HTTPClient indicates an expected call of HTTPClient. -func (mr *MockGfSpConnAPIMockRecorder) HTTPClient(ctx interface{}) *gomock.Call { +func (mr *MockGfSpConnAPIMockRecorder) HTTPClient(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTPClient", reflect.TypeOf((*MockGfSpConnAPI)(nil).HTTPClient), ctx) } @@ -4795,7 +4859,7 @@ func (mr *MockGfSpConnAPIMockRecorder) HTTPClient(ctx interface{}) *gomock.Call // ManagerConn mocks base method. func (m *MockGfSpConnAPI) ManagerConn(ctx context.Context, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -4806,16 +4870,16 @@ func (m *MockGfSpConnAPI) ManagerConn(ctx context.Context, opts ...grpc.DialOpti } // ManagerConn indicates an expected call of ManagerConn. -func (mr *MockGfSpConnAPIMockRecorder) ManagerConn(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpConnAPIMockRecorder) ManagerConn(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManagerConn", reflect.TypeOf((*MockGfSpConnAPI)(nil).ManagerConn), varargs...) } // P2PConn mocks base method. func (m *MockGfSpConnAPI) P2PConn(ctx context.Context, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -4826,16 +4890,16 @@ func (m *MockGfSpConnAPI) P2PConn(ctx context.Context, opts ...grpc.DialOption) } // P2PConn indicates an expected call of P2PConn. -func (mr *MockGfSpConnAPIMockRecorder) P2PConn(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpConnAPIMockRecorder) P2PConn(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "P2PConn", reflect.TypeOf((*MockGfSpConnAPI)(nil).P2PConn), varargs...) } // SignerConn mocks base method. func (m *MockGfSpConnAPI) SignerConn(ctx context.Context, opts ...grpc.DialOption) (*grpc.ClientConn, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx} + varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } @@ -4846,9 +4910,9 @@ func (m *MockGfSpConnAPI) SignerConn(ctx context.Context, opts ...grpc.DialOptio } // SignerConn indicates an expected call of SignerConn. -func (mr *MockGfSpConnAPIMockRecorder) SignerConn(ctx interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockGfSpConnAPIMockRecorder) SignerConn(ctx any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx}, opts...) + varargs := append([]any{ctx}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignerConn", reflect.TypeOf((*MockGfSpConnAPI)(nil).SignerConn), varargs...) } @@ -4899,7 +4963,7 @@ func (m *MockstdLib) Read(p []byte) (int, error) { } // Read indicates an expected call of Read. -func (mr *MockstdLibMockRecorder) Read(p interface{}) *gomock.Call { +func (mr *MockstdLibMockRecorder) Read(p any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockstdLib)(nil).Read), p) } diff --git a/base/gfspclient/manager.go b/base/gfspclient/manager.go index d51aed1b9..636da2c62 100644 --- a/base/gfspclient/manager.go +++ b/base/gfspclient/manager.go @@ -257,6 +257,46 @@ func (s *GfSpClient) ResetRecoveryFailedList(ctx context.Context) ([]string, err return resp.GetRecoveryFailedList(), nil } +func (s *GfSpClient) TriggerRecoverForSuccessorSP(ctx context.Context, vgfID, gvgID uint32, replicateIndex int32) error { + conn, connErr := s.ManagerConn(ctx) + if connErr != nil { + log.CtxErrorw(ctx, "client failed to connect manager", "error", connErr) + return ErrRPCUnknownWithDetail("client failed to connect manager, error: ", connErr) + } + resp, err := gfspserver.NewGfSpManageServiceClient(conn).GfSpTriggerRecoverForSuccessorSP(ctx, &gfspserver.GfSpTriggerRecoverForSuccessorSPRequest{ + VgfId: vgfID, GvgId: gvgID, ReplicateIndex: replicateIndex, + }) + if err != nil { + log.CtxErrorw(ctx, "client failed to trigger recover objects for successor SP", "vgf_id", vgfID, "gvg_id", gvgID, "error", err) + return ErrRPCUnknownWithDetail("client failed to notify post migrate bucket, error: ", err) + } + if resp.GetErr() != nil { + log.CtxErrorw(ctx, "failed to trigger recover objects for successor SP", "vgf_id", vgfID, "gvg_id", gvgID, "error", err) + return resp.GetErr() + } + return nil +} + +func (s *GfSpClient) QueryRecoverProcess(ctx context.Context, vgfID, gvgID uint32) ([]*gfspserver.RecoverProcess, bool, error) { + conn, connErr := s.ManagerConn(ctx) + if connErr != nil { + log.CtxErrorw(ctx, "client failed to connect manager", "error", connErr) + return nil, false, ErrRPCUnknownWithDetail("client failed to connect manager, error: ", connErr) + } + resp, err := gfspserver.NewGfSpManageServiceClient(conn).GfSpQueryRecoverProcess(ctx, &gfspserver.GfSpQueryRecoverProcessRequest{ + VgfId: vgfID, GvgId: gvgID, + }) + if err != nil { + log.CtxErrorw(ctx, "client failed to query recover process", "vgf_id", vgfID, "gvg_id", gvgID, "error", err) + return nil, false, ErrRPCUnknownWithDetail("client failed to query recover process, error: ", err) + } + if resp.GetErr() != nil { + log.CtxErrorw(ctx, "failed to query recover process", "vgf_id", vgfID, "gvg_id", gvgID, "error", err) + return nil, false, resp.GetErr() + } + return resp.GetRecoverProcesses(), resp.Executing, nil +} + func (s *GfSpClient) GetMigrateBucketProgress(ctx context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) { conn, connErr := s.ManagerConn(ctx) if connErr != nil { diff --git a/base/gfspclient/signer.go b/base/gfspclient/signer.go index 156bc12dc..407de99bd 100644 --- a/base/gfspclient/signer.go +++ b/base/gfspclient/signer.go @@ -588,3 +588,114 @@ func (s *GfSpClient) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG *vi } return resp.GetTxHash(), nil } + +func (s *GfSpClient) ReserveSwapIn(ctx context.Context, reserveSwapIn *virtualgrouptypes.MsgReserveSwapIn) (string, error) { + conn, err := s.SignerConn(ctx) + if err != nil { + log.Errorw("failed to connect to signer", "error", err) + return "", ErrRPCUnknownWithDetail("client failed to connect to signer, error: ", err) + } + req := &gfspserver.GfSpSignRequest{ + Request: &gfspserver.GfSpSignRequest_ReserveSwapIn{ + ReserveSwapIn: reserveSwapIn, + }, + } + resp, err := gfspserver.NewGfSpSignServiceClient(conn).GfSpSign(ctx, req) + if err != nil { + log.CtxErrorw(ctx, "client failed to reserve swap in", "msg", reserveSwapIn, "error", err) + return "", ErrRPCUnknownWithDetail("client failed to reserve swap in, error: ", err) + } + if resp.GetErr() != nil { + return "", resp.GetErr() + } + return resp.GetTxHash(), nil +} + +func (s *GfSpClient) CompleteSwapIn(ctx context.Context, completeSwapIn *virtualgrouptypes.MsgCompleteSwapIn) (string, error) { + conn, err := s.SignerConn(ctx) + if err != nil { + log.Errorw("failed to connect to signer", "error", err) + return "", ErrRPCUnknownWithDetail("client failed to connect to signer, error: ", err) + } + req := &gfspserver.GfSpSignRequest{ + Request: &gfspserver.GfSpSignRequest_CompleteSwapIn{ + CompleteSwapIn: completeSwapIn, + }, + } + resp, err := gfspserver.NewGfSpSignServiceClient(conn).GfSpSign(ctx, req) + if err != nil { + log.CtxErrorw(ctx, "client failed to complete swap in", "msg", completeSwapIn, "error", err) + return "", ErrRPCUnknownWithDetail("client failed to complete swap in, error: ", err) + } + if resp.GetErr() != nil { + return "", resp.GetErr() + } + return resp.GetTxHash(), nil +} + +// SpExit sent sp exit tx for sp gracefully exit +func (s *GfSpClient) SpExit(ctx context.Context, spExit *virtualgrouptypes.MsgStorageProviderExit) (string, error) { + conn, err := s.SignerConn(ctx) + if err != nil { + log.Errorw("failed to connect to signer", "error", err) + return "", ErrRPCUnknownWithDetail("client failed to connect to signer, error: ", err) + } + req := &gfspserver.GfSpSignRequest{ + Request: &gfspserver.GfSpSignRequest_SpExit{ + SpExit: spExit, + }, + } + resp, err := gfspserver.NewGfSpSignServiceClient(conn).GfSpSign(ctx, req) + if err != nil { + log.CtxErrorw(ctx, "client failed to send sp exit tx", "msg", spExit, "error", err) + return "", ErrRPCUnknownWithDetail("client failed to send sp exit tx, error: ", err) + } + if resp.GetErr() != nil { + return "", resp.GetErr() + } + return resp.GetTxHash(), nil +} + +func (s *GfSpClient) CompleteSpExit(ctx context.Context, completeSpExit *virtualgrouptypes.MsgCompleteStorageProviderExit) (string, error) { + conn, err := s.SignerConn(ctx) + if err != nil { + log.Errorw("failed to connect to signer", "error", err) + return "", ErrRPCUnknownWithDetail("client failed to connect to signer, error: ", err) + } + req := &gfspserver.GfSpSignRequest{ + Request: &gfspserver.GfSpSignRequest_CompleteSpExit{ + CompleteSpExit: completeSpExit, + }, + } + resp, err := gfspserver.NewGfSpSignServiceClient(conn).GfSpSign(ctx, req) + if err != nil { + log.CtxErrorw(ctx, "client failed to send complete sp exit tx", "msg", completeSpExit, "error", err) + return "", ErrRPCUnknownWithDetail("client failed to send complete sp exit tx, error: ", err) + } + if resp.GetErr() != nil { + return "", resp.GetErr() + } + return resp.GetTxHash(), nil +} + +func (s *GfSpClient) CancelSwapIn(ctx context.Context, cancelSwapIn *virtualgrouptypes.MsgCancelSwapIn) (string, error) { + conn, err := s.SignerConn(ctx) + if err != nil { + log.Errorw("failed to connect to signer", "error", err) + return "", ErrRPCUnknownWithDetail("client failed to connect to signer, error: ", err) + } + req := &gfspserver.GfSpSignRequest{ + Request: &gfspserver.GfSpSignRequest_CancelSwapIn{ + CancelSwapIn: cancelSwapIn, + }, + } + resp, err := gfspserver.NewGfSpSignServiceClient(conn).GfSpSign(ctx, req) + if err != nil { + log.CtxErrorw(ctx, "client failed to cancel swap in", "msg", cancelSwapIn, "error", err) + return "", ErrRPCUnknownWithDetail("client failed to cancel swap in, error: ", err) + } + if resp.GetErr() != nil { + return "", resp.GetErr() + } + return resp.GetTxHash(), nil +} diff --git a/base/gnfd/gnfd_service.go b/base/gnfd/gnfd_service.go index bd23de787..019aea0c4 100644 --- a/base/gnfd/gnfd_service.go +++ b/base/gnfd/gnfd_service.go @@ -90,6 +90,10 @@ const ( ChainSuccessVerifyPutObjectPermission = "verify_put_object_permission_success" // ChainFailureVerifyPutObjectPermission defines the metrics label of unsuccessfully verify put object permission ChainFailureVerifyPutObjectPermission = "verify_put_object_permission_failure" + // ChainSuccessQuerySwapInInfo defines the metrics label of successfully query swap in info + ChainSuccessQuerySwapInInfo = "query_swap_in_info_success" + // ChainFailureQuerySwapInInfo defines the metrics label of unsuccessfully query swap in info + ChainFailureQuerySwapInInfo = "query_swap_in_info_failure" // ConfirmBlockNumber defines wait block number. ConfirmBlockNumber = 3 @@ -896,3 +900,36 @@ func (g *Gnfd) getLatestBlockHeight(ctx context.Context) (int64, error) { } return block.SdkBlock.Header.Height, nil } + +// QuerySwapInInfo is used to chain get swapIn info +func (g *Gnfd) QuerySwapInInfo(ctx context.Context, vgfID, gvgID uint32) (swapInInfo *virtualgrouptypes.SwapInInfo, err error) { + startTime := time.Now() + defer func() { + if err != nil { + metrics.GnfdChainCounter.WithLabelValues(ChainFailureQuerySwapInInfo).Inc() + metrics.GnfdChainTime.WithLabelValues(ChainFailureQuerySwapInInfo).Observe( + time.Since(startTime).Seconds()) + metrics.GnfdChainCounter.WithLabelValues(ChainFailureTotal).Inc() + metrics.GnfdChainTime.WithLabelValues(ChainFailureTotal).Observe( + time.Since(startTime).Seconds()) + return + } + metrics.GnfdChainCounter.WithLabelValues(ChainSuccessQuerySwapInInfo).Inc() + metrics.GnfdChainTime.WithLabelValues(ChainSuccessQuerySwapInInfo).Observe( + time.Since(startTime).Seconds()) + metrics.GnfdChainCounter.WithLabelValues(ChainSuccessTotal).Inc() + metrics.GnfdChainTime.WithLabelValues(ChainSuccessTotal).Observe( + time.Since(startTime).Seconds()) + }() + + client := g.getCurrentClient().GnfdClient() + resp, err := client.SwapInInfo(ctx, + &virtualgrouptypes.QuerySwapInInfoRequest{ + GlobalVirtualGroupFamilyId: vgfID, GlobalVirtualGroupId: gvgID, + }) + if err != nil { + log.CtxErrorw(ctx, "failed to query swapIn info", "vgf_id", vgfID, "gvg_id", gvgID, "error", err) + return nil, err + } + return resp.SwapInInfo, nil +} diff --git a/base/types/gfspserver/manage.pb.go b/base/types/gfspserver/manage.pb.go index 4323755bb..795f4cde7 100644 --- a/base/types/gfspserver/manage.pb.go +++ b/base/types/gfspserver/manage.pb.go @@ -1522,6 +1522,402 @@ func (m *GfSpResetRecoveryFailedListResponse) GetRecoveryFailedList() []string { return nil } +type GfSpTriggerRecoverForSuccessorSPRequest struct { + VgfId uint32 `protobuf:"varint,1,opt,name=vgf_id,json=vgfId,proto3" json:"vgf_id,omitempty"` + GvgId uint32 `protobuf:"varint,2,opt,name=gvg_id,json=gvgId,proto3" json:"gvg_id,omitempty"` + ReplicateIndex int32 `protobuf:"varint,3,opt,name=replicate_index,json=replicateIndex,proto3" json:"replicate_index,omitempty"` +} + +func (m *GfSpTriggerRecoverForSuccessorSPRequest) Reset() { + *m = GfSpTriggerRecoverForSuccessorSPRequest{} +} +func (m *GfSpTriggerRecoverForSuccessorSPRequest) String() string { return proto.CompactTextString(m) } +func (*GfSpTriggerRecoverForSuccessorSPRequest) ProtoMessage() {} +func (*GfSpTriggerRecoverForSuccessorSPRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7801aa704e62bc53, []int{22} +} +func (m *GfSpTriggerRecoverForSuccessorSPRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GfSpTriggerRecoverForSuccessorSPRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GfSpTriggerRecoverForSuccessorSPRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GfSpTriggerRecoverForSuccessorSPRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GfSpTriggerRecoverForSuccessorSPRequest.Merge(m, src) +} +func (m *GfSpTriggerRecoverForSuccessorSPRequest) XXX_Size() int { + return m.Size() +} +func (m *GfSpTriggerRecoverForSuccessorSPRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GfSpTriggerRecoverForSuccessorSPRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GfSpTriggerRecoverForSuccessorSPRequest proto.InternalMessageInfo + +func (m *GfSpTriggerRecoverForSuccessorSPRequest) GetVgfId() uint32 { + if m != nil { + return m.VgfId + } + return 0 +} + +func (m *GfSpTriggerRecoverForSuccessorSPRequest) GetGvgId() uint32 { + if m != nil { + return m.GvgId + } + return 0 +} + +func (m *GfSpTriggerRecoverForSuccessorSPRequest) GetReplicateIndex() int32 { + if m != nil { + return m.ReplicateIndex + } + return 0 +} + +type GfSpTriggerRecoverForSuccessorSPResponse struct { + Err *gfsperrors.GfSpError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` +} + +func (m *GfSpTriggerRecoverForSuccessorSPResponse) Reset() { + *m = GfSpTriggerRecoverForSuccessorSPResponse{} +} +func (m *GfSpTriggerRecoverForSuccessorSPResponse) String() string { return proto.CompactTextString(m) } +func (*GfSpTriggerRecoverForSuccessorSPResponse) ProtoMessage() {} +func (*GfSpTriggerRecoverForSuccessorSPResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7801aa704e62bc53, []int{23} +} +func (m *GfSpTriggerRecoverForSuccessorSPResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GfSpTriggerRecoverForSuccessorSPResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GfSpTriggerRecoverForSuccessorSPResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GfSpTriggerRecoverForSuccessorSPResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GfSpTriggerRecoverForSuccessorSPResponse.Merge(m, src) +} +func (m *GfSpTriggerRecoverForSuccessorSPResponse) XXX_Size() int { + return m.Size() +} +func (m *GfSpTriggerRecoverForSuccessorSPResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GfSpTriggerRecoverForSuccessorSPResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GfSpTriggerRecoverForSuccessorSPResponse proto.InternalMessageInfo + +func (m *GfSpTriggerRecoverForSuccessorSPResponse) GetErr() *gfsperrors.GfSpError { + if m != nil { + return m.Err + } + return nil +} + +type GfSpQueryRecoverProcessRequest struct { + VgfId uint32 `protobuf:"varint,1,opt,name=vgf_id,json=vgfId,proto3" json:"vgf_id,omitempty"` + GvgId uint32 `protobuf:"varint,2,opt,name=gvg_id,json=gvgId,proto3" json:"gvg_id,omitempty"` +} + +func (m *GfSpQueryRecoverProcessRequest) Reset() { *m = GfSpQueryRecoverProcessRequest{} } +func (m *GfSpQueryRecoverProcessRequest) String() string { return proto.CompactTextString(m) } +func (*GfSpQueryRecoverProcessRequest) ProtoMessage() {} +func (*GfSpQueryRecoverProcessRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7801aa704e62bc53, []int{24} +} +func (m *GfSpQueryRecoverProcessRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GfSpQueryRecoverProcessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GfSpQueryRecoverProcessRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GfSpQueryRecoverProcessRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GfSpQueryRecoverProcessRequest.Merge(m, src) +} +func (m *GfSpQueryRecoverProcessRequest) XXX_Size() int { + return m.Size() +} +func (m *GfSpQueryRecoverProcessRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GfSpQueryRecoverProcessRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GfSpQueryRecoverProcessRequest proto.InternalMessageInfo + +func (m *GfSpQueryRecoverProcessRequest) GetVgfId() uint32 { + if m != nil { + return m.VgfId + } + return 0 +} + +func (m *GfSpQueryRecoverProcessRequest) GetGvgId() uint32 { + if m != nil { + return m.GvgId + } + return 0 +} + +type FailedRecoverObject struct { + ObjectId uint64 `protobuf:"varint,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"` + VirtualGroupId uint32 `protobuf:"varint,2,opt,name=virtual_group_id,json=virtualGroupId,proto3" json:"virtual_group_id,omitempty"` + RedundancyIndex int32 `protobuf:"varint,3,opt,name=redundancy_index,json=redundancyIndex,proto3" json:"redundancy_index,omitempty"` + RetryTime int32 `protobuf:"varint,4,opt,name=retry_time,json=retryTime,proto3" json:"retry_time,omitempty"` +} + +func (m *FailedRecoverObject) Reset() { *m = FailedRecoverObject{} } +func (m *FailedRecoverObject) String() string { return proto.CompactTextString(m) } +func (*FailedRecoverObject) ProtoMessage() {} +func (*FailedRecoverObject) Descriptor() ([]byte, []int) { + return fileDescriptor_7801aa704e62bc53, []int{25} +} +func (m *FailedRecoverObject) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FailedRecoverObject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FailedRecoverObject.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *FailedRecoverObject) XXX_Merge(src proto.Message) { + xxx_messageInfo_FailedRecoverObject.Merge(m, src) +} +func (m *FailedRecoverObject) XXX_Size() int { + return m.Size() +} +func (m *FailedRecoverObject) XXX_DiscardUnknown() { + xxx_messageInfo_FailedRecoverObject.DiscardUnknown(m) +} + +var xxx_messageInfo_FailedRecoverObject proto.InternalMessageInfo + +func (m *FailedRecoverObject) GetObjectId() uint64 { + if m != nil { + return m.ObjectId + } + return 0 +} + +func (m *FailedRecoverObject) GetVirtualGroupId() uint32 { + if m != nil { + return m.VirtualGroupId + } + return 0 +} + +func (m *FailedRecoverObject) GetRedundancyIndex() int32 { + if m != nil { + return m.RedundancyIndex + } + return 0 +} + +func (m *FailedRecoverObject) GetRetryTime() int32 { + if m != nil { + return m.RetryTime + } + return 0 +} + +type RecoverProcess struct { + VirtualGroupId uint32 `protobuf:"varint,1,opt,name=virtual_group_id,json=virtualGroupId,proto3" json:"virtual_group_id,omitempty"` + VirtualGroupFamilyId uint32 `protobuf:"varint,2,opt,name=virtual_group_family_id,json=virtualGroupFamilyId,proto3" json:"virtual_group_family_id,omitempty"` + RedundancyIndex int32 `protobuf:"varint,3,opt,name=redundancy_index,json=redundancyIndex,proto3" json:"redundancy_index,omitempty"` + StartAfter uint64 `protobuf:"varint,4,opt,name=start_after,json=startAfter,proto3" json:"start_after,omitempty"` + Limit uint64 `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"` + Status int32 `protobuf:"varint,6,opt,name=status,proto3" json:"status,omitempty"` + ObjectCount uint64 `protobuf:"varint,7,opt,name=object_count,json=objectCount,proto3" json:"object_count,omitempty"` + FailedObjectTotalCount uint64 `protobuf:"varint,8,opt,name=failed_object_total_count,json=failedObjectTotalCount,proto3" json:"failed_object_total_count,omitempty"` + RecoverFailedObject []*FailedRecoverObject `protobuf:"bytes,9,rep,name=recover_failed_object,json=recoverFailedObject,proto3" json:"recover_failed_object,omitempty"` +} + +func (m *RecoverProcess) Reset() { *m = RecoverProcess{} } +func (m *RecoverProcess) String() string { return proto.CompactTextString(m) } +func (*RecoverProcess) ProtoMessage() {} +func (*RecoverProcess) Descriptor() ([]byte, []int) { + return fileDescriptor_7801aa704e62bc53, []int{26} +} +func (m *RecoverProcess) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RecoverProcess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RecoverProcess.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RecoverProcess) XXX_Merge(src proto.Message) { + xxx_messageInfo_RecoverProcess.Merge(m, src) +} +func (m *RecoverProcess) XXX_Size() int { + return m.Size() +} +func (m *RecoverProcess) XXX_DiscardUnknown() { + xxx_messageInfo_RecoverProcess.DiscardUnknown(m) +} + +var xxx_messageInfo_RecoverProcess proto.InternalMessageInfo + +func (m *RecoverProcess) GetVirtualGroupId() uint32 { + if m != nil { + return m.VirtualGroupId + } + return 0 +} + +func (m *RecoverProcess) GetVirtualGroupFamilyId() uint32 { + if m != nil { + return m.VirtualGroupFamilyId + } + return 0 +} + +func (m *RecoverProcess) GetRedundancyIndex() int32 { + if m != nil { + return m.RedundancyIndex + } + return 0 +} + +func (m *RecoverProcess) GetStartAfter() uint64 { + if m != nil { + return m.StartAfter + } + return 0 +} + +func (m *RecoverProcess) GetLimit() uint64 { + if m != nil { + return m.Limit + } + return 0 +} + +func (m *RecoverProcess) GetStatus() int32 { + if m != nil { + return m.Status + } + return 0 +} + +func (m *RecoverProcess) GetObjectCount() uint64 { + if m != nil { + return m.ObjectCount + } + return 0 +} + +func (m *RecoverProcess) GetFailedObjectTotalCount() uint64 { + if m != nil { + return m.FailedObjectTotalCount + } + return 0 +} + +func (m *RecoverProcess) GetRecoverFailedObject() []*FailedRecoverObject { + if m != nil { + return m.RecoverFailedObject + } + return nil +} + +type GfSpQueryRecoverProcessResponse struct { + Err *gfsperrors.GfSpError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` + RecoverProcesses []*RecoverProcess `protobuf:"bytes,2,rep,name=recover_processes,json=recoverProcesses,proto3" json:"recover_processes,omitempty"` + Executing bool `protobuf:"varint,3,opt,name=executing,proto3" json:"executing,omitempty"` +} + +func (m *GfSpQueryRecoverProcessResponse) Reset() { *m = GfSpQueryRecoverProcessResponse{} } +func (m *GfSpQueryRecoverProcessResponse) String() string { return proto.CompactTextString(m) } +func (*GfSpQueryRecoverProcessResponse) ProtoMessage() {} +func (*GfSpQueryRecoverProcessResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7801aa704e62bc53, []int{27} +} +func (m *GfSpQueryRecoverProcessResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GfSpQueryRecoverProcessResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GfSpQueryRecoverProcessResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GfSpQueryRecoverProcessResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GfSpQueryRecoverProcessResponse.Merge(m, src) +} +func (m *GfSpQueryRecoverProcessResponse) XXX_Size() int { + return m.Size() +} +func (m *GfSpQueryRecoverProcessResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GfSpQueryRecoverProcessResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GfSpQueryRecoverProcessResponse proto.InternalMessageInfo + +func (m *GfSpQueryRecoverProcessResponse) GetErr() *gfsperrors.GfSpError { + if m != nil { + return m.Err + } + return nil +} + +func (m *GfSpQueryRecoverProcessResponse) GetRecoverProcesses() []*RecoverProcess { + if m != nil { + return m.RecoverProcesses + } + return nil +} + +func (m *GfSpQueryRecoverProcessResponse) GetExecuting() bool { + if m != nil { + return m.Executing + } + return false +} + func init() { proto.RegisterType((*GfSpBeginTaskRequest)(nil), "base.types.gfspserver.GfSpBeginTaskRequest") proto.RegisterType((*GfSpBeginTaskResponse)(nil), "base.types.gfspserver.GfSpBeginTaskResponse") @@ -1545,6 +1941,12 @@ func init() { proto.RegisterType((*MigrateBucketProgressMeta)(nil), "base.types.gfspserver.MigrateBucketProgressMeta") proto.RegisterType((*GfSpResetRecoveryFailedListRequest)(nil), "base.types.gfspserver.GfSpResetRecoveryFailedListRequest") proto.RegisterType((*GfSpResetRecoveryFailedListResponse)(nil), "base.types.gfspserver.GfSpResetRecoveryFailedListResponse") + proto.RegisterType((*GfSpTriggerRecoverForSuccessorSPRequest)(nil), "base.types.gfspserver.GfSpTriggerRecoverForSuccessorSPRequest") + proto.RegisterType((*GfSpTriggerRecoverForSuccessorSPResponse)(nil), "base.types.gfspserver.GfSpTriggerRecoverForSuccessorSPResponse") + proto.RegisterType((*GfSpQueryRecoverProcessRequest)(nil), "base.types.gfspserver.GfSpQueryRecoverProcessRequest") + proto.RegisterType((*FailedRecoverObject)(nil), "base.types.gfspserver.FailedRecoverObject") + proto.RegisterType((*RecoverProcess)(nil), "base.types.gfspserver.RecoverProcess") + proto.RegisterType((*GfSpQueryRecoverProcessResponse)(nil), "base.types.gfspserver.GfSpQueryRecoverProcessResponse") } func init() { @@ -1552,115 +1954,138 @@ func init() { } var fileDescriptor_7801aa704e62bc53 = []byte{ - // 1720 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x6f, 0xdb, 0xd8, - 0x11, 0xb7, 0x62, 0xf9, 0x43, 0x23, 0xdb, 0xb1, 0x19, 0x3b, 0x75, 0x94, 0xd4, 0xb1, 0xe9, 0x06, - 0x71, 0x3e, 0x2c, 0x25, 0x6e, 0x91, 0x8f, 0x1e, 0xd2, 0xda, 0x49, 0xad, 0x18, 0xb5, 0x13, 0x87, - 0x4e, 0x5c, 0x34, 0x40, 0xc1, 0x50, 0xe4, 0x13, 0xfd, 0x6a, 0x8a, 0x64, 0xde, 0x23, 0x15, 0xbb, - 0x87, 0x1e, 0x7b, 0x2b, 0x50, 0xa0, 0x68, 0xd1, 0x5e, 0x16, 0x58, 0x2c, 0xf6, 0x7f, 0xd9, 0x63, - 0x8e, 0xbb, 0xb7, 0x45, 0x02, 0xec, 0x65, 0x8f, 0x7b, 0xd9, 0xe3, 0xe2, 0x7d, 0x50, 0x12, 0x29, - 0x91, 0x72, 0xec, 0x78, 0x17, 0x7b, 0x71, 0x98, 0x99, 0xf9, 0xfd, 0xde, 0xbc, 0x79, 0x33, 0xf3, - 0x86, 0x14, 0xa8, 0x35, 0x83, 0xa2, 0x4a, 0x70, 0xe8, 0x23, 0x5a, 0xb1, 0xeb, 0xd4, 0xa7, 0x88, - 0x34, 0x11, 0xa9, 0x34, 0x0c, 0xd7, 0xb0, 0x51, 0xd9, 0x27, 0x5e, 0xe0, 0x29, 0x33, 0xcc, 0xa6, - 0xcc, 0x6d, 0xca, 0x6d, 0x9b, 0xd2, 0x42, 0x02, 0x8a, 0x08, 0xf1, 0x08, 0xad, 0xf0, 0x7f, 0x04, - 0xb2, 0x34, 0x9f, 0x30, 0x71, 0x70, 0x03, 0x07, 0x15, 0xfe, 0x57, 0x5a, 0xcc, 0x25, 0x2c, 0x02, - 0x83, 0xee, 0x57, 0xd8, 0x9f, 0x88, 0xc1, 0x26, 0x08, 0xb9, 0x75, 0x8c, 0x1c, 0xab, 0xd2, 0xc4, - 0x24, 0x08, 0x0d, 0xc7, 0x26, 0x5e, 0xe8, 0x57, 0x82, 0x03, 0x61, 0xa1, 0x7e, 0x97, 0x83, 0xe9, - 0x6a, 0x7d, 0xc7, 0x5f, 0x43, 0x36, 0x76, 0x9f, 0x1b, 0x74, 0x5f, 0x43, 0xaf, 0x43, 0x44, 0x03, - 0xe5, 0xcf, 0xa0, 0x84, 0xbe, 0xe3, 0x19, 0x96, 0xee, 0xd5, 0xfe, 0x8a, 0xcc, 0x40, 0x67, 0xb4, - 0xb3, 0xb9, 0xf9, 0xdc, 0x52, 0x71, 0xe5, 0x5a, 0x39, 0xb1, 0x27, 0xbe, 0x24, 0xa3, 0x79, 0xc1, - 0x21, 0x4f, 0x39, 0x82, 0xb1, 0x3d, 0x1e, 0xd0, 0x26, 0xc3, 0x84, 0x4c, 0x09, 0xe1, 0x12, 0x41, - 0x34, 0x6c, 0x18, 0x35, 0x07, 0xe9, 0x3d, 0x16, 0x39, 0xc3, 0x17, 0x59, 0x49, 0x5d, 0x44, 0x8b, - 0xc0, 0x3d, 0x56, 0xbb, 0x40, 0xd2, 0x94, 0x6b, 0x05, 0x18, 0x21, 0x62, 0x73, 0xea, 0x1f, 0x61, - 0x26, 0xb1, 0x69, 0xea, 0x7b, 0x2e, 0x45, 0xca, 0x0a, 0x0c, 0x22, 0x42, 0xe4, 0x36, 0xe7, 0x93, - 0x1e, 0x88, 0x33, 0xe2, 0x3e, 0xfc, 0x81, 0x3d, 0x6a, 0xcc, 0x58, 0x7d, 0x0e, 0x0a, 0x93, 0xac, - 0xd2, 0xfd, 0xce, 0xf8, 0x3d, 0x00, 0x70, 0x3d, 0x0b, 0xe9, 0xfc, 0xb8, 0x24, 0xe1, 0xe5, 0x24, - 0xa1, 0x38, 0x4b, 0x86, 0xde, 0x64, 0x4f, 0x5a, 0x81, 0x41, 0xf8, 0xa3, 0xfa, 0xfd, 0x30, 0x9c, - 0x8b, 0xd1, 0x1e, 0xdf, 0x43, 0x45, 0x87, 0x69, 0x82, 0x7c, 0x07, 0x9b, 0x46, 0x80, 0x74, 0x1f, - 0x23, 0x13, 0x75, 0x06, 0xfa, 0x46, 0x46, 0xa0, 0x25, 0x68, 0x9b, 0x61, 0x64, 0x84, 0x15, 0xd2, - 0x25, 0x55, 0x76, 0x60, 0x92, 0x22, 0xc3, 0x89, 0x9d, 0xe2, 0x20, 0x27, 0xbf, 0x9a, 0x4a, 0xbe, - 0x83, 0x0c, 0x27, 0x76, 0x74, 0x13, 0x34, 0x26, 0x61, 0x19, 0x48, 0x90, 0x89, 0x70, 0x33, 0xe6, - 0x73, 0xbe, 0x4f, 0x06, 0x6a, 0x02, 0xd2, 0xe9, 0xf1, 0x24, 0x49, 0xc8, 0x94, 0x2d, 0x98, 0xb0, - 0xcd, 0x98, 0xb7, 0x43, 0x9c, 0xf6, 0x4a, 0x2a, 0x6d, 0xf5, 0x61, 0xcc, 0xd7, 0x31, 0xdb, 0xec, - 0xf0, 0xf4, 0x2f, 0x30, 0x6d, 0x9b, 0xfa, 0xdf, 0xbc, 0x46, 0x0d, 0xc7, 0x7c, 0x1d, 0xe6, 0xa4, - 0xd7, 0x33, 0x48, 0x5f, 0x72, 0x4c, 0xa7, 0xb3, 0x53, 0xb6, 0x99, 0x10, 0x2a, 0x55, 0x18, 0xb3, - 0x4d, 0xbd, 0x81, 0x02, 0x43, 0xd0, 0x8e, 0x70, 0xda, 0xc5, 0x0c, 0xda, 0x2d, 0x14, 0x18, 0x92, - 0x0f, 0x6c, 0x33, 0xfa, 0x9f, 0x8c, 0xa8, 0xd7, 0x44, 0xa4, 0xd3, 0xcb, 0xd1, 0xfe, 0x11, 0x65, - 0x90, 0x64, 0x44, 0x63, 0x32, 0x96, 0x01, 0x0d, 0x6c, 0x13, 0x96, 0x60, 0x76, 0xd3, 0x16, 0xc4, - 0x85, 0x3e, 0x19, 0xb0, 0x25, 0x00, 0xd5, 0xdd, 0x6a, 0x94, 0x01, 0x92, 0xa2, 0xda, 0xb4, 0x39, - 0x29, 0x86, 0x59, 0xdb, 0xd4, 0x6b, 0xa1, 0xb9, 0x8f, 0x02, 0x5d, 0xe8, 0xb0, 0xe7, 0x0a, 0x72, - 0xe0, 0xe4, 0xe5, 0x8c, 0x20, 0xac, 0x71, 0xdc, 0x56, 0x04, 0x93, 0x6b, 0xcc, 0xd8, 0x66, 0x0f, - 0xc5, 0x1a, 0xc0, 0x28, 0x91, 0x25, 0xa6, 0x7e, 0x55, 0x10, 0xed, 0x41, 0x43, 0xbe, 0x47, 0x82, - 0x1f, 0xa9, 0x29, 0xfe, 0x3c, 0x6b, 0xb4, 0xbb, 0x90, 0xf2, 0xa7, 0x51, 0x48, 0x43, 0xa7, 0x53, - 0x48, 0xc3, 0xc7, 0x2d, 0x24, 0x1d, 0xa6, 0x2d, 0xef, 0x8d, 0xdb, 0x95, 0x09, 0x23, 0x7d, 0x0e, - 0xeb, 0x91, 0x04, 0xc5, 0x42, 0xa0, 0x58, 0x5d, 0x52, 0xb6, 0x80, 0xb9, 0x67, 0x38, 0x0e, 0x72, - 0x6d, 0xd4, 0x5d, 0xab, 0xe9, 0x0b, 0x3c, 0x8c, 0x40, 0xb1, 0x6c, 0x30, 0xbb, 0xa4, 0x29, 0xcd, - 0xb5, 0xf0, 0x31, 0x9a, 0x6b, 0xbf, 0xeb, 0x1d, 0x4e, 0xe5, 0x7a, 0x4f, 0x69, 0x6e, 0xc5, 0xd3, - 0x6a, 0x6e, 0x63, 0xa7, 0xd9, 0xdc, 0xc6, 0x3f, 0x6e, 0x73, 0xeb, 0x98, 0x7c, 0x36, 0xe1, 0x7c, - 0xb2, 0xb5, 0x9d, 0x60, 0xf4, 0xf9, 0x4f, 0x0e, 0x16, 0x98, 0x68, 0x1b, 0x9b, 0xfb, 0xbb, 0x62, - 0xbe, 0xac, 0xb2, 0xf9, 0x72, 0xdd, 0x68, 0x60, 0xe7, 0x30, 0xea, 0x9a, 0x3e, 0x5c, 0x34, 0x09, - 0x62, 0xd1, 0x93, 0xbb, 0x35, 0x7c, 0x9f, 0x78, 0x4d, 0xc3, 0xe9, 0x6c, 0x9f, 0xb7, 0xd3, 0x73, - 0x9a, 0x63, 0xc5, 0xbe, 0x56, 0x25, 0x92, 0x7b, 0x3e, 0x6b, 0xa6, 0x68, 0x54, 0x0f, 0xd4, 0x2c, - 0xb7, 0x4e, 0x30, 0x4a, 0xcd, 0xc0, 0x70, 0xd3, 0xae, 0xeb, 0xd8, 0xe2, 0x8d, 0x79, 0x5c, 0x1b, - 0x6a, 0xda, 0xf5, 0x0d, 0x4b, 0x35, 0xe0, 0x32, 0x33, 0x7c, 0xe2, 0x05, 0xb8, 0x7e, 0x28, 0x8f, - 0x7e, 0xe7, 0x8d, 0xe1, 0x3f, 0x0d, 0x83, 0xf6, 0x40, 0x38, 0x4a, 0xdf, 0x18, 0xbe, 0xee, 0x85, - 0xd1, 0x38, 0xb8, 0x58, 0x6e, 0x8f, 0xe7, 0xe5, 0xce, 0xf1, 0xbc, 0xbc, 0x45, 0xed, 0x08, 0x3d, - 0x42, 0xc5, 0x83, 0xba, 0x0b, 0xf3, 0xe9, 0x4b, 0x9c, 0xe0, 0x0c, 0x7f, 0x2f, 0x8e, 0x50, 0xf0, - 0x6e, 0x13, 0x24, 0xa9, 0x45, 0x54, 0x23, 0xe7, 0x2f, 0x42, 0x41, 0x9e, 0x1d, 0xb6, 0x38, 0x7d, - 0x5e, 0x1b, 0x15, 0x82, 0x0d, 0x4b, 0xfd, 0x5f, 0x4e, 0x84, 0x3b, 0x8d, 0xe2, 0x04, 0xe1, 0x7e, - 0x00, 0x43, 0xaf, 0x43, 0x2f, 0x30, 0xe4, 0x35, 0xb8, 0x94, 0x9a, 0x24, 0x62, 0xad, 0x67, 0xcc, - 0x76, 0xc3, 0xad, 0x7b, 0x9a, 0x80, 0xa9, 0x9f, 0xc5, 0x5d, 0xf3, 0x68, 0xf0, 0xc1, 0xdb, 0x53, - 0x5e, 0xc1, 0x4c, 0x57, 0x95, 0x62, 0xb7, 0xee, 0x49, 0x9f, 0x6e, 0xf6, 0xf1, 0xa9, 0x55, 0x8a, - 0xdc, 0xaf, 0x73, 0xb5, 0x6e, 0xa1, 0xfa, 0xff, 0x1c, 0x2c, 0x66, 0x7a, 0xf9, 0x13, 0x46, 0xf0, - 0x12, 0x94, 0x98, 0xf6, 0x59, 0x88, 0xc8, 0x21, 0xab, 0x2d, 0xba, 0x13, 0x18, 0x01, 0x95, 0x81, - 0x53, 0x77, 0xe1, 0x62, 0x4f, 0xad, 0x74, 0xf8, 0x2e, 0x0c, 0x51, 0x26, 0x90, 0x2e, 0x2f, 0x94, - 0x7b, 0xbe, 0x0b, 0x97, 0x3b, 0x90, 0xc2, 0x5e, 0xfd, 0xe6, 0x0c, 0x40, 0x5b, 0xaa, 0x2c, 0xc0, - 0x98, 0xbc, 0x48, 0x4c, 0x2f, 0x74, 0x45, 0xfd, 0x8c, 0x6b, 0x45, 0x21, 0x7b, 0xc8, 0x44, 0xca, - 0x55, 0x38, 0xdb, 0x9e, 0x9f, 0x84, 0x95, 0xa8, 0xd0, 0x89, 0x96, 0x58, 0x18, 0xfe, 0x12, 0x80, - 0xcf, 0x41, 0xc2, 0x66, 0x90, 0xdb, 0x14, 0x98, 0x44, 0xa8, 0x7f, 0x03, 0xe7, 0xbb, 0x6e, 0x2f, - 0x61, 0x9a, 0xe7, 0xa6, 0xd3, 0x89, 0x1b, 0x48, 0xa0, 0x16, 0x61, 0xbc, 0x61, 0x1c, 0x48, 0x7b, - 0xec, 0xda, 0x7c, 0x62, 0x19, 0xd7, 0xc6, 0x1a, 0xc6, 0xc1, 0x8b, 0x48, 0xa6, 0x5c, 0x87, 0xa9, - 0xce, 0x6b, 0x44, 0xb0, 0x0e, 0x73, 0xc3, 0xb3, 0xed, 0xcb, 0xa1, 0xc3, 0x0d, 0x7e, 0x0d, 0x1d, - 0xea, 0x3e, 0xf1, 0x4c, 0x44, 0xa9, 0x04, 0x8c, 0x44, 0x6e, 0x08, 0xed, 0xb6, 0x50, 0x0a, 0xd4, - 0x2d, 0x68, 0xc9, 0xf5, 0xba, 0x81, 0x1d, 0x64, 0xe9, 0x0e, 0xa6, 0xc1, 0xec, 0xe8, 0xfc, 0xe0, - 0x52, 0x41, 0x8b, 0xee, 0xc7, 0xc3, 0x75, 0xae, 0xda, 0xc4, 0x34, 0x50, 0xd7, 0xe1, 0x6a, 0xeb, - 0x00, 0x13, 0xf9, 0xba, 0x4d, 0x3c, 0x9b, 0x20, 0x4a, 0x8f, 0xd4, 0x03, 0x0e, 0x60, 0xa9, 0x3f, - 0x8f, 0xcc, 0x8a, 0x4d, 0x18, 0xf5, 0xa5, 0x4c, 0x26, 0xc6, 0xad, 0x94, 0xc4, 0x88, 0x95, 0x41, - 0xc4, 0xc3, 0xa6, 0x30, 0xad, 0xc5, 0xa0, 0x7e, 0x3b, 0x08, 0x17, 0x52, 0xed, 0xb2, 0x2b, 0xfb, - 0x0e, 0xfc, 0x82, 0x86, 0x35, 0x6a, 0x12, 0x5c, 0x43, 0x96, 0x5e, 0x73, 0x3c, 0x73, 0x5f, 0xdf, - 0x43, 0xd8, 0xde, 0x13, 0xb9, 0x93, 0xd7, 0x66, 0xda, 0xea, 0x35, 0xa6, 0x7d, 0xcc, 0x95, 0xfc, - 0xb4, 0xe5, 0x41, 0xb2, 0x74, 0x45, 0x32, 0x8b, 0xc6, 0xa4, 0x90, 0xe5, 0x2c, 0x52, 0x54, 0x18, - 0x0f, 0xbc, 0xc0, 0x70, 0xf8, 0x59, 0xbb, 0x61, 0x43, 0xe6, 0x4f, 0x91, 0x0b, 0xab, 0x4d, 0xfb, - 0x49, 0xd8, 0x50, 0xee, 0xc3, 0x05, 0x89, 0xb1, 0xf4, 0x3a, 0x76, 0x31, 0xdd, 0x43, 0x56, 0xcb, - 0x5e, 0xa4, 0xd0, 0xf9, 0xc8, 0x60, 0x5d, 0xea, 0x25, 0x74, 0x19, 0xce, 0xd9, 0x66, 0x37, 0x48, - 0xa4, 0xd3, 0xa4, 0x6d, 0x26, 0xcc, 0x6f, 0x82, 0xe2, 0x13, 0xa4, 0x5b, 0xc8, 0x0a, 0x4d, 0xb6, - 0x9a, 0xe8, 0x09, 0x23, 0x7c, 0x97, 0x93, 0x3e, 0x41, 0x8f, 0xa4, 0x82, 0xd7, 0x3f, 0xab, 0x37, - 0x96, 0x2b, 0xa1, 0x2f, 0xed, 0x46, 0xb9, 0x5d, 0x51, 0xc8, 0x84, 0xc9, 0x35, 0x98, 0x72, 0x0c, - 0x1a, 0xe8, 0xed, 0xf1, 0x1f, 0x5b, 0x7c, 0x7e, 0xcc, 0x6b, 0x13, 0x4c, 0x51, 0x95, 0x73, 0xfd, - 0x86, 0xa5, 0x2c, 0xc2, 0x44, 0x64, 0xca, 0xdc, 0xc4, 0x16, 0x1f, 0x01, 0xf3, 0x5a, 0x51, 0xd8, - 0x55, 0x9b, 0xf6, 0x86, 0xa5, 0x5c, 0x81, 0x89, 0x56, 0x28, 0x6a, 0x87, 0x01, 0xa2, 0x7c, 0x74, - 0xcb, 0x6b, 0x51, 0xa4, 0xad, 0x35, 0x26, 0x54, 0x7f, 0x25, 0xfa, 0xb9, 0x86, 0x28, 0xeb, 0x8b, - 0xc9, 0x74, 0x8e, 0xda, 0xd2, 0x9f, 0x44, 0x3f, 0x4d, 0xb5, 0x92, 0x89, 0x98, 0x56, 0x2e, 0xb9, - 0xb4, 0x72, 0x59, 0xf9, 0x47, 0x11, 0xa6, 0xf8, 0x74, 0xc7, 0xbf, 0xf0, 0xed, 0x20, 0xd2, 0xc4, - 0x26, 0x52, 0x1c, 0x18, 0x8f, 0x7d, 0x4e, 0x52, 0x6e, 0xa4, 0xe4, 0x73, 0xaf, 0x2f, 0x6d, 0xa5, - 0x9b, 0x47, 0x33, 0x96, 0x2f, 0xa7, 0x03, 0x4a, 0x1d, 0x8a, 0x1d, 0x1f, 0x86, 0x94, 0x6b, 0x19, - 0xf0, 0xf8, 0x37, 0xa9, 0xd2, 0xf5, 0xa3, 0x98, 0xb6, 0xd6, 0xf1, 0x60, 0x22, 0x3e, 0x2a, 0x2a, - 0x59, 0x9e, 0x76, 0xbd, 0x2c, 0x97, 0x96, 0x8f, 0x68, 0xdd, 0x5a, 0xf0, 0xdf, 0x39, 0x71, 0xd7, - 0xf4, 0x1e, 0xdb, 0x94, 0x7b, 0x19, 0x7c, 0x99, 0x03, 0x68, 0xe9, 0xfe, 0x31, 0x90, 0x2d, 0xaf, - 0xfe, 0x99, 0x83, 0xd9, 0xb4, 0xc1, 0x4b, 0xb9, 0x93, 0xc1, 0x9c, 0x31, 0x0c, 0x96, 0xee, 0x7e, - 0x30, 0xae, 0xe5, 0xcf, 0xdf, 0xc5, 0x77, 0xc1, 0xc4, 0x95, 0xab, 0xdc, 0xce, 0x60, 0xec, 0x7d, - 0x79, 0x97, 0x56, 0x3e, 0x04, 0xd2, 0x5a, 0xff, 0xf3, 0x9c, 0x18, 0x44, 0xb3, 0x5a, 0xbd, 0xf2, - 0xa0, 0x1f, 0x75, 0xf6, 0x5d, 0x53, 0xfa, 0xdd, 0xb1, 0xf1, 0x2d, 0x3f, 0x3f, 0xcd, 0x89, 0x2b, - 0xa9, 0xf7, 0x54, 0xba, 0xea, 0x5a, 0xa2, 0xe5, 0x89, 0x6e, 0x76, 0xaf, 0xef, 0x79, 0xa4, 0x4c, - 0xc6, 0x99, 0xb9, 0x95, 0x3d, 0x10, 0xab, 0x03, 0xca, 0x27, 0x69, 0x83, 0xdf, 0xaa, 0x6b, 0x69, - 0x1d, 0xcd, 0xf6, 0x08, 0x8b, 0xa4, 0x8c, 0xb6, 0xa5, 0xdf, 0x1e, 0x07, 0xda, 0x72, 0xf0, 0xbf, - 0x39, 0x31, 0xe0, 0xa5, 0x74, 0xd2, 0x4c, 0xc7, 0xb2, 0x7b, 0x74, 0xa6, 0x63, 0x7d, 0x1a, 0xb7, - 0x3a, 0xb0, 0xf6, 0xea, 0x8b, 0x77, 0x73, 0xb9, 0xb7, 0xef, 0xe6, 0x72, 0x5f, 0xbf, 0x9b, 0xcb, - 0xfd, 0xeb, 0xfd, 0xdc, 0xc0, 0xdb, 0xf7, 0x73, 0x03, 0x5f, 0xbe, 0x9f, 0x1b, 0x78, 0xb9, 0x6e, - 0xe3, 0x60, 0x2f, 0xac, 0x95, 0x4d, 0xaf, 0x51, 0xa9, 0xb9, 0xb5, 0x65, 0x73, 0xcf, 0xc0, 0x6e, - 0xa5, 0xfd, 0xa6, 0xb5, 0x4c, 0x03, 0x8f, 0x18, 0x36, 0x5a, 0x66, 0xef, 0x8b, 0xd8, 0x42, 0xa4, - 0xd2, 0xf3, 0x47, 0x9c, 0xda, 0x30, 0xff, 0x81, 0xe4, 0xd7, 0x3f, 0x04, 0x00, 0x00, 0xff, 0xff, - 0xcc, 0x8d, 0xc3, 0x30, 0xe4, 0x19, 0x00, 0x00, + // 2095 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x6f, 0x1c, 0x49, + 0x15, 0x77, 0xc7, 0x33, 0xb6, 0xe7, 0xf9, 0x23, 0x76, 0xf9, 0x23, 0xce, 0x24, 0x38, 0x4e, 0x9b, + 0x28, 0x4e, 0x36, 0x9e, 0xd9, 0x35, 0x6c, 0x76, 0xc3, 0x21, 0x60, 0x67, 0xf1, 0xac, 0x45, 0x9c, + 0xf5, 0xb6, 0xb3, 0x41, 0xac, 0xc4, 0xf6, 0xf6, 0x74, 0xd7, 0xb4, 0x0b, 0xcf, 0x74, 0xf7, 0x56, + 0x75, 0x4f, 0x6c, 0x0e, 0x88, 0x33, 0x12, 0x12, 0x12, 0x02, 0xc1, 0x05, 0x09, 0x21, 0x90, 0xf8, + 0x1b, 0xf8, 0x03, 0xe0, 0xb8, 0x47, 0xb8, 0xa1, 0x44, 0xe2, 0xc2, 0x91, 0x0b, 0x47, 0x54, 0x1f, + 0x3d, 0x33, 0xdd, 0x33, 0xdd, 0xe3, 0x8f, 0x18, 0xc4, 0xc5, 0x9e, 0x79, 0xf5, 0xde, 0xab, 0x5f, + 0xbf, 0x7a, 0xef, 0xd5, 0xef, 0xf5, 0x80, 0x5e, 0xb7, 0x18, 0xae, 0x86, 0x27, 0x01, 0x66, 0x55, + 0xb7, 0xc1, 0x02, 0x86, 0x69, 0x1b, 0xd3, 0x6a, 0xcb, 0xf2, 0x2c, 0x17, 0x57, 0x02, 0xea, 0x87, + 0x3e, 0x5a, 0xe4, 0x3a, 0x15, 0xa1, 0x53, 0xe9, 0xea, 0x94, 0x6f, 0xa7, 0x4c, 0x31, 0xa5, 0x3e, + 0x65, 0x55, 0xf1, 0x4f, 0x5a, 0x96, 0x57, 0x53, 0x2a, 0x4d, 0xd2, 0x22, 0x61, 0x55, 0xfc, 0x55, + 0x1a, 0x2b, 0x29, 0x8d, 0xd0, 0x62, 0x47, 0x55, 0xfe, 0x27, 0xf6, 0xe0, 0x52, 0x8c, 0xbd, 0x06, + 0xc1, 0x4d, 0xa7, 0xda, 0x26, 0x34, 0x8c, 0xac, 0xa6, 0x4b, 0xfd, 0x28, 0xa8, 0x86, 0xc7, 0x52, + 0x43, 0xff, 0x97, 0x06, 0x0b, 0xb5, 0xc6, 0x41, 0xb0, 0x8d, 0x5d, 0xe2, 0x3d, 0xb7, 0xd8, 0x91, + 0x81, 0xbf, 0x88, 0x30, 0x0b, 0xd1, 0xf7, 0x00, 0x45, 0x41, 0xd3, 0xb7, 0x1c, 0xd3, 0xaf, 0xff, + 0x00, 0xdb, 0xa1, 0xc9, 0xdd, 0x2e, 0x6b, 0xab, 0xda, 0xfa, 0xe4, 0xe6, 0xbd, 0x4a, 0xea, 0x99, + 0xc4, 0x96, 0xdc, 0xcd, 0x27, 0xc2, 0xe4, 0x23, 0x61, 0xc1, 0xbd, 0x7d, 0x38, 0x62, 0xcc, 0x46, + 0x29, 0x19, 0x8a, 0xe0, 0x26, 0xc5, 0x2c, 0x6a, 0x59, 0xf5, 0x26, 0x36, 0x07, 0x6c, 0x72, 0x45, + 0x6c, 0xb2, 0x99, 0xb9, 0x89, 0x11, 0x1b, 0x0f, 0xd8, 0xed, 0x3a, 0xcd, 0x5a, 0xdc, 0x2e, 0xc1, + 0x38, 0x95, 0x0f, 0xa7, 0x7f, 0x07, 0x16, 0x53, 0x0f, 0xcd, 0x02, 0xdf, 0x63, 0x18, 0x6d, 0xc2, + 0x28, 0xa6, 0x54, 0x3d, 0xe6, 0x6a, 0x1a, 0x81, 0x3c, 0x23, 0x81, 0xe1, 0xdb, 0xfc, 0xa3, 0xc1, + 0x95, 0xf5, 0xe7, 0x80, 0xb8, 0x64, 0x8b, 0x1d, 0xf5, 0xc6, 0xef, 0x31, 0x80, 0xe7, 0x3b, 0xd8, + 0x14, 0xc7, 0xa5, 0x1c, 0xde, 0x4a, 0x3b, 0x94, 0x67, 0xc9, 0xad, 0x9f, 0xf2, 0x4f, 0x46, 0x89, + 0x9b, 0x88, 0x8f, 0xfa, 0xbf, 0xc7, 0x60, 0x3e, 0xe1, 0xf6, 0xfc, 0x08, 0x91, 0x09, 0x0b, 0x14, + 0x07, 0x4d, 0x62, 0x5b, 0x21, 0x36, 0x03, 0x82, 0x6d, 0xdc, 0x1b, 0xe8, 0xb7, 0x72, 0x02, 0xad, + 0x8c, 0xf6, 0xb9, 0x8d, 0x8a, 0x30, 0xa2, 0x7d, 0x52, 0x74, 0x00, 0xb3, 0x0c, 0x5b, 0xcd, 0xc4, + 0x29, 0x8e, 0x0a, 0xe7, 0x77, 0x33, 0x9d, 0x1f, 0x60, 0xab, 0x99, 0x38, 0xba, 0x19, 0x96, 0x90, + 0xf0, 0x0c, 0xa4, 0xd8, 0xc6, 0xa4, 0x9d, 0xc0, 0x5c, 0x18, 0x92, 0x81, 0x86, 0x34, 0xe9, 0x45, + 0x3c, 0x4b, 0x53, 0x32, 0xb4, 0x07, 0x33, 0xae, 0x9d, 0x40, 0x5b, 0x14, 0x6e, 0xef, 0x64, 0xba, + 0xad, 0x3d, 0x49, 0x60, 0x9d, 0x72, 0xed, 0x1e, 0xa4, 0xdf, 0x87, 0x05, 0xd7, 0x36, 0x7f, 0xe8, + 0xb7, 0xea, 0x24, 0x81, 0x75, 0x4c, 0x38, 0xbd, 0x9f, 0xe3, 0xf4, 0x53, 0x61, 0xd3, 0x0b, 0x76, + 0xce, 0xb5, 0x53, 0x42, 0x54, 0x83, 0x29, 0xd7, 0x36, 0x5b, 0x38, 0xb4, 0xa4, 0xdb, 0x71, 0xe1, + 0x76, 0x2d, 0xc7, 0xed, 0x1e, 0x0e, 0x2d, 0xe5, 0x0f, 0x5c, 0x3b, 0xfe, 0xa6, 0x22, 0xea, 0xb7, + 0x31, 0xed, 0x45, 0x39, 0x31, 0x3c, 0xa2, 0xdc, 0x24, 0x1d, 0xd1, 0x84, 0x8c, 0x67, 0x40, 0x8b, + 0xb8, 0x94, 0x27, 0x98, 0xdb, 0x76, 0xa5, 0xe3, 0xd2, 0x90, 0x0c, 0xd8, 0x93, 0x06, 0xb5, 0x17, + 0xb5, 0x38, 0x03, 0x94, 0x8b, 0x5a, 0xdb, 0x15, 0x4e, 0x09, 0x2c, 0xbb, 0xb6, 0x59, 0x8f, 0xec, + 0x23, 0x1c, 0x9a, 0x72, 0x8d, 0xf8, 0x9e, 0x74, 0x0e, 0xc2, 0x79, 0x25, 0x27, 0x08, 0xdb, 0xc2, + 0x6e, 0x2f, 0x36, 0x53, 0x7b, 0x2c, 0xba, 0xf6, 0x80, 0x85, 0x6d, 0x80, 0x09, 0xaa, 0x4a, 0x4c, + 0xff, 0x5b, 0x49, 0xb6, 0x07, 0x03, 0x07, 0x3e, 0x0d, 0xff, 0x4b, 0x4d, 0xf1, 0xff, 0xb3, 0x46, + 0xfb, 0x0b, 0xa9, 0x70, 0x19, 0x85, 0x54, 0xbc, 0x9c, 0x42, 0x1a, 0x3b, 0x6f, 0x21, 0x99, 0xb0, + 0xe0, 0xf8, 0x2f, 0xbd, 0xbe, 0x4c, 0x18, 0x1f, 0x72, 0x58, 0x1f, 0x28, 0xa3, 0x44, 0x08, 0x90, + 0xd3, 0x27, 0xe5, 0x1b, 0xd8, 0x87, 0x56, 0xb3, 0x89, 0x3d, 0x17, 0xf7, 0xd7, 0x6a, 0xf6, 0x06, + 0x4f, 0x62, 0xa3, 0x44, 0x36, 0xd8, 0x7d, 0xd2, 0x8c, 0xe6, 0x5a, 0x7a, 0x13, 0xcd, 0x75, 0xd8, + 0xf5, 0x0e, 0x97, 0x72, 0xbd, 0x67, 0x34, 0xb7, 0xc9, 0xcb, 0x6a, 0x6e, 0x53, 0x97, 0xd9, 0xdc, + 0xa6, 0xdf, 0x6c, 0x73, 0xeb, 0x61, 0x3e, 0x4f, 0x61, 0x29, 0xdd, 0xda, 0x2e, 0x40, 0x7d, 0x7e, + 0xa1, 0xc1, 0x6d, 0x2e, 0xda, 0x27, 0xf6, 0xd1, 0x0b, 0xc9, 0x2f, 0x6b, 0x9c, 0x5f, 0xee, 0x58, + 0x2d, 0xd2, 0x3c, 0x89, 0xbb, 0x66, 0x00, 0x37, 0x6c, 0x8a, 0x79, 0xf4, 0xd4, 0xd3, 0x5a, 0x41, + 0x40, 0xfd, 0xb6, 0xd5, 0xec, 0x6d, 0x9f, 0xef, 0x64, 0xe7, 0xb4, 0xb0, 0x95, 0xcf, 0xb5, 0xa5, + 0x2c, 0x05, 0xf2, 0x65, 0x3b, 0x63, 0x45, 0xf7, 0x41, 0xcf, 0x83, 0x75, 0x01, 0x2a, 0xb5, 0x08, + 0x63, 0x6d, 0xb7, 0x61, 0x12, 0x47, 0x34, 0xe6, 0x69, 0xa3, 0xd8, 0x76, 0x1b, 0xbb, 0x8e, 0x6e, + 0xc1, 0x2d, 0xae, 0xf8, 0xcc, 0x0f, 0x49, 0xe3, 0x44, 0x1d, 0xfd, 0xc1, 0x4b, 0x2b, 0xf8, 0x28, + 0x0a, 0xbb, 0x84, 0x70, 0x82, 0xbd, 0xb4, 0x02, 0xd3, 0x8f, 0x62, 0x3a, 0xb8, 0x56, 0xe9, 0xd2, + 0xf3, 0x4a, 0x2f, 0x3d, 0xaf, 0xec, 0x31, 0x37, 0xb6, 0x1e, 0x67, 0xf2, 0x83, 0xfe, 0x02, 0x56, + 0xb3, 0xb7, 0xb8, 0xc0, 0x19, 0x7e, 0x4b, 0x1e, 0xa1, 0xf4, 0xbb, 0x4f, 0xb1, 0x72, 0x2d, 0xa3, + 0x1a, 0x83, 0xbf, 0x01, 0x25, 0x75, 0x76, 0xc4, 0x11, 0xee, 0x0b, 0xc6, 0x84, 0x14, 0xec, 0x3a, + 0xfa, 0xaf, 0x34, 0x19, 0xee, 0x2c, 0x17, 0x17, 0x08, 0xf7, 0x63, 0x28, 0x7e, 0x11, 0xf9, 0xa1, + 0xa5, 0xae, 0xc1, 0xf5, 0xcc, 0x24, 0x91, 0x7b, 0x7d, 0xcc, 0x75, 0x77, 0xbd, 0x86, 0x6f, 0x48, + 0x33, 0xfd, 0x77, 0x49, 0x68, 0x3e, 0x0b, 0xcf, 0xfc, 0x78, 0xe8, 0x73, 0x58, 0xec, 0xab, 0x52, + 0xe2, 0x35, 0x7c, 0x85, 0xe9, 0xc1, 0x10, 0x4c, 0x9d, 0x52, 0x14, 0xb8, 0xe6, 0xeb, 0xfd, 0x42, + 0xfd, 0xd7, 0x1a, 0xac, 0xe5, 0xa2, 0xfc, 0x1f, 0x46, 0xf0, 0x26, 0x94, 0xf9, 0xea, 0xc7, 0x11, + 0xa6, 0x27, 0xbc, 0xb6, 0xd8, 0x41, 0x68, 0x85, 0x4c, 0x05, 0x4e, 0x7f, 0x01, 0x37, 0x06, 0xae, + 0x2a, 0xc0, 0xef, 0x41, 0x91, 0x71, 0x81, 0x82, 0x7c, 0xbb, 0x32, 0x70, 0x16, 0xae, 0xf4, 0x58, + 0x4a, 0x7d, 0xfd, 0x1f, 0x57, 0x00, 0xba, 0x52, 0x74, 0x1b, 0xa6, 0xd4, 0x45, 0x62, 0xfb, 0x91, + 0x27, 0xeb, 0x67, 0xda, 0x98, 0x94, 0xb2, 0x27, 0x5c, 0x84, 0xee, 0xc2, 0xd5, 0x2e, 0x7f, 0x92, + 0x5a, 0xb2, 0x42, 0x67, 0x3a, 0x62, 0xa9, 0xf8, 0x15, 0x00, 0xc1, 0x83, 0xa4, 0xce, 0xa8, 0xd0, + 0x29, 0x71, 0x89, 0x5c, 0xfe, 0x3a, 0x2c, 0xf5, 0xdd, 0x5e, 0x52, 0xb5, 0x20, 0x54, 0x17, 0x52, + 0x37, 0x90, 0xb4, 0x5a, 0x83, 0xe9, 0x96, 0x75, 0xac, 0xf4, 0x89, 0xe7, 0x0a, 0xc6, 0x32, 0x6d, + 0x4c, 0xb5, 0xac, 0xe3, 0x4f, 0x62, 0x19, 0xba, 0x0f, 0x73, 0xbd, 0xd7, 0x88, 0xf4, 0x3a, 0x26, + 0x14, 0xaf, 0x76, 0x2f, 0x87, 0x1e, 0x18, 0xe2, 0x1a, 0x3a, 0x31, 0x03, 0xea, 0xdb, 0x98, 0x31, + 0x65, 0x30, 0x1e, 0xc3, 0x90, 0xab, 0xfb, 0x72, 0x51, 0x5a, 0xbd, 0x0d, 0x1d, 0xb9, 0xd9, 0xb0, + 0x48, 0x13, 0x3b, 0x66, 0x93, 0xb0, 0x70, 0x79, 0x62, 0x75, 0x74, 0xbd, 0x64, 0xc4, 0xf7, 0xe3, + 0xc9, 0x8e, 0x58, 0x7a, 0x4a, 0x58, 0xa8, 0xef, 0xc0, 0xdd, 0xce, 0x01, 0xa6, 0xf2, 0x75, 0x9f, + 0xfa, 0x2e, 0xc5, 0x8c, 0x9d, 0xaa, 0x07, 0x1c, 0xc3, 0xfa, 0x70, 0x3f, 0x2a, 0x2b, 0x9e, 0xc2, + 0x44, 0xa0, 0x64, 0x2a, 0x31, 0xde, 0xce, 0x48, 0x8c, 0x44, 0x19, 0xc4, 0x7e, 0x38, 0x0b, 0x33, + 0x3a, 0x1e, 0xf4, 0x7f, 0x8e, 0xc2, 0xf5, 0x4c, 0xbd, 0xfc, 0xca, 0x7e, 0x08, 0xd7, 0x58, 0x54, + 0x67, 0x36, 0x25, 0x75, 0xec, 0x98, 0xf5, 0xa6, 0x6f, 0x1f, 0x99, 0x87, 0x98, 0xb8, 0x87, 0x32, + 0x77, 0x0a, 0xc6, 0x62, 0x77, 0x79, 0x9b, 0xaf, 0x7e, 0x28, 0x16, 0xc5, 0x69, 0xab, 0x83, 0xe4, + 0xe9, 0x8a, 0x55, 0x16, 0x4d, 0x29, 0x21, 0xcf, 0x59, 0x8c, 0x74, 0x98, 0x0e, 0xfd, 0xd0, 0x6a, + 0x8a, 0xb3, 0xf6, 0xa2, 0x96, 0xca, 0x9f, 0x49, 0x21, 0xac, 0xb5, 0xdd, 0x67, 0x51, 0x0b, 0x3d, + 0x82, 0xeb, 0xca, 0xc6, 0x31, 0x1b, 0xc4, 0x23, 0xec, 0x10, 0x3b, 0x1d, 0x7d, 0x99, 0x42, 0x4b, + 0xb1, 0xc2, 0x8e, 0x5a, 0x57, 0xa6, 0x1b, 0x30, 0xef, 0xda, 0xfd, 0x46, 0x32, 0x9d, 0x66, 0x5d, + 0x3b, 0xa5, 0xfe, 0x00, 0x50, 0x40, 0xb1, 0xe9, 0x60, 0x27, 0xb2, 0xf9, 0x6e, 0xb2, 0x27, 0x8c, + 0x8b, 0xa7, 0x9c, 0x0d, 0x28, 0xfe, 0x40, 0x2d, 0x88, 0xfa, 0xe7, 0xf5, 0xc6, 0x73, 0x25, 0x0a, + 0x94, 0xde, 0x84, 0xd0, 0x9b, 0x94, 0x32, 0xa9, 0x72, 0x0f, 0xe6, 0x9a, 0x16, 0x0b, 0xcd, 0x2e, + 0xfd, 0x27, 0x8e, 0xe0, 0x8f, 0x05, 0x63, 0x86, 0x2f, 0xd4, 0x14, 0xaf, 0xdf, 0x75, 0xd0, 0x1a, + 0xcc, 0xc4, 0xaa, 0x1c, 0x26, 0x71, 0x04, 0x05, 0x2c, 0x18, 0x93, 0x52, 0xaf, 0xd6, 0x76, 0x77, + 0x1d, 0x74, 0x07, 0x66, 0x3a, 0xa1, 0xa8, 0x9f, 0x84, 0x98, 0x09, 0xea, 0x56, 0x30, 0xe2, 0x48, + 0x3b, 0xdb, 0x5c, 0xa8, 0x7f, 0x55, 0xf6, 0x73, 0x03, 0x33, 0xde, 0x17, 0xd3, 0xe9, 0x1c, 0xb7, + 0xa5, 0xef, 0xca, 0x7e, 0x9a, 0xa9, 0xa5, 0x12, 0x31, 0xab, 0x5c, 0xb4, 0xcc, 0x72, 0xf9, 0xb1, + 0x26, 0xeb, 0xe5, 0x39, 0x25, 0xae, 0x8b, 0xa9, 0xf2, 0xbd, 0xe3, 0xd3, 0x83, 0xc8, 0xe6, 0x65, + 0xe8, 0xd3, 0x83, 0xfd, 0xb8, 0x5e, 0xba, 0x54, 0x41, 0xeb, 0xa1, 0x0a, 0x5c, 0xac, 0xa2, 0xa0, + 0x18, 0x84, 0x2b, 0x9e, 0x3f, 0xd1, 0xbf, 0x88, 0xe7, 0xe0, 0x63, 0x91, 0x55, 0xc5, 0x9e, 0xfe, + 0xb5, 0xcb, 0xa5, 0xfa, 0x67, 0xb2, 0xd2, 0xf2, 0x11, 0x5c, 0x80, 0x0f, 0x3c, 0x83, 0x95, 0x4e, + 0x25, 0xc7, 0xec, 0x58, 0xf6, 0x98, 0x73, 0x3d, 0x98, 0xfe, 0x07, 0x0d, 0xe6, 0x65, 0x04, 0x95, + 0x37, 0x99, 0x17, 0xbc, 0x32, 0xbb, 0x89, 0xa3, 0x2a, 0xd3, 0x8f, 0x53, 0x66, 0x1d, 0x66, 0x15, + 0x21, 0x32, 0x05, 0x23, 0xea, 0x7a, 0x9d, 0x69, 0xf7, 0x10, 0xba, 0x5d, 0x07, 0xdd, 0x83, 0x59, + 0x8a, 0x9d, 0xc8, 0x73, 0x2c, 0xcf, 0x3e, 0x49, 0x04, 0xee, 0x6a, 0x57, 0x2e, 0x22, 0xc7, 0x3b, + 0x3f, 0xc5, 0x21, 0x3d, 0x31, 0x43, 0xd2, 0xc2, 0xa2, 0x1c, 0x8b, 0x46, 0x49, 0x48, 0x9e, 0x93, + 0x16, 0xd6, 0xff, 0x38, 0x0a, 0x33, 0xc9, 0x07, 0x1e, 0x08, 0x43, 0x1b, 0x08, 0xe3, 0x5d, 0xb8, + 0x96, 0xd4, 0x6c, 0x08, 0xae, 0xd9, 0xc5, 0xbd, 0xd0, 0xee, 0x23, 0xa2, 0x67, 0x43, 0x7f, 0x0b, + 0x26, 0x59, 0x68, 0xd1, 0xd0, 0xb4, 0x1a, 0x21, 0xa6, 0x02, 0x7e, 0xc1, 0x00, 0x21, 0xda, 0xe2, + 0x12, 0xb4, 0x00, 0x45, 0xf9, 0xb2, 0xb1, 0x28, 0x96, 0xe4, 0x17, 0xb4, 0x04, 0x63, 0xbc, 0x47, + 0x45, 0x4c, 0xb4, 0x86, 0xa2, 0xa1, 0xbe, 0xf1, 0x12, 0x57, 0xe1, 0xef, 0x5e, 0x2b, 0x05, 0x63, + 0x52, 0xca, 0xe4, 0x6d, 0xf2, 0x08, 0xae, 0xab, 0xaa, 0x88, 0xc7, 0x37, 0xd1, 0xcf, 0xa4, 0xbe, + 0x6c, 0x09, 0x4b, 0x52, 0x41, 0x8d, 0x61, 0x7c, 0x59, 0x9a, 0x7e, 0x06, 0x8b, 0xf1, 0x30, 0x96, + 0x70, 0xb1, 0x5c, 0x5a, 0x1d, 0x1d, 0x34, 0xc9, 0xab, 0x7e, 0x3f, 0x20, 0x4f, 0x8c, 0x79, 0xe5, + 0x68, 0xa7, 0x67, 0x27, 0xfd, 0xcf, 0x9a, 0x24, 0xdc, 0x03, 0xb3, 0xf4, 0x02, 0x6c, 0xc9, 0x80, + 0xb9, 0xce, 0x10, 0x29, 0xdd, 0x61, 0xb6, 0x7c, 0x45, 0x60, 0xbe, 0x93, 0x81, 0x39, 0xb5, 0x7b, + 0x67, 0x7a, 0x8c, 0xcd, 0xd1, 0x4d, 0x28, 0xe1, 0x63, 0x6c, 0x47, 0x21, 0xe7, 0x05, 0xfc, 0x70, + 0x27, 0x8c, 0xae, 0x60, 0xf3, 0x4f, 0xd3, 0x30, 0x27, 0xe6, 0x45, 0xf1, 0x9b, 0xc1, 0x01, 0xa6, + 0x6d, 0x62, 0x63, 0xd4, 0x84, 0xe9, 0xc4, 0x0b, 0x6a, 0xf4, 0x56, 0xc6, 0xee, 0x83, 0xde, 0xdd, + 0x97, 0x1f, 0x9c, 0x4e, 0x59, 0xbd, 0xee, 0x1a, 0x41, 0x0d, 0x98, 0xec, 0x79, 0xd5, 0x8c, 0xee, + 0xe5, 0x98, 0x27, 0xdf, 0x72, 0x97, 0xef, 0x9f, 0x46, 0xb5, 0xb3, 0x8f, 0x0f, 0x33, 0xc9, 0xe1, + 0x13, 0xe5, 0x21, 0xed, 0x7b, 0xfd, 0x56, 0xde, 0x38, 0xa5, 0x76, 0x67, 0xc3, 0x9f, 0x6b, 0x92, + 0xbd, 0x0e, 0x1e, 0x04, 0xd1, 0xfb, 0x39, 0xfe, 0x72, 0x47, 0xda, 0xf2, 0xa3, 0x73, 0x58, 0x76, + 0x50, 0xfd, 0x54, 0x83, 0xe5, 0xac, 0x51, 0x0e, 0x3d, 0xcc, 0xf1, 0x9c, 0x33, 0x5e, 0x96, 0xdf, + 0x3b, 0xb3, 0x5d, 0x07, 0xcf, 0x8f, 0xe4, 0x2f, 0x0d, 0x29, 0x12, 0x8f, 0xde, 0xc9, 0xf1, 0x38, + 0x78, 0x1c, 0x28, 0x6f, 0x9e, 0xc5, 0xa4, 0xb3, 0xff, 0xef, 0x35, 0x39, 0xda, 0xe6, 0x91, 0x47, + 0xf4, 0x78, 0x98, 0xeb, 0x7c, 0xf6, 0x5a, 0xfe, 0xe6, 0xb9, 0xed, 0x3b, 0x38, 0x7f, 0xab, 0xc9, + 0xab, 0x77, 0xf0, 0x9c, 0xbb, 0xe5, 0x39, 0x92, 0x44, 0x49, 0x7e, 0xf4, 0xfe, 0xd0, 0xf3, 0xc8, + 0x98, 0xb5, 0x73, 0x73, 0x2b, 0x7f, 0xc4, 0xd6, 0x47, 0xd0, 0x6f, 0xb2, 0x46, 0xc9, 0x2d, 0x4f, + 0xf4, 0xd5, 0x98, 0xbe, 0x9d, 0x62, 0x93, 0x8c, 0x61, 0xb9, 0xfc, 0x8d, 0xf3, 0x98, 0x76, 0x00, + 0xfe, 0x52, 0x93, 0x23, 0x63, 0x06, 0x37, 0xcb, 0x05, 0x96, 0xcf, 0xfa, 0x72, 0x81, 0x0d, 0xa1, + 0x82, 0x3d, 0x59, 0x98, 0x47, 0xac, 0x72, 0xb3, 0xf0, 0x14, 0x9c, 0x30, 0x37, 0x0b, 0x4f, 0xc3, + 0xe8, 0xf4, 0x11, 0xf4, 0x13, 0x0d, 0xae, 0x65, 0x5c, 0x7d, 0xe8, 0xdd, 0x61, 0x49, 0x3e, 0x90, + 0xd0, 0x95, 0x1f, 0x9e, 0xd5, 0x2c, 0x06, 0xb3, 0xfd, 0xf9, 0x5f, 0x5e, 0xad, 0x68, 0x5f, 0xbe, + 0x5a, 0xd1, 0xfe, 0xfe, 0x6a, 0x45, 0xfb, 0xd9, 0xeb, 0x95, 0x91, 0x2f, 0x5f, 0xaf, 0x8c, 0xfc, + 0xf5, 0xf5, 0xca, 0xc8, 0xa7, 0x3b, 0x2e, 0x09, 0x0f, 0xa3, 0x7a, 0xc5, 0xf6, 0x5b, 0xd5, 0xba, + 0x57, 0xdf, 0xb0, 0x0f, 0x2d, 0xe2, 0x55, 0xbb, 0x2f, 0xbc, 0x36, 0x58, 0xe8, 0x53, 0xcb, 0xc5, + 0x1b, 0x01, 0xf5, 0xdb, 0xc4, 0xc1, 0xb4, 0x3a, 0xf0, 0xb7, 0xf4, 0xfa, 0x98, 0xf8, 0x9d, 0xfa, + 0x6b, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x0d, 0xc4, 0xfb, 0x7c, 0x6b, 0x1f, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1685,6 +2110,8 @@ type GfSpManageServiceClient interface { GfSpNotifyPreMigrateBucketAndDeductQuota(ctx context.Context, in *GfSpNotifyPreMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPreMigrateBucketResponse, error) GfSpNotifyPostMigrateAndRecoupQuota(ctx context.Context, in *GfSpNotifyPostMigrateBucketRequest, opts ...grpc.CallOption) (*GfSpNotifyPostMigrateBucketResponse, error) GfSpResetRecoveryFailedList(ctx context.Context, in *GfSpResetRecoveryFailedListRequest, opts ...grpc.CallOption) (*GfSpResetRecoveryFailedListResponse, error) + GfSpTriggerRecoverForSuccessorSP(ctx context.Context, in *GfSpTriggerRecoverForSuccessorSPRequest, opts ...grpc.CallOption) (*GfSpTriggerRecoverForSuccessorSPResponse, error) + GfSpQueryRecoverProcess(ctx context.Context, in *GfSpQueryRecoverProcessRequest, opts ...grpc.CallOption) (*GfSpQueryRecoverProcessResponse, error) } type gfSpManageServiceClient struct { @@ -1785,6 +2212,24 @@ func (c *gfSpManageServiceClient) GfSpResetRecoveryFailedList(ctx context.Contex return out, nil } +func (c *gfSpManageServiceClient) GfSpTriggerRecoverForSuccessorSP(ctx context.Context, in *GfSpTriggerRecoverForSuccessorSPRequest, opts ...grpc.CallOption) (*GfSpTriggerRecoverForSuccessorSPResponse, error) { + out := new(GfSpTriggerRecoverForSuccessorSPResponse) + err := c.cc.Invoke(ctx, "/base.types.gfspserver.GfSpManageService/GfSpTriggerRecoverForSuccessorSP", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gfSpManageServiceClient) GfSpQueryRecoverProcess(ctx context.Context, in *GfSpQueryRecoverProcessRequest, opts ...grpc.CallOption) (*GfSpQueryRecoverProcessResponse, error) { + out := new(GfSpQueryRecoverProcessResponse) + err := c.cc.Invoke(ctx, "/base.types.gfspserver.GfSpManageService/GfSpQueryRecoverProcess", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // GfSpManageServiceServer is the server API for GfSpManageService service. type GfSpManageServiceServer interface { GfSpBeginTask(context.Context, *GfSpBeginTaskRequest) (*GfSpBeginTaskResponse, error) @@ -1797,6 +2242,8 @@ type GfSpManageServiceServer interface { GfSpNotifyPreMigrateBucketAndDeductQuota(context.Context, *GfSpNotifyPreMigrateBucketRequest) (*GfSpNotifyPreMigrateBucketResponse, error) GfSpNotifyPostMigrateAndRecoupQuota(context.Context, *GfSpNotifyPostMigrateBucketRequest) (*GfSpNotifyPostMigrateBucketResponse, error) GfSpResetRecoveryFailedList(context.Context, *GfSpResetRecoveryFailedListRequest) (*GfSpResetRecoveryFailedListResponse, error) + GfSpTriggerRecoverForSuccessorSP(context.Context, *GfSpTriggerRecoverForSuccessorSPRequest) (*GfSpTriggerRecoverForSuccessorSPResponse, error) + GfSpQueryRecoverProcess(context.Context, *GfSpQueryRecoverProcessRequest) (*GfSpQueryRecoverProcessResponse, error) } // UnimplementedGfSpManageServiceServer can be embedded to have forward compatible implementations. @@ -1833,6 +2280,12 @@ func (*UnimplementedGfSpManageServiceServer) GfSpNotifyPostMigrateAndRecoupQuota func (*UnimplementedGfSpManageServiceServer) GfSpResetRecoveryFailedList(ctx context.Context, req *GfSpResetRecoveryFailedListRequest) (*GfSpResetRecoveryFailedListResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GfSpResetRecoveryFailedList not implemented") } +func (*UnimplementedGfSpManageServiceServer) GfSpTriggerRecoverForSuccessorSP(ctx context.Context, req *GfSpTriggerRecoverForSuccessorSPRequest) (*GfSpTriggerRecoverForSuccessorSPResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GfSpTriggerRecoverForSuccessorSP not implemented") +} +func (*UnimplementedGfSpManageServiceServer) GfSpQueryRecoverProcess(ctx context.Context, req *GfSpQueryRecoverProcessRequest) (*GfSpQueryRecoverProcessResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GfSpQueryRecoverProcess not implemented") +} func RegisterGfSpManageServiceServer(s grpc1.Server, srv GfSpManageServiceServer) { s.RegisterService(&_GfSpManageService_serviceDesc, srv) @@ -2018,6 +2471,42 @@ func _GfSpManageService_GfSpResetRecoveryFailedList_Handler(srv interface{}, ctx return interceptor(ctx, in, info, handler) } +func _GfSpManageService_GfSpTriggerRecoverForSuccessorSP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GfSpTriggerRecoverForSuccessorSPRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GfSpManageServiceServer).GfSpTriggerRecoverForSuccessorSP(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/base.types.gfspserver.GfSpManageService/GfSpTriggerRecoverForSuccessorSP", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GfSpManageServiceServer).GfSpTriggerRecoverForSuccessorSP(ctx, req.(*GfSpTriggerRecoverForSuccessorSPRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GfSpManageService_GfSpQueryRecoverProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GfSpQueryRecoverProcessRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GfSpManageServiceServer).GfSpQueryRecoverProcess(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/base.types.gfspserver.GfSpManageService/GfSpQueryRecoverProcess", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GfSpManageServiceServer).GfSpQueryRecoverProcess(ctx, req.(*GfSpQueryRecoverProcessRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _GfSpManageService_serviceDesc = grpc.ServiceDesc{ ServiceName: "base.types.gfspserver.GfSpManageService", HandlerType: (*GfSpManageServiceServer)(nil), @@ -2062,6 +2551,14 @@ var _GfSpManageService_serviceDesc = grpc.ServiceDesc{ MethodName: "GfSpResetRecoveryFailedList", Handler: _GfSpManageService_GfSpResetRecoveryFailedList_Handler, }, + { + MethodName: "GfSpTriggerRecoverForSuccessorSP", + Handler: _GfSpManageService_GfSpTriggerRecoverForSuccessorSP_Handler, + }, + { + MethodName: "GfSpQueryRecoverProcess", + Handler: _GfSpManageService_GfSpQueryRecoverProcess_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "base/types/gfspserver/manage.proto", @@ -3412,6 +3909,291 @@ func (m *GfSpResetRecoveryFailedListResponse) MarshalToSizedBuffer(dAtA []byte) return len(dAtA) - i, nil } +func (m *GfSpTriggerRecoverForSuccessorSPRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GfSpTriggerRecoverForSuccessorSPRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpTriggerRecoverForSuccessorSPRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ReplicateIndex != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.ReplicateIndex)) + i-- + dAtA[i] = 0x18 + } + if m.GvgId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.GvgId)) + i-- + dAtA[i] = 0x10 + } + if m.VgfId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.VgfId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GfSpTriggerRecoverForSuccessorSPResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GfSpTriggerRecoverForSuccessorSPResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpTriggerRecoverForSuccessorSPResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Err != nil { + { + size, err := m.Err.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintManage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GfSpQueryRecoverProcessRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GfSpQueryRecoverProcessRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpQueryRecoverProcessRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.GvgId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.GvgId)) + i-- + dAtA[i] = 0x10 + } + if m.VgfId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.VgfId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *FailedRecoverObject) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FailedRecoverObject) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FailedRecoverObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RetryTime != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.RetryTime)) + i-- + dAtA[i] = 0x20 + } + if m.RedundancyIndex != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.RedundancyIndex)) + i-- + dAtA[i] = 0x18 + } + if m.VirtualGroupId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.VirtualGroupId)) + i-- + dAtA[i] = 0x10 + } + if m.ObjectId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.ObjectId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *RecoverProcess) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RecoverProcess) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RecoverProcess) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.RecoverFailedObject) > 0 { + for iNdEx := len(m.RecoverFailedObject) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RecoverFailedObject[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintManage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + } + if m.FailedObjectTotalCount != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.FailedObjectTotalCount)) + i-- + dAtA[i] = 0x40 + } + if m.ObjectCount != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.ObjectCount)) + i-- + dAtA[i] = 0x38 + } + if m.Status != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.Status)) + i-- + dAtA[i] = 0x30 + } + if m.Limit != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.Limit)) + i-- + dAtA[i] = 0x28 + } + if m.StartAfter != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.StartAfter)) + i-- + dAtA[i] = 0x20 + } + if m.RedundancyIndex != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.RedundancyIndex)) + i-- + dAtA[i] = 0x18 + } + if m.VirtualGroupFamilyId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.VirtualGroupFamilyId)) + i-- + dAtA[i] = 0x10 + } + if m.VirtualGroupId != 0 { + i = encodeVarintManage(dAtA, i, uint64(m.VirtualGroupId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GfSpQueryRecoverProcessResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GfSpQueryRecoverProcessResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpQueryRecoverProcessResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Executing { + i-- + if m.Executing { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.RecoverProcesses) > 0 { + for iNdEx := len(m.RecoverProcesses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RecoverProcesses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintManage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.Err != nil { + { + size, err := m.Err.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintManage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintManage(dAtA []byte, offset int, v uint64) int { offset -= sovManage(v) base := offset @@ -4056,18 +4838,146 @@ func (m *GfSpResetRecoveryFailedListResponse) Size() (n int) { return n } -func sovManage(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozManage(x uint64) (n int) { - return sovManage(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *GfSpBeginTaskRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 +func (m *GfSpTriggerRecoverForSuccessorSPRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.VgfId != 0 { + n += 1 + sovManage(uint64(m.VgfId)) + } + if m.GvgId != 0 { + n += 1 + sovManage(uint64(m.GvgId)) + } + if m.ReplicateIndex != 0 { + n += 1 + sovManage(uint64(m.ReplicateIndex)) + } + return n +} + +func (m *GfSpTriggerRecoverForSuccessorSPResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Err != nil { + l = m.Err.Size() + n += 1 + l + sovManage(uint64(l)) + } + return n +} + +func (m *GfSpQueryRecoverProcessRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.VgfId != 0 { + n += 1 + sovManage(uint64(m.VgfId)) + } + if m.GvgId != 0 { + n += 1 + sovManage(uint64(m.GvgId)) + } + return n +} + +func (m *FailedRecoverObject) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ObjectId != 0 { + n += 1 + sovManage(uint64(m.ObjectId)) + } + if m.VirtualGroupId != 0 { + n += 1 + sovManage(uint64(m.VirtualGroupId)) + } + if m.RedundancyIndex != 0 { + n += 1 + sovManage(uint64(m.RedundancyIndex)) + } + if m.RetryTime != 0 { + n += 1 + sovManage(uint64(m.RetryTime)) + } + return n +} + +func (m *RecoverProcess) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.VirtualGroupId != 0 { + n += 1 + sovManage(uint64(m.VirtualGroupId)) + } + if m.VirtualGroupFamilyId != 0 { + n += 1 + sovManage(uint64(m.VirtualGroupFamilyId)) + } + if m.RedundancyIndex != 0 { + n += 1 + sovManage(uint64(m.RedundancyIndex)) + } + if m.StartAfter != 0 { + n += 1 + sovManage(uint64(m.StartAfter)) + } + if m.Limit != 0 { + n += 1 + sovManage(uint64(m.Limit)) + } + if m.Status != 0 { + n += 1 + sovManage(uint64(m.Status)) + } + if m.ObjectCount != 0 { + n += 1 + sovManage(uint64(m.ObjectCount)) + } + if m.FailedObjectTotalCount != 0 { + n += 1 + sovManage(uint64(m.FailedObjectTotalCount)) + } + if len(m.RecoverFailedObject) > 0 { + for _, e := range m.RecoverFailedObject { + l = e.Size() + n += 1 + l + sovManage(uint64(l)) + } + } + return n +} + +func (m *GfSpQueryRecoverProcessResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Err != nil { + l = m.Err.Size() + n += 1 + l + sovManage(uint64(l)) + } + if len(m.RecoverProcesses) > 0 { + for _, e := range m.RecoverProcesses { + l = e.Size() + n += 1 + l + sovManage(uint64(l)) + } + } + if m.Executing { + n += 2 + } + return n +} + +func sovManage(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozManage(x uint64) (n int) { + return sovManage(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GfSpBeginTaskRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowManage @@ -7024,6 +7934,789 @@ func (m *GfSpResetRecoveryFailedListResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *GfSpTriggerRecoverForSuccessorSPRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GfSpTriggerRecoverForSuccessorSPRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GfSpTriggerRecoverForSuccessorSPRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VgfId", wireType) + } + m.VgfId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VgfId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GvgId", wireType) + } + m.GvgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GvgId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReplicateIndex", wireType) + } + m.ReplicateIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ReplicateIndex |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipManage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthManage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GfSpTriggerRecoverForSuccessorSPResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GfSpTriggerRecoverForSuccessorSPResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GfSpTriggerRecoverForSuccessorSPResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthManage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthManage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Err == nil { + m.Err = &gfsperrors.GfSpError{} + } + if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipManage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthManage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GfSpQueryRecoverProcessRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GfSpQueryRecoverProcessRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GfSpQueryRecoverProcessRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VgfId", wireType) + } + m.VgfId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VgfId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GvgId", wireType) + } + m.GvgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GvgId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipManage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthManage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FailedRecoverObject) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FailedRecoverObject: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FailedRecoverObject: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType) + } + m.ObjectId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ObjectId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VirtualGroupId", wireType) + } + m.VirtualGroupId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VirtualGroupId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RedundancyIndex", wireType) + } + m.RedundancyIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RedundancyIndex |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RetryTime", wireType) + } + m.RetryTime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RetryTime |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipManage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthManage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RecoverProcess) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RecoverProcess: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RecoverProcess: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VirtualGroupId", wireType) + } + m.VirtualGroupId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VirtualGroupId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VirtualGroupFamilyId", wireType) + } + m.VirtualGroupFamilyId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VirtualGroupFamilyId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RedundancyIndex", wireType) + } + m.RedundancyIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RedundancyIndex |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartAfter", wireType) + } + m.StartAfter = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartAfter |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) + } + m.Limit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Limit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + m.Status = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Status |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectCount", wireType) + } + m.ObjectCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ObjectCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FailedObjectTotalCount", wireType) + } + m.FailedObjectTotalCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FailedObjectTotalCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RecoverFailedObject", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthManage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthManage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RecoverFailedObject = append(m.RecoverFailedObject, &FailedRecoverObject{}) + if err := m.RecoverFailedObject[len(m.RecoverFailedObject)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipManage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthManage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GfSpQueryRecoverProcessResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GfSpQueryRecoverProcessResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GfSpQueryRecoverProcessResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthManage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthManage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Err == nil { + m.Err = &gfsperrors.GfSpError{} + } + if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RecoverProcesses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthManage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthManage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RecoverProcesses = append(m.RecoverProcesses, &RecoverProcess{}) + if err := m.RecoverProcesses[len(m.RecoverProcesses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Executing", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowManage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Executing = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipManage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthManage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipManage(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/base/types/gfspserver/sign.pb.go b/base/types/gfspserver/sign.pb.go index 501b0b9f0..3fb020e6f 100644 --- a/base/types/gfspserver/sign.pb.go +++ b/base/types/gfspserver/sign.pb.go @@ -192,6 +192,9 @@ type GfSpSignRequest struct { // *GfSpSignRequest_RejectMigrateBucket // *GfSpSignRequest_Deposit // *GfSpSignRequest_DeleteGlobalVirtualGroup + // *GfSpSignRequest_ReserveSwapIn + // *GfSpSignRequest_CompleteSwapIn + // *GfSpSignRequest_CancelSwapIn Request isGfSpSignRequest_Request `protobuf_oneof:"request"` } @@ -315,6 +318,15 @@ type GfSpSignRequest_Deposit struct { type GfSpSignRequest_DeleteGlobalVirtualGroup struct { DeleteGlobalVirtualGroup *types2.MsgDeleteGlobalVirtualGroup `protobuf:"bytes,27,opt,name=delete_global_virtual_group,json=deleteGlobalVirtualGroup,proto3,oneof" json:"delete_global_virtual_group,omitempty"` } +type GfSpSignRequest_ReserveSwapIn struct { + ReserveSwapIn *types2.MsgReserveSwapIn `protobuf:"bytes,28,opt,name=reserve_swap_in,json=reserveSwapIn,proto3,oneof" json:"reserve_swap_in,omitempty"` +} +type GfSpSignRequest_CompleteSwapIn struct { + CompleteSwapIn *types2.MsgCompleteSwapIn `protobuf:"bytes,29,opt,name=complete_swap_in,json=completeSwapIn,proto3,oneof" json:"complete_swap_in,omitempty"` +} +type GfSpSignRequest_CancelSwapIn struct { + CancelSwapIn *types2.MsgCancelSwapIn `protobuf:"bytes,30,opt,name=cancel_swap_in,json=cancelSwapIn,proto3,oneof" json:"cancel_swap_in,omitempty"` +} func (*GfSpSignRequest_CreateBucketInfo) isGfSpSignRequest_Request() {} func (*GfSpSignRequest_MigrateBucketInfo) isGfSpSignRequest_Request() {} @@ -343,6 +355,9 @@ func (*GfSpSignRequest_GfspBucketMigrateInfo) isGfSpSignRequest_Request() func (*GfSpSignRequest_RejectMigrateBucket) isGfSpSignRequest_Request() {} func (*GfSpSignRequest_Deposit) isGfSpSignRequest_Request() {} func (*GfSpSignRequest_DeleteGlobalVirtualGroup) isGfSpSignRequest_Request() {} +func (*GfSpSignRequest_ReserveSwapIn) isGfSpSignRequest_Request() {} +func (*GfSpSignRequest_CompleteSwapIn) isGfSpSignRequest_Request() {} +func (*GfSpSignRequest_CancelSwapIn) isGfSpSignRequest_Request() {} func (m *GfSpSignRequest) GetRequest() isGfSpSignRequest_Request { if m != nil { @@ -540,6 +555,27 @@ func (m *GfSpSignRequest) GetDeleteGlobalVirtualGroup() *types2.MsgDeleteGlobalV return nil } +func (m *GfSpSignRequest) GetReserveSwapIn() *types2.MsgReserveSwapIn { + if x, ok := m.GetRequest().(*GfSpSignRequest_ReserveSwapIn); ok { + return x.ReserveSwapIn + } + return nil +} + +func (m *GfSpSignRequest) GetCompleteSwapIn() *types2.MsgCompleteSwapIn { + if x, ok := m.GetRequest().(*GfSpSignRequest_CompleteSwapIn); ok { + return x.CompleteSwapIn + } + return nil +} + +func (m *GfSpSignRequest) GetCancelSwapIn() *types2.MsgCancelSwapIn { + if x, ok := m.GetRequest().(*GfSpSignRequest_CancelSwapIn); ok { + return x.CancelSwapIn + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*GfSpSignRequest) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -570,6 +606,9 @@ func (*GfSpSignRequest) XXX_OneofWrappers() []interface{} { (*GfSpSignRequest_RejectMigrateBucket)(nil), (*GfSpSignRequest_Deposit)(nil), (*GfSpSignRequest_DeleteGlobalVirtualGroup)(nil), + (*GfSpSignRequest_ReserveSwapIn)(nil), + (*GfSpSignRequest_CompleteSwapIn)(nil), + (*GfSpSignRequest_CancelSwapIn)(nil), } } @@ -643,89 +682,93 @@ func init() { func init() { proto.RegisterFile("base/types/gfspserver/sign.proto", fileDescriptor_16c5938400680494) } var fileDescriptor_16c5938400680494 = []byte{ - // 1302 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x57, 0xcf, 0x73, 0xdb, 0xc4, - 0x17, 0xb7, 0x9b, 0x7e, 0xe3, 0x64, 0xd3, 0xa4, 0xee, 0x26, 0x69, 0xd4, 0x24, 0xe3, 0xaf, 0x6b, - 0x98, 0x36, 0x40, 0x6b, 0x4d, 0x53, 0x3a, 0x0c, 0x27, 0x68, 0xfa, 0x23, 0x31, 0x33, 0x99, 0x76, - 0x64, 0x28, 0x03, 0x03, 0xa3, 0xca, 0xab, 0xb5, 0xbc, 0xc4, 0xd6, 0x2e, 0xbb, 0xb2, 0x9b, 0x1c, - 0x38, 0x30, 0x5c, 0x39, 0xf0, 0x67, 0x71, 0xec, 0x91, 0x23, 0x93, 0x5e, 0xf9, 0x23, 0x98, 0x7d, - 0xbb, 0xb2, 0x64, 0xc5, 0x8e, 0xcb, 0x25, 0xb1, 0xde, 0x8f, 0xcf, 0x7b, 0xfb, 0xf6, 0xbd, 0x8f, - 0x9e, 0x50, 0xbd, 0x13, 0x28, 0xea, 0x26, 0x67, 0x82, 0x2a, 0x37, 0xea, 0x2a, 0xa1, 0xa8, 0x1c, - 0x51, 0xe9, 0x2a, 0x16, 0xc5, 0x4d, 0x21, 0x79, 0xc2, 0xf1, 0xa6, 0xb6, 0x68, 0x82, 0x45, 0x33, - 0xb3, 0xd8, 0xbe, 0x5d, 0x70, 0xa4, 0x52, 0x72, 0xa9, 0x5c, 0xf8, 0x67, 0x3c, 0xb7, 0x77, 0x0b, - 0x26, 0x62, 0x5f, 0xb8, 0x62, 0x5f, 0x58, 0x6d, 0xad, 0xa0, 0x4d, 0x02, 0x75, 0xe2, 0xea, 0x3f, - 0xa9, 0x9e, 0x70, 0x35, 0xe0, 0xca, 0x05, 0xb3, 0xd1, 0x83, 0x0e, 0x4d, 0x82, 0x07, 0x2e, 0xe1, - 0xcc, 0xe6, 0xb5, 0x7d, 0x33, 0x92, 0x94, 0xc6, 0x5d, 0x46, 0xfb, 0xa1, 0xab, 0x84, 0x9b, 0x9c, - 0x5a, 0xf9, 0xff, 0xf3, 0xf2, 0x84, 0xcb, 0x20, 0xa2, 0x2e, 0xe1, 0x83, 0x01, 0x4f, 0x1d, 0x77, - 0xa6, 0x18, 0x8c, 0xbd, 0xeb, 0x39, 0xe5, 0x88, 0xc9, 0x64, 0x18, 0xf4, 0x23, 0xc9, 0x87, 0x19, - 0x7e, 0xe3, 0xf7, 0x32, 0x72, 0x0e, 0xbb, 0x6d, 0xd1, 0x66, 0x51, 0xdc, 0xa6, 0x84, 0xc7, 0x61, - 0x20, 0xcf, 0xda, 0x34, 0xe8, 0x1f, 0xf4, 0x15, 0xde, 0x41, 0xcb, 0xbc, 0xf3, 0x13, 0x25, 0x89, - 0xcf, 0x42, 0xa7, 0x5c, 0x2f, 0xef, 0x5d, 0xf5, 0x96, 0x8c, 0xa0, 0x15, 0xe2, 0x47, 0x68, 0x2b, - 0xea, 0xf3, 0x4e, 0xd0, 0xf7, 0x2d, 0xb2, 0x0f, 0xd0, 0xda, 0xf4, 0x4a, 0xbd, 0xbc, 0xb7, 0xea, - 0x6d, 0x18, 0xf5, 0x2b, 0xa3, 0x3d, 0xd4, 0xca, 0x56, 0x88, 0x77, 0xd1, 0x32, 0xe9, 0x51, 0x72, - 0xa2, 0x86, 0x03, 0xe5, 0x2c, 0xd4, 0x17, 0xf6, 0xae, 0x79, 0x99, 0xa0, 0x71, 0x5e, 0x46, 0xbb, - 0x3a, 0x9d, 0x27, 0x92, 0x06, 0x09, 0x3d, 0xbc, 0x00, 0xa0, 0xa3, 0x4e, 0x86, 0xeb, 0x06, 0x03, - 0xd6, 0x3f, 0x4b, 0x13, 0x5c, 0xf5, 0x36, 0x46, 0x39, 0xf3, 0xe7, 0xa0, 0x6c, 0x85, 0xf8, 0x1e, - 0xc2, 0x42, 0xb2, 0x41, 0x20, 0xcf, 0x7c, 0x25, 0xfc, 0x20, 0x0c, 0x25, 0x55, 0x0a, 0xf2, 0x5c, - 0xf6, 0xaa, 0x56, 0xd3, 0x16, 0x8f, 0x8d, 0x1c, 0xef, 0xa1, 0xaa, 0x4a, 0x6b, 0xa1, 0xed, 0x59, - 0x68, 0x52, 0x5d, 0xf5, 0xd6, 0xc6, 0xf2, 0xb6, 0x68, 0x85, 0x0a, 0x3f, 0x44, 0x95, 0x90, 0x0a, - 0xae, 0x58, 0xe2, 0x5c, 0xad, 0x97, 0xf7, 0x56, 0xf6, 0x6f, 0x35, 0xcd, 0x45, 0x37, 0xa1, 0xcf, - 0xec, 0x45, 0x37, 0x9f, 0x70, 0x16, 0x7b, 0xa9, 0x65, 0xe3, 0x9f, 0x75, 0x74, 0x3d, 0xad, 0xb9, - 0x47, 0x7f, 0x1e, 0x52, 0x95, 0xe0, 0x36, 0xc2, 0x04, 0xce, 0xec, 0x77, 0x86, 0xe4, 0x84, 0x26, - 0x3e, 0x8b, 0xbb, 0x1c, 0x8e, 0xb4, 0xb2, 0xff, 0x41, 0x33, 0xbb, 0xc6, 0xa6, 0xbd, 0xe3, 0xe6, - 0xb1, 0x8a, 0x4c, 0x91, 0x0e, 0xc0, 0xfe, 0xa8, 0xe4, 0x55, 0x49, 0xee, 0xb9, 0x15, 0x77, 0x39, - 0x7e, 0x85, 0xd6, 0x07, 0x2c, 0x92, 0x45, 0xd4, 0x2b, 0x80, 0xfa, 0xe1, 0x0c, 0xd4, 0x63, 0xe3, - 0x31, 0x86, 0xbd, 0x31, 0xc8, 0x0b, 0x00, 0x37, 0x4b, 0x36, 0x6d, 0x0f, 0x0d, 0xbb, 0xf0, 0x1e, - 0xc9, 0xbe, 0x00, 0xfb, 0x2c, 0x59, 0xf3, 0x0c, 0xa0, 0xc7, 0xba, 0xe8, 0x41, 0x7f, 0x02, 0xd2, - 0xd4, 0xf4, 0xf6, 0x0c, 0x48, 0xdd, 0xa6, 0x63, 0xc0, 0x35, 0x35, 0x7e, 0x02, 0xb8, 0x0e, 0xda, - 0x0a, 0x99, 0x22, 0x3c, 0x4e, 0x58, 0x3c, 0x9c, 0x3c, 0xff, 0xff, 0x00, 0x75, 0x6f, 0x06, 0xea, - 0xd3, 0xcc, 0x6b, 0x5c, 0x83, 0xcd, 0xb0, 0x28, 0x84, 0x18, 0x3d, 0xb4, 0xa5, 0xa9, 0xc5, 0xcf, - 0x35, 0x8b, 0x3e, 0x41, 0xa7, 0xaf, 0x9c, 0x45, 0x88, 0xe1, 0x36, 0xa7, 0xd2, 0x4d, 0x73, 0xd6, - 0xc4, 0x1d, 0x95, 0xbc, 0x0d, 0x35, 0x6d, 0x12, 0x3f, 0x47, 0x4b, 0x82, 0xc5, 0x91, 0x3f, 0x50, - 0x91, 0x53, 0x01, 0xe8, 0xdd, 0x22, 0xb4, 0xe6, 0x22, 0x8d, 0xfb, 0x92, 0xc5, 0xd1, 0x51, 0xc9, - 0xab, 0x68, 0xfb, 0x63, 0x15, 0x81, 0x2b, 0xb7, 0xae, 0x4b, 0x73, 0x5c, 0xb9, 0x75, 0xe5, 0xc6, - 0xf5, 0xd7, 0x32, 0x6a, 0x68, 0xbd, 0x2f, 0xa9, 0xe8, 0x33, 0xa2, 0x2f, 0x5c, 0x30, 0x4a, 0xa8, - 0x1f, 0x08, 0x21, 0xf9, 0x28, 0xe8, 0xfb, 0x9a, 0xe1, 0x9c, 0x65, 0x40, 0x7d, 0x58, 0x44, 0x05, - 0xf6, 0xd3, 0xb0, 0x5e, 0xea, 0xfd, 0x52, 0x3b, 0x3f, 0xb6, 0xbe, 0x5f, 0x07, 0xea, 0xe4, 0xa8, - 0xe4, 0xd5, 0xb4, 0xe9, 0x6c, 0x0b, 0x7d, 0x8f, 0x36, 0x05, 0x42, 0xd9, 0x28, 0x4d, 0x00, 0xe2, - 0x22, 0x88, 0xfb, 0xd1, 0x25, 0x71, 0xc1, 0x05, 0x30, 0x6d, 0xb4, 0x0d, 0x13, 0x6d, 0x52, 0x9e, - 0x8f, 0xc1, 0x47, 0x54, 0xe6, 0x63, 0xac, 0xcc, 0x8f, 0xa1, 0x5d, 0xa6, 0xc5, 0x98, 0x90, 0xe3, - 0x6f, 0x11, 0x96, 0x14, 0x3a, 0x3b, 0xdf, 0xe0, 0xd7, 0x00, 0xfe, 0xee, 0x8c, 0x56, 0xf4, 0xc0, - 0x61, 0xa2, 0xcd, 0xab, 0x06, 0x24, 0xd7, 0xe8, 0x09, 0xda, 0xb1, 0xc3, 0x38, 0x8d, 0x8e, 0x9d, - 0xd5, 0xe9, 0x97, 0x93, 0x6b, 0xc4, 0x59, 0x5c, 0x7b, 0x54, 0xf2, 0x1c, 0x32, 0x8b, 0x87, 0xd3, - 0x92, 0xa5, 0xfc, 0x92, 0x2b, 0xd9, 0xda, 0x9c, 0x92, 0x59, 0x82, 0xb9, 0x50, 0xb2, 0xa2, 0x1c, - 0x77, 0xd1, 0x16, 0xe1, 0x03, 0xd1, 0xa7, 0x09, 0xf5, 0x27, 0x79, 0xcc, 0xb9, 0x0e, 0x31, 0xee, - 0xcd, 0xe2, 0x1a, 0xeb, 0x55, 0xa4, 0xb2, 0x4d, 0x32, 0x4d, 0x81, 0x7f, 0x2b, 0xa3, 0x46, 0x71, - 0x8e, 0xd3, 0x93, 0x31, 0x1e, 0xa7, 0x31, 0xab, 0x10, 0xf3, 0xd1, 0xb4, 0x98, 0xd9, 0xbc, 0xda, - 0x53, 0x30, 0x1e, 0x1b, 0x70, 0x3d, 0xe5, 0x4f, 0x39, 0xd1, 0x8d, 0x3e, 0x39, 0xd8, 0x45, 0x43, - 0xfc, 0x25, 0x5a, 0x52, 0x6f, 0x02, 0xe1, 0xf3, 0x61, 0xe2, 0xdc, 0xb8, 0x48, 0xa5, 0xf9, 0xd7, - 0x37, 0x90, 0xdf, 0x9b, 0x40, 0xbc, 0x18, 0xea, 0x53, 0x55, 0x94, 0xf9, 0x89, 0x5b, 0x68, 0xd5, - 0x1c, 0x23, 0x85, 0xc1, 0xff, 0x05, 0x66, 0x05, 0xf2, 0xb3, 0x50, 0xdf, 0xa1, 0x1b, 0xe3, 0xd2, - 0x8f, 0xe1, 0xd6, 0x01, 0xee, 0x93, 0xcb, 0xe0, 0xd2, 0xca, 0x67, 0xb0, 0xd7, 0xc9, 0xa4, 0x08, - 0x7f, 0x85, 0x2a, 0x4a, 0xf8, 0xf4, 0x94, 0x25, 0xce, 0x86, 0x25, 0xc9, 0xcb, 0xf2, 0x33, 0x15, - 0x7e, 0x29, 0xf9, 0x88, 0x85, 0x54, 0x3e, 0x3b, 0x65, 0x1a, 0x74, 0x51, 0x09, 0xfd, 0x0b, 0x13, - 0x54, 0xcd, 0xd2, 0xb4, 0xa0, 0x9b, 0x00, 0xfa, 0xd9, 0x7b, 0x65, 0x39, 0x15, 0x7c, 0x6d, 0x9c, - 0xb1, 0x09, 0xe2, 0xa1, 0xaa, 0x12, 0xbe, 0xbd, 0x6a, 0x5f, 0x48, 0x46, 0xa8, 0x73, 0x13, 0x82, - 0xdc, 0x99, 0xe8, 0x05, 0x80, 0xfe, 0x46, 0x84, 0x81, 0xf6, 0x1c, 0x43, 0x33, 0x42, 0xe1, 0xed, - 0x34, 0x21, 0xc1, 0x3f, 0xa0, 0xcd, 0x89, 0xf1, 0x89, 0x46, 0x91, 0x19, 0x9e, 0x2d, 0x4b, 0x08, - 0x73, 0x86, 0xe7, 0xf0, 0xd5, 0xa1, 0x1d, 0x1d, 0x9c, 0x1b, 0x9d, 0xc3, 0x51, 0x04, 0x83, 0x13, - 0x21, 0x07, 0xd0, 0xed, 0x4b, 0x2f, 0x0d, 0x02, 0x8c, 0xe3, 0xd8, 0xc9, 0x99, 0x15, 0xc0, 0x74, - 0xe3, 0xb8, 0x39, 0x35, 0xc5, 0xe8, 0xc9, 0xd1, 0x36, 0x79, 0x15, 0x05, 0xee, 0x79, 0x8d, 0x36, - 0x2d, 0xa9, 0x15, 0xe6, 0xf3, 0x16, 0x44, 0xf9, 0xf8, 0x52, 0x5e, 0x2b, 0x4e, 0xe7, 0xba, 0xbc, - 0x28, 0xc6, 0x5f, 0x64, 0x0b, 0xd6, 0xf6, 0xfc, 0x6e, 0x7e, 0x6a, 0x4c, 0xf5, 0x50, 0x58, 0x2f, - 0x3c, 0x44, 0x3b, 0x21, 0x85, 0x06, 0x99, 0x4a, 0x8f, 0x3b, 0x00, 0xfa, 0xe9, 0xe5, 0xa0, 0xda, - 0x7d, 0x3a, 0x3f, 0x86, 0x33, 0x74, 0x07, 0xcb, 0xa8, 0x22, 0xcd, 0x6a, 0xd7, 0xf8, 0x05, 0x55, - 0xb3, 0x6d, 0x4f, 0x09, 0x1e, 0x2b, 0x8a, 0xf7, 0xd1, 0x02, 0x95, 0xd2, 0xee, 0x77, 0xf5, 0xe2, - 0x65, 0x98, 0xaf, 0x0f, 0xb8, 0x8e, 0x67, 0xfa, 0xa7, 0xa7, 0x8d, 0xf5, 0xe6, 0xac, 0x47, 0x34, - 0x48, 0x86, 0x92, 0xc2, 0x0e, 0x77, 0xcd, 0xcb, 0x04, 0x78, 0x0b, 0x55, 0x92, 0x53, 0xbf, 0x17, - 0xa8, 0x1e, 0x2c, 0x62, 0xcb, 0xde, 0x62, 0x72, 0x7a, 0x14, 0xa8, 0xde, 0xbe, 0xc8, 0x96, 0xcd, - 0x36, 0x95, 0x23, 0xdd, 0x7d, 0x3f, 0xa2, 0xa5, 0x54, 0x84, 0xef, 0xcc, 0x59, 0x51, 0xec, 0x82, - 0xba, 0x7d, 0x77, 0xae, 0x9d, 0x39, 0x5a, 0xa3, 0x74, 0xf0, 0xfa, 0xcf, 0xf3, 0x5a, 0xf9, 0xed, - 0x79, 0xad, 0xfc, 0xf7, 0x79, 0xad, 0xfc, 0xc7, 0xbb, 0x5a, 0xe9, 0xed, 0xbb, 0x5a, 0xe9, 0xaf, - 0x77, 0xb5, 0xd2, 0xf7, 0xcf, 0x23, 0x96, 0xf4, 0x86, 0x9d, 0x26, 0xe1, 0x03, 0xb7, 0x13, 0x77, - 0xee, 0x93, 0x5e, 0xc0, 0x62, 0x37, 0xab, 0xfd, 0x7d, 0xdb, 0x24, 0xf7, 0x85, 0x1d, 0x49, 0x77, - 0xea, 0x07, 0x5d, 0x67, 0x11, 0x3e, 0x5e, 0x1e, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xef, 0xf3, - 0x09, 0x7d, 0xf0, 0x0d, 0x00, 0x00, + // 1367 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x57, 0x4b, 0x73, 0x1b, 0x45, + 0x10, 0x96, 0xe2, 0x60, 0xd9, 0xe3, 0x97, 0x32, 0xb1, 0xe2, 0x8d, 0x6d, 0x84, 0x22, 0xa8, 0xc4, + 0x40, 0xa2, 0xad, 0x38, 0xa4, 0x28, 0x4e, 0x10, 0xe7, 0x61, 0x89, 0x2a, 0x57, 0x5c, 0x2b, 0x30, + 0x05, 0x05, 0xb5, 0x59, 0xcd, 0x8e, 0x56, 0x83, 0xa5, 0x9d, 0x61, 0x66, 0xa5, 0xd8, 0x07, 0x0e, + 0x14, 0x57, 0x0e, 0xfc, 0x2c, 0x8e, 0x39, 0x72, 0xa4, 0x9c, 0x23, 0x7f, 0x82, 0x9a, 0xc7, 0x6a, + 0x1f, 0x7a, 0x85, 0x8b, 0xad, 0xed, 0xe9, 0xfe, 0xba, 0xa7, 0xa7, 0xbf, 0x6f, 0x67, 0x41, 0xad, + 0xe3, 0x09, 0x6c, 0x47, 0x97, 0x0c, 0x0b, 0x3b, 0xe8, 0x0a, 0x26, 0x30, 0x1f, 0x61, 0x6e, 0x0b, + 0x12, 0x84, 0x0d, 0xc6, 0x69, 0x44, 0x61, 0x45, 0x7a, 0x34, 0x94, 0x47, 0x23, 0xf1, 0xd8, 0xbd, + 0x93, 0x0b, 0xc4, 0x9c, 0x53, 0x2e, 0x6c, 0xf5, 0x4f, 0x47, 0xee, 0xee, 0xe7, 0x5c, 0xd8, 0x21, + 0xb3, 0xd9, 0x21, 0x33, 0xab, 0xd5, 0xdc, 0x6a, 0xe4, 0x89, 0x73, 0x5b, 0xfe, 0x89, 0xd7, 0x11, + 0x15, 0x03, 0x2a, 0x6c, 0xe5, 0x36, 0x7a, 0xd8, 0xc1, 0x91, 0xf7, 0xd0, 0x46, 0x94, 0x98, 0xba, + 0x76, 0x6f, 0x05, 0x1c, 0xe3, 0xb0, 0x4b, 0x70, 0xdf, 0xb7, 0x05, 0xb3, 0xa3, 0x0b, 0x63, 0xff, + 0x20, 0x6d, 0x8f, 0x28, 0xf7, 0x02, 0x6c, 0x23, 0x3a, 0x18, 0xd0, 0x38, 0x70, 0x6f, 0x8a, 0xc3, + 0x38, 0xba, 0x96, 0x5a, 0x1c, 0x11, 0x1e, 0x0d, 0xbd, 0x7e, 0xc0, 0xe9, 0x30, 0xc1, 0xaf, 0xff, + 0x51, 0x04, 0xd6, 0x71, 0xb7, 0xcd, 0xda, 0x24, 0x08, 0xdb, 0x18, 0xd1, 0xd0, 0xf7, 0xf8, 0x65, + 0x1b, 0x7b, 0xfd, 0xa3, 0xbe, 0x80, 0x7b, 0x60, 0x95, 0x76, 0x7e, 0xc6, 0x28, 0x72, 0x89, 0x6f, + 0x15, 0x6b, 0xc5, 0x83, 0xeb, 0xce, 0x8a, 0x36, 0xb4, 0x7c, 0xf8, 0x18, 0xec, 0x04, 0x7d, 0xda, + 0xf1, 0xfa, 0xae, 0x41, 0x76, 0x15, 0xb4, 0x74, 0xbd, 0x56, 0x2b, 0x1e, 0x6c, 0x38, 0xdb, 0x7a, + 0xf9, 0x4c, 0xaf, 0x1e, 0xcb, 0xc5, 0x96, 0x0f, 0xf7, 0xc1, 0x2a, 0xea, 0x61, 0x74, 0x2e, 0x86, + 0x03, 0x61, 0x2d, 0xd5, 0x96, 0x0e, 0xd6, 0x9d, 0xc4, 0x50, 0xbf, 0x2a, 0x82, 0x7d, 0x59, 0xce, + 0x53, 0x8e, 0xbd, 0x08, 0x1f, 0x4f, 0x00, 0xc8, 0xac, 0xd9, 0x74, 0x5d, 0x6f, 0x40, 0xfa, 0x97, + 0x71, 0x81, 0x1b, 0xce, 0xf6, 0x28, 0xe5, 0xfe, 0x42, 0x2d, 0xb6, 0x7c, 0x78, 0x1f, 0x40, 0xc6, + 0xc9, 0xc0, 0xe3, 0x97, 0xae, 0x60, 0xae, 0xe7, 0xfb, 0x1c, 0x0b, 0xa1, 0xea, 0x5c, 0x75, 0xca, + 0x66, 0xa5, 0xcd, 0x9e, 0x68, 0x3b, 0x3c, 0x00, 0x65, 0x11, 0xf7, 0x42, 0xfa, 0x13, 0x5f, 0x97, + 0xba, 0xe1, 0x6c, 0x8e, 0xed, 0x6d, 0xd6, 0xf2, 0x05, 0x7c, 0x04, 0x4a, 0x3e, 0x66, 0x54, 0x90, + 0xc8, 0xba, 0x5e, 0x2b, 0x1e, 0xac, 0x1d, 0xde, 0x6e, 0xe8, 0x83, 0x6e, 0xa8, 0x39, 0x33, 0x07, + 0xdd, 0x78, 0x4a, 0x49, 0xe8, 0xc4, 0x9e, 0xf5, 0x7f, 0x2b, 0x60, 0x2b, 0xee, 0xb9, 0x83, 0x7f, + 0x19, 0x62, 0x11, 0xc1, 0x36, 0x80, 0x48, 0xed, 0xd9, 0xed, 0x0c, 0xd1, 0x39, 0x8e, 0x5c, 0x12, + 0x76, 0xa9, 0xda, 0xd2, 0xda, 0xe1, 0x87, 0x8d, 0xe4, 0x18, 0x1b, 0xe6, 0x8c, 0x1b, 0x27, 0x22, + 0xd0, 0x4d, 0x3a, 0x52, 0xfe, 0xcd, 0x82, 0x53, 0x46, 0xa9, 0xe7, 0x56, 0xd8, 0xa5, 0xf0, 0x0c, + 0xdc, 0x1c, 0x90, 0x80, 0xe7, 0x51, 0xaf, 0x29, 0xd4, 0x8f, 0x66, 0xa0, 0x9e, 0xe8, 0x88, 0x31, + 0xec, 0x8d, 0x41, 0xda, 0xa0, 0x70, 0x93, 0x62, 0xe3, 0xf1, 0x90, 0xb0, 0x4b, 0xef, 0x50, 0xec, + 0x4b, 0xe5, 0x9f, 0x14, 0xab, 0x9f, 0x15, 0xe8, 0x89, 0x6c, 0xba, 0xd7, 0xcf, 0x40, 0xea, 0x9e, + 0xde, 0x99, 0x01, 0x29, 0xc7, 0x74, 0x0c, 0xb8, 0x29, 0xc6, 0x4f, 0x0a, 0xae, 0x03, 0x76, 0x7c, + 0x22, 0x10, 0x0d, 0x23, 0x12, 0x0e, 0xb3, 0xfb, 0x7f, 0x4f, 0xa1, 0x1e, 0xcc, 0x40, 0x7d, 0x96, + 0x44, 0x8d, 0x7b, 0x50, 0xf1, 0xf3, 0x46, 0x95, 0xa3, 0x07, 0x76, 0xa4, 0xb4, 0xb8, 0xa9, 0x61, + 0x91, 0x3b, 0xe8, 0xf4, 0x85, 0xb5, 0xac, 0x72, 0xd8, 0x8d, 0xa9, 0x72, 0xd3, 0x98, 0xc5, 0xb8, + 0x66, 0xc1, 0xd9, 0x16, 0xd3, 0x98, 0xf8, 0x05, 0x58, 0x61, 0x24, 0x0c, 0xdc, 0x81, 0x08, 0xac, + 0x92, 0x82, 0xde, 0xcf, 0x43, 0x4b, 0x2d, 0x92, 0xb8, 0xa7, 0x24, 0x0c, 0x9a, 0x05, 0xa7, 0x24, + 0xfd, 0x4f, 0x44, 0xa0, 0x42, 0xa9, 0x09, 0x5d, 0x59, 0x10, 0x4a, 0x4d, 0x28, 0xd5, 0xa1, 0xbf, + 0x15, 0x41, 0x5d, 0xae, 0xbb, 0x1c, 0xb3, 0x3e, 0x41, 0xf2, 0xc0, 0x19, 0xc1, 0x08, 0xbb, 0x1e, + 0x63, 0x9c, 0x8e, 0xbc, 0xbe, 0x2b, 0x15, 0xce, 0x5a, 0x55, 0xa8, 0x8f, 0xf2, 0xa8, 0x4a, 0xfd, + 0x24, 0xac, 0x13, 0x47, 0x9f, 0xca, 0xe0, 0x27, 0x26, 0xf6, 0x1b, 0x4f, 0x9c, 0x37, 0x0b, 0x4e, + 0x55, 0xba, 0xce, 0xf6, 0x90, 0xe7, 0x68, 0x4a, 0x40, 0x98, 0x8c, 0xe2, 0x02, 0x54, 0x5e, 0xa0, + 0xf2, 0x7e, 0x3c, 0x27, 0xaf, 0x0a, 0x51, 0x98, 0x26, 0xdb, 0xb6, 0xce, 0x96, 0xb5, 0xa7, 0x73, + 0xd0, 0x11, 0xe6, 0xe9, 0x1c, 0x6b, 0x8b, 0x73, 0xc8, 0x90, 0x69, 0x39, 0x32, 0x76, 0xf8, 0x1d, + 0x80, 0x1c, 0xab, 0xc9, 0x4e, 0x0f, 0xf8, 0xba, 0x82, 0xbf, 0x37, 0x63, 0x14, 0x1d, 0x15, 0x90, + 0x19, 0xf3, 0xb2, 0x06, 0x49, 0x0d, 0x7a, 0x04, 0xf6, 0x0c, 0x19, 0xa7, 0xc9, 0xb1, 0xb5, 0x31, + 0xfd, 0x70, 0x52, 0x83, 0x38, 0x4b, 0x6b, 0x9b, 0x05, 0xc7, 0x42, 0xb3, 0x74, 0x38, 0x6e, 0x59, + 0xac, 0x2f, 0xa9, 0x96, 0x6d, 0x2e, 0x68, 0x99, 0x11, 0x98, 0x89, 0x96, 0xe5, 0xed, 0xb0, 0x0b, + 0x76, 0x10, 0x1d, 0xb0, 0x3e, 0x8e, 0xb0, 0x9b, 0xd5, 0x31, 0x6b, 0x4b, 0xe5, 0xb8, 0x3f, 0x4b, + 0x6b, 0x4c, 0x54, 0x5e, 0xca, 0x2a, 0x68, 0xda, 0x02, 0xfc, 0xbd, 0x08, 0xea, 0x79, 0x1e, 0xc7, + 0x3b, 0x23, 0x34, 0x8c, 0x73, 0x96, 0x55, 0xce, 0xc7, 0xd3, 0x72, 0x26, 0x7c, 0x35, 0xbb, 0x20, + 0x34, 0xd4, 0xe0, 0x92, 0xe5, 0xcf, 0x28, 0x92, 0x83, 0x9e, 0x25, 0x76, 0xde, 0x11, 0x7e, 0x05, + 0x56, 0xc4, 0x6b, 0x8f, 0xb9, 0x74, 0x18, 0x59, 0x37, 0x26, 0xa5, 0x34, 0xfd, 0xfa, 0x56, 0xe2, + 0xf7, 0xda, 0x63, 0x2f, 0x87, 0x72, 0x57, 0x25, 0xa1, 0x7f, 0xc2, 0x16, 0xd8, 0xd0, 0xdb, 0x88, + 0x61, 0xe0, 0xff, 0x81, 0x59, 0x53, 0xf5, 0x19, 0xa8, 0xef, 0xc1, 0x8d, 0x71, 0xeb, 0xc7, 0x70, + 0x37, 0x15, 0xdc, 0xa7, 0xf3, 0xe0, 0xe2, 0xce, 0x27, 0xb0, 0x5b, 0x28, 0x6b, 0x82, 0x5f, 0x83, + 0x92, 0x60, 0x2e, 0xbe, 0x20, 0x91, 0xb5, 0x6d, 0x44, 0x72, 0x5e, 0x7d, 0xba, 0xc3, 0xa7, 0x9c, + 0x8e, 0x88, 0x8f, 0xf9, 0xf3, 0x0b, 0x22, 0x41, 0x97, 0x05, 0x93, 0xbf, 0x20, 0x02, 0xe5, 0xa4, + 0x4c, 0x03, 0x5a, 0x51, 0xa0, 0x9f, 0xbf, 0x53, 0x95, 0x53, 0xc1, 0x37, 0xc7, 0x15, 0xeb, 0x24, + 0x0e, 0x28, 0x0b, 0xe6, 0x9a, 0xa3, 0x76, 0x19, 0x27, 0x08, 0x5b, 0xb7, 0x54, 0x92, 0xbb, 0x99, + 0x59, 0x50, 0xd0, 0xdf, 0x32, 0xdf, 0x93, 0x91, 0x63, 0x68, 0x82, 0xb0, 0x7a, 0x3b, 0x65, 0x2c, + 0xf0, 0x47, 0x50, 0xc9, 0xd0, 0x27, 0x18, 0x05, 0x9a, 0x3c, 0x3b, 0x46, 0x10, 0x16, 0x90, 0xe7, + 0xf8, 0xec, 0xd8, 0x50, 0x07, 0xa6, 0xa8, 0x73, 0x3c, 0x0a, 0x14, 0x71, 0x02, 0x60, 0x29, 0x74, + 0xf3, 0xd2, 0x8b, 0x93, 0x28, 0xc5, 0xb1, 0x0c, 0x73, 0x66, 0x25, 0xd0, 0xd3, 0x38, 0x1e, 0x4e, + 0x29, 0x31, 0x92, 0x39, 0xd2, 0x27, 0xbd, 0x84, 0x95, 0xf6, 0xbc, 0x02, 0x15, 0x23, 0x6a, 0x39, + 0x7e, 0xde, 0x56, 0x59, 0x3e, 0x99, 0xab, 0x6b, 0x79, 0x76, 0xde, 0xe4, 0x93, 0x66, 0xf8, 0x65, + 0x72, 0xc1, 0xda, 0x5d, 0x3c, 0xcd, 0xcf, 0xb4, 0xab, 0x24, 0x85, 0x89, 0x82, 0x43, 0xb0, 0xe7, + 0x63, 0x35, 0x20, 0x53, 0xe5, 0x71, 0x4f, 0x81, 0x7e, 0x36, 0x1f, 0x54, 0x86, 0x4f, 0xd7, 0x47, + 0x7f, 0xc6, 0x1a, 0x6c, 0x83, 0x2d, 0x8e, 0x95, 0xc8, 0x6a, 0xfe, 0x90, 0xd0, 0xda, 0x37, 0xba, + 0x38, 0x27, 0x95, 0xa3, 0x43, 0x24, 0x55, 0x5a, 0x61, 0xb3, 0xe0, 0x6c, 0xf0, 0xb4, 0x01, 0x9e, + 0xa5, 0xc7, 0xdd, 0xa0, 0xbe, 0x3f, 0xd9, 0xe9, 0x79, 0xa4, 0x54, 0xb0, 0x9b, 0x28, 0x63, 0x81, + 0xa7, 0x60, 0x13, 0x79, 0x21, 0xc2, 0xfd, 0x31, 0x6a, 0x75, 0xf2, 0x8a, 0x34, 0x81, 0xaa, 0x22, + 0xc6, 0x98, 0xeb, 0x28, 0xf5, 0x7c, 0xb4, 0x0a, 0x4a, 0x5c, 0xdf, 0x6c, 0xeb, 0xbf, 0x82, 0x72, + 0x72, 0xd9, 0x15, 0x8c, 0x86, 0x02, 0xc3, 0x43, 0xb0, 0x84, 0x39, 0x37, 0xd7, 0xdb, 0x5a, 0x7e, + 0x16, 0xf5, 0xc7, 0x97, 0x9a, 0xc6, 0xe7, 0xf2, 0xa7, 0x23, 0x9d, 0xe5, 0x87, 0x83, 0x54, 0x28, + 0x2f, 0x1a, 0x72, 0xac, 0xae, 0xb0, 0xeb, 0x4e, 0x62, 0x80, 0x3b, 0xa0, 0x14, 0x5d, 0xb8, 0x3d, + 0x4f, 0xf4, 0xd4, 0x3d, 0x74, 0xd5, 0x59, 0x8e, 0x2e, 0x9a, 0x9e, 0xe8, 0x1d, 0xb2, 0xe4, 0xae, + 0xdd, 0xc6, 0x7c, 0x24, 0xc9, 0xf7, 0x13, 0x58, 0x89, 0x4d, 0xf0, 0xee, 0x82, 0x1b, 0x9a, 0xb9, + 0x9f, 0xef, 0xde, 0x5b, 0xe8, 0xa7, 0xb7, 0x56, 0x2f, 0x1c, 0xbd, 0xfa, 0xeb, 0xaa, 0x5a, 0x7c, + 0x73, 0x55, 0x2d, 0xfe, 0x73, 0x55, 0x2d, 0xfe, 0xf9, 0xb6, 0x5a, 0x78, 0xf3, 0xb6, 0x5a, 0xf8, + 0xfb, 0x6d, 0xb5, 0xf0, 0xc3, 0x8b, 0x80, 0x44, 0xbd, 0x61, 0xa7, 0x81, 0xe8, 0xc0, 0xee, 0x84, + 0x9d, 0x07, 0xa8, 0xe7, 0x91, 0xd0, 0x4e, 0x7a, 0xfc, 0xc0, 0x70, 0xe4, 0x01, 0x33, 0x8a, 0x64, + 0x4f, 0xfd, 0x9e, 0xed, 0x2c, 0xab, 0x6f, 0xb7, 0x47, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xd0, + 0xf8, 0x76, 0x76, 0xef, 0x0e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1538,6 +1581,75 @@ func (m *GfSpSignRequest_DeleteGlobalVirtualGroup) MarshalToSizedBuffer(dAtA []b } return len(dAtA) - i, nil } +func (m *GfSpSignRequest_ReserveSwapIn) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpSignRequest_ReserveSwapIn) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ReserveSwapIn != nil { + { + size, err := m.ReserveSwapIn.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSign(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *GfSpSignRequest_CompleteSwapIn) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpSignRequest_CompleteSwapIn) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.CompleteSwapIn != nil { + { + size, err := m.CompleteSwapIn.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSign(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *GfSpSignRequest_CancelSwapIn) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GfSpSignRequest_CancelSwapIn) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.CancelSwapIn != nil { + { + size, err := m.CancelSwapIn.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSign(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} func (m *GfSpSignResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1982,6 +2094,42 @@ func (m *GfSpSignRequest_DeleteGlobalVirtualGroup) Size() (n int) { } return n } +func (m *GfSpSignRequest_ReserveSwapIn) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ReserveSwapIn != nil { + l = m.ReserveSwapIn.Size() + n += 2 + l + sovSign(uint64(l)) + } + return n +} +func (m *GfSpSignRequest_CompleteSwapIn) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CompleteSwapIn != nil { + l = m.CompleteSwapIn.Size() + n += 2 + l + sovSign(uint64(l)) + } + return n +} +func (m *GfSpSignRequest_CancelSwapIn) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CancelSwapIn != nil { + l = m.CancelSwapIn.Size() + n += 2 + l + sovSign(uint64(l)) + } + return n +} func (m *GfSpSignResponse) Size() (n int) { if m == nil { return 0 @@ -3316,6 +3464,111 @@ func (m *GfSpSignRequest) Unmarshal(dAtA []byte) error { } m.Request = &GfSpSignRequest_DeleteGlobalVirtualGroup{v} iNdEx = postIndex + case 28: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReserveSwapIn", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSign + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSign + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSign + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &types2.MsgReserveSwapIn{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Request = &GfSpSignRequest_ReserveSwapIn{v} + iNdEx = postIndex + case 29: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CompleteSwapIn", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSign + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSign + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSign + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &types2.MsgCompleteSwapIn{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Request = &GfSpSignRequest_CompleteSwapIn{v} + iNdEx = postIndex + case 30: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CancelSwapIn", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSign + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSign + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSign + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &types2.MsgCancelSwapIn{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Request = &GfSpSignRequest_CancelSwapIn{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSign(dAtA[iNdEx:]) diff --git a/base/types/gfsptask/recovery.go b/base/types/gfsptask/recovery.go index 2107a1582..f212f3d59 100644 --- a/base/types/gfsptask/recovery.go +++ b/base/types/gfsptask/recovery.go @@ -183,6 +183,22 @@ func (m *GfSpRecoverPieceTask) SetRecoverDone() { m.Recovered = true } +func (m *GfSpRecoverPieceTask) SetBySuccessorSP(bySuccessor bool) { + m.BySuccessorSp = bySuccessor +} + +func (m *GfSpRecoverPieceTask) BySuccessorSP() bool { + return m.BySuccessorSp +} + +func (m *GfSpRecoverPieceTask) SetGVGID(gvgID uint32) { + m.GvgId = gvgID +} + +func (m *GfSpRecoverPieceTask) GetGVGID() uint32 { + return m.GvgId +} + func (m *GfSpRecoverPieceTask) GetSignBytes() []byte { fakeMsg := &GfSpRecoverPieceTask{ ObjectInfo: m.GetObjectInfo(), diff --git a/base/types/gfsptask/task.pb.go b/base/types/gfsptask/task.pb.go index 1b1ad6d92..5a19a1987 100644 --- a/base/types/gfsptask/task.pb.go +++ b/base/types/gfsptask/task.pb.go @@ -707,6 +707,8 @@ type GfSpRecoverPieceTask struct { PieceSize uint64 `protobuf:"varint,6,opt,name=piece_size,json=pieceSize,proto3" json:"piece_size,omitempty"` Signature []byte `protobuf:"bytes,7,opt,name=signature,proto3" json:"signature,omitempty"` Recovered bool `protobuf:"varint,8,opt,name=recovered,proto3" json:"recovered,omitempty"` + BySuccessorSp bool `protobuf:"varint,9,opt,name=by_successor_sp,json=bySuccessorSp,proto3" json:"by_successor_sp,omitempty"` + GvgId uint32 `protobuf:"varint,10,opt,name=gvg_id,json=gvgId,proto3" json:"gvg_id,omitempty"` } func (m *GfSpRecoverPieceTask) Reset() { *m = GfSpRecoverPieceTask{} } @@ -798,6 +800,20 @@ func (m *GfSpRecoverPieceTask) GetRecovered() bool { return false } +func (m *GfSpRecoverPieceTask) GetBySuccessorSp() bool { + if m != nil { + return m.BySuccessorSp + } + return false +} + +func (m *GfSpRecoverPieceTask) GetGvgId() uint32 { + if m != nil { + return m.GvgId + } + return 0 +} + type GfSpReceivePieceTask struct { Task *GfSpTask `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"` ObjectInfo *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"` @@ -2078,140 +2094,142 @@ func init() { func init() { proto.RegisterFile("base/types/gfsptask/task.proto", fileDescriptor_0d22df708e229306) } var fileDescriptor_0d22df708e229306 = []byte{ - // 2113 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcb, 0x6f, 0x1c, 0x49, - 0x19, 0xdf, 0x79, 0xcf, 0x7c, 0x33, 0xe3, 0x38, 0xed, 0x49, 0x32, 0x79, 0x8d, 0x9d, 0x36, 0x59, - 0x79, 0x61, 0x3d, 0xb3, 0xeb, 0x55, 0xc4, 0x31, 0xf2, 0x63, 0x33, 0x6b, 0x41, 0x1e, 0xdb, 0x0e, - 0x7b, 0xd8, 0x03, 0xad, 0x9a, 0xee, 0x9a, 0x9e, 0xc6, 0xfd, 0xa2, 0xba, 0x7b, 0x62, 0xe7, 0x8c, - 0xc4, 0x11, 0xc4, 0x85, 0x1b, 0x67, 0xc4, 0x0d, 0x09, 0x71, 0xe3, 0x84, 0xb4, 0x42, 0x82, 0xc3, - 0x1e, 0x91, 0xb8, 0xac, 0x12, 0x2e, 0xfc, 0x17, 0xa8, 0xbe, 0xaa, 0x7e, 0xcc, 0x78, 0x6c, 0x9c, - 0xc4, 0x40, 0x82, 0xb8, 0x24, 0xae, 0xef, 0xf7, 0x55, 0xf5, 0x57, 0xdf, 0xe3, 0x57, 0x5f, 0xd5, - 0x40, 0x6f, 0x44, 0x42, 0x3a, 0x88, 0x8e, 0x03, 0x1a, 0x0e, 0xac, 0x71, 0x18, 0x44, 0x24, 0x3c, - 0x1c, 0xf0, 0x7f, 0xfa, 0x01, 0xf3, 0x23, 0x5f, 0x59, 0xe1, 0x78, 0x1f, 0xf1, 0x7e, 0x82, 0xdf, - 0xb8, 0x33, 0x37, 0x89, 0x32, 0xe6, 0xb3, 0x70, 0x80, 0xff, 0x89, 0x79, 0x37, 0xae, 0x5b, 0x8c, - 0x52, 0x6f, 0x6c, 0x53, 0xc7, 0x1c, 0x84, 0x81, 0xd0, 0x95, 0xd0, 0x6a, 0x1e, 0x8a, 0x7c, 0x46, - 0x2c, 0x3a, 0x08, 0x08, 0x23, 0x6e, 0xa2, 0x70, 0x73, 0x81, 0x42, 0x74, 0x24, 0xc1, 0xde, 0x22, - 0x30, 0xb7, 0xfa, 0x7a, 0x0e, 0x9f, 0xda, 0x2c, 0x8a, 0x89, 0x63, 0x31, 0x3f, 0x9e, 0x31, 0x41, - 0xfd, 0x63, 0x11, 0xea, 0xc3, 0xf1, 0x41, 0xf0, 0x94, 0x84, 0x87, 0x4a, 0x17, 0x6a, 0xc4, 0x34, - 0x19, 0x0d, 0xc3, 0x6e, 0x61, 0xad, 0xb0, 0xd1, 0xd0, 0x92, 0xa1, 0xb2, 0x0a, 0x4d, 0x83, 0x51, - 0x12, 0x51, 0x3d, 0xb2, 0x5d, 0xda, 0x2d, 0xae, 0x15, 0x36, 0x4a, 0x1a, 0x08, 0xd1, 0x53, 0xdb, - 0xa5, 0x5c, 0x21, 0x0e, 0xcc, 0x54, 0xa1, 0x24, 0x14, 0x84, 0x08, 0x15, 0xba, 0x50, 0xe3, 0x88, - 0x1f, 0x47, 0xdd, 0x32, 0x82, 0xc9, 0x50, 0x59, 0x87, 0x36, 0xf7, 0xa5, 0x1e, 0x30, 0xdb, 0x67, - 0x76, 0x74, 0xdc, 0xad, 0xac, 0x15, 0x36, 0x2a, 0x5a, 0x8b, 0x0b, 0x9f, 0x48, 0x99, 0xd2, 0x81, - 0x0a, 0xa3, 0x11, 0x3b, 0xee, 0x56, 0x71, 0xb2, 0x18, 0x28, 0x37, 0xa1, 0xe1, 0x92, 0x23, 0x5d, - 0x20, 0x35, 0x44, 0xea, 0x2e, 0x39, 0xd2, 0x10, 0xbc, 0x03, 0xad, 0x38, 0xa4, 0x4c, 0x4f, 0xb6, - 0x54, 0xc7, 0x2d, 0x35, 0xb9, 0x6c, 0x5b, 0x6e, 0x4b, 0x81, 0xb2, 0xe3, 0x5b, 0x61, 0xb7, 0x81, - 0x10, 0xfe, 0xad, 0x6c, 0x41, 0x89, 0x32, 0xd6, 0x85, 0xb5, 0xc2, 0x46, 0x73, 0x6b, 0xad, 0x3f, - 0x17, 0x75, 0x11, 0xe0, 0x3e, 0x77, 0xd9, 0xa7, 0xfc, 0x4f, 0x8d, 0x2b, 0xab, 0x5f, 0x15, 0xe0, - 0x16, 0x17, 0xed, 0xa2, 0x43, 0x76, 0x62, 0xe3, 0x90, 0x46, 0xdb, 0x41, 0xc0, 0xfc, 0x29, 0x71, - 0xd0, 0xb3, 0x1f, 0x43, 0x99, 0x6f, 0x07, 0xdd, 0xda, 0xdc, 0xba, 0xdd, 0x5f, 0x90, 0x4b, 0xfd, - 0x24, 0x0c, 0x1a, 0xaa, 0x2a, 0x9f, 0x83, 0x22, 0x5d, 0x3e, 0xc2, 0xf5, 0x74, 0xdb, 0x1b, 0xfb, - 0xe8, 0xf9, 0xe6, 0xd6, 0x7a, 0x3f, 0x8b, 0x6d, 0x5f, 0xc6, 0xbe, 0xff, 0x30, 0xb4, 0xf2, 0xdf, - 0xd7, 0x96, 0x8d, 0xdc, 0x68, 0xdf, 0x1b, 0xfb, 0xca, 0x1a, 0x34, 0xc7, 0xb6, 0x67, 0x51, 0x16, - 0x30, 0xdb, 0x8b, 0x30, 0x48, 0x2d, 0x2d, 0x2f, 0x52, 0x7f, 0x5d, 0x80, 0xdb, 0xdc, 0x8e, 0x87, - 0xb6, 0xc5, 0x2e, 0x6c, 0x27, 0x4f, 0x61, 0xc5, 0x15, 0xeb, 0x2d, 0xd8, 0xca, 0xb7, 0x4e, 0xd9, - 0xca, 0x8c, 0x05, 0xda, 0x65, 0x37, 0x3f, 0xe4, 0x9b, 0x99, 0xf3, 0xf9, 0xe3, 0xd1, 0x8f, 0xa8, - 0x71, 0x81, 0x3e, 0xf7, 0x71, 0xbd, 0xf3, 0xfb, 0x5c, 0x7c, 0x3f, 0xf1, 0xb9, 0x18, 0x9d, 0xd3, - 0xe7, 0x7f, 0x28, 0x43, 0x8f, 0xdb, 0xa1, 0xd1, 0xc0, 0xb1, 0x0d, 0x12, 0xd1, 0x27, 0x36, 0x35, - 0xe8, 0x9b, 0x6e, 0xe5, 0x3e, 0x34, 0x4f, 0xee, 0xa1, 0xb7, 0x68, 0x0f, 0x99, 0xb1, 0x1a, 0xf8, - 0x99, 0xe1, 0xdb, 0xb0, 0x24, 0x35, 0x74, 0xc1, 0x49, 0x68, 0x7b, 0x73, 0xeb, 0xc6, 0xa2, 0x35, - 0x9e, 0xa0, 0x86, 0xd6, 0x96, 0x63, 0x31, 0x54, 0xee, 0xc1, 0x35, 0x5e, 0xd8, 0x61, 0xa0, 0xfb, - 0x01, 0x65, 0x24, 0xf2, 0xb3, 0x62, 0x2c, 0x63, 0xc5, 0x75, 0x48, 0x78, 0x78, 0x10, 0x3c, 0x96, - 0x60, 0x52, 0x95, 0xeb, 0xd0, 0xc6, 0x69, 0xb6, 0xe5, 0x91, 0x28, 0x66, 0x14, 0x09, 0xa1, 0xa5, - 0xb5, 0xb8, 0x72, 0x22, 0x53, 0x3e, 0x82, 0x0e, 0x41, 0x17, 0x51, 0x93, 0x7f, 0x80, 0x7a, 0x66, - 0xe0, 0x73, 0x07, 0x57, 0x71, 0x61, 0x25, 0xc1, 0x0e, 0x82, 0x4f, 0x25, 0xa2, 0xdc, 0x87, 0x5b, - 0xf9, 0x19, 0x27, 0x4c, 0xaa, 0xe1, 0xcc, 0xeb, 0xd9, 0xcc, 0x79, 0xbb, 0x36, 0x41, 0xc9, 0x16, - 0x48, 0x8d, 0xab, 0xa3, 0x71, 0x97, 0xd3, 0x69, 0xa9, 0x85, 0x73, 0xdf, 0x23, 0x32, 0xa0, 0xe9, - 0xf7, 0x1a, 0xf3, 0xdf, 0x4b, 0x42, 0x9e, 0x7c, 0xef, 0x2e, 0x2c, 0xd1, 0xa3, 0xc0, 0x66, 0xd4, - 0xd4, 0x27, 0xd4, 0xb6, 0x26, 0x11, 0x92, 0x52, 0x59, 0x6b, 0x4b, 0xe9, 0x67, 0x28, 0x54, 0x7f, - 0x52, 0x84, 0x0e, 0x0f, 0xfe, 0x0f, 0x02, 0xc7, 0x27, 0xa6, 0x88, 0xe6, 0xeb, 0x66, 0xcd, 0x3d, - 0xb8, 0x26, 0x8f, 0x0a, 0x1d, 0xcf, 0x0a, 0x7d, 0x4c, 0x5c, 0xdb, 0x39, 0xd6, 0x6d, 0x13, 0x33, - 0xa8, 0xad, 0x75, 0x24, 0x3c, 0xe4, 0xe8, 0x03, 0x04, 0xf7, 0xcd, 0xf9, 0x64, 0x2b, 0x5d, 0x40, - 0xb2, 0x95, 0x5f, 0x31, 0xd9, 0xd4, 0xbf, 0x15, 0x05, 0x75, 0x69, 0x34, 0x8c, 0x5d, 0x32, 0x72, - 0xe8, 0x45, 0xf8, 0xe3, 0x6d, 0xa8, 0xa2, 0xab, 0x50, 0xf5, 0xc7, 0xe3, 0x90, 0x8a, 0x83, 0xb3, - 0xac, 0xc9, 0x11, 0x97, 0x3b, 0xd4, 0xb3, 0xa2, 0x09, 0xd6, 0x47, 0x59, 0x93, 0x23, 0xe5, 0x16, - 0x34, 0x0c, 0xdf, 0x0d, 0x1c, 0x1a, 0x51, 0x13, 0xcb, 0xa1, 0xae, 0x65, 0x82, 0xb3, 0x22, 0x5c, - 0x3b, 0x3d, 0xc2, 0xea, 0xdf, 0x4b, 0x70, 0xf5, 0x24, 0x49, 0xbd, 0xcb, 0x6e, 0x1d, 0xc0, 0x4a, - 0x48, 0x0d, 0xdf, 0x33, 0x09, 0x3b, 0x4e, 0x6a, 0x92, 0xf2, 0xbc, 0x2b, 0x71, 0xfe, 0x48, 0xa1, - 0xed, 0x04, 0x51, 0x3e, 0x86, 0x4e, 0x36, 0x21, 0xad, 0xff, 0xb0, 0x5b, 0x59, 0x2b, 0x6d, 0xb4, - 0xb4, 0x6c, 0xb1, 0x94, 0x01, 0x30, 0x74, 0x21, 0x25, 0x4e, 0x1a, 0x07, 0x39, 0xe2, 0x41, 0xb0, - 0x1c, 0x7f, 0x44, 0x1c, 0x7d, 0x36, 0x16, 0x59, 0x10, 0x04, 0xfc, 0x45, 0x2e, 0x14, 0xfb, 0xe6, - 0xac, 0xc9, 0x09, 0xe3, 0xf1, 0xc6, 0x66, 0xd6, 0xe4, 0x84, 0xf1, 0xf8, 0x1e, 0x3b, 0x9e, 0x1f, - 0xe9, 0x64, 0x4a, 0x6c, 0x87, 0x97, 0x04, 0xe7, 0x21, 0xdb, 0x3c, 0x42, 0xea, 0xa9, 0x68, 0x97, - 0x3d, 0x3f, 0xda, 0x4e, 0xa0, 0x83, 0x60, 0xdf, 0x3c, 0x52, 0xbf, 0x91, 0x5c, 0xa2, 0x51, 0xc3, - 0x9f, 0x52, 0xf6, 0xce, 0x07, 0x79, 0x15, 0x9a, 0x21, 0xb5, 0x5c, 0xea, 0x45, 0xb8, 0xef, 0x32, - 0x3a, 0x17, 0xa4, 0x68, 0xdf, 0x3c, 0x52, 0xae, 0x40, 0x95, 0x1a, 0x88, 0x89, 0xae, 0xb3, 0x42, - 0x0d, 0x2e, 0xbe, 0x0d, 0x10, 0xf0, 0xbd, 0xeb, 0xa1, 0xfd, 0x9c, 0x62, 0xf0, 0xca, 0x5a, 0x03, - 0x25, 0x07, 0xf6, 0x73, 0xca, 0x4b, 0x2c, 0x3b, 0x00, 0x6a, 0x78, 0x00, 0x64, 0x02, 0x8e, 0x32, - 0xe1, 0x3f, 0x6a, 0xe2, 0xf1, 0x50, 0xd7, 0x32, 0x81, 0xfa, 0xb3, 0x72, 0xea, 0x62, 0x6a, 0x4f, - 0xe9, 0xff, 0xbe, 0x8b, 0xef, 0xc2, 0x12, 0xa3, 0x66, 0xec, 0x99, 0xc4, 0x33, 0x8e, 0x73, 0xae, - 0x6e, 0x67, 0xd2, 0xc5, 0x2e, 0x2f, 0xe5, 0x5d, 0x7e, 0x17, 0x96, 0x04, 0x6c, 0x4c, 0xa8, 0x71, - 0x18, 0xc6, 0xae, 0xf4, 0x7b, 0x1b, 0xa5, 0xbb, 0x52, 0x38, 0x1b, 0x99, 0xfa, 0x7c, 0x64, 0xb2, - 0x7a, 0x6c, 0xcc, 0xd4, 0xe3, 0x0d, 0xa8, 0x8f, 0x6d, 0xcf, 0x0e, 0x27, 0xd4, 0xc4, 0x33, 0xb6, - 0xae, 0xa5, 0xe3, 0xb3, 0x6a, 0xb5, 0x79, 0x46, 0xad, 0x7e, 0x00, 0xcb, 0xb2, 0xd9, 0x15, 0xad, - 0xab, 0xed, 0x7b, 0xdd, 0x16, 0x2e, 0x7d, 0x49, 0xc8, 0x1f, 0x26, 0x62, 0xf5, 0x97, 0x25, 0x50, - 0x78, 0x60, 0x0f, 0x28, 0x71, 0xde, 0xfd, 0xe3, 0xea, 0x3f, 0xc1, 0xab, 0x67, 0xc4, 0xa4, 0xfa, - 0xea, 0xfc, 0x59, 0x3b, 0x8d, 0x3f, 0xd5, 0xdf, 0x17, 0xc5, 0xa9, 0xb7, 0xe7, 0x3f, 0xf3, 0xde, - 0x82, 0x66, 0xe2, 0x3e, 0x34, 0xf3, 0x17, 0xa8, 0x33, 0xda, 0xac, 0xec, 0x9e, 0xa4, 0xc1, 0x28, - 0xbb, 0x00, 0xbe, 0x79, 0x9b, 0xa5, 0x2c, 0x43, 0xc9, 0xf1, 0x9f, 0x61, 0x09, 0x97, 0x34, 0xfe, - 0x27, 0xbf, 0x44, 0x4f, 0x6c, 0x6b, 0x22, 0x4b, 0x16, 0xff, 0x56, 0x7f, 0x57, 0x82, 0x2b, 0x79, - 0xc7, 0xfd, 0x77, 0x59, 0xee, 0x6d, 0xf0, 0xdb, 0x1d, 0x68, 0x51, 0x0f, 0xcf, 0x60, 0x24, 0x30, - 0x74, 0x60, 0x5d, 0x6b, 0x0a, 0x19, 0xd2, 0x17, 0x67, 0xc0, 0xc8, 0x8f, 0x88, 0x33, 0x73, 0xe8, - 0xa0, 0x04, 0x19, 0xf0, 0x26, 0x08, 0x3a, 0xd4, 0x0f, 0xe9, 0xb1, 0xbc, 0xac, 0xd4, 0x51, 0xf0, - 0x3d, 0x8a, 0x8f, 0x1d, 0x02, 0x94, 0xad, 0x62, 0x1d, 0x67, 0x37, 0x51, 0xf6, 0x58, 0xf4, 0x8b, - 0xa9, 0x8a, 0xec, 0x1a, 0x1b, 0x39, 0x95, 0xef, 0xa3, 0x48, 0xfd, 0x4a, 0x76, 0x79, 0xbb, 0x13, - 0xe2, 0x70, 0x2d, 0xfa, 0xff, 0xb8, 0xcd, 0x1d, 0x6f, 0x95, 0x73, 0x1c, 0x6f, 0xd5, 0x45, 0xc7, - 0xdb, 0x5d, 0x58, 0xb2, 0xbd, 0x88, 0x5a, 0xcc, 0x8e, 0x8e, 0xf5, 0x09, 0x09, 0x27, 0xc9, 0xf9, - 0x95, 0x4a, 0x3f, 0x23, 0xe1, 0x24, 0x3b, 0x05, 0x51, 0xa5, 0x8e, 0x14, 0x28, 0xc2, 0x8e, 0xf0, - 0xfb, 0x70, 0x49, 0xc0, 0x26, 0x89, 0x88, 0xc8, 0x93, 0x06, 0x96, 0x9d, 0x38, 0x06, 0xf7, 0x48, - 0x44, 0x78, 0xae, 0xa8, 0xbf, 0x2a, 0xc2, 0x32, 0x8f, 0xc6, 0x70, 0xf7, 0xcd, 0x28, 0xeb, 0x43, - 0x50, 0xc2, 0x88, 0xb0, 0x48, 0x1f, 0x39, 0xbe, 0x71, 0xa8, 0x7b, 0xb1, 0x3b, 0xa2, 0x0c, 0x23, - 0x59, 0xd6, 0x96, 0x11, 0xd9, 0xe1, 0xc0, 0x23, 0x94, 0x2b, 0x1b, 0xb0, 0x4c, 0x3d, 0x73, 0x56, - 0xb7, 0x84, 0xba, 0x4b, 0xd4, 0x33, 0xf3, 0x9a, 0x1f, 0x41, 0xc7, 0x88, 0x19, 0xe3, 0x5e, 0x9d, - 0xd1, 0x16, 0x37, 0x1c, 0x45, 0x62, 0xf9, 0x19, 0x9f, 0xc0, 0x55, 0x87, 0x84, 0x91, 0x6e, 0x52, - 0xbc, 0xc7, 0xa4, 0x0f, 0x34, 0xa6, 0xbc, 0xfd, 0xac, 0x70, 0x74, 0x4f, 0x80, 0x32, 0x9d, 0x4c, - 0xa5, 0x0b, 0x35, 0x16, 0x7b, 0x9e, 0xed, 0x59, 0xb2, 0x01, 0x4f, 0x86, 0xea, 0x5f, 0x0a, 0x82, - 0xa0, 0x86, 0xbb, 0x5f, 0xfa, 0xee, 0xc8, 0x7e, 0xb3, 0x44, 0xcf, 0x7d, 0xa6, 0x38, 0xf3, 0x19, - 0x1e, 0x2f, 0xe1, 0xbf, 0xcc, 0x5c, 0xe1, 0x90, 0x36, 0x8a, 0x53, 0x43, 0x55, 0x68, 0x73, 0xcf, - 0x65, 0x5a, 0xc2, 0x11, 0x4d, 0xea, 0x65, 0x9b, 0xc9, 0x37, 0x29, 0x95, 0xd9, 0x26, 0x45, 0xfd, - 0x69, 0x01, 0x96, 0xc4, 0x76, 0x1e, 0xd2, 0x88, 0xbc, 0xee, 0x3e, 0x56, 0xa1, 0x99, 0x44, 0x85, - 0xe7, 0xb1, 0x08, 0x33, 0x48, 0x11, 0x4f, 0xe2, 0x3b, 0xd0, 0x12, 0xfe, 0xd7, 0x0d, 0x3f, 0x96, - 0xaf, 0x59, 0x65, 0xad, 0x29, 0x64, 0xbb, 0x5c, 0xa4, 0xfe, 0xa2, 0x2c, 0x9a, 0x19, 0xf9, 0x7e, - 0x37, 0xfc, 0x62, 0xf8, 0xba, 0xd6, 0xdc, 0x84, 0x46, 0x52, 0xfd, 0xa6, 0xb4, 0xa5, 0x2e, 0x6b, - 0xdb, 0x54, 0xf6, 0xa0, 0x16, 0x32, 0x43, 0xb7, 0xa6, 0x96, 0xa4, 0x85, 0xef, 0xe4, 0x4b, 0x3a, - 0xff, 0xdc, 0xdd, 0x1f, 0x9e, 0x68, 0x05, 0xb4, 0x6a, 0xc8, 0x8c, 0xe1, 0xd4, 0x52, 0x1e, 0x40, - 0xdd, 0xa4, 0x61, 0x84, 0xcb, 0x94, 0x5f, 0x7d, 0x99, 0x1a, 0x9f, 0xcc, 0xd7, 0x39, 0x67, 0x8b, - 0x7b, 0x0f, 0xf8, 0x87, 0xf5, 0x30, 0xc0, 0x6c, 0x9c, 0xa7, 0xb2, 0xa0, 0x7f, 0x20, 0x99, 0x87, - 0xf9, 0x53, 0xdb, 0xa4, 0x4c, 0xab, 0x84, 0xcc, 0x38, 0x08, 0x78, 0xb7, 0x83, 0xa9, 0x2f, 0xdf, - 0x40, 0xf3, 0x69, 0x52, 0x43, 0xb7, 0x74, 0x38, 0x2c, 0x1d, 0xbe, 0x38, 0x5f, 0xea, 0x73, 0x4d, - 0xed, 0x2a, 0x34, 0xc5, 0x23, 0x92, 0x78, 0xae, 0x17, 0x1c, 0x02, 0x42, 0x84, 0xcf, 0xf5, 0x33, - 0x7d, 0x34, 0xcc, 0xf7, 0xd1, 0xfd, 0xf4, 0x45, 0xd7, 0xd4, 0x47, 0xc7, 0x11, 0x0d, 0x05, 0x15, - 0x35, 0xd1, 0x9a, 0xe4, 0xad, 0xd6, 0xdc, 0xe1, 0x08, 0xd2, 0xd1, 0x3f, 0xe4, 0xb5, 0x52, 0xda, - 0xf8, 0xce, 0xdf, 0x79, 0x78, 0x59, 0x63, 0x20, 0xb3, 0x77, 0x47, 0xf1, 0xa0, 0xd9, 0xc6, 0x88, - 0xa5, 0x4f, 0x8e, 0x17, 0x75, 0x78, 0x7c, 0x1b, 0x2e, 0xdb, 0xa1, 0x3e, 0x73, 0x9f, 0x10, 0xf7, - 0xce, 0xba, 0x76, 0xc9, 0x0e, 0x77, 0x72, 0xf7, 0x09, 0xaa, 0xfe, 0xa6, 0x08, 0xd7, 0x05, 0x15, - 0xec, 0xcc, 0xde, 0x33, 0xfe, 0x2d, 0x75, 0xf8, 0x01, 0x5c, 0xc6, 0xdc, 0xb4, 0x8c, 0x13, 0x14, - 0xb7, 0xc4, 0x81, 0xa1, 0x91, 0xe6, 0xe3, 0x3a, 0x2c, 0x25, 0xaa, 0xd6, 0xd4, 0xca, 0x91, 0x9c, - 0xd0, 0x1b, 0x4e, 0xad, 0xb3, 0x49, 0x8e, 0x93, 0xa4, 0xe8, 0x8f, 0xf8, 0x74, 0x2f, 0x76, 0x65, - 0x8b, 0xd4, 0x44, 0xe1, 0x70, 0x6a, 0x3d, 0x8a, 0x5d, 0x65, 0x13, 0x56, 0x2c, 0x43, 0x4f, 0xa6, - 0xa4, 0x9a, 0xa2, 0x4e, 0x96, 0x2d, 0xe3, 0x81, 0x44, 0x84, 0xba, 0xfa, 0xdb, 0x22, 0x5c, 0xe3, - 0xdb, 0x9d, 0x73, 0x15, 0xe6, 0xc9, 0xcc, 0xbe, 0x0b, 0x73, 0xfb, 0xce, 0xdb, 0x59, 0x9c, 0xb3, - 0xf3, 0x94, 0xea, 0x28, 0x9d, 0x52, 0x1d, 0xca, 0x77, 0x01, 0x89, 0x84, 0xf3, 0x42, 0xf9, 0x5c, - 0xbc, 0x50, 0xe5, 0xea, 0x48, 0x0c, 0x09, 0x9f, 0x54, 0x5e, 0x85, 0x4f, 0xe6, 0x8a, 0xbf, 0x7a, - 0x76, 0xf1, 0xcf, 0x3f, 0x6f, 0xa8, 0x7f, 0x2e, 0xc2, 0x4a, 0xe6, 0xb3, 0xcf, 0x63, 0x3f, 0x22, - 0xff, 0xda, 0x5f, 0x1d, 0xa8, 0xb8, 0xbe, 0x17, 0x4d, 0xd0, 0x59, 0x0d, 0x4d, 0x0c, 0xb8, 0x25, - 0x72, 0x8a, 0x47, 0xe4, 0xaf, 0x86, 0x8d, 0xa4, 0x81, 0x7b, 0x44, 0x5c, 0xca, 0xfb, 0x0f, 0x46, - 0x89, 0xa9, 0x1b, 0xbe, 0x17, 0xc6, 0x2e, 0xbe, 0xbb, 0x3f, 0xa7, 0x32, 0x6f, 0x96, 0x39, 0xb2, - 0x2b, 0x01, 0xe9, 0xc8, 0xee, 0x98, 0x51, 0xaa, 0xff, 0x98, 0xdb, 0x34, 0x37, 0x47, 0x74, 0x09, - 0x57, 0x38, 0x8e, 0x26, 0xcf, 0x4c, 0x7c, 0x1f, 0x2e, 0xe5, 0x26, 0xe6, 0xda, 0xef, 0x76, 0xaa, - 0x8f, 0x7a, 0x1f, 0x82, 0x62, 0x4c, 0x08, 0xb3, 0xa8, 0x99, 0x57, 0x95, 0xc9, 0x25, 0x91, 0x4c, - 0x7b, 0x1d, 0xda, 0xc4, 0x71, 0xfc, 0x67, 0x69, 0xc5, 0x0a, 0x16, 0x6e, 0xa1, 0x30, 0xf9, 0x7d, - 0xeb, 0x87, 0x7f, 0x7a, 0xd1, 0x2b, 0x7c, 0xfd, 0xa2, 0x57, 0xf8, 0xe6, 0x45, 0xaf, 0xf0, 0xf3, - 0x97, 0xbd, 0xf7, 0xbe, 0x7e, 0xd9, 0x7b, 0xef, 0xaf, 0x2f, 0x7b, 0xef, 0x7d, 0xb9, 0x67, 0xd9, - 0xd1, 0x24, 0x1e, 0xf5, 0x0d, 0xdf, 0x1d, 0x8c, 0xbc, 0xd1, 0xa6, 0x31, 0x21, 0xb6, 0x37, 0xc8, - 0x22, 0xbc, 0x29, 0x39, 0x69, 0x33, 0x90, 0xf1, 0x1d, 0x2c, 0xf8, 0x05, 0x7b, 0x54, 0xc5, 0xdf, - 0x79, 0x3f, 0xf9, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7b, 0xd1, 0xd8, 0x43, 0xdf, 0x1e, 0x00, - 0x00, + // 2152 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x8f, 0x1b, 0x49, + 0x15, 0x8f, 0xbf, 0xed, 0x67, 0x7b, 0x32, 0xe9, 0x71, 0x12, 0xe7, 0xcb, 0x99, 0xf4, 0x90, 0x68, + 0x16, 0x36, 0xf6, 0x6e, 0x56, 0x11, 0xc7, 0x28, 0x99, 0xd9, 0x78, 0x47, 0x90, 0x8f, 0x6d, 0x87, + 0x3d, 0xec, 0x81, 0x56, 0xb9, 0xbb, 0xdc, 0x6e, 0xa6, 0xbf, 0xa8, 0xee, 0x76, 0xc6, 0x39, 0x23, + 0x71, 0x04, 0x71, 0xe1, 0x06, 0x57, 0xc4, 0x0d, 0x09, 0x71, 0xe3, 0x84, 0xb4, 0x42, 0x82, 0xc3, + 0x1e, 0x91, 0xb8, 0xa0, 0x84, 0x0b, 0xff, 0x05, 0xaa, 0x57, 0xd5, 0x1f, 0xf6, 0x78, 0x86, 0x49, + 0x32, 0x40, 0x82, 0xb8, 0x24, 0x53, 0xef, 0xbd, 0xaa, 0x7e, 0xf5, 0x7e, 0xef, 0xfd, 0xea, 0x55, + 0x19, 0x7a, 0x63, 0x12, 0xd2, 0x41, 0x34, 0x0f, 0x68, 0x38, 0xb0, 0x26, 0x61, 0x10, 0x91, 0x70, + 0x7f, 0xc0, 0xff, 0xe9, 0x07, 0xcc, 0x8f, 0x7c, 0x65, 0x83, 0xeb, 0xfb, 0xa8, 0xef, 0x27, 0xfa, + 0xcb, 0x37, 0x96, 0x26, 0x51, 0xc6, 0x7c, 0x16, 0x0e, 0xf0, 0x3f, 0x31, 0xef, 0xf2, 0x25, 0x8b, + 0x51, 0xea, 0x4d, 0x6c, 0xea, 0x98, 0x83, 0x30, 0x10, 0xb6, 0x52, 0x75, 0x3d, 0xaf, 0x8a, 0x7c, + 0x46, 0x2c, 0x3a, 0x08, 0x08, 0x23, 0x6e, 0x62, 0x70, 0x65, 0x85, 0x41, 0x74, 0x20, 0x95, 0xbd, + 0x55, 0xca, 0xdc, 0xea, 0x5b, 0x39, 0xfd, 0xcc, 0x66, 0x51, 0x4c, 0x1c, 0x8b, 0xf9, 0xf1, 0x82, + 0x0b, 0xea, 0x1f, 0x8a, 0x50, 0x1f, 0x4e, 0x46, 0xc1, 0x33, 0x12, 0xee, 0x2b, 0x5d, 0xa8, 0x11, + 0xd3, 0x64, 0x34, 0x0c, 0xbb, 0x85, 0xcd, 0xc2, 0x76, 0x43, 0x4b, 0x86, 0xca, 0x75, 0x68, 0x1a, + 0x8c, 0x92, 0x88, 0xea, 0x91, 0xed, 0xd2, 0x6e, 0x71, 0xb3, 0xb0, 0x5d, 0xd2, 0x40, 0x88, 0x9e, + 0xd9, 0x2e, 0xe5, 0x06, 0x71, 0x60, 0xa6, 0x06, 0x25, 0x61, 0x20, 0x44, 0x68, 0xd0, 0x85, 0x1a, + 0xd7, 0xf8, 0x71, 0xd4, 0x2d, 0xa3, 0x32, 0x19, 0x2a, 0x5b, 0xd0, 0xe6, 0xb1, 0xd4, 0x03, 0x66, + 0xfb, 0xcc, 0x8e, 0xe6, 0xdd, 0xca, 0x66, 0x61, 0xbb, 0xa2, 0xb5, 0xb8, 0xf0, 0xa9, 0x94, 0x29, + 0x1d, 0xa8, 0x30, 0x1a, 0xb1, 0x79, 0xb7, 0x8a, 0x93, 0xc5, 0x40, 0xb9, 0x02, 0x0d, 0x97, 0x1c, + 0xe8, 0x42, 0x53, 0x43, 0x4d, 0xdd, 0x25, 0x07, 0x1a, 0x2a, 0x6f, 0x40, 0x2b, 0x0e, 0x29, 0xd3, + 0x93, 0x2d, 0xd5, 0x71, 0x4b, 0x4d, 0x2e, 0xbb, 0x2f, 0xb7, 0xa5, 0x40, 0xd9, 0xf1, 0xad, 0xb0, + 0xdb, 0x40, 0x15, 0xfe, 0xad, 0xdc, 0x81, 0x12, 0x65, 0xac, 0x0b, 0x9b, 0x85, 0xed, 0xe6, 0x9d, + 0xcd, 0xfe, 0x12, 0xea, 0x02, 0xe0, 0x3e, 0x0f, 0xd9, 0xa7, 0xfc, 0x4f, 0x8d, 0x1b, 0xab, 0x5f, + 0x15, 0xe0, 0x2a, 0x17, 0xed, 0x60, 0x40, 0x1e, 0xc4, 0xc6, 0x3e, 0x8d, 0xee, 0x07, 0x01, 0xf3, + 0x67, 0xc4, 0xc1, 0xc8, 0x7e, 0x0c, 0x65, 0xbe, 0x1d, 0x0c, 0x6b, 0xf3, 0xce, 0xb5, 0xfe, 0x8a, + 0x5c, 0xea, 0x27, 0x30, 0x68, 0x68, 0xaa, 0x7c, 0x0e, 0x8a, 0x0c, 0xf9, 0x18, 0xd7, 0xd3, 0x6d, + 0x6f, 0xe2, 0x63, 0xe4, 0x9b, 0x77, 0xb6, 0xfa, 0x19, 0xb6, 0x7d, 0x89, 0x7d, 0xff, 0x51, 0x68, + 0xe5, 0xbf, 0xaf, 0xad, 0x1b, 0xb9, 0xd1, 0x9e, 0x37, 0xf1, 0x95, 0x4d, 0x68, 0x4e, 0x6c, 0xcf, + 0xa2, 0x2c, 0x60, 0xb6, 0x17, 0x21, 0x48, 0x2d, 0x2d, 0x2f, 0x52, 0x7f, 0x55, 0x80, 0x6b, 0xdc, + 0x8f, 0x47, 0xb6, 0xc5, 0x4e, 0x6d, 0x27, 0xcf, 0x60, 0xc3, 0x15, 0xeb, 0xad, 0xd8, 0xca, 0x37, + 0x8e, 0xd8, 0xca, 0x82, 0x07, 0xda, 0x39, 0x37, 0x3f, 0xe4, 0x9b, 0x59, 0x8a, 0xf9, 0x93, 0xf1, + 0x0f, 0xa8, 0x71, 0x8a, 0x31, 0xf7, 0x71, 0xbd, 0x93, 0xc7, 0x5c, 0x7c, 0x3f, 0x89, 0xb9, 0x18, + 0x9d, 0x30, 0xe6, 0xbf, 0x2f, 0x43, 0x8f, 0xfb, 0xa1, 0xd1, 0xc0, 0xb1, 0x0d, 0x12, 0xd1, 0xa7, + 0x36, 0x35, 0xe8, 0xdb, 0x6e, 0xe5, 0x1e, 0x34, 0x0f, 0xef, 0xa1, 0xb7, 0x6a, 0x0f, 0x99, 0xb3, + 0x1a, 0xf8, 0x99, 0xe3, 0xf7, 0x61, 0x4d, 0x5a, 0xe8, 0x82, 0x93, 0xd0, 0xf7, 0xe6, 0x9d, 0xcb, + 0xab, 0xd6, 0x78, 0x8a, 0x16, 0x5a, 0x5b, 0x8e, 0xc5, 0x50, 0xb9, 0x0b, 0x17, 0x79, 0x61, 0x87, + 0x81, 0xee, 0x07, 0x94, 0x91, 0xc8, 0xcf, 0x8a, 0xb1, 0x8c, 0x15, 0xd7, 0x21, 0xe1, 0xfe, 0x28, + 0x78, 0x22, 0x95, 0x49, 0x55, 0x6e, 0x41, 0x1b, 0xa7, 0xd9, 0x96, 0x47, 0xa2, 0x98, 0x51, 0x24, + 0x84, 0x96, 0xd6, 0xe2, 0xc6, 0x89, 0x4c, 0xf9, 0x08, 0x3a, 0x04, 0x43, 0x44, 0x4d, 0xfe, 0x01, + 0xea, 0x99, 0x81, 0xcf, 0x03, 0x5c, 0xc5, 0x85, 0x95, 0x44, 0x37, 0x0a, 0x3e, 0x95, 0x1a, 0xe5, + 0x1e, 0x5c, 0xcd, 0xcf, 0x38, 0xe4, 0x52, 0x0d, 0x67, 0x5e, 0xca, 0x66, 0x2e, 0xfb, 0x75, 0x1b, + 0x94, 0x6c, 0x81, 0xd4, 0xb9, 0x3a, 0x3a, 0x77, 0x2e, 0x9d, 0x96, 0x7a, 0xb8, 0xf4, 0x3d, 0x22, + 0x01, 0x4d, 0xbf, 0xd7, 0x58, 0xfe, 0x5e, 0x02, 0x79, 0xf2, 0xbd, 0x9b, 0xb0, 0x46, 0x0f, 0x02, + 0x9b, 0x51, 0x53, 0x9f, 0x52, 0xdb, 0x9a, 0x46, 0x48, 0x4a, 0x65, 0xad, 0x2d, 0xa5, 0x9f, 0xa1, + 0x50, 0xfd, 0x51, 0x11, 0x3a, 0x1c, 0xfc, 0xef, 0x05, 0x8e, 0x4f, 0x4c, 0x81, 0xe6, 0x9b, 0x66, + 0xcd, 0x5d, 0xb8, 0x28, 0x8f, 0x0a, 0x1d, 0xcf, 0x0a, 0x7d, 0x42, 0x5c, 0xdb, 0x99, 0xeb, 0xb6, + 0x89, 0x19, 0xd4, 0xd6, 0x3a, 0x52, 0x3d, 0xe4, 0xda, 0x87, 0xa8, 0xdc, 0x33, 0x97, 0x93, 0xad, + 0x74, 0x0a, 0xc9, 0x56, 0x7e, 0xcd, 0x64, 0x53, 0xff, 0x5a, 0x14, 0xd4, 0xa5, 0xd1, 0x30, 0x76, + 0xc9, 0xd8, 0xa1, 0xa7, 0x11, 0x8f, 0x77, 0xa1, 0x8a, 0x2e, 0x40, 0xd5, 0x9f, 0x4c, 0x42, 0x2a, + 0x0e, 0xce, 0xb2, 0x26, 0x47, 0x5c, 0xee, 0x50, 0xcf, 0x8a, 0xa6, 0x58, 0x1f, 0x65, 0x4d, 0x8e, + 0x94, 0xab, 0xd0, 0x30, 0x7c, 0x37, 0x70, 0x68, 0x44, 0x4d, 0x2c, 0x87, 0xba, 0x96, 0x09, 0x8e, + 0x43, 0xb8, 0x76, 0x34, 0xc2, 0xea, 0xdf, 0x4b, 0x70, 0xe1, 0x30, 0x49, 0xbd, 0xcf, 0x61, 0x1d, + 0xc0, 0x46, 0x48, 0x0d, 0xdf, 0x33, 0x09, 0x9b, 0x27, 0x35, 0x49, 0x79, 0xde, 0x95, 0x38, 0x7f, + 0xa4, 0xaa, 0xfb, 0x89, 0x46, 0xf9, 0x18, 0x3a, 0xd9, 0x84, 0xb4, 0xfe, 0xc3, 0x6e, 0x65, 0xb3, + 0xb4, 0xdd, 0xd2, 0xb2, 0xc5, 0x52, 0x06, 0x40, 0xe8, 0x42, 0x4a, 0x9c, 0x14, 0x07, 0x39, 0xe2, + 0x20, 0x58, 0x8e, 0x3f, 0x26, 0x8e, 0xbe, 0x88, 0x45, 0x06, 0x82, 0x50, 0x7f, 0x91, 0x83, 0x62, + 0xcf, 0x5c, 0x74, 0x39, 0x61, 0x3c, 0xde, 0xd8, 0x2c, 0xba, 0x9c, 0x30, 0x1e, 0xdf, 0x63, 0xc7, + 0xf3, 0x23, 0x9d, 0xcc, 0x88, 0xed, 0xf0, 0x92, 0xe0, 0x3c, 0x64, 0x9b, 0x07, 0x48, 0x3d, 0x15, + 0xed, 0x9c, 0xe7, 0x47, 0xf7, 0x13, 0xd5, 0x28, 0xd8, 0x33, 0x0f, 0xd4, 0x5f, 0x96, 0x04, 0x97, + 0x68, 0xd4, 0xf0, 0x67, 0x94, 0xbd, 0xf7, 0x20, 0x5f, 0x87, 0x66, 0x48, 0x2d, 0x97, 0x7a, 0x11, + 0xee, 0xbb, 0x8c, 0xc1, 0x05, 0x29, 0xda, 0x33, 0x0f, 0x94, 0xf3, 0x50, 0xa5, 0x06, 0xea, 0x44, + 0xd7, 0x59, 0xa1, 0x06, 0x17, 0x5f, 0x03, 0x08, 0xf8, 0xde, 0xf5, 0xd0, 0x7e, 0x41, 0x11, 0xbc, + 0xb2, 0xd6, 0x40, 0xc9, 0xc8, 0x7e, 0x41, 0x79, 0x89, 0x65, 0x07, 0x40, 0x0d, 0x0f, 0x80, 0x4c, + 0xc0, 0xb5, 0x4c, 0xc4, 0x8f, 0x9a, 0x78, 0x3c, 0xd4, 0xb5, 0x4c, 0xa0, 0xdc, 0x82, 0xb3, 0xe3, + 0xb9, 0x1e, 0xc6, 0x86, 0x41, 0xc3, 0xd0, 0x67, 0x7a, 0x18, 0x20, 0x1c, 0x75, 0xad, 0x3d, 0x9e, + 0x8f, 0x12, 0xe9, 0x28, 0xe0, 0x9e, 0x59, 0x33, 0x8b, 0xa7, 0x04, 0xa0, 0xd7, 0x15, 0x6b, 0x66, + 0xed, 0x99, 0xea, 0x4f, 0xca, 0x29, 0x42, 0xd4, 0x9e, 0xd1, 0xff, 0x7d, 0x84, 0x6e, 0xc2, 0x1a, + 0xa3, 0x66, 0xec, 0x99, 0xc4, 0x33, 0xe6, 0x39, 0xa4, 0xda, 0x99, 0x74, 0x35, 0x62, 0xa5, 0x3c, + 0x62, 0x37, 0x61, 0x4d, 0xa8, 0x8d, 0x29, 0x35, 0xf6, 0xc3, 0xd8, 0x95, 0xb0, 0xb5, 0x51, 0xba, + 0x23, 0x85, 0x8b, 0xc0, 0xd6, 0x97, 0x81, 0xcd, 0xca, 0xb9, 0xb1, 0x50, 0xce, 0x97, 0xa1, 0x3e, + 0xb1, 0x3d, 0x3b, 0x9c, 0x52, 0x01, 0x56, 0x5d, 0x4b, 0xc7, 0xc7, 0x95, 0x7a, 0xf3, 0x98, 0x52, + 0xff, 0x00, 0xd6, 0x65, 0xaf, 0x2c, 0x3a, 0x5f, 0xdb, 0xf7, 0xba, 0x2d, 0x5c, 0xfa, 0xac, 0x90, + 0x3f, 0x4a, 0xc4, 0xea, 0xcf, 0x4b, 0xa0, 0x70, 0x60, 0x47, 0x94, 0x38, 0xef, 0xff, 0x69, 0xf7, + 0x9f, 0xa0, 0xe5, 0x63, 0x30, 0xa9, 0xbe, 0x3e, 0xfd, 0xd6, 0x8e, 0xa2, 0x5f, 0xf5, 0x77, 0x45, + 0x71, 0x68, 0xee, 0xfa, 0xcf, 0xbd, 0x77, 0xa0, 0x17, 0xb9, 0x07, 0xcd, 0xfc, 0xfd, 0xeb, 0x98, + 0x2e, 0x2d, 0xbb, 0x66, 0x69, 0x30, 0xce, 0xee, 0x8f, 0x6f, 0xdf, 0xa5, 0x29, 0xeb, 0x50, 0x72, + 0xfc, 0xe7, 0x58, 0xc2, 0x25, 0x8d, 0xff, 0xc9, 0xef, 0xe0, 0x53, 0xdb, 0x9a, 0xca, 0x92, 0xc5, + 0xbf, 0xd5, 0xdf, 0x96, 0xe0, 0x7c, 0x3e, 0x70, 0xff, 0x5d, 0x96, 0x7b, 0x17, 0xe2, 0x76, 0x03, + 0x5a, 0xd4, 0xc3, 0x23, 0x1c, 0x09, 0x0c, 0x03, 0x58, 0xd7, 0x9a, 0x42, 0x86, 0xf4, 0xc5, 0x19, + 0x30, 0xf2, 0x23, 0xe2, 0x2c, 0x9c, 0x59, 0x28, 0x41, 0x06, 0xbc, 0x02, 0x82, 0x0e, 0xf5, 0x7d, + 0x3a, 0x97, 0x77, 0x9d, 0x3a, 0x0a, 0xbe, 0x43, 0xf1, 0xad, 0x44, 0x28, 0x65, 0xa7, 0x59, 0xc7, + 0xd9, 0x4d, 0x94, 0x3d, 0x11, 0xed, 0x66, 0x6a, 0x22, 0x9b, 0xce, 0x46, 0xce, 0xe4, 0xbb, 0x28, + 0x52, 0xbf, 0x92, 0x4d, 0xe2, 0xce, 0x94, 0x38, 0xdc, 0x8a, 0xfe, 0x1f, 0xb7, 0xa5, 0xe3, 0xad, + 0x72, 0x82, 0xe3, 0xad, 0xba, 0xea, 0x78, 0xbb, 0x09, 0x6b, 0xb6, 0x17, 0x51, 0x8b, 0xd9, 0xd1, + 0x5c, 0x9f, 0x92, 0x70, 0x9a, 0x9c, 0x5f, 0xa9, 0xf4, 0x33, 0x12, 0x4e, 0xb3, 0x53, 0x10, 0x4d, + 0xea, 0x48, 0x81, 0x02, 0x76, 0x54, 0xdf, 0x82, 0xb3, 0x42, 0x6d, 0x92, 0x88, 0x88, 0x3c, 0x69, + 0x60, 0xd9, 0x89, 0x63, 0x70, 0x97, 0x44, 0x84, 0xe7, 0x8a, 0xfa, 0x8b, 0x22, 0xac, 0x73, 0x34, + 0x86, 0x3b, 0x6f, 0x47, 0x59, 0x1f, 0x82, 0x12, 0x46, 0x84, 0x45, 0xfa, 0xd8, 0xf1, 0x8d, 0x7d, + 0xdd, 0x8b, 0xdd, 0x31, 0x65, 0x88, 0x64, 0x59, 0x5b, 0x47, 0xcd, 0x03, 0xae, 0x78, 0x8c, 0x72, + 0x65, 0x1b, 0xd6, 0xa9, 0x67, 0x2e, 0xda, 0x96, 0xd0, 0x76, 0x8d, 0x7a, 0x66, 0xde, 0xf2, 0x23, + 0xe8, 0x18, 0x31, 0x63, 0x3c, 0xaa, 0x0b, 0xd6, 0xe2, 0x82, 0xa4, 0x48, 0x5d, 0x7e, 0xc6, 0x27, + 0x70, 0xc1, 0x21, 0x61, 0xa4, 0x9b, 0x14, 0xaf, 0x41, 0xe9, 0xfb, 0x8e, 0x29, 0x2f, 0x4f, 0x1b, + 0x5c, 0xbb, 0x2b, 0x94, 0x32, 0x9d, 0x4c, 0xa5, 0x0b, 0x35, 0x16, 0x7b, 0x9e, 0xed, 0x59, 0xb2, + 0x7f, 0x4f, 0x86, 0xea, 0x9f, 0x0b, 0x82, 0xa0, 0x86, 0x3b, 0x5f, 0xfa, 0xee, 0xd8, 0x7e, 0xbb, + 0x44, 0xcf, 0x7d, 0xa6, 0xb8, 0xf0, 0x19, 0x8e, 0x97, 0x88, 0x5f, 0xe6, 0xae, 0x08, 0x48, 0x1b, + 0xc5, 0xa9, 0xa3, 0x2a, 0xb4, 0x79, 0xe4, 0x32, 0x2b, 0x11, 0x88, 0x26, 0xf5, 0xb2, 0xcd, 0xe4, + 0x9b, 0x94, 0xca, 0x62, 0x93, 0xa2, 0xfe, 0xb8, 0x00, 0x6b, 0x62, 0x3b, 0x8f, 0x68, 0x44, 0xde, + 0x74, 0x1f, 0xd7, 0xa1, 0x99, 0xa0, 0xc2, 0xf3, 0x58, 0xc0, 0x0c, 0x52, 0xc4, 0x93, 0xf8, 0x06, + 0xb4, 0x44, 0xfc, 0x75, 0xc3, 0x8f, 0xe5, 0x63, 0x58, 0x59, 0x6b, 0x0a, 0xd9, 0x0e, 0x17, 0xa9, + 0x3f, 0x2b, 0x8b, 0x66, 0x46, 0x3e, 0xff, 0x0d, 0xbf, 0x18, 0xbe, 0xa9, 0x37, 0x57, 0xa0, 0x91, + 0x54, 0xbf, 0x29, 0x7d, 0xa9, 0xcb, 0xda, 0x36, 0x95, 0x5d, 0xa8, 0x85, 0xcc, 0xd0, 0xad, 0x99, + 0x25, 0x69, 0xe1, 0x5b, 0xf9, 0x92, 0xce, 0xbf, 0x96, 0xf7, 0x87, 0x87, 0x5a, 0x01, 0xad, 0x1a, + 0x32, 0x63, 0x38, 0xb3, 0x94, 0x87, 0x50, 0x37, 0x69, 0x18, 0xe1, 0x32, 0xe5, 0xd7, 0x5f, 0xa6, + 0xc6, 0x27, 0xf3, 0x75, 0x4e, 0xd8, 0xe2, 0xde, 0x05, 0xfe, 0x61, 0x7e, 0x61, 0xa8, 0xae, 0xa0, + 0xb2, 0xa0, 0x3f, 0x92, 0xcc, 0xc3, 0xfc, 0x99, 0x6d, 0x52, 0xa6, 0x55, 0x42, 0x66, 0x8c, 0x02, + 0xde, 0xed, 0x60, 0xea, 0xcb, 0x27, 0xd4, 0x7c, 0x9a, 0xd4, 0x30, 0x2c, 0x1d, 0xae, 0x96, 0x01, + 0x5f, 0x9d, 0x2f, 0xf5, 0xa5, 0xa6, 0xf6, 0x3a, 0x34, 0xc5, 0x1b, 0x94, 0x78, 0xed, 0x17, 0x1c, + 0x02, 0x42, 0x84, 0xaf, 0xfd, 0x0b, 0x7d, 0x34, 0x2c, 0xf7, 0xd1, 0xfd, 0xf4, 0x41, 0xd8, 0xd4, + 0xc7, 0xf3, 0x88, 0x86, 0x82, 0x8a, 0x9a, 0xe8, 0x4d, 0xf2, 0xd4, 0x6b, 0x3e, 0xe0, 0x1a, 0xa4, + 0xa3, 0x7f, 0xc8, 0x17, 0x2e, 0xe9, 0xe3, 0x7b, 0x7f, 0xe7, 0xe1, 0x65, 0x8d, 0x40, 0x66, 0xcf, + 0x96, 0xe2, 0x3d, 0xb4, 0x8d, 0x88, 0xa5, 0x2f, 0x96, 0xa7, 0x75, 0x78, 0x7c, 0x13, 0xce, 0xd9, + 0xa1, 0xbe, 0x70, 0x9f, 0x10, 0xd7, 0xd6, 0xba, 0x76, 0xd6, 0x0e, 0x1f, 0xe4, 0xee, 0x13, 0x54, + 0xfd, 0x75, 0x11, 0x2e, 0x09, 0x2a, 0x78, 0xb0, 0x78, 0xcf, 0xf8, 0xb7, 0xd4, 0xe1, 0x07, 0x70, + 0x0e, 0x73, 0xd3, 0x32, 0x0e, 0x51, 0xdc, 0x1a, 0x57, 0x0c, 0x8d, 0x34, 0x1f, 0xb7, 0x60, 0x2d, + 0x31, 0x95, 0xf7, 0x62, 0x49, 0x72, 0xc2, 0x6e, 0xc8, 0x6f, 0xc7, 0xc7, 0x91, 0x1c, 0x27, 0x49, + 0xd1, 0x1f, 0xf1, 0xe9, 0x5e, 0xec, 0xca, 0x16, 0xa9, 0x89, 0xc2, 0xe1, 0xcc, 0x7a, 0x1c, 0xbb, + 0xca, 0x6d, 0xd8, 0xb0, 0x0c, 0x3d, 0x99, 0x92, 0x5a, 0x8a, 0x3a, 0x59, 0xb7, 0x8c, 0x87, 0x52, + 0x23, 0xcc, 0xd5, 0xdf, 0x14, 0xe1, 0x22, 0xdf, 0xee, 0x52, 0xa8, 0x30, 0x4f, 0x16, 0xf6, 0x5d, + 0x58, 0xda, 0x77, 0xde, 0xcf, 0xe2, 0x92, 0x9f, 0x47, 0x54, 0x47, 0xe9, 0x88, 0xea, 0x50, 0xbe, + 0x0d, 0x48, 0x24, 0x9c, 0x17, 0xca, 0x27, 0xe2, 0x85, 0x2a, 0x37, 0x47, 0x62, 0x48, 0xf8, 0xa4, + 0xf2, 0x3a, 0x7c, 0xb2, 0x54, 0xfc, 0xd5, 0xe3, 0x8b, 0x7f, 0xf9, 0x75, 0x44, 0xfd, 0x53, 0x11, + 0x36, 0xb2, 0x98, 0x7d, 0x1e, 0xfb, 0x11, 0xf9, 0xd7, 0xf1, 0xea, 0x40, 0xc5, 0xf5, 0xbd, 0x68, + 0x8a, 0xc1, 0x6a, 0x68, 0x62, 0xc0, 0x3d, 0x91, 0x53, 0x3c, 0x22, 0x7f, 0x74, 0x6c, 0x24, 0x0d, + 0xdc, 0x63, 0xe2, 0x52, 0xde, 0x7f, 0x30, 0x4a, 0x4c, 0xdd, 0xf0, 0xbd, 0x30, 0x76, 0xf1, 0xd9, + 0xfe, 0x05, 0x95, 0x79, 0xb3, 0xce, 0x35, 0x3b, 0x52, 0x21, 0x03, 0xd9, 0x9d, 0x30, 0x4a, 0xf5, + 0x1f, 0x72, 0x9f, 0x96, 0xe6, 0x88, 0x2e, 0xe1, 0x3c, 0xd7, 0xa3, 0xcb, 0x0b, 0x13, 0x6f, 0xc1, + 0xd9, 0xdc, 0xc4, 0x5c, 0xfb, 0xdd, 0x4e, 0xed, 0xd1, 0xee, 0x43, 0x50, 0x8c, 0x29, 0x61, 0x16, + 0x35, 0xf3, 0xa6, 0x32, 0xb9, 0xa4, 0x26, 0xb3, 0xde, 0x82, 0x36, 0x71, 0x1c, 0xff, 0x79, 0x5a, + 0xb1, 0x82, 0x85, 0x5b, 0x28, 0x4c, 0x7e, 0x1e, 0xfb, 0xfe, 0x1f, 0x5f, 0xf6, 0x0a, 0x5f, 0xbf, + 0xec, 0x15, 0xfe, 0xf6, 0xb2, 0x57, 0xf8, 0xe9, 0xab, 0xde, 0x99, 0xaf, 0x5f, 0xf5, 0xce, 0xfc, + 0xe5, 0x55, 0xef, 0xcc, 0x97, 0xbb, 0x96, 0x1d, 0x4d, 0xe3, 0x71, 0xdf, 0xf0, 0xdd, 0xc1, 0xd8, + 0x1b, 0xdf, 0x36, 0xa6, 0xc4, 0xf6, 0x06, 0x19, 0xc2, 0xb7, 0x25, 0x27, 0xdd, 0x0e, 0x24, 0xbe, + 0x83, 0x15, 0x3f, 0x80, 0x8f, 0xab, 0xf8, 0x33, 0xf1, 0x27, 0xff, 0x0c, 0x00, 0x00, 0xff, 0xff, + 0x08, 0xc1, 0xd6, 0x95, 0x1e, 0x1f, 0x00, 0x00, } func (m *GfSpTask) Marshal() (dAtA []byte, err error) { @@ -2835,6 +2853,21 @@ func (m *GfSpRecoverPieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.GvgId != 0 { + i = encodeVarintTask(dAtA, i, uint64(m.GvgId)) + i-- + dAtA[i] = 0x50 + } + if m.BySuccessorSp { + i-- + if m.BySuccessorSp { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } if m.Recovered { i-- if m.Recovered { @@ -4301,6 +4334,12 @@ func (m *GfSpRecoverPieceTask) Size() (n int) { if m.Recovered { n += 2 } + if m.BySuccessorSp { + n += 2 + } + if m.GvgId != 0 { + n += 1 + sovTask(uint64(m.GvgId)) + } return n } @@ -6845,6 +6884,45 @@ func (m *GfSpRecoverPieceTask) Unmarshal(dAtA []byte) error { } } m.Recovered = bool(v != 0) + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BySuccessorSp", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTask + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.BySuccessorSp = bool(v != 0) + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GvgId", wireType) + } + m.GvgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTask + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GvgId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) diff --git a/cmd/command/recovery.go b/cmd/command/recovery.go index 5cfcf5f69..bbe26490b 100644 --- a/cmd/command/recovery.go +++ b/cmd/command/recovery.go @@ -19,12 +19,13 @@ import ( ) const ( - maxRecoveryRetry = 3 - MaxRecoveryTime = 50 - recoveryCommands = "RECOVERY COMMANDS" - MaxRecoveryJob = 1000 - FullQueueWaitTime = 5 * time.Second - RecoveryJobSyncTime = 30 * time.Second + maxRecoveryRetry = 3 + MaxRecoveryTime = 50 + recoveryCommands = "RECOVERY COMMANDS" + MaxRecoveryJob = 1000 + MaxCurrentRecoveryObjects = 500 + FullQueueWaitTime = 5 * time.Second + RecoveryJobSyncTime = 30 * time.Second ) var bucketFlag = &cli.StringFlag{ @@ -93,11 +94,11 @@ func recoverObjectAction(ctx *cli.Context) error { objectNames := ctx.String(objectListFlag.Name) objectNameList := strings.Split(objectNames, "//") for _, objectName := range objectNameList { - recoverObject(bucketName, objectName, cfg, client) + recoverObject(bucketName, objectName, cfg, client, false, 0) } } else { objectName := ctx.String(objectFlag.Name) - recoverObject(bucketName, objectName, cfg, client) + recoverObject(bucketName, objectName, cfg, client, false, 0) } taskCheckTicker := time.NewTicker(RecoveryJobSyncTime) @@ -117,7 +118,7 @@ func recoverObjectAction(ctx *cli.Context) error { return nil } -func recoverObject(bucketName string, objectName string, cfg *gfspconfig.GfSpConfig, client *gfspclient.GfSpClient) error { +func recoverObject(bucketName string, objectName string, cfg *gfspconfig.GfSpConfig, client *gfspclient.GfSpClient, bySuccessorSP bool, exitSPIdx int) error { var ( replicateIdx int processingCount uint32 @@ -137,9 +138,14 @@ func recoverObject(bucketName string, objectName string, cfg *gfspconfig.GfSpCon return err } - replicateIdx, err = getReplicateIdxBySP(bucketInfo, objectInfo, cfg) - if err != nil { - return err + if bySuccessorSP { + replicateIdx = exitSPIdx + } else { + replicateIdx, err = getReplicateIdxBySP(bucketInfo, objectInfo, cfg) + if err != nil { + fmt.Printf("get replicate idx by sp failed, err=%s", err.Error()) + return err + } } maxSegmentSize := storageParams.GetMaxSegmentSize() @@ -151,6 +157,7 @@ func recoverObject(bucketName string, objectName string, cfg *gfspconfig.GfSpCon for segmentIdx := uint32(0); segmentIdx < segmentCount; segmentIdx++ { task := &gfsptask.GfSpRecoverPieceTask{} task.InitRecoverPieceTask(objectInfo, storageParams, coretask.DefaultSmallerPriority, segmentIdx, int32(-1), maxSegmentSize, MaxRecoveryTime, maxRecoveryRetry) + task.SetBySuccessorSP(bySuccessorSP) err = client.ReportTask(context.Background(), task) time.Sleep(time.Second) } @@ -160,6 +167,7 @@ func recoverObject(bucketName string, objectName string, cfg *gfspconfig.GfSpCon for segmentIdx := uint32(0); segmentIdx < segmentCount; segmentIdx++ { task := &gfsptask.GfSpRecoverPieceTask{} task.InitRecoverPieceTask(objectInfo, storageParams, coretask.DefaultSmallerPriority, segmentIdx, int32(replicateIdx), maxSegmentSize, MaxRecoveryTime, maxRecoveryRetry) + task.SetBySuccessorSP(bySuccessorSP) err = client.ReportTask(context.Background(), task) time.Sleep(time.Second) } diff --git a/cmd/command/sp_exit.go b/cmd/command/sp_exit.go new file mode 100644 index 000000000..0476ecad3 --- /dev/null +++ b/cmd/command/sp_exit.go @@ -0,0 +1,77 @@ +package command + +import ( + "fmt" + + "github.com/bnb-chain/greenfield-storage-provider/cmd/utils" + virtualgrouptypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" + + "github.com/urfave/cli/v2" +) + +const spExitCommands = "Sp Exit Commands" + +var SpExitCmd = &cli.Command{ + Action: SpExitAction, + Name: "spExit", + Usage: "sp exit", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + }, + Category: spExitCommands, + Description: `Running this command sends exit tx to the chain and cannot be canceled after execution`, +} + +func SpExitAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + + msg := &virtualgrouptypes.MsgStorageProviderExit{ + StorageProvider: cfg.SpAccount.SpOperatorAddress, + } + + spClient := utils.MakeGfSpClient(cfg) + tx, err := spClient.SpExit(ctx.Context, msg) + if err != nil { + println(err.Error()) + return err + } + fmt.Printf("tx successfully! tx_hash:%s", tx) + return nil +} + +var CompleteSpExitCmd = &cli.Command{ + Action: CompleteSpExitAction, + Name: "completeSpExit", + Usage: "complete sp exit", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + }, + Category: spExitCommands, + Description: `When Successor has recovered all resources, you can use this CMD to complete the exit`, +} + +func CompleteSpExitAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + + msg := &virtualgrouptypes.MsgCompleteStorageProviderExit{ + StorageProvider: cfg.SpAccount.SpOperatorAddress, + Operator: cfg.SpAccount.SpOperatorAddress, + } + + spClient := utils.MakeGfSpClient(cfg) + tx, err := spClient.CompleteSpExit(ctx.Context, msg) + if err != nil { + println(err.Error()) + return err + } + fmt.Printf("tx successfully! tx_hash:%s", tx) + return nil +} diff --git a/cmd/command/swap_in.go b/cmd/command/swap_in.go new file mode 100644 index 000000000..237e87ccd --- /dev/null +++ b/cmd/command/swap_in.go @@ -0,0 +1,422 @@ +package command + +import ( + "encoding/json" + "errors" + "fmt" + "os" + + "github.com/bnb-chain/greenfield-storage-provider/cmd/utils" + virtualgrouptypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" + + "github.com/urfave/cli/v2" +) + +const swapInCommands = "SwapIn Commands" + +var gvgIDFlag = &cli.Uint64Flag{ + Name: "gvgId", + Usage: "assign global virtual group id", + Aliases: []string{"gid"}, + Required: true, +} + +var vgfIDFlag = &cli.Uint64Flag{ + Name: "vgf", + Usage: "assign global virtual group family id", + Aliases: []string{"f"}, + Required: true, +} + +var targetSPIDFlag = &cli.Uint64Flag{ + Name: "targetSP", + Usage: "assign target sp", + Aliases: []string{"sp"}, + Required: true, +} + +var SwapInCmd = &cli.Command{ + Action: SwapInAction, + Name: "swapIn", + Usage: "Successor swap in GVG/VGF", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + gvgIDFlag, + vgfIDFlag, + targetSPIDFlag, + }, + Category: swapInCommands, + Description: `You can use this command if you know that an sp is exiting and are ready to take over` + + `This command is for the transaction that sends a Swap In the chain`, +} + +var RecoverGVGCmd = &cli.Command{ + Action: RecoverGVGAction, + Name: "recover-gvg", + Usage: "recover object in gvg", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + gvgIDFlag, + }, + Category: swapInCommands, + Description: `After determining a successful successor you can use the "recover-gvg" CMD` + + `This command notifies sp and causes sp to recover resource` + + `Resources include all resources that exit sp serves as the secondary sp in gvg`, +} + +var RecoverVGFCmd = &cli.Command{ + Action: RecoverVGFAction, + Name: "recover-vgf", + Usage: "recover objects in vgf", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + vgfIDFlag, + }, + Category: swapInCommands, + Description: `After determining a successful successor you can use the "recover-gvg" CMD` + + `This command notifies sp and causes sp to recover resource` + + `Resources include all resources that exit sp serves as the primary sp in gvg family`, +} + +var CompleteSwapInCmd = &cli.Command{ + Action: CompleteSwapInAction, + Name: "completeSwapIn", + Usage: "complete swap in", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + gvgIDFlag, + vgfIDFlag, + }, + Category: swapInCommands, + Description: `After confirming that the recover resource is complete, send a complete swap in to the chain using the completeSwapIn command`, +} + +var CancelSwapInCmd = &cli.Command{ + Action: CancelSwapInAction, + Name: "cancelSwapIn", + Usage: "cancel swap in", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + gvgIDFlag, + vgfIDFlag, + }, + Category: swapInCommands, +} + +var QueryRecoverProcessCmd = &cli.Command{ + Action: QueryRecoverProcessAction, + Name: "query-recover-p", + Usage: "query recover process", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + gvgIDFlag, + vgfIDFlag, + }, + Category: swapInCommands, + Description: `It is used to query the recovery resource progress. The progress is displayed in std and recover_process.json`, +} + +var ListGlobalVirtualGroupsBySecondarySPCmd = &cli.Command{ + Action: ListGlobalVirtualGroupsBySecondarySPAction, + Name: "query-gvg-by-sp", + Usage: "get GlobalVirtualGroups List By SecondarySP", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + targetSPIDFlag, + }, + Category: swapInCommands, + Description: `get GlobalVirtualGroups List By SecondarySP`, +} + +var ListVirtualGroupFamiliesBySpIDCmd = &cli.Command{ + Action: ListVirtualGroupFamiliesBySpIDAction, + Name: "query-vgf-by-sp", + Usage: "get VirtualGroupFamily List By SpID", + Flags: []cli.Flag{ + utils.ConfigFileFlag, + targetSPIDFlag, + }, + Category: swapInCommands, + Description: `get VirtualGroupFamily List By SpID`, +} + +func SwapInAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + + targetSpID := ctx.Uint64(targetSPIDFlag.Name) + gvgID := ctx.Uint64(gvgIDFlag.Name) + gvgfID := ctx.Uint64(vgfIDFlag.Name) + + reserveSwapIn := &virtualgrouptypes.MsgReserveSwapIn{ + TargetSpId: uint32(targetSpID), + GlobalVirtualGroupFamilyId: uint32(gvgfID), + GlobalVirtualGroupId: uint32(gvgID), + StorageProvider: cfg.SpAccount.SpOperatorAddress, + } + + spClient := utils.MakeGfSpClient(cfg) + tx, err := spClient.ReserveSwapIn(ctx.Context, reserveSwapIn) + if err != nil { + println(err.Error()) + return err + } + fmt.Printf("tx successfully! tx_hash:%s", tx) + return nil +} + +func CompleteSwapInAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + + gvgID := ctx.Uint64(gvgIDFlag.Name) + gvgfID := ctx.Uint64(vgfIDFlag.Name) + + completeSwapIn := &virtualgrouptypes.MsgCompleteSwapIn{ + GlobalVirtualGroupFamilyId: uint32(gvgfID), + GlobalVirtualGroupId: uint32(gvgID), + StorageProvider: cfg.SpAccount.SpOperatorAddress, + } + + spClient := utils.MakeGfSpClient(cfg) + tx, err := spClient.CompleteSwapIn(ctx.Context, completeSwapIn) + if err != nil { + println(err.Error()) + return err + } + fmt.Printf("tx successfully! tx_hash:%s", tx) + return nil +} + +func RecoverGVGAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + + // get client + chainClient, err := utils.MakeGnfd(cfg) + if err != nil { + println(err.Error()) + return err + } + spClient := utils.MakeGfSpClient(cfg) + + // check swapIn info + sp, err := chainClient.QuerySP(ctx.Context, cfg.SpAccount.SpOperatorAddress) + if err != nil { + println(err.Error()) + return err + } + gvgID := ctx.Uint64(gvgIDFlag.Name) + swapInInfo, err := chainClient.QuerySwapInInfo(ctx.Context, 0, uint32(gvgID)) + if err != nil { + println(err.Error()) + return err + } + if swapInInfo.GetSuccessorSpId() != sp.GetId() { + println("sp is not successor sp") + return errors.New("sp is not successor sp") + } + + //get replicateIndex + gvgInfo, err := spClient.GetGlobalVirtualGroupByGvgID(ctx.Context, uint32(gvgID)) + if err != nil { + println(err.Error()) + return err + } + var replicateIndex int32 + for idx, sspID := range gvgInfo.SecondarySpIds { + if sspID == swapInInfo.TargetSpId { + replicateIndex = int32(idx) + } + } + + _, executing, err := spClient.QueryRecoverProcess(ctx.Context, uint32(0), uint32(gvgID)) + if err != nil { + println(err.Error()) + return err + } + if executing { + println("Please wait until the previous recover work is completed") + return nil + } + + err = spClient.TriggerRecoverForSuccessorSP(ctx.Context, 0, uint32(gvgID), replicateIndex) + if err != nil { + println(err.Error()) + return err + } + println("Trigger successfully! please waiting process") + return nil +} + +func RecoverVGFAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + + // get client + chainClient, err := utils.MakeGnfd(cfg) + if err != nil { + println(err.Error()) + return err + } + spClient := utils.MakeGfSpClient(cfg) + + // check swapIn info + sp, err := chainClient.QuerySP(ctx.Context, cfg.SpAccount.SpOperatorAddress) + if err != nil { + println(err.Error()) + return err + } + vgfID := ctx.Uint64(vgfIDFlag.Name) + swapInInfo, err := chainClient.QuerySwapInInfo(ctx.Context, uint32(vgfID), 0) + if err != nil { + println(err.Error()) + return err + } + if swapInInfo.GetSuccessorSpId() != sp.GetId() { + println("sp is not successor sp") + return errors.New("sp is not successor sp") + } + + _, executing, err := spClient.QueryRecoverProcess(ctx.Context, uint32(vgfID), uint32(0)) + if err != nil { + println(err.Error()) + return err + } + if executing { + println("Please wait until the previous recover work is completed") + return nil + } + + // trigger + err = spClient.TriggerRecoverForSuccessorSP(ctx.Context, uint32(vgfID), 0, -1) + if err != nil { + println(err.Error()) + return err + } + println("Trigger successfully! please waiting process") + return nil +} + +func QueryRecoverProcessAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + spClient := utils.MakeGfSpClient(cfg) + gvgID := ctx.Uint64(gvgIDFlag.Name) + gvgfID := ctx.Uint64(vgfIDFlag.Name) + gvgstatsList, executing, err := spClient.QueryRecoverProcess(ctx.Context, uint32(gvgfID), uint32(gvgID)) + if err != nil { + println(err.Error()) + return err + } + if executing { + println("Please Wait, recover executing") + } else { + println("recover progress：") + } + + res, err := json.Marshal(gvgstatsList) + if err != nil { + println(err.Error()) + return err + } + println(string(res)) + // create file + f, err := os.Create("recover_process.json") + if err != nil { + println(err.Error()) + return err + } + + _, err = fmt.Fprintln(f, string(res)) + if err != nil { + println(err.Error()) + return err + } + return nil +} + +func ListGlobalVirtualGroupsBySecondarySPAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + spClient := utils.MakeGfSpClient(cfg) + spID := ctx.Uint64(targetSPIDFlag.Name) + res, err := spClient.ListGlobalVirtualGroupsBySecondarySP(ctx.Context, uint32(spID)) + if err != nil { + println(err.Error()) + return err + } + resJson, err := json.Marshal(res) + if err != nil { + println(err.Error()) + return err + } + println(string(resJson)) + return nil +} + +func ListVirtualGroupFamiliesBySpIDAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + spClient := utils.MakeGfSpClient(cfg) + spID := ctx.Uint64(targetSPIDFlag.Name) + res, err := spClient.ListVirtualGroupFamiliesSpID(ctx.Context, uint32(spID)) + if err != nil { + println(err.Error()) + return err + } + resJson, err := json.Marshal(res) + if err != nil { + println(err.Error()) + return err + } + println(string(resJson)) + return nil +} + +func CancelSwapInAction(ctx *cli.Context) error { + cfg, err := utils.MakeConfig(ctx) + if err != nil { + println(err.Error()) + return err + } + + gvgID := ctx.Uint64(gvgIDFlag.Name) + gvgfID := ctx.Uint64(vgfIDFlag.Name) + + cancelSwapIn := &virtualgrouptypes.MsgCancelSwapIn{ + GlobalVirtualGroupFamilyId: uint32(gvgfID), + GlobalVirtualGroupId: uint32(gvgID), + StorageProvider: cfg.SpAccount.SpOperatorAddress, + } + + spClient := utils.MakeGfSpClient(cfg) + tx, err := spClient.CancelSwapIn(ctx.Context, cancelSwapIn) + if err != nil { + println(err.Error()) + return err + } + fmt.Printf("tx successfully! tx_hash:%s", tx) + return nil +} diff --git a/cmd/storage_provider/main.go b/cmd/storage_provider/main.go index 22b9595ab..66e2691f2 100644 --- a/cmd/storage_provider/main.go +++ b/cmd/storage_provider/main.go @@ -131,6 +131,17 @@ func init() { command.SetQuotaCmd, // block syncer bs_data_migration.BsDataMigrationCmd, + // be related to sp exit + command.SpExitCmd, + command.CompleteSpExitCmd, + command.SwapInCmd, + command.CompleteSwapInCmd, + command.CancelSwapInCmd, + command.RecoverGVGCmd, + command.RecoverVGFCmd, + command.QueryRecoverProcessCmd, + command.ListGlobalVirtualGroupsBySecondarySPCmd, + command.ListVirtualGroupFamiliesBySpIDCmd, } registerModular() } diff --git a/core/consensus/consensus.go b/core/consensus/consensus.go index 0241b57c6..bdc178c8f 100644 --- a/core/consensus/consensus.go +++ b/core/consensus/consensus.go @@ -73,6 +73,8 @@ type Consensus interface { ConfirmTransaction(ctx context.Context, txHash string) (*sdk.TxResponse, error) // WaitForNextBlock is used to chain generate a new block. WaitForNextBlock(ctx context.Context) error + // QuerySwapInInfo is used to query the onchain swapIn info + QuerySwapInInfo(ctx context.Context, familyID, gvgID uint32) (*virtualgrouptypes.SwapInInfo, error) // Close the Consensus interface. Close() error } @@ -163,4 +165,8 @@ func (*NullConsensus) ConfirmTransaction(context.Context, string) (*sdk.TxRespon func (*NullConsensus) WaitForNextBlock(context.Context) error { return nil } +func (c *NullConsensus) QuerySwapInInfo(ctx context.Context, familyID, gvgID uint32) (*virtualgrouptypes.SwapInInfo, error) { + return nil, nil +} + func (*NullConsensus) Close() error { return nil } diff --git a/core/consensus/consensus_mock.go b/core/consensus/consensus_mock.go index fbe7bfcb3..e563ed8f9 100644 --- a/core/consensus/consensus_mock.go +++ b/core/consensus/consensus_mock.go @@ -404,6 +404,21 @@ func (mr *MockConsensusMockRecorder) QueryStorageParamsByTimestamp(ctx, timestam return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryStorageParamsByTimestamp", reflect.TypeOf((*MockConsensus)(nil).QueryStorageParamsByTimestamp), ctx, timestamp) } +// QuerySwapInInfo mocks base method. +func (m *MockConsensus) QuerySwapInInfo(ctx context.Context, familyID, gvgID uint32) (*types2.SwapInInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QuerySwapInInfo", ctx, familyID, gvgID) + ret0, _ := ret[0].(*types2.SwapInInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QuerySwapInInfo indicates an expected call of QuerySwapInInfo. +func (mr *MockConsensusMockRecorder) QuerySwapInInfo(ctx, familyID, gvgID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySwapInInfo", reflect.TypeOf((*MockConsensus)(nil).QuerySwapInInfo), ctx, familyID, gvgID) +} + // QueryVirtualGroupFamily mocks base method. func (m *MockConsensus) QueryVirtualGroupFamily(ctx context.Context, vgfID uint32) (*types2.GlobalVirtualGroupFamily, error) { m.ctrl.T.Helper() diff --git a/core/module/modular.go b/core/module/modular.go index c4381b019..4f635ed04 100644 --- a/core/module/modular.go +++ b/core/module/modular.go @@ -233,6 +233,10 @@ type Manager interface { NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, bmStatus *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) // ResetRecoveryFailedList reset failed list for recovery ResetRecoveryFailedList(ctx context.Context) []string + // TriggerRecoverForSuccessorSP is used to trigger recover process + TriggerRecoverForSuccessorSP(ctx context.Context, vgfID, gvgID uint32, redundancyIndex int32) error + // QueryRecoverProcess is used to get recover process + QueryRecoverProcess(ctx context.Context, vgfID, gvgID uint32) ([]*gfspserver.RecoverProcess, bool, error) } // P2P is an abstract interface to the to do replicate piece approvals between SPs. @@ -313,6 +317,12 @@ type Signer interface { SignBucketMigrationInfo(ctx context.Context, task *gfsptask.GfSpBucketMigrationInfo) ([]byte, error) // RejectMigrateBucket rejects the bucket migration by dest SP. RejectMigrateBucket(ctx context.Context, rejectMigrateBucket *storagetypes.MsgRejectMigrateBucket) (string, error) + // ReserveSwapIn reserve swapIn + ReserveSwapIn(ctx context.Context, reserveSwapIn *virtualgrouptypes.MsgReserveSwapIn) (string, error) + // CompleteSwapIn complete swapIn + CompleteSwapIn(ctx context.Context, reserveSwapIn *virtualgrouptypes.MsgCompleteSwapIn) (string, error) + // CancelSwapIn cancel swapIn + CancelSwapIn(ctx context.Context, cancelSwapIn *virtualgrouptypes.MsgCancelSwapIn) (string, error) // Deposit into a Global virtual group for more store size Deposit(ctx context.Context, deposit *virtualgrouptypes.MsgDeposit) (string, error) // DeleteGlobalVirtualGroup rejects the bucket migration by dest SP. diff --git a/core/module/modular_mock.go b/core/module/modular_mock.go index 035f65872..08e5a00fa 100644 --- a/core/module/modular_mock.go +++ b/core/module/modular_mock.go @@ -1,6 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: core/module/modular.go - +// Source: ./modular.go +// +// Generated by this command: +// +// mockgen -source=./modular.go -destination=./modular_mock.go -package=module +// // Package module is a generated GoMock package. package module @@ -65,7 +69,7 @@ func (m *MockModular) ReleaseResource(ctx context.Context, scope rcmgr.ResourceS } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockModularMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockModularMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockModular)(nil).ReleaseResource), ctx, scope) } @@ -80,7 +84,7 @@ func (m *MockModular) ReserveResource(ctx context.Context, state *rcmgr.ScopeSta } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockModularMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockModularMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockModular)(nil).ReserveResource), ctx, state) } @@ -94,7 +98,7 @@ func (m *MockModular) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockModularMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockModularMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockModular)(nil).Start), ctx) } @@ -108,7 +112,7 @@ func (m *MockModular) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockModularMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockModularMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockModular)(nil).Stop), ctx) } @@ -146,7 +150,7 @@ func (m *MockAuthenticator) GetAuthNonce(ctx context.Context, account, domain st } // GetAuthNonce indicates an expected call of GetAuthNonce. -func (mr *MockAuthenticatorMockRecorder) GetAuthNonce(ctx, account, domain interface{}) *gomock.Call { +func (mr *MockAuthenticatorMockRecorder) GetAuthNonce(ctx, account, domain any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthNonce", reflect.TypeOf((*MockAuthenticator)(nil).GetAuthNonce), ctx, account, domain) } @@ -172,7 +176,7 @@ func (m *MockAuthenticator) ReleaseResource(ctx context.Context, scope rcmgr.Res } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockAuthenticatorMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockAuthenticatorMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockAuthenticator)(nil).ReleaseResource), ctx, scope) } @@ -187,7 +191,7 @@ func (m *MockAuthenticator) ReserveResource(ctx context.Context, state *rcmgr.Sc } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockAuthenticatorMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockAuthenticatorMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockAuthenticator)(nil).ReserveResource), ctx, state) } @@ -201,7 +205,7 @@ func (m *MockAuthenticator) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockAuthenticatorMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockAuthenticatorMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockAuthenticator)(nil).Start), ctx) } @@ -215,7 +219,7 @@ func (m *MockAuthenticator) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockAuthenticatorMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockAuthenticatorMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockAuthenticator)(nil).Stop), ctx) } @@ -230,7 +234,7 @@ func (m *MockAuthenticator) UpdateUserPublicKey(ctx context.Context, account, do } // UpdateUserPublicKey indicates an expected call of UpdateUserPublicKey. -func (mr *MockAuthenticatorMockRecorder) UpdateUserPublicKey(ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate interface{}) *gomock.Call { +func (mr *MockAuthenticatorMockRecorder) UpdateUserPublicKey(ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPublicKey", reflect.TypeOf((*MockAuthenticator)(nil).UpdateUserPublicKey), ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate) } @@ -245,7 +249,7 @@ func (m *MockAuthenticator) VerifyAuthentication(ctx context.Context, auth AuthO } // VerifyAuthentication indicates an expected call of VerifyAuthentication. -func (mr *MockAuthenticatorMockRecorder) VerifyAuthentication(ctx, auth, account, bucket, object interface{}) *gomock.Call { +func (mr *MockAuthenticatorMockRecorder) VerifyAuthentication(ctx, auth, account, bucket, object any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyAuthentication", reflect.TypeOf((*MockAuthenticator)(nil).VerifyAuthentication), ctx, auth, account, bucket, object) } @@ -260,7 +264,7 @@ func (m *MockAuthenticator) VerifyGNFD1EddsaSignature(ctx context.Context, accou } // VerifyGNFD1EddsaSignature indicates an expected call of VerifyGNFD1EddsaSignature. -func (mr *MockAuthenticatorMockRecorder) VerifyGNFD1EddsaSignature(ctx, account, domain, offChainSig, realMsgToSign interface{}) *gomock.Call { +func (mr *MockAuthenticatorMockRecorder) VerifyGNFD1EddsaSignature(ctx, account, domain, offChainSig, realMsgToSign any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGNFD1EddsaSignature", reflect.TypeOf((*MockAuthenticator)(nil).VerifyGNFD1EddsaSignature), ctx, account, domain, offChainSig, realMsgToSign) } @@ -298,7 +302,7 @@ func (m *MockApprover) HandleCreateBucketApprovalTask(ctx context.Context, task } // HandleCreateBucketApprovalTask indicates an expected call of HandleCreateBucketApprovalTask. -func (mr *MockApproverMockRecorder) HandleCreateBucketApprovalTask(ctx, task interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) HandleCreateBucketApprovalTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCreateBucketApprovalTask", reflect.TypeOf((*MockApprover)(nil).HandleCreateBucketApprovalTask), ctx, task) } @@ -313,7 +317,7 @@ func (m *MockApprover) HandleCreateObjectApprovalTask(ctx context.Context, task } // HandleCreateObjectApprovalTask indicates an expected call of HandleCreateObjectApprovalTask. -func (mr *MockApproverMockRecorder) HandleCreateObjectApprovalTask(ctx, task interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) HandleCreateObjectApprovalTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCreateObjectApprovalTask", reflect.TypeOf((*MockApprover)(nil).HandleCreateObjectApprovalTask), ctx, task) } @@ -328,7 +332,7 @@ func (m *MockApprover) HandleMigrateBucketApprovalTask(ctx context.Context, task } // HandleMigrateBucketApprovalTask indicates an expected call of HandleMigrateBucketApprovalTask. -func (mr *MockApproverMockRecorder) HandleMigrateBucketApprovalTask(ctx, task interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) HandleMigrateBucketApprovalTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMigrateBucketApprovalTask", reflect.TypeOf((*MockApprover)(nil).HandleMigrateBucketApprovalTask), ctx, task) } @@ -354,7 +358,7 @@ func (m *MockApprover) PostCreateBucketApproval(ctx context.Context, task task.A } // PostCreateBucketApproval indicates an expected call of PostCreateBucketApproval. -func (mr *MockApproverMockRecorder) PostCreateBucketApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) PostCreateBucketApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostCreateBucketApproval", reflect.TypeOf((*MockApprover)(nil).PostCreateBucketApproval), ctx, task) } @@ -366,7 +370,7 @@ func (m *MockApprover) PostCreateObjectApproval(ctx context.Context, task task.A } // PostCreateObjectApproval indicates an expected call of PostCreateObjectApproval. -func (mr *MockApproverMockRecorder) PostCreateObjectApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) PostCreateObjectApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostCreateObjectApproval", reflect.TypeOf((*MockApprover)(nil).PostCreateObjectApproval), ctx, task) } @@ -378,7 +382,7 @@ func (m *MockApprover) PostMigrateBucketApproval(ctx context.Context, task task. } // PostMigrateBucketApproval indicates an expected call of PostMigrateBucketApproval. -func (mr *MockApproverMockRecorder) PostMigrateBucketApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) PostMigrateBucketApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMigrateBucketApproval", reflect.TypeOf((*MockApprover)(nil).PostMigrateBucketApproval), ctx, task) } @@ -392,7 +396,7 @@ func (m *MockApprover) PreCreateBucketApproval(ctx context.Context, task task.Ap } // PreCreateBucketApproval indicates an expected call of PreCreateBucketApproval. -func (mr *MockApproverMockRecorder) PreCreateBucketApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) PreCreateBucketApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreCreateBucketApproval", reflect.TypeOf((*MockApprover)(nil).PreCreateBucketApproval), ctx, task) } @@ -406,7 +410,7 @@ func (m *MockApprover) PreCreateObjectApproval(ctx context.Context, task task.Ap } // PreCreateObjectApproval indicates an expected call of PreCreateObjectApproval. -func (mr *MockApproverMockRecorder) PreCreateObjectApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) PreCreateObjectApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreCreateObjectApproval", reflect.TypeOf((*MockApprover)(nil).PreCreateObjectApproval), ctx, task) } @@ -420,7 +424,7 @@ func (m *MockApprover) PreMigrateBucketApproval(ctx context.Context, task task.A } // PreMigrateBucketApproval indicates an expected call of PreMigrateBucketApproval. -func (mr *MockApproverMockRecorder) PreMigrateBucketApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) PreMigrateBucketApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreMigrateBucketApproval", reflect.TypeOf((*MockApprover)(nil).PreMigrateBucketApproval), ctx, task) } @@ -435,7 +439,7 @@ func (m *MockApprover) QueryTasks(ctx context.Context, subKey task.TKey) ([]task } // QueryTasks indicates an expected call of QueryTasks. -func (mr *MockApproverMockRecorder) QueryTasks(ctx, subKey interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockApprover)(nil).QueryTasks), ctx, subKey) } @@ -447,7 +451,7 @@ func (m *MockApprover) ReleaseResource(ctx context.Context, scope rcmgr.Resource } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockApproverMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockApprover)(nil).ReleaseResource), ctx, scope) } @@ -462,7 +466,7 @@ func (m *MockApprover) ReserveResource(ctx context.Context, state *rcmgr.ScopeSt } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockApproverMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockApprover)(nil).ReserveResource), ctx, state) } @@ -476,7 +480,7 @@ func (m *MockApprover) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockApproverMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockApprover)(nil).Start), ctx) } @@ -490,7 +494,7 @@ func (m *MockApprover) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockApproverMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockApproverMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockApprover)(nil).Stop), ctx) } @@ -530,7 +534,7 @@ func (m *MockDownloader) HandleChallengePiece(ctx context.Context, task task.Cha } // HandleChallengePiece indicates an expected call of HandleChallengePiece. -func (mr *MockDownloaderMockRecorder) HandleChallengePiece(ctx, task interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) HandleChallengePiece(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleChallengePiece", reflect.TypeOf((*MockDownloader)(nil).HandleChallengePiece), ctx, task) } @@ -545,7 +549,7 @@ func (m *MockDownloader) HandleDownloadObjectTask(ctx context.Context, task task } // HandleDownloadObjectTask indicates an expected call of HandleDownloadObjectTask. -func (mr *MockDownloaderMockRecorder) HandleDownloadObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) HandleDownloadObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDownloadObjectTask", reflect.TypeOf((*MockDownloader)(nil).HandleDownloadObjectTask), ctx, task) } @@ -560,7 +564,7 @@ func (m *MockDownloader) HandleDownloadPieceTask(ctx context.Context, task task. } // HandleDownloadPieceTask indicates an expected call of HandleDownloadPieceTask. -func (mr *MockDownloaderMockRecorder) HandleDownloadPieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) HandleDownloadPieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDownloadPieceTask", reflect.TypeOf((*MockDownloader)(nil).HandleDownloadPieceTask), ctx, task) } @@ -586,7 +590,7 @@ func (m *MockDownloader) PostChallengePiece(ctx context.Context, task task.Chall } // PostChallengePiece indicates an expected call of PostChallengePiece. -func (mr *MockDownloaderMockRecorder) PostChallengePiece(ctx, task interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) PostChallengePiece(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostChallengePiece", reflect.TypeOf((*MockDownloader)(nil).PostChallengePiece), ctx, task) } @@ -598,7 +602,7 @@ func (m *MockDownloader) PostDownloadObject(ctx context.Context, task task.Downl } // PostDownloadObject indicates an expected call of PostDownloadObject. -func (mr *MockDownloaderMockRecorder) PostDownloadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) PostDownloadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDownloadObject", reflect.TypeOf((*MockDownloader)(nil).PostDownloadObject), ctx, task) } @@ -610,7 +614,7 @@ func (m *MockDownloader) PostDownloadPiece(ctx context.Context, task task.Downlo } // PostDownloadPiece indicates an expected call of PostDownloadPiece. -func (mr *MockDownloaderMockRecorder) PostDownloadPiece(ctx, task interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) PostDownloadPiece(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDownloadPiece", reflect.TypeOf((*MockDownloader)(nil).PostDownloadPiece), ctx, task) } @@ -624,7 +628,7 @@ func (m *MockDownloader) PreChallengePiece(ctx context.Context, task task.Challe } // PreChallengePiece indicates an expected call of PreChallengePiece. -func (mr *MockDownloaderMockRecorder) PreChallengePiece(ctx, task interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) PreChallengePiece(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreChallengePiece", reflect.TypeOf((*MockDownloader)(nil).PreChallengePiece), ctx, task) } @@ -638,7 +642,7 @@ func (m *MockDownloader) PreDownloadObject(ctx context.Context, task task.Downlo } // PreDownloadObject indicates an expected call of PreDownloadObject. -func (mr *MockDownloaderMockRecorder) PreDownloadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) PreDownloadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreDownloadObject", reflect.TypeOf((*MockDownloader)(nil).PreDownloadObject), ctx, task) } @@ -652,7 +656,7 @@ func (m *MockDownloader) PreDownloadPiece(ctx context.Context, task task.Downloa } // PreDownloadPiece indicates an expected call of PreDownloadPiece. -func (mr *MockDownloaderMockRecorder) PreDownloadPiece(ctx, task interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) PreDownloadPiece(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreDownloadPiece", reflect.TypeOf((*MockDownloader)(nil).PreDownloadPiece), ctx, task) } @@ -667,7 +671,7 @@ func (m *MockDownloader) QueryTasks(ctx context.Context, subKey task.TKey) ([]ta } // QueryTasks indicates an expected call of QueryTasks. -func (mr *MockDownloaderMockRecorder) QueryTasks(ctx, subKey interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockDownloader)(nil).QueryTasks), ctx, subKey) } @@ -679,7 +683,7 @@ func (m *MockDownloader) ReleaseResource(ctx context.Context, scope rcmgr.Resour } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockDownloaderMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockDownloader)(nil).ReleaseResource), ctx, scope) } @@ -694,7 +698,7 @@ func (m *MockDownloader) ReserveResource(ctx context.Context, state *rcmgr.Scope } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockDownloaderMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockDownloader)(nil).ReserveResource), ctx, state) } @@ -708,7 +712,7 @@ func (m *MockDownloader) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockDownloaderMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockDownloader)(nil).Start), ctx) } @@ -722,7 +726,7 @@ func (m *MockDownloader) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockDownloaderMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockDownloaderMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockDownloader)(nil).Stop), ctx) } @@ -759,7 +763,7 @@ func (m *MockTaskExecutor) AskTask(ctx context.Context) error { } // AskTask indicates an expected call of AskTask. -func (mr *MockTaskExecutorMockRecorder) AskTask(ctx interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) AskTask(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskTask", reflect.TypeOf((*MockTaskExecutor)(nil).AskTask), ctx) } @@ -771,7 +775,7 @@ func (m *MockTaskExecutor) HandleGCMetaTask(ctx context.Context, task task.GCMet } // HandleGCMetaTask indicates an expected call of HandleGCMetaTask. -func (mr *MockTaskExecutorMockRecorder) HandleGCMetaTask(ctx, task interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) HandleGCMetaTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCMetaTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleGCMetaTask), ctx, task) } @@ -783,7 +787,7 @@ func (m *MockTaskExecutor) HandleGCObjectTask(ctx context.Context, task task.GCO } // HandleGCObjectTask indicates an expected call of HandleGCObjectTask. -func (mr *MockTaskExecutorMockRecorder) HandleGCObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) HandleGCObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCObjectTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleGCObjectTask), ctx, task) } @@ -795,7 +799,7 @@ func (m *MockTaskExecutor) HandleGCZombiePieceTask(ctx context.Context, task tas } // HandleGCZombiePieceTask indicates an expected call of HandleGCZombiePieceTask. -func (mr *MockTaskExecutorMockRecorder) HandleGCZombiePieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) HandleGCZombiePieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCZombiePieceTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleGCZombiePieceTask), ctx, task) } @@ -807,7 +811,7 @@ func (m *MockTaskExecutor) HandleMigrateGVGTask(ctx context.Context, gvgTask tas } // HandleMigrateGVGTask indicates an expected call of HandleMigrateGVGTask. -func (mr *MockTaskExecutorMockRecorder) HandleMigrateGVGTask(ctx, gvgTask interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) HandleMigrateGVGTask(ctx, gvgTask any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMigrateGVGTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleMigrateGVGTask), ctx, gvgTask) } @@ -819,7 +823,7 @@ func (m *MockTaskExecutor) HandleReceivePieceTask(ctx context.Context, task task } // HandleReceivePieceTask indicates an expected call of HandleReceivePieceTask. -func (mr *MockTaskExecutorMockRecorder) HandleReceivePieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) HandleReceivePieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReceivePieceTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleReceivePieceTask), ctx, task) } @@ -831,7 +835,7 @@ func (m *MockTaskExecutor) HandleReplicatePieceTask(ctx context.Context, task ta } // HandleReplicatePieceTask indicates an expected call of HandleReplicatePieceTask. -func (mr *MockTaskExecutorMockRecorder) HandleReplicatePieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) HandleReplicatePieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReplicatePieceTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleReplicatePieceTask), ctx, task) } @@ -843,7 +847,7 @@ func (m *MockTaskExecutor) HandleSealObjectTask(ctx context.Context, task task.S } // HandleSealObjectTask indicates an expected call of HandleSealObjectTask. -func (mr *MockTaskExecutorMockRecorder) HandleSealObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) HandleSealObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSealObjectTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleSealObjectTask), ctx, task) } @@ -869,7 +873,7 @@ func (m *MockTaskExecutor) ReleaseResource(ctx context.Context, scope rcmgr.Reso } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockTaskExecutorMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockTaskExecutor)(nil).ReleaseResource), ctx, scope) } @@ -883,7 +887,7 @@ func (m *MockTaskExecutor) ReportTask(ctx context.Context, task task.Task) error } // ReportTask indicates an expected call of ReportTask. -func (mr *MockTaskExecutorMockRecorder) ReportTask(ctx, task interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) ReportTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportTask", reflect.TypeOf((*MockTaskExecutor)(nil).ReportTask), ctx, task) } @@ -898,7 +902,7 @@ func (m *MockTaskExecutor) ReserveResource(ctx context.Context, state *rcmgr.Sco } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockTaskExecutorMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockTaskExecutor)(nil).ReserveResource), ctx, state) } @@ -912,7 +916,7 @@ func (m *MockTaskExecutor) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockTaskExecutorMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockTaskExecutor)(nil).Start), ctx) } @@ -926,7 +930,7 @@ func (m *MockTaskExecutor) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockTaskExecutorMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockTaskExecutorMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockTaskExecutor)(nil).Stop), ctx) } @@ -964,7 +968,7 @@ func (m *MockManager) DispatchTask(ctx context.Context, limit rcmgr.Limit) (task } // DispatchTask indicates an expected call of DispatchTask. -func (mr *MockManagerMockRecorder) DispatchTask(ctx, limit interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) DispatchTask(ctx, limit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchTask", reflect.TypeOf((*MockManager)(nil).DispatchTask), ctx, limit) } @@ -978,7 +982,7 @@ func (m *MockManager) HandleChallengePieceTask(ctx context.Context, task task.Ch } // HandleChallengePieceTask indicates an expected call of HandleChallengePieceTask. -func (mr *MockManagerMockRecorder) HandleChallengePieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleChallengePieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleChallengePieceTask", reflect.TypeOf((*MockManager)(nil).HandleChallengePieceTask), ctx, task) } @@ -992,7 +996,7 @@ func (m *MockManager) HandleCreateResumableUploadObjectTask(ctx context.Context, } // HandleCreateResumableUploadObjectTask indicates an expected call of HandleCreateResumableUploadObjectTask. -func (mr *MockManagerMockRecorder) HandleCreateResumableUploadObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleCreateResumableUploadObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCreateResumableUploadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleCreateResumableUploadObjectTask), ctx, task) } @@ -1006,7 +1010,7 @@ func (m *MockManager) HandleCreateUploadObjectTask(ctx context.Context, task tas } // HandleCreateUploadObjectTask indicates an expected call of HandleCreateUploadObjectTask. -func (mr *MockManagerMockRecorder) HandleCreateUploadObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleCreateUploadObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCreateUploadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleCreateUploadObjectTask), ctx, task) } @@ -1020,7 +1024,7 @@ func (m *MockManager) HandleDoneResumableUploadObjectTask(ctx context.Context, t } // HandleDoneResumableUploadObjectTask indicates an expected call of HandleDoneResumableUploadObjectTask. -func (mr *MockManagerMockRecorder) HandleDoneResumableUploadObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleDoneResumableUploadObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDoneResumableUploadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleDoneResumableUploadObjectTask), ctx, task) } @@ -1034,7 +1038,7 @@ func (m *MockManager) HandleDoneUploadObjectTask(ctx context.Context, task task. } // HandleDoneUploadObjectTask indicates an expected call of HandleDoneUploadObjectTask. -func (mr *MockManagerMockRecorder) HandleDoneUploadObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleDoneUploadObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDoneUploadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleDoneUploadObjectTask), ctx, task) } @@ -1048,7 +1052,7 @@ func (m *MockManager) HandleDownloadObjectTask(ctx context.Context, task task.Do } // HandleDownloadObjectTask indicates an expected call of HandleDownloadObjectTask. -func (mr *MockManagerMockRecorder) HandleDownloadObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleDownloadObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDownloadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleDownloadObjectTask), ctx, task) } @@ -1062,7 +1066,7 @@ func (m *MockManager) HandleGCBucketMigrationTask(ctx context.Context, task task } // HandleGCBucketMigrationTask indicates an expected call of HandleGCBucketMigrationTask. -func (mr *MockManagerMockRecorder) HandleGCBucketMigrationTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleGCBucketMigrationTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCBucketMigrationTask", reflect.TypeOf((*MockManager)(nil).HandleGCBucketMigrationTask), ctx, task) } @@ -1076,7 +1080,7 @@ func (m *MockManager) HandleGCMetaTask(ctx context.Context, task task.GCMetaTask } // HandleGCMetaTask indicates an expected call of HandleGCMetaTask. -func (mr *MockManagerMockRecorder) HandleGCMetaTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleGCMetaTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCMetaTask", reflect.TypeOf((*MockManager)(nil).HandleGCMetaTask), ctx, task) } @@ -1090,7 +1094,7 @@ func (m *MockManager) HandleGCObjectTask(ctx context.Context, task task.GCObject } // HandleGCObjectTask indicates an expected call of HandleGCObjectTask. -func (mr *MockManagerMockRecorder) HandleGCObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleGCObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCObjectTask", reflect.TypeOf((*MockManager)(nil).HandleGCObjectTask), ctx, task) } @@ -1104,7 +1108,7 @@ func (m *MockManager) HandleGCZombiePieceTask(ctx context.Context, task task.GCZ } // HandleGCZombiePieceTask indicates an expected call of HandleGCZombiePieceTask. -func (mr *MockManagerMockRecorder) HandleGCZombiePieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleGCZombiePieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCZombiePieceTask", reflect.TypeOf((*MockManager)(nil).HandleGCZombiePieceTask), ctx, task) } @@ -1118,7 +1122,7 @@ func (m *MockManager) HandleMigrateGVGTask(ctx context.Context, task task.Migrat } // HandleMigrateGVGTask indicates an expected call of HandleMigrateGVGTask. -func (mr *MockManagerMockRecorder) HandleMigrateGVGTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleMigrateGVGTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMigrateGVGTask", reflect.TypeOf((*MockManager)(nil).HandleMigrateGVGTask), ctx, task) } @@ -1132,7 +1136,7 @@ func (m *MockManager) HandleReceivePieceTask(ctx context.Context, task task.Rece } // HandleReceivePieceTask indicates an expected call of HandleReceivePieceTask. -func (mr *MockManagerMockRecorder) HandleReceivePieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleReceivePieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReceivePieceTask", reflect.TypeOf((*MockManager)(nil).HandleReceivePieceTask), ctx, task) } @@ -1146,7 +1150,7 @@ func (m *MockManager) HandleRecoverPieceTask(ctx context.Context, task task.Reco } // HandleRecoverPieceTask indicates an expected call of HandleRecoverPieceTask. -func (mr *MockManagerMockRecorder) HandleRecoverPieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleRecoverPieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRecoverPieceTask", reflect.TypeOf((*MockManager)(nil).HandleRecoverPieceTask), ctx, task) } @@ -1160,7 +1164,7 @@ func (m *MockManager) HandleReplicatePieceTask(ctx context.Context, task task.Re } // HandleReplicatePieceTask indicates an expected call of HandleReplicatePieceTask. -func (mr *MockManagerMockRecorder) HandleReplicatePieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleReplicatePieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReplicatePieceTask", reflect.TypeOf((*MockManager)(nil).HandleReplicatePieceTask), ctx, task) } @@ -1174,7 +1178,7 @@ func (m *MockManager) HandleSealObjectTask(ctx context.Context, task task.SealOb } // HandleSealObjectTask indicates an expected call of HandleSealObjectTask. -func (mr *MockManagerMockRecorder) HandleSealObjectTask(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) HandleSealObjectTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSealObjectTask", reflect.TypeOf((*MockManager)(nil).HandleSealObjectTask), ctx, task) } @@ -1202,7 +1206,7 @@ func (m *MockManager) NotifyMigrateSwapOut(ctx context.Context, swapOut *types1. } // NotifyMigrateSwapOut indicates an expected call of NotifyMigrateSwapOut. -func (mr *MockManagerMockRecorder) NotifyMigrateSwapOut(ctx, swapOut interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) NotifyMigrateSwapOut(ctx, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyMigrateSwapOut", reflect.TypeOf((*MockManager)(nil).NotifyMigrateSwapOut), ctx, swapOut) } @@ -1217,7 +1221,7 @@ func (m *MockManager) NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, } // NotifyPostMigrateBucketAndRecoupQuota indicates an expected call of NotifyPostMigrateBucketAndRecoupQuota. -func (mr *MockManagerMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmStatus interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmStatus any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucketAndRecoupQuota", reflect.TypeOf((*MockManager)(nil).NotifyPostMigrateBucketAndRecoupQuota), ctx, bmStatus) } @@ -1232,7 +1236,7 @@ func (m *MockManager) NotifyPreMigrateBucketAndDeductQuota(ctx context.Context, } // NotifyPreMigrateBucketAndDeductQuota indicates an expected call of NotifyPreMigrateBucketAndDeductQuota. -func (mr *MockManagerMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucketAndDeductQuota", reflect.TypeOf((*MockManager)(nil).NotifyPreMigrateBucketAndDeductQuota), ctx, bucketID) } @@ -1247,7 +1251,7 @@ func (m *MockManager) PickVirtualGroupFamily(ctx context.Context, task task.Appr } // PickVirtualGroupFamily indicates an expected call of PickVirtualGroupFamily. -func (mr *MockManagerMockRecorder) PickVirtualGroupFamily(ctx, task interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) PickVirtualGroupFamily(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickVirtualGroupFamily", reflect.TypeOf((*MockManager)(nil).PickVirtualGroupFamily), ctx, task) } @@ -1262,7 +1266,7 @@ func (m *MockManager) QueryBucketMigrate(ctx context.Context) (*gfspserver.GfSpQ } // QueryBucketMigrate indicates an expected call of QueryBucketMigrate. -func (mr *MockManagerMockRecorder) QueryBucketMigrate(ctx interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) QueryBucketMigrate(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBucketMigrate", reflect.TypeOf((*MockManager)(nil).QueryBucketMigrate), ctx) } @@ -1277,11 +1281,27 @@ func (m *MockManager) QueryBucketMigrationProgress(ctx context.Context, bucketID } // QueryBucketMigrationProgress indicates an expected call of QueryBucketMigrationProgress. -func (mr *MockManagerMockRecorder) QueryBucketMigrationProgress(ctx, bucketID interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) QueryBucketMigrationProgress(ctx, bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBucketMigrationProgress", reflect.TypeOf((*MockManager)(nil).QueryBucketMigrationProgress), ctx, bucketID) } +// QueryRecoverProcess mocks base method. +func (m *MockManager) QueryRecoverProcess(ctx context.Context, vgfID, gvgID uint32) ([]*gfspserver.RecoverProcess, bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryRecoverProcess", ctx, vgfID, gvgID) + ret0, _ := ret[0].([]*gfspserver.RecoverProcess) + ret1, _ := ret[1].(bool) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// QueryRecoverProcess indicates an expected call of QueryRecoverProcess. +func (mr *MockManagerMockRecorder) QueryRecoverProcess(ctx, vgfID, gvgID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRecoverProcess", reflect.TypeOf((*MockManager)(nil).QueryRecoverProcess), ctx, vgfID, gvgID) +} + // QuerySpExit mocks base method. func (m *MockManager) QuerySpExit(ctx context.Context) (*gfspserver.GfSpQuerySpExitResponse, error) { m.ctrl.T.Helper() @@ -1292,7 +1312,7 @@ func (m *MockManager) QuerySpExit(ctx context.Context) (*gfspserver.GfSpQuerySpE } // QuerySpExit indicates an expected call of QuerySpExit. -func (mr *MockManagerMockRecorder) QuerySpExit(ctx interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) QuerySpExit(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySpExit", reflect.TypeOf((*MockManager)(nil).QuerySpExit), ctx) } @@ -1307,7 +1327,7 @@ func (m *MockManager) QueryTasks(ctx context.Context, subKey task.TKey) ([]task. } // QueryTasks indicates an expected call of QueryTasks. -func (mr *MockManagerMockRecorder) QueryTasks(ctx, subKey interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockManager)(nil).QueryTasks), ctx, subKey) } @@ -1328,7 +1348,7 @@ func (m *MockManager) QueryTasksStats(ctx context.Context) (int, int, int, int, } // QueryTasksStats indicates an expected call of QueryTasksStats. -func (mr *MockManagerMockRecorder) QueryTasksStats(ctx interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) QueryTasksStats(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasksStats", reflect.TypeOf((*MockManager)(nil).QueryTasksStats), ctx) } @@ -1340,7 +1360,7 @@ func (m *MockManager) ReleaseResource(ctx context.Context, scope rcmgr.ResourceS } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockManagerMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockManager)(nil).ReleaseResource), ctx, scope) } @@ -1355,7 +1375,7 @@ func (m *MockManager) ReserveResource(ctx context.Context, state *rcmgr.ScopeSta } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockManagerMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockManager)(nil).ReserveResource), ctx, state) } @@ -1369,7 +1389,7 @@ func (m *MockManager) ResetRecoveryFailedList(ctx context.Context) []string { } // ResetRecoveryFailedList indicates an expected call of ResetRecoveryFailedList. -func (mr *MockManagerMockRecorder) ResetRecoveryFailedList(ctx interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) ResetRecoveryFailedList(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetRecoveryFailedList", reflect.TypeOf((*MockManager)(nil).ResetRecoveryFailedList), ctx) } @@ -1383,7 +1403,7 @@ func (m *MockManager) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockManagerMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockManager)(nil).Start), ctx) } @@ -1397,11 +1417,25 @@ func (m *MockManager) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockManagerMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockManagerMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockManager)(nil).Stop), ctx) } +// TriggerRecoverForSuccessorSP mocks base method. +func (m *MockManager) TriggerRecoverForSuccessorSP(ctx context.Context, vgfID, gvgID uint32, redundancyIndex int32) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TriggerRecoverForSuccessorSP", ctx, vgfID, gvgID, redundancyIndex) + ret0, _ := ret[0].(error) + return ret0 +} + +// TriggerRecoverForSuccessorSP indicates an expected call of TriggerRecoverForSuccessorSP. +func (mr *MockManagerMockRecorder) TriggerRecoverForSuccessorSP(ctx, vgfID, gvgID, redundancyIndex any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TriggerRecoverForSuccessorSP", reflect.TypeOf((*MockManager)(nil).TriggerRecoverForSuccessorSP), ctx, vgfID, gvgID, redundancyIndex) +} + // MockP2P is a mock of P2P interface. type MockP2P struct { ctrl *gomock.Controller @@ -1435,7 +1469,7 @@ func (m *MockP2P) HandleQueryBootstrap(ctx context.Context) ([]string, error) { } // HandleQueryBootstrap indicates an expected call of HandleQueryBootstrap. -func (mr *MockP2PMockRecorder) HandleQueryBootstrap(ctx interface{}) *gomock.Call { +func (mr *MockP2PMockRecorder) HandleQueryBootstrap(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleQueryBootstrap", reflect.TypeOf((*MockP2P)(nil).HandleQueryBootstrap), ctx) } @@ -1450,7 +1484,7 @@ func (m *MockP2P) HandleReplicatePieceApproval(ctx context.Context, t task.Appro } // HandleReplicatePieceApproval indicates an expected call of HandleReplicatePieceApproval. -func (mr *MockP2PMockRecorder) HandleReplicatePieceApproval(ctx, t, min, max, timeout interface{}) *gomock.Call { +func (mr *MockP2PMockRecorder) HandleReplicatePieceApproval(ctx, t, min, max, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReplicatePieceApproval", reflect.TypeOf((*MockP2P)(nil).HandleReplicatePieceApproval), ctx, t, min, max, timeout) } @@ -1479,7 +1513,7 @@ func (m *MockP2P) QueryTasks(ctx context.Context, subKey task.TKey) ([]task.Task } // QueryTasks indicates an expected call of QueryTasks. -func (mr *MockP2PMockRecorder) QueryTasks(ctx, subKey interface{}) *gomock.Call { +func (mr *MockP2PMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockP2P)(nil).QueryTasks), ctx, subKey) } @@ -1491,7 +1525,7 @@ func (m *MockP2P) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScope } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockP2PMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockP2PMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockP2P)(nil).ReleaseResource), ctx, scope) } @@ -1506,7 +1540,7 @@ func (m *MockP2P) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) ( } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockP2PMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockP2PMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockP2P)(nil).ReserveResource), ctx, state) } @@ -1520,7 +1554,7 @@ func (m *MockP2P) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockP2PMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockP2PMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockP2P)(nil).Start), ctx) } @@ -1534,7 +1568,7 @@ func (m *MockP2P) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockP2PMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockP2PMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockP2P)(nil).Stop), ctx) } @@ -1572,7 +1606,7 @@ func (m *MockReceiver) HandleDoneReceivePieceTask(ctx context.Context, task task } // HandleDoneReceivePieceTask indicates an expected call of HandleDoneReceivePieceTask. -func (mr *MockReceiverMockRecorder) HandleDoneReceivePieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockReceiverMockRecorder) HandleDoneReceivePieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDoneReceivePieceTask", reflect.TypeOf((*MockReceiver)(nil).HandleDoneReceivePieceTask), ctx, task) } @@ -1586,7 +1620,7 @@ func (m *MockReceiver) HandleReceivePieceTask(ctx context.Context, task task.Rec } // HandleReceivePieceTask indicates an expected call of HandleReceivePieceTask. -func (mr *MockReceiverMockRecorder) HandleReceivePieceTask(ctx, task, data interface{}) *gomock.Call { +func (mr *MockReceiverMockRecorder) HandleReceivePieceTask(ctx, task, data any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReceivePieceTask", reflect.TypeOf((*MockReceiver)(nil).HandleReceivePieceTask), ctx, task, data) } @@ -1615,7 +1649,7 @@ func (m *MockReceiver) QueryTasks(ctx context.Context, subKey task.TKey) ([]task } // QueryTasks indicates an expected call of QueryTasks. -func (mr *MockReceiverMockRecorder) QueryTasks(ctx, subKey interface{}) *gomock.Call { +func (mr *MockReceiverMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockReceiver)(nil).QueryTasks), ctx, subKey) } @@ -1627,7 +1661,7 @@ func (m *MockReceiver) ReleaseResource(ctx context.Context, scope rcmgr.Resource } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockReceiverMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockReceiverMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockReceiver)(nil).ReleaseResource), ctx, scope) } @@ -1642,7 +1676,7 @@ func (m *MockReceiver) ReserveResource(ctx context.Context, state *rcmgr.ScopeSt } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockReceiverMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockReceiverMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockReceiver)(nil).ReserveResource), ctx, state) } @@ -1656,7 +1690,7 @@ func (m *MockReceiver) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockReceiverMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockReceiverMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockReceiver)(nil).Start), ctx) } @@ -1670,7 +1704,7 @@ func (m *MockReceiver) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockReceiverMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockReceiverMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockReceiver)(nil).Stop), ctx) } @@ -1698,6 +1732,21 @@ func (m *MockSigner) EXPECT() *MockSignerMockRecorder { return m.recorder } +// CancelSwapIn mocks base method. +func (m *MockSigner) CancelSwapIn(ctx context.Context, cancelSwapIn *types1.MsgCancelSwapIn) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelSwapIn", ctx, cancelSwapIn) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelSwapIn indicates an expected call of CancelSwapIn. +func (mr *MockSignerMockRecorder) CancelSwapIn(ctx, cancelSwapIn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSwapIn", reflect.TypeOf((*MockSigner)(nil).CancelSwapIn), ctx, cancelSwapIn) +} + // CompleteMigrateBucket mocks base method. func (m *MockSigner) CompleteMigrateBucket(ctx context.Context, migrateBucket *types0.MsgCompleteMigrateBucket) (string, error) { m.ctrl.T.Helper() @@ -1708,7 +1757,7 @@ func (m *MockSigner) CompleteMigrateBucket(ctx context.Context, migrateBucket *t } // CompleteMigrateBucket indicates an expected call of CompleteMigrateBucket. -func (mr *MockSignerMockRecorder) CompleteMigrateBucket(ctx, migrateBucket interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) CompleteMigrateBucket(ctx, migrateBucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMigrateBucket", reflect.TypeOf((*MockSigner)(nil).CompleteMigrateBucket), ctx, migrateBucket) } @@ -1723,11 +1772,26 @@ func (m *MockSigner) CompleteSPExit(ctx context.Context, completeSPExit *types1. } // CompleteSPExit indicates an expected call of CompleteSPExit. -func (mr *MockSignerMockRecorder) CompleteSPExit(ctx, completeSPExit interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) CompleteSPExit(ctx, completeSPExit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSPExit", reflect.TypeOf((*MockSigner)(nil).CompleteSPExit), ctx, completeSPExit) } +// CompleteSwapIn mocks base method. +func (m *MockSigner) CompleteSwapIn(ctx context.Context, reserveSwapIn *types1.MsgCompleteSwapIn) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CompleteSwapIn", ctx, reserveSwapIn) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CompleteSwapIn indicates an expected call of CompleteSwapIn. +func (mr *MockSignerMockRecorder) CompleteSwapIn(ctx, reserveSwapIn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapIn", reflect.TypeOf((*MockSigner)(nil).CompleteSwapIn), ctx, reserveSwapIn) +} + // CompleteSwapOut mocks base method. func (m *MockSigner) CompleteSwapOut(ctx context.Context, completeSwapOut *types1.MsgCompleteSwapOut) (string, error) { m.ctrl.T.Helper() @@ -1738,7 +1802,7 @@ func (m *MockSigner) CompleteSwapOut(ctx context.Context, completeSwapOut *types } // CompleteSwapOut indicates an expected call of CompleteSwapOut. -func (mr *MockSignerMockRecorder) CompleteSwapOut(ctx, completeSwapOut interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) CompleteSwapOut(ctx, completeSwapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapOut", reflect.TypeOf((*MockSigner)(nil).CompleteSwapOut), ctx, completeSwapOut) } @@ -1753,7 +1817,7 @@ func (m *MockSigner) CreateGlobalVirtualGroup(ctx context.Context, gvg *types1.M } // CreateGlobalVirtualGroup indicates an expected call of CreateGlobalVirtualGroup. -func (mr *MockSignerMockRecorder) CreateGlobalVirtualGroup(ctx, gvg interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) CreateGlobalVirtualGroup(ctx, gvg any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalVirtualGroup", reflect.TypeOf((*MockSigner)(nil).CreateGlobalVirtualGroup), ctx, gvg) } @@ -1768,7 +1832,7 @@ func (m *MockSigner) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG *ty } // DeleteGlobalVirtualGroup indicates an expected call of DeleteGlobalVirtualGroup. -func (mr *MockSignerMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalVirtualGroup", reflect.TypeOf((*MockSigner)(nil).DeleteGlobalVirtualGroup), ctx, deleteGVG) } @@ -1783,7 +1847,7 @@ func (m *MockSigner) Deposit(ctx context.Context, deposit *types1.MsgDeposit) (s } // Deposit indicates an expected call of Deposit. -func (mr *MockSignerMockRecorder) Deposit(ctx, deposit interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) Deposit(ctx, deposit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deposit", reflect.TypeOf((*MockSigner)(nil).Deposit), ctx, deposit) } @@ -1798,7 +1862,7 @@ func (m *MockSigner) DiscontinueBucket(ctx context.Context, bucket *types0.MsgDi } // DiscontinueBucket indicates an expected call of DiscontinueBucket. -func (mr *MockSignerMockRecorder) DiscontinueBucket(ctx, bucket interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) DiscontinueBucket(ctx, bucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscontinueBucket", reflect.TypeOf((*MockSigner)(nil).DiscontinueBucket), ctx, bucket) } @@ -1827,7 +1891,7 @@ func (m *MockSigner) RejectMigrateBucket(ctx context.Context, rejectMigrateBucke } // RejectMigrateBucket indicates an expected call of RejectMigrateBucket. -func (mr *MockSignerMockRecorder) RejectMigrateBucket(ctx, rejectMigrateBucket interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) RejectMigrateBucket(ctx, rejectMigrateBucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectMigrateBucket", reflect.TypeOf((*MockSigner)(nil).RejectMigrateBucket), ctx, rejectMigrateBucket) } @@ -1842,7 +1906,7 @@ func (m *MockSigner) RejectUnSealObject(ctx context.Context, object *types0.MsgR } // RejectUnSealObject indicates an expected call of RejectUnSealObject. -func (mr *MockSignerMockRecorder) RejectUnSealObject(ctx, object interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) RejectUnSealObject(ctx, object any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectUnSealObject", reflect.TypeOf((*MockSigner)(nil).RejectUnSealObject), ctx, object) } @@ -1854,7 +1918,7 @@ func (m *MockSigner) ReleaseResource(ctx context.Context, scope rcmgr.ResourceSc } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockSignerMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockSigner)(nil).ReleaseResource), ctx, scope) } @@ -1869,11 +1933,26 @@ func (m *MockSigner) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockSignerMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockSigner)(nil).ReserveResource), ctx, state) } +// ReserveSwapIn mocks base method. +func (m *MockSigner) ReserveSwapIn(ctx context.Context, reserveSwapIn *types1.MsgReserveSwapIn) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReserveSwapIn", ctx, reserveSwapIn) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReserveSwapIn indicates an expected call of ReserveSwapIn. +func (mr *MockSignerMockRecorder) ReserveSwapIn(ctx, reserveSwapIn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveSwapIn", reflect.TypeOf((*MockSigner)(nil).ReserveSwapIn), ctx, reserveSwapIn) +} + // SPExit mocks base method. func (m *MockSigner) SPExit(ctx context.Context, spExit *types1.MsgStorageProviderExit) (string, error) { m.ctrl.T.Helper() @@ -1884,7 +1963,7 @@ func (m *MockSigner) SPExit(ctx context.Context, spExit *types1.MsgStorageProvid } // SPExit indicates an expected call of SPExit. -func (mr *MockSignerMockRecorder) SPExit(ctx, spExit interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SPExit(ctx, spExit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPExit", reflect.TypeOf((*MockSigner)(nil).SPExit), ctx, spExit) } @@ -1899,7 +1978,7 @@ func (m *MockSigner) SealObject(ctx context.Context, object *types0.MsgSealObjec } // SealObject indicates an expected call of SealObject. -func (mr *MockSignerMockRecorder) SealObject(ctx, object interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SealObject(ctx, object any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealObject", reflect.TypeOf((*MockSigner)(nil).SealObject), ctx, object) } @@ -1914,7 +1993,7 @@ func (m *MockSigner) SignBucketMigrationInfo(ctx context.Context, task *gfsptask } // SignBucketMigrationInfo indicates an expected call of SignBucketMigrationInfo. -func (mr *MockSignerMockRecorder) SignBucketMigrationInfo(ctx, task interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignBucketMigrationInfo(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignBucketMigrationInfo", reflect.TypeOf((*MockSigner)(nil).SignBucketMigrationInfo), ctx, task) } @@ -1929,7 +2008,7 @@ func (m *MockSigner) SignCreateBucketApproval(ctx context.Context, bucket *types } // SignCreateBucketApproval indicates an expected call of SignCreateBucketApproval. -func (mr *MockSignerMockRecorder) SignCreateBucketApproval(ctx, bucket interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignCreateBucketApproval(ctx, bucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateBucketApproval", reflect.TypeOf((*MockSigner)(nil).SignCreateBucketApproval), ctx, bucket) } @@ -1944,7 +2023,7 @@ func (m *MockSigner) SignCreateObjectApproval(ctx context.Context, task *types0. } // SignCreateObjectApproval indicates an expected call of SignCreateObjectApproval. -func (mr *MockSignerMockRecorder) SignCreateObjectApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignCreateObjectApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateObjectApproval", reflect.TypeOf((*MockSigner)(nil).SignCreateObjectApproval), ctx, task) } @@ -1959,7 +2038,7 @@ func (m *MockSigner) SignMigrateBucketApproval(ctx context.Context, bucket *type } // SignMigrateBucketApproval indicates an expected call of SignMigrateBucketApproval. -func (mr *MockSignerMockRecorder) SignMigrateBucketApproval(ctx, bucket interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignMigrateBucketApproval(ctx, bucket any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateBucketApproval", reflect.TypeOf((*MockSigner)(nil).SignMigrateBucketApproval), ctx, bucket) } @@ -1974,7 +2053,7 @@ func (m *MockSigner) SignMigrateGVG(ctx context.Context, task *gfsptask.GfSpMigr } // SignMigrateGVG indicates an expected call of SignMigrateGVG. -func (mr *MockSignerMockRecorder) SignMigrateGVG(ctx, task interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignMigrateGVG(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateGVG", reflect.TypeOf((*MockSigner)(nil).SignMigrateGVG), ctx, task) } @@ -1989,7 +2068,7 @@ func (m *MockSigner) SignP2PPingMsg(ctx context.Context, ping *gfspp2p.GfSpPing) } // SignP2PPingMsg indicates an expected call of SignP2PPingMsg. -func (mr *MockSignerMockRecorder) SignP2PPingMsg(ctx, ping interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignP2PPingMsg(ctx, ping any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPingMsg", reflect.TypeOf((*MockSigner)(nil).SignP2PPingMsg), ctx, ping) } @@ -2004,7 +2083,7 @@ func (m *MockSigner) SignP2PPongMsg(ctx context.Context, pong *gfspp2p.GfSpPong) } // SignP2PPongMsg indicates an expected call of SignP2PPongMsg. -func (mr *MockSignerMockRecorder) SignP2PPongMsg(ctx, pong interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignP2PPongMsg(ctx, pong any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPongMsg", reflect.TypeOf((*MockSigner)(nil).SignP2PPongMsg), ctx, pong) } @@ -2019,7 +2098,7 @@ func (m *MockSigner) SignReceivePieceTask(ctx context.Context, task task.Receive } // SignReceivePieceTask indicates an expected call of SignReceivePieceTask. -func (mr *MockSignerMockRecorder) SignReceivePieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignReceivePieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReceivePieceTask", reflect.TypeOf((*MockSigner)(nil).SignReceivePieceTask), ctx, task) } @@ -2034,7 +2113,7 @@ func (m *MockSigner) SignRecoveryPieceTask(ctx context.Context, task task.Recove } // SignRecoveryPieceTask indicates an expected call of SignRecoveryPieceTask. -func (mr *MockSignerMockRecorder) SignRecoveryPieceTask(ctx, task interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignRecoveryPieceTask(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignRecoveryPieceTask", reflect.TypeOf((*MockSigner)(nil).SignRecoveryPieceTask), ctx, task) } @@ -2049,7 +2128,7 @@ func (m *MockSigner) SignReplicatePieceApproval(ctx context.Context, task task.A } // SignReplicatePieceApproval indicates an expected call of SignReplicatePieceApproval. -func (mr *MockSignerMockRecorder) SignReplicatePieceApproval(ctx, task interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignReplicatePieceApproval(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReplicatePieceApproval", reflect.TypeOf((*MockSigner)(nil).SignReplicatePieceApproval), ctx, task) } @@ -2064,7 +2143,7 @@ func (m *MockSigner) SignSecondarySPMigrationBucket(ctx context.Context, signDoc } // SignSecondarySPMigrationBucket indicates an expected call of SignSecondarySPMigrationBucket. -func (mr *MockSignerMockRecorder) SignSecondarySPMigrationBucket(ctx, signDoc interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignSecondarySPMigrationBucket(ctx, signDoc any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySPMigrationBucket", reflect.TypeOf((*MockSigner)(nil).SignSecondarySPMigrationBucket), ctx, signDoc) } @@ -2079,7 +2158,7 @@ func (m *MockSigner) SignSecondarySealBls(ctx context.Context, objectID uint64, } // SignSecondarySealBls indicates an expected call of SignSecondarySealBls. -func (mr *MockSignerMockRecorder) SignSecondarySealBls(ctx, objectID, gvgId, hash interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignSecondarySealBls(ctx, objectID, gvgId, hash any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySealBls", reflect.TypeOf((*MockSigner)(nil).SignSecondarySealBls), ctx, objectID, gvgId, hash) } @@ -2094,7 +2173,7 @@ func (m *MockSigner) SignSwapOut(ctx context.Context, swapOut *types1.MsgSwapOut } // SignSwapOut indicates an expected call of SignSwapOut. -func (mr *MockSignerMockRecorder) SignSwapOut(ctx, swapOut interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SignSwapOut(ctx, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSwapOut", reflect.TypeOf((*MockSigner)(nil).SignSwapOut), ctx, swapOut) } @@ -2108,7 +2187,7 @@ func (m *MockSigner) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockSignerMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockSigner)(nil).Start), ctx) } @@ -2122,7 +2201,7 @@ func (m *MockSigner) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockSignerMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockSigner)(nil).Stop), ctx) } @@ -2137,7 +2216,7 @@ func (m *MockSigner) SwapOut(ctx context.Context, swapOut *types1.MsgSwapOut) (s } // SwapOut indicates an expected call of SwapOut. -func (mr *MockSignerMockRecorder) SwapOut(ctx, swapOut interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) SwapOut(ctx, swapOut any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapOut", reflect.TypeOf((*MockSigner)(nil).SwapOut), ctx, swapOut) } @@ -2152,7 +2231,7 @@ func (m *MockSigner) UpdateSPPrice(ctx context.Context, price *types.MsgUpdateSp } // UpdateSPPrice indicates an expected call of UpdateSPPrice. -func (mr *MockSignerMockRecorder) UpdateSPPrice(ctx, price interface{}) *gomock.Call { +func (mr *MockSignerMockRecorder) UpdateSPPrice(ctx, price any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSPPrice", reflect.TypeOf((*MockSigner)(nil).UpdateSPPrice), ctx, price) } @@ -2189,7 +2268,7 @@ func (m *MockUploader) HandleResumableUploadObjectTask(ctx context.Context, task } // HandleResumableUploadObjectTask indicates an expected call of HandleResumableUploadObjectTask. -func (mr *MockUploaderMockRecorder) HandleResumableUploadObjectTask(ctx, task, stream interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) HandleResumableUploadObjectTask(ctx, task, stream any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResumableUploadObjectTask", reflect.TypeOf((*MockUploader)(nil).HandleResumableUploadObjectTask), ctx, task, stream) } @@ -2203,7 +2282,7 @@ func (m *MockUploader) HandleUploadObjectTask(ctx context.Context, task task.Upl } // HandleUploadObjectTask indicates an expected call of HandleUploadObjectTask. -func (mr *MockUploaderMockRecorder) HandleUploadObjectTask(ctx, task, stream interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) HandleUploadObjectTask(ctx, task, stream any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleUploadObjectTask", reflect.TypeOf((*MockUploader)(nil).HandleUploadObjectTask), ctx, task, stream) } @@ -2229,7 +2308,7 @@ func (m *MockUploader) PostResumableUploadObject(ctx context.Context, task task. } // PostResumableUploadObject indicates an expected call of PostResumableUploadObject. -func (mr *MockUploaderMockRecorder) PostResumableUploadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) PostResumableUploadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostResumableUploadObject", reflect.TypeOf((*MockUploader)(nil).PostResumableUploadObject), ctx, task) } @@ -2241,7 +2320,7 @@ func (m *MockUploader) PostUploadObject(ctx context.Context, task task.UploadObj } // PostUploadObject indicates an expected call of PostUploadObject. -func (mr *MockUploaderMockRecorder) PostUploadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) PostUploadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostUploadObject", reflect.TypeOf((*MockUploader)(nil).PostUploadObject), ctx, task) } @@ -2255,7 +2334,7 @@ func (m *MockUploader) PreResumableUploadObject(ctx context.Context, task task.R } // PreResumableUploadObject indicates an expected call of PreResumableUploadObject. -func (mr *MockUploaderMockRecorder) PreResumableUploadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) PreResumableUploadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreResumableUploadObject", reflect.TypeOf((*MockUploader)(nil).PreResumableUploadObject), ctx, task) } @@ -2269,7 +2348,7 @@ func (m *MockUploader) PreUploadObject(ctx context.Context, task task.UploadObje } // PreUploadObject indicates an expected call of PreUploadObject. -func (mr *MockUploaderMockRecorder) PreUploadObject(ctx, task interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) PreUploadObject(ctx, task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreUploadObject", reflect.TypeOf((*MockUploader)(nil).PreUploadObject), ctx, task) } @@ -2284,7 +2363,7 @@ func (m *MockUploader) QueryTasks(ctx context.Context, subKey task.TKey) ([]task } // QueryTasks indicates an expected call of QueryTasks. -func (mr *MockUploaderMockRecorder) QueryTasks(ctx, subKey interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockUploader)(nil).QueryTasks), ctx, subKey) } @@ -2296,7 +2375,7 @@ func (m *MockUploader) ReleaseResource(ctx context.Context, scope rcmgr.Resource } // ReleaseResource indicates an expected call of ReleaseResource. -func (mr *MockUploaderMockRecorder) ReleaseResource(ctx, scope interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockUploader)(nil).ReleaseResource), ctx, scope) } @@ -2311,7 +2390,7 @@ func (m *MockUploader) ReserveResource(ctx context.Context, state *rcmgr.ScopeSt } // ReserveResource indicates an expected call of ReserveResource. -func (mr *MockUploaderMockRecorder) ReserveResource(ctx, state interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) ReserveResource(ctx, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockUploader)(nil).ReserveResource), ctx, state) } @@ -2325,7 +2404,7 @@ func (m *MockUploader) Start(ctx context.Context) error { } // Start indicates an expected call of Start. -func (mr *MockUploaderMockRecorder) Start(ctx interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) Start(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockUploader)(nil).Start), ctx) } @@ -2339,7 +2418,7 @@ func (m *MockUploader) Stop(ctx context.Context) error { } // Stop indicates an expected call of Stop. -func (mr *MockUploaderMockRecorder) Stop(ctx interface{}) *gomock.Call { +func (mr *MockUploaderMockRecorder) Stop(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockUploader)(nil).Stop), ctx) } diff --git a/core/module/null_modular.go b/core/module/null_modular.go index 2fea71053..b89fda013 100644 --- a/core/module/null_modular.go +++ b/core/module/null_modular.go @@ -85,6 +85,10 @@ func (m *NullModular) ResetRecoveryFailedList(ctx context.Context) []string { return nil } +func (m *NullModular) TriggerRecoverForSuccessorSP(ctx context.Context, vgfID, gvgID uint32, redundancyIndex int32) error { + return nil +} + func (*NullModular) PreCreateObjectApproval(context.Context, task.ApprovalCreateObjectTask) error { return ErrNilModular } @@ -311,6 +315,9 @@ func (*NilModular) SignMigrateGVG(ctx context.Context, task *gfsptask.GfSpMigrat func (*NilModular) SignBucketMigrationInfo(ctx context.Context, task *gfsptask.GfSpBucketMigrationInfo) ([]byte, error) { return nil, ErrNilModular } +func (m *NilModular) ReserveSwapIn(ctx context.Context, reserveSwapIn *virtualgrouptypes.MsgReserveSwapIn) (string, error) { + return "", ErrNilModular +} var _ Receiver = (*NullReceiveModular)(nil) @@ -332,3 +339,12 @@ func (*NullReceiveModular) HandleReceivePieceTask(context.Context, task.ReceiveP func (*NullReceiveModular) HandleDoneReceivePieceTask(context.Context, task.ReceivePieceTask) ([]byte, error) { return nil, ErrNilModular } +func (m *NullModular) QueryRecoverProcess(context.Context, uint32, uint32) ([]*gfspserver.RecoverProcess, bool, error) { + return nil, false, ErrNilModular +} +func (m *NilModular) CompleteSwapIn(ctx context.Context, reserveSwapIn *virtualgrouptypes.MsgCompleteSwapIn) (string, error) { + return "nil", ErrNilModular +} +func (m *NilModular) CancelSwapIn(ctx context.Context, cancelSwapIn *virtualgrouptypes.MsgCancelSwapIn) (string, error) { + return "nil", ErrNilModular +} diff --git a/core/spdb/entity.go b/core/spdb/entity.go index 8575aef0e..e1603f4ae 100644 --- a/core/spdb/entity.go +++ b/core/spdb/entity.go @@ -132,6 +132,31 @@ type SwapOutMeta struct { CompletedGVGs []uint32 } +type RecoverStatus int + +const ( + Processing RecoverStatus = 0 + Processed RecoverStatus = 1 + Completed RecoverStatus = 2 +) + +type RecoverGVGStats struct { + VirtualGroupID uint32 + VirtualGroupFamilyID uint32 + RedundancyIndex int32 + StartAfter uint64 + Limit uint64 + Status RecoverStatus + ObjectCount uint64 +} + +type RecoverFailedObject struct { + ObjectID uint64 + VirtualGroupID uint32 + RedundancyIndex int32 + RetryTime int +} + // MigrateBucketProgressMeta is used to record migrate bucket progress meta. type MigrateBucketProgressMeta struct { BucketID uint64 // as primary key diff --git a/core/spdb/spdb.go b/core/spdb/spdb.go index dc16f5675..7ef66ac8c 100644 --- a/core/spdb/spdb.go +++ b/core/spdb/spdb.go @@ -19,6 +19,7 @@ type SPDB interface { SPInfoDB OffChainAuthKeyDB MigrateDB + ExitRecoverDB } // UploadObjectProgressDB interface which records upload object related progress(includes foreground and background) and state. @@ -85,6 +86,8 @@ type SignatureDB interface { */ // SetReplicatePieceChecksum sets(maybe overwrite) the piece hash. SetReplicatePieceChecksum(objectID uint64, segmentIdx uint32, redundancyIdx int32, checksum []byte) error + // GetReplicatePieceChecksum gets all piece hashes. + GetReplicatePieceChecksum(objectID uint64, segmentIdx uint32, redundancyIdx int32) ([]byte, error) // GetAllReplicatePieceChecksum gets all piece hashes. GetAllReplicatePieceChecksum(objectID uint64, redundancyIdx int32, pieceCount uint32) ([][]byte, error) // GetAllReplicatePieceChecksumOptimized gets all piece hashes. @@ -223,3 +226,32 @@ type MigrateDB interface { // DeleteMigrateBucket delete the bucket migrate status DeleteMigrateBucket(bucketID uint64) error } + +// ExitRecoverDB is used to support sp exit and recover resource. +type ExitRecoverDB interface { + // GetRecoverGVGStats return recover gvg stats + GetRecoverGVGStats(gvgID uint32) (*RecoverGVGStats, error) + // BatchGetRecoverGVGStats return recover gvg stats list + BatchGetRecoverGVGStats(gvgID []uint32) ([]*RecoverGVGStats, error) + // SetRecoverGVGStats insert a recover gvg stats unit + SetRecoverGVGStats(stats []*RecoverGVGStats) error + // UpdateRecoverGVGStats update recover gvg stats + UpdateRecoverGVGStats(stats *RecoverGVGStats) (err error) + // DeleteRecoverGVGStats delete recover gvg stats + DeleteRecoverGVGStats(gvgID uint32) (err error) + + // InsertRecoverFailedObject inserts a new failed object unit. + InsertRecoverFailedObject(object *RecoverFailedObject) error + // UpdateRecoverFailedObject update failed object unit + UpdateRecoverFailedObject(object *RecoverFailedObject) (err error) + // DeleteRecoverFailedObject delete failed object unit + DeleteRecoverFailedObject(objectID uint64) (err error) + // GetRecoverFailedObject return the failed object. + GetRecoverFailedObject(objectID uint64) (*RecoverFailedObject, error) + // GetRecoverFailedObjects return the failed object by retry time + GetRecoverFailedObjects(retry, limit uint32) ([]*RecoverFailedObject, error) + // GetRecoverFailedObjectsByRetryTime return the failed object by retry time + GetRecoverFailedObjectsByRetryTime(retry uint32) ([]*RecoverFailedObject, error) + // CountRecoverFailedObject return the failed object total count + CountRecoverFailedObject() (int64, error) +} diff --git a/core/spdb/spdb_mock.go b/core/spdb/spdb_mock.go index 580de2b99..683f0d6f4 100644 --- a/core/spdb/spdb_mock.go +++ b/core/spdb/spdb_mock.go @@ -1,6 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: core/spdb/spdb.go - +// Source: ./spdb.go +// +// Generated by this command: +// +// mockgen -source=./spdb.go -destination=./spdb_mock.go -package=spdb +// // Package spdb is a generated GoMock package. package spdb @@ -37,6 +41,21 @@ func (m *MockSPDB) EXPECT() *MockSPDBMockRecorder { return m.recorder } +// BatchGetRecoverGVGStats mocks base method. +func (m *MockSPDB) BatchGetRecoverGVGStats(gvgID []uint32) ([]*RecoverGVGStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetRecoverGVGStats", gvgID) + ret0, _ := ret[0].([]*RecoverGVGStats) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetRecoverGVGStats indicates an expected call of BatchGetRecoverGVGStats. +func (mr *MockSPDBMockRecorder) BatchGetRecoverGVGStats(gvgID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetRecoverGVGStats", reflect.TypeOf((*MockSPDB)(nil).BatchGetRecoverGVGStats), gvgID) +} + // CheckQuotaAndAddReadRecord mocks base method. func (m *MockSPDB) CheckQuotaAndAddReadRecord(record *ReadRecord, quota *BucketQuota) error { m.ctrl.T.Helper() @@ -46,11 +65,26 @@ func (m *MockSPDB) CheckQuotaAndAddReadRecord(record *ReadRecord, quota *BucketQ } // CheckQuotaAndAddReadRecord indicates an expected call of CheckQuotaAndAddReadRecord. -func (mr *MockSPDBMockRecorder) CheckQuotaAndAddReadRecord(record, quota interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) CheckQuotaAndAddReadRecord(record, quota any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckQuotaAndAddReadRecord", reflect.TypeOf((*MockSPDB)(nil).CheckQuotaAndAddReadRecord), record, quota) } +// CountRecoverFailedObject mocks base method. +func (m *MockSPDB) CountRecoverFailedObject() (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CountRecoverFailedObject") + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CountRecoverFailedObject indicates an expected call of CountRecoverFailedObject. +func (mr *MockSPDBMockRecorder) CountRecoverFailedObject() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountRecoverFailedObject", reflect.TypeOf((*MockSPDB)(nil).CountRecoverFailedObject)) +} + // DeleteAllReplicatePieceChecksum mocks base method. func (m *MockSPDB) DeleteAllReplicatePieceChecksum(objectID uint64, redundancyIdx int32, pieceCount uint32) error { m.ctrl.T.Helper() @@ -60,7 +94,7 @@ func (m *MockSPDB) DeleteAllReplicatePieceChecksum(objectID uint64, redundancyId } // DeleteAllReplicatePieceChecksum indicates an expected call of DeleteAllReplicatePieceChecksum. -func (mr *MockSPDBMockRecorder) DeleteAllReplicatePieceChecksum(objectID, redundancyIdx, pieceCount interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteAllReplicatePieceChecksum(objectID, redundancyIdx, pieceCount any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllReplicatePieceChecksum", reflect.TypeOf((*MockSPDB)(nil).DeleteAllReplicatePieceChecksum), objectID, redundancyIdx, pieceCount) } @@ -74,7 +108,7 @@ func (m *MockSPDB) DeleteAllReplicatePieceChecksumOptimized(objectID uint64, red } // DeleteAllReplicatePieceChecksumOptimized indicates an expected call of DeleteAllReplicatePieceChecksumOptimized. -func (mr *MockSPDBMockRecorder) DeleteAllReplicatePieceChecksumOptimized(objectID, redundancyIdx interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteAllReplicatePieceChecksumOptimized(objectID, redundancyIdx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllReplicatePieceChecksumOptimized", reflect.TypeOf((*MockSPDB)(nil).DeleteAllReplicatePieceChecksumOptimized), objectID, redundancyIdx) } @@ -88,7 +122,7 @@ func (m *MockSPDB) DeleteExpiredBucketTraffic(yearMonth string) error { } // DeleteExpiredBucketTraffic indicates an expected call of DeleteExpiredBucketTraffic. -func (mr *MockSPDBMockRecorder) DeleteExpiredBucketTraffic(yearMonth interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteExpiredBucketTraffic(yearMonth any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpiredBucketTraffic", reflect.TypeOf((*MockSPDB)(nil).DeleteExpiredBucketTraffic), yearMonth) } @@ -102,7 +136,7 @@ func (m *MockSPDB) DeleteExpiredReadRecord(ts, limit uint64) error { } // DeleteExpiredReadRecord indicates an expected call of DeleteExpiredReadRecord. -func (mr *MockSPDBMockRecorder) DeleteExpiredReadRecord(ts, limit interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteExpiredReadRecord(ts, limit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpiredReadRecord", reflect.TypeOf((*MockSPDB)(nil).DeleteExpiredReadRecord), ts, limit) } @@ -116,7 +150,7 @@ func (m *MockSPDB) DeleteGCObjectProgress(taskKey string) error { } // DeleteGCObjectProgress indicates an expected call of DeleteGCObjectProgress. -func (mr *MockSPDBMockRecorder) DeleteGCObjectProgress(taskKey interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteGCObjectProgress(taskKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGCObjectProgress", reflect.TypeOf((*MockSPDB)(nil).DeleteGCObjectProgress), taskKey) } @@ -130,7 +164,7 @@ func (m *MockSPDB) DeleteMigrateBucket(bucketID uint64) error { } // DeleteMigrateBucket indicates an expected call of DeleteMigrateBucket. -func (mr *MockSPDBMockRecorder) DeleteMigrateBucket(bucketID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteMigrateBucket(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMigrateBucket", reflect.TypeOf((*MockSPDB)(nil).DeleteMigrateBucket), bucketID) } @@ -144,7 +178,7 @@ func (m *MockSPDB) DeleteMigrateGVGUnit(meta *MigrateGVGUnitMeta) error { } // DeleteMigrateGVGUnit indicates an expected call of DeleteMigrateGVGUnit. -func (mr *MockSPDBMockRecorder) DeleteMigrateGVGUnit(meta interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteMigrateGVGUnit(meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMigrateGVGUnit", reflect.TypeOf((*MockSPDB)(nil).DeleteMigrateGVGUnit), meta) } @@ -158,7 +192,7 @@ func (m *MockSPDB) DeleteMigrateGVGUnitsByBucketID(bucketID uint64) error { } // DeleteMigrateGVGUnitsByBucketID indicates an expected call of DeleteMigrateGVGUnitsByBucketID. -func (mr *MockSPDBMockRecorder) DeleteMigrateGVGUnitsByBucketID(bucketID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteMigrateGVGUnitsByBucketID(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMigrateGVGUnitsByBucketID", reflect.TypeOf((*MockSPDB)(nil).DeleteMigrateGVGUnitsByBucketID), bucketID) } @@ -172,11 +206,39 @@ func (m *MockSPDB) DeleteObjectIntegrity(objectID uint64, redundancyIndex int32) } // DeleteObjectIntegrity indicates an expected call of DeleteObjectIntegrity. -func (mr *MockSPDBMockRecorder) DeleteObjectIntegrity(objectID, redundancyIndex interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteObjectIntegrity(objectID, redundancyIndex any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectIntegrity", reflect.TypeOf((*MockSPDB)(nil).DeleteObjectIntegrity), objectID, redundancyIndex) } +// DeleteRecoverFailedObject mocks base method. +func (m *MockSPDB) DeleteRecoverFailedObject(objectID uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRecoverFailedObject", objectID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteRecoverFailedObject indicates an expected call of DeleteRecoverFailedObject. +func (mr *MockSPDBMockRecorder) DeleteRecoverFailedObject(objectID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRecoverFailedObject", reflect.TypeOf((*MockSPDB)(nil).DeleteRecoverFailedObject), objectID) +} + +// DeleteRecoverGVGStats mocks base method. +func (m *MockSPDB) DeleteRecoverGVGStats(gvgID uint32) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRecoverGVGStats", gvgID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteRecoverGVGStats indicates an expected call of DeleteRecoverGVGStats. +func (mr *MockSPDBMockRecorder) DeleteRecoverGVGStats(gvgID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRecoverGVGStats", reflect.TypeOf((*MockSPDB)(nil).DeleteRecoverGVGStats), gvgID) +} + // DeleteReplicatePieceChecksum mocks base method. func (m *MockSPDB) DeleteReplicatePieceChecksum(objectID uint64, segmentIdx uint32, redundancyIdx int32) error { m.ctrl.T.Helper() @@ -186,7 +248,7 @@ func (m *MockSPDB) DeleteReplicatePieceChecksum(objectID uint64, segmentIdx uint } // DeleteReplicatePieceChecksum indicates an expected call of DeleteReplicatePieceChecksum. -func (mr *MockSPDBMockRecorder) DeleteReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicatePieceChecksum", reflect.TypeOf((*MockSPDB)(nil).DeleteReplicatePieceChecksum), objectID, segmentIdx, redundancyIdx) } @@ -200,7 +262,7 @@ func (m *MockSPDB) DeleteUploadProgress(objectID uint64) error { } // DeleteUploadProgress indicates an expected call of DeleteUploadProgress. -func (mr *MockSPDBMockRecorder) DeleteUploadProgress(objectID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) DeleteUploadProgress(objectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUploadProgress", reflect.TypeOf((*MockSPDB)(nil).DeleteUploadProgress), objectID) } @@ -208,7 +270,7 @@ func (mr *MockSPDBMockRecorder) DeleteUploadProgress(objectID interface{}) *gomo // FetchAllSp mocks base method. func (m *MockSPDB) FetchAllSp(status ...types0.Status) ([]*types0.StorageProvider, error) { m.ctrl.T.Helper() - varargs := []interface{}{} + varargs := []any{} for _, a := range status { varargs = append(varargs, a) } @@ -219,7 +281,7 @@ func (m *MockSPDB) FetchAllSp(status ...types0.Status) ([]*types0.StorageProvide } // FetchAllSp indicates an expected call of FetchAllSp. -func (mr *MockSPDBMockRecorder) FetchAllSp(status ...interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) FetchAllSp(status ...any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchAllSp", reflect.TypeOf((*MockSPDB)(nil).FetchAllSp), status...) } @@ -227,7 +289,7 @@ func (mr *MockSPDBMockRecorder) FetchAllSp(status ...interface{}) *gomock.Call { // FetchAllSpWithoutOwnSp mocks base method. func (m *MockSPDB) FetchAllSpWithoutOwnSp(status ...types0.Status) ([]*types0.StorageProvider, error) { m.ctrl.T.Helper() - varargs := []interface{}{} + varargs := []any{} for _, a := range status { varargs = append(varargs, a) } @@ -238,7 +300,7 @@ func (m *MockSPDB) FetchAllSpWithoutOwnSp(status ...types0.Status) ([]*types0.St } // FetchAllSpWithoutOwnSp indicates an expected call of FetchAllSpWithoutOwnSp. -func (mr *MockSPDBMockRecorder) FetchAllSpWithoutOwnSp(status ...interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) FetchAllSpWithoutOwnSp(status ...any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchAllSpWithoutOwnSp", reflect.TypeOf((*MockSPDB)(nil).FetchAllSpWithoutOwnSp), status...) } @@ -253,7 +315,7 @@ func (m *MockSPDB) GetAllReplicatePieceChecksum(objectID uint64, redundancyIdx i } // GetAllReplicatePieceChecksum indicates an expected call of GetAllReplicatePieceChecksum. -func (mr *MockSPDBMockRecorder) GetAllReplicatePieceChecksum(objectID, redundancyIdx, pieceCount interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetAllReplicatePieceChecksum(objectID, redundancyIdx, pieceCount any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllReplicatePieceChecksum", reflect.TypeOf((*MockSPDB)(nil).GetAllReplicatePieceChecksum), objectID, redundancyIdx, pieceCount) } @@ -268,7 +330,7 @@ func (m *MockSPDB) GetAllReplicatePieceChecksumOptimized(objectID uint64, redund } // GetAllReplicatePieceChecksumOptimized indicates an expected call of GetAllReplicatePieceChecksumOptimized. -func (mr *MockSPDBMockRecorder) GetAllReplicatePieceChecksumOptimized(objectID, redundancyIdx, pieceCount interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetAllReplicatePieceChecksumOptimized(objectID, redundancyIdx, pieceCount any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllReplicatePieceChecksumOptimized", reflect.TypeOf((*MockSPDB)(nil).GetAllReplicatePieceChecksumOptimized), objectID, redundancyIdx, pieceCount) } @@ -283,7 +345,7 @@ func (m *MockSPDB) GetAuthKey(userAddress, domain string) (*OffChainAuthKey, err } // GetAuthKey indicates an expected call of GetAuthKey. -func (mr *MockSPDBMockRecorder) GetAuthKey(userAddress, domain interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetAuthKey(userAddress, domain any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthKey", reflect.TypeOf((*MockSPDB)(nil).GetAuthKey), userAddress, domain) } @@ -298,7 +360,7 @@ func (m *MockSPDB) GetBucketReadRecord(bucketID uint64, timeRange *TrafficTimeRa } // GetBucketReadRecord indicates an expected call of GetBucketReadRecord. -func (mr *MockSPDBMockRecorder) GetBucketReadRecord(bucketID, timeRange interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetBucketReadRecord(bucketID, timeRange any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReadRecord", reflect.TypeOf((*MockSPDB)(nil).GetBucketReadRecord), bucketID, timeRange) } @@ -313,7 +375,7 @@ func (m *MockSPDB) GetBucketTraffic(bucketID uint64, yearMonth string) (*BucketT } // GetBucketTraffic indicates an expected call of GetBucketTraffic. -func (mr *MockSPDBMockRecorder) GetBucketTraffic(bucketID, yearMonth interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetBucketTraffic(bucketID, yearMonth any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTraffic", reflect.TypeOf((*MockSPDB)(nil).GetBucketTraffic), bucketID, yearMonth) } @@ -328,7 +390,7 @@ func (m *MockSPDB) GetGCMetasToGC(limit int) ([]*GCObjectMeta, error) { } // GetGCMetasToGC indicates an expected call of GetGCMetasToGC. -func (mr *MockSPDBMockRecorder) GetGCMetasToGC(limit interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetGCMetasToGC(limit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGCMetasToGC", reflect.TypeOf((*MockSPDB)(nil).GetGCMetasToGC), limit) } @@ -343,7 +405,7 @@ func (m *MockSPDB) GetLatestBucketTraffic(bucketID uint64) (*BucketTraffic, erro } // GetLatestBucketTraffic indicates an expected call of GetLatestBucketTraffic. -func (mr *MockSPDBMockRecorder) GetLatestBucketTraffic(bucketID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetLatestBucketTraffic(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestBucketTraffic", reflect.TypeOf((*MockSPDB)(nil).GetLatestBucketTraffic), bucketID) } @@ -358,7 +420,7 @@ func (m *MockSPDB) GetObjectIntegrity(objectID uint64, redundancyIndex int32) (* } // GetObjectIntegrity indicates an expected call of GetObjectIntegrity. -func (mr *MockSPDBMockRecorder) GetObjectIntegrity(objectID, redundancyIndex interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetObjectIntegrity(objectID, redundancyIndex any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectIntegrity", reflect.TypeOf((*MockSPDB)(nil).GetObjectIntegrity), objectID, redundancyIndex) } @@ -373,7 +435,7 @@ func (m *MockSPDB) GetObjectReadRecord(objectID uint64, timeRange *TrafficTimeRa } // GetObjectReadRecord indicates an expected call of GetObjectReadRecord. -func (mr *MockSPDBMockRecorder) GetObjectReadRecord(objectID, timeRange interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetObjectReadRecord(objectID, timeRange any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectReadRecord", reflect.TypeOf((*MockSPDB)(nil).GetObjectReadRecord), objectID, timeRange) } @@ -403,11 +465,86 @@ func (m *MockSPDB) GetReadRecord(timeRange *TrafficTimeRange) ([]*ReadRecord, er } // GetReadRecord indicates an expected call of GetReadRecord. -func (mr *MockSPDBMockRecorder) GetReadRecord(timeRange interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetReadRecord(timeRange any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReadRecord", reflect.TypeOf((*MockSPDB)(nil).GetReadRecord), timeRange) } +// GetRecoverFailedObject mocks base method. +func (m *MockSPDB) GetRecoverFailedObject(objectID uint64) (*RecoverFailedObject, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecoverFailedObject", objectID) + ret0, _ := ret[0].(*RecoverFailedObject) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecoverFailedObject indicates an expected call of GetRecoverFailedObject. +func (mr *MockSPDBMockRecorder) GetRecoverFailedObject(objectID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecoverFailedObject", reflect.TypeOf((*MockSPDB)(nil).GetRecoverFailedObject), objectID) +} + +// GetRecoverFailedObjects mocks base method. +func (m *MockSPDB) GetRecoverFailedObjects(retry, limit uint32) ([]*RecoverFailedObject, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecoverFailedObjects", retry, limit) + ret0, _ := ret[0].([]*RecoverFailedObject) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecoverFailedObjects indicates an expected call of GetRecoverFailedObjects. +func (mr *MockSPDBMockRecorder) GetRecoverFailedObjects(retry, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecoverFailedObjects", reflect.TypeOf((*MockSPDB)(nil).GetRecoverFailedObjects), retry, limit) +} + +// GetRecoverFailedObjectsByRetryTime mocks base method. +func (m *MockSPDB) GetRecoverFailedObjectsByRetryTime(retry uint32) ([]*RecoverFailedObject, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecoverFailedObjectsByRetryTime", retry) + ret0, _ := ret[0].([]*RecoverFailedObject) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecoverFailedObjectsByRetryTime indicates an expected call of GetRecoverFailedObjectsByRetryTime. +func (mr *MockSPDBMockRecorder) GetRecoverFailedObjectsByRetryTime(retry any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecoverFailedObjectsByRetryTime", reflect.TypeOf((*MockSPDB)(nil).GetRecoverFailedObjectsByRetryTime), retry) +} + +// GetRecoverGVGStats mocks base method. +func (m *MockSPDB) GetRecoverGVGStats(gvgID uint32) (*RecoverGVGStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecoverGVGStats", gvgID) + ret0, _ := ret[0].(*RecoverGVGStats) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecoverGVGStats indicates an expected call of GetRecoverGVGStats. +func (mr *MockSPDBMockRecorder) GetRecoverGVGStats(gvgID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecoverGVGStats", reflect.TypeOf((*MockSPDB)(nil).GetRecoverGVGStats), gvgID) +} + +// GetReplicatePieceChecksum mocks base method. +func (m *MockSPDB) GetReplicatePieceChecksum(objectID uint64, segmentIdx uint32, redundancyIdx int32) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReplicatePieceChecksum", objectID, segmentIdx, redundancyIdx) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetReplicatePieceChecksum indicates an expected call of GetReplicatePieceChecksum. +func (mr *MockSPDBMockRecorder) GetReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicatePieceChecksum", reflect.TypeOf((*MockSPDB)(nil).GetReplicatePieceChecksum), objectID, segmentIdx, redundancyIdx) +} + // GetSpByAddress mocks base method. func (m *MockSPDB) GetSpByAddress(address string, addressType SpAddressType) (*types0.StorageProvider, error) { m.ctrl.T.Helper() @@ -418,7 +555,7 @@ func (m *MockSPDB) GetSpByAddress(address string, addressType SpAddressType) (*t } // GetSpByAddress indicates an expected call of GetSpByAddress. -func (mr *MockSPDBMockRecorder) GetSpByAddress(address, addressType interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetSpByAddress(address, addressType any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpByAddress", reflect.TypeOf((*MockSPDB)(nil).GetSpByAddress), address, addressType) } @@ -433,7 +570,7 @@ func (m *MockSPDB) GetSpByEndpoint(endpoint string) (*types0.StorageProvider, er } // GetSpByEndpoint indicates an expected call of GetSpByEndpoint. -func (mr *MockSPDBMockRecorder) GetSpByEndpoint(endpoint interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetSpByEndpoint(endpoint any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpByEndpoint", reflect.TypeOf((*MockSPDB)(nil).GetSpByEndpoint), endpoint) } @@ -448,7 +585,7 @@ func (m *MockSPDB) GetSpByID(id uint32) (*types0.StorageProvider, error) { } // GetSpByID indicates an expected call of GetSpByID. -func (mr *MockSPDBMockRecorder) GetSpByID(id interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetSpByID(id any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpByID", reflect.TypeOf((*MockSPDB)(nil).GetSpByID), id) } @@ -463,7 +600,7 @@ func (m *MockSPDB) GetUploadMetasToRejectUnsealByRangeTS(limit int, startTimeSta } // GetUploadMetasToRejectUnsealByRangeTS indicates an expected call of GetUploadMetasToRejectUnsealByRangeTS. -func (mr *MockSPDBMockRecorder) GetUploadMetasToRejectUnsealByRangeTS(limit, startTimeStamp, endTimeStamp interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetUploadMetasToRejectUnsealByRangeTS(limit, startTimeStamp, endTimeStamp any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToRejectUnsealByRangeTS", reflect.TypeOf((*MockSPDB)(nil).GetUploadMetasToRejectUnsealByRangeTS), limit, startTimeStamp, endTimeStamp) } @@ -478,7 +615,7 @@ func (m *MockSPDB) GetUploadMetasToReplicate(limit int, timeout int64) ([]*Uploa } // GetUploadMetasToReplicate indicates an expected call of GetUploadMetasToReplicate. -func (mr *MockSPDBMockRecorder) GetUploadMetasToReplicate(limit, timeout interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetUploadMetasToReplicate(limit, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToReplicate", reflect.TypeOf((*MockSPDB)(nil).GetUploadMetasToReplicate), limit, timeout) } @@ -493,7 +630,7 @@ func (m *MockSPDB) GetUploadMetasToReplicateByStartTS(limit int, startTimeStamp } // GetUploadMetasToReplicateByStartTS indicates an expected call of GetUploadMetasToReplicateByStartTS. -func (mr *MockSPDBMockRecorder) GetUploadMetasToReplicateByStartTS(limit, startTimeStamp interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetUploadMetasToReplicateByStartTS(limit, startTimeStamp any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToReplicateByStartTS", reflect.TypeOf((*MockSPDB)(nil).GetUploadMetasToReplicateByStartTS), limit, startTimeStamp) } @@ -508,7 +645,7 @@ func (m *MockSPDB) GetUploadMetasToSeal(limit int, timeout int64) ([]*UploadObje } // GetUploadMetasToSeal indicates an expected call of GetUploadMetasToSeal. -func (mr *MockSPDBMockRecorder) GetUploadMetasToSeal(limit, timeout interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetUploadMetasToSeal(limit, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToSeal", reflect.TypeOf((*MockSPDB)(nil).GetUploadMetasToSeal), limit, timeout) } @@ -523,7 +660,7 @@ func (m *MockSPDB) GetUploadMetasToSealByStartTS(limit int, startTimeStamp int64 } // GetUploadMetasToSealByStartTS indicates an expected call of GetUploadMetasToSealByStartTS. -func (mr *MockSPDBMockRecorder) GetUploadMetasToSealByStartTS(limit, startTimeStamp interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetUploadMetasToSealByStartTS(limit, startTimeStamp any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToSealByStartTS", reflect.TypeOf((*MockSPDB)(nil).GetUploadMetasToSealByStartTS), limit, startTimeStamp) } @@ -539,7 +676,7 @@ func (m *MockSPDB) GetUploadState(objectID uint64) (types.TaskState, string, err } // GetUploadState indicates an expected call of GetUploadState. -func (mr *MockSPDBMockRecorder) GetUploadState(objectID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetUploadState(objectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadState", reflect.TypeOf((*MockSPDB)(nil).GetUploadState), objectID) } @@ -554,7 +691,7 @@ func (m *MockSPDB) GetUserReadRecord(userAddress string, timeRange *TrafficTimeR } // GetUserReadRecord indicates an expected call of GetUserReadRecord. -func (mr *MockSPDBMockRecorder) GetUserReadRecord(userAddress, timeRange interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) GetUserReadRecord(userAddress, timeRange any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserReadRecord", reflect.TypeOf((*MockSPDB)(nil).GetUserReadRecord), userAddress, timeRange) } @@ -568,7 +705,7 @@ func (m *MockSPDB) InitBucketTraffic(record *ReadRecord, quota *BucketQuota) err } // InitBucketTraffic indicates an expected call of InitBucketTraffic. -func (mr *MockSPDBMockRecorder) InitBucketTraffic(record, quota interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) InitBucketTraffic(record, quota any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitBucketTraffic", reflect.TypeOf((*MockSPDB)(nil).InitBucketTraffic), record, quota) } @@ -582,7 +719,7 @@ func (m *MockSPDB) InsertAuthKey(newRecord *OffChainAuthKey) error { } // InsertAuthKey indicates an expected call of InsertAuthKey. -func (mr *MockSPDBMockRecorder) InsertAuthKey(newRecord interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) InsertAuthKey(newRecord any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAuthKey", reflect.TypeOf((*MockSPDB)(nil).InsertAuthKey), newRecord) } @@ -596,7 +733,7 @@ func (m *MockSPDB) InsertGCObjectProgress(gcMeta *GCObjectMeta) error { } // InsertGCObjectProgress indicates an expected call of InsertGCObjectProgress. -func (mr *MockSPDBMockRecorder) InsertGCObjectProgress(gcMeta interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) InsertGCObjectProgress(gcMeta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertGCObjectProgress", reflect.TypeOf((*MockSPDB)(nil).InsertGCObjectProgress), gcMeta) } @@ -610,7 +747,7 @@ func (m *MockSPDB) InsertMigrateGVGUnit(meta *MigrateGVGUnitMeta) error { } // InsertMigrateGVGUnit indicates an expected call of InsertMigrateGVGUnit. -func (mr *MockSPDBMockRecorder) InsertMigrateGVGUnit(meta interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) InsertMigrateGVGUnit(meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMigrateGVGUnit", reflect.TypeOf((*MockSPDB)(nil).InsertMigrateGVGUnit), meta) } @@ -624,11 +761,25 @@ func (m *MockSPDB) InsertPutEvent(task task.Task) error { } // InsertPutEvent indicates an expected call of InsertPutEvent. -func (mr *MockSPDBMockRecorder) InsertPutEvent(task interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) InsertPutEvent(task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPutEvent", reflect.TypeOf((*MockSPDB)(nil).InsertPutEvent), task) } +// InsertRecoverFailedObject mocks base method. +func (m *MockSPDB) InsertRecoverFailedObject(object *RecoverFailedObject) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InsertRecoverFailedObject", object) + ret0, _ := ret[0].(error) + return ret0 +} + +// InsertRecoverFailedObject indicates an expected call of InsertRecoverFailedObject. +func (mr *MockSPDBMockRecorder) InsertRecoverFailedObject(object any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertRecoverFailedObject", reflect.TypeOf((*MockSPDB)(nil).InsertRecoverFailedObject), object) +} + // InsertSwapOutUnit mocks base method. func (m *MockSPDB) InsertSwapOutUnit(meta *SwapOutMeta) error { m.ctrl.T.Helper() @@ -638,7 +789,7 @@ func (m *MockSPDB) InsertSwapOutUnit(meta *SwapOutMeta) error { } // InsertSwapOutUnit indicates an expected call of InsertSwapOutUnit. -func (mr *MockSPDBMockRecorder) InsertSwapOutUnit(meta interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) InsertSwapOutUnit(meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertSwapOutUnit", reflect.TypeOf((*MockSPDB)(nil).InsertSwapOutUnit), meta) } @@ -652,7 +803,7 @@ func (m *MockSPDB) InsertUploadProgress(objectID uint64) error { } // InsertUploadProgress indicates an expected call of InsertUploadProgress. -func (mr *MockSPDBMockRecorder) InsertUploadProgress(objectID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) InsertUploadProgress(objectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertUploadProgress", reflect.TypeOf((*MockSPDB)(nil).InsertUploadProgress), objectID) } @@ -667,7 +818,7 @@ func (m *MockSPDB) ListBucketMigrationToConfirm(migrationStates []int) ([]*Migra } // ListBucketMigrationToConfirm indicates an expected call of ListBucketMigrationToConfirm. -func (mr *MockSPDBMockRecorder) ListBucketMigrationToConfirm(migrationStates interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) ListBucketMigrationToConfirm(migrationStates any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMigrationToConfirm", reflect.TypeOf((*MockSPDB)(nil).ListBucketMigrationToConfirm), migrationStates) } @@ -697,7 +848,7 @@ func (m *MockSPDB) ListIntegrityMetaByObjectIDRange(startObjectID, endObjectID i } // ListIntegrityMetaByObjectIDRange indicates an expected call of ListIntegrityMetaByObjectIDRange. -func (mr *MockSPDBMockRecorder) ListIntegrityMetaByObjectIDRange(startObjectID, endObjectID, includePrivate interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) ListIntegrityMetaByObjectIDRange(startObjectID, endObjectID, includePrivate any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIntegrityMetaByObjectIDRange", reflect.TypeOf((*MockSPDB)(nil).ListIntegrityMetaByObjectIDRange), startObjectID, endObjectID, includePrivate) } @@ -712,7 +863,7 @@ func (m *MockSPDB) ListMigrateGVGUnitsByBucketID(bucketID uint64) ([]*MigrateGVG } // ListMigrateGVGUnitsByBucketID indicates an expected call of ListMigrateGVGUnitsByBucketID. -func (mr *MockSPDBMockRecorder) ListMigrateGVGUnitsByBucketID(bucketID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) ListMigrateGVGUnitsByBucketID(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMigrateGVGUnitsByBucketID", reflect.TypeOf((*MockSPDB)(nil).ListMigrateGVGUnitsByBucketID), bucketID) } @@ -727,7 +878,7 @@ func (m *MockSPDB) ListReplicatePieceChecksumByObjectIDRange(startObjectID, endO } // ListReplicatePieceChecksumByObjectIDRange indicates an expected call of ListReplicatePieceChecksumByObjectIDRange. -func (mr *MockSPDBMockRecorder) ListReplicatePieceChecksumByObjectIDRange(startObjectID, endObjectID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) ListReplicatePieceChecksumByObjectIDRange(startObjectID, endObjectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReplicatePieceChecksumByObjectIDRange", reflect.TypeOf((*MockSPDB)(nil).ListReplicatePieceChecksumByObjectIDRange), startObjectID, endObjectID) } @@ -757,7 +908,7 @@ func (m *MockSPDB) QueryMigrateBucketProgress(bucketID uint64) (*MigrateBucketPr } // QueryMigrateBucketProgress indicates an expected call of QueryMigrateBucketProgress. -func (mr *MockSPDBMockRecorder) QueryMigrateBucketProgress(bucketID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) QueryMigrateBucketProgress(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateBucketProgress", reflect.TypeOf((*MockSPDB)(nil).QueryMigrateBucketProgress), bucketID) } @@ -772,7 +923,7 @@ func (m *MockSPDB) QueryMigrateBucketState(bucketID uint64) (int, error) { } // QueryMigrateBucketState indicates an expected call of QueryMigrateBucketState. -func (mr *MockSPDBMockRecorder) QueryMigrateBucketState(bucketID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) QueryMigrateBucketState(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateBucketState", reflect.TypeOf((*MockSPDB)(nil).QueryMigrateBucketState), bucketID) } @@ -787,7 +938,7 @@ func (m *MockSPDB) QueryMigrateGVGUnit(migrateKey string) (*MigrateGVGUnitMeta, } // QueryMigrateGVGUnit indicates an expected call of QueryMigrateGVGUnit. -func (mr *MockSPDBMockRecorder) QueryMigrateGVGUnit(migrateKey interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) QueryMigrateGVGUnit(migrateKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateGVGUnit", reflect.TypeOf((*MockSPDB)(nil).QueryMigrateGVGUnit), migrateKey) } @@ -832,7 +983,7 @@ func (m *MockSPDB) QuerySwapOutUnitInSrcSP(swapOutKey string) (*SwapOutMeta, err } // QuerySwapOutUnitInSrcSP indicates an expected call of QuerySwapOutUnitInSrcSP. -func (mr *MockSPDBMockRecorder) QuerySwapOutUnitInSrcSP(swapOutKey interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) QuerySwapOutUnitInSrcSP(swapOutKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySwapOutUnitInSrcSP", reflect.TypeOf((*MockSPDB)(nil).QuerySwapOutUnitInSrcSP), swapOutKey) } @@ -846,7 +997,7 @@ func (m *MockSPDB) SetObjectIntegrity(integrity *IntegrityMeta) error { } // SetObjectIntegrity indicates an expected call of SetObjectIntegrity. -func (mr *MockSPDBMockRecorder) SetObjectIntegrity(integrity interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) SetObjectIntegrity(integrity any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectIntegrity", reflect.TypeOf((*MockSPDB)(nil).SetObjectIntegrity), integrity) } @@ -860,11 +1011,25 @@ func (m *MockSPDB) SetOwnSpInfo(sp *types0.StorageProvider) error { } // SetOwnSpInfo indicates an expected call of SetOwnSpInfo. -func (mr *MockSPDBMockRecorder) SetOwnSpInfo(sp interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) SetOwnSpInfo(sp any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOwnSpInfo", reflect.TypeOf((*MockSPDB)(nil).SetOwnSpInfo), sp) } +// SetRecoverGVGStats mocks base method. +func (m *MockSPDB) SetRecoverGVGStats(stats []*RecoverGVGStats) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRecoverGVGStats", stats) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetRecoverGVGStats indicates an expected call of SetRecoverGVGStats. +func (mr *MockSPDBMockRecorder) SetRecoverGVGStats(stats any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRecoverGVGStats", reflect.TypeOf((*MockSPDB)(nil).SetRecoverGVGStats), stats) +} + // SetReplicatePieceChecksum mocks base method. func (m *MockSPDB) SetReplicatePieceChecksum(objectID uint64, segmentIdx uint32, redundancyIdx int32, checksum []byte) error { m.ctrl.T.Helper() @@ -874,7 +1039,7 @@ func (m *MockSPDB) SetReplicatePieceChecksum(objectID uint64, segmentIdx uint32, } // SetReplicatePieceChecksum indicates an expected call of SetReplicatePieceChecksum. -func (mr *MockSPDBMockRecorder) SetReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx, checksum interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) SetReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx, checksum any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReplicatePieceChecksum", reflect.TypeOf((*MockSPDB)(nil).SetReplicatePieceChecksum), objectID, segmentIdx, redundancyIdx, checksum) } @@ -888,7 +1053,7 @@ func (m *MockSPDB) UpdateAllSp(spList []*types0.StorageProvider) error { } // UpdateAllSp indicates an expected call of UpdateAllSp. -func (mr *MockSPDBMockRecorder) UpdateAllSp(spList interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateAllSp(spList any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAllSp", reflect.TypeOf((*MockSPDB)(nil).UpdateAllSp), spList) } @@ -902,7 +1067,7 @@ func (m *MockSPDB) UpdateAuthKey(userAddress, domain string, oldNonce, newNonce } // UpdateAuthKey indicates an expected call of UpdateAuthKey. -func (mr *MockSPDBMockRecorder) UpdateAuthKey(userAddress, domain, oldNonce, newNonce, newPublicKey, newExpiryDate interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateAuthKey(userAddress, domain, oldNonce, newNonce, newPublicKey, newExpiryDate any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthKey", reflect.TypeOf((*MockSPDB)(nil).UpdateAuthKey), userAddress, domain, oldNonce, newNonce, newPublicKey, newExpiryDate) } @@ -916,7 +1081,7 @@ func (m *MockSPDB) UpdateBucketMigrateGCSubscribeProgress(blockHeight uint64) er } // UpdateBucketMigrateGCSubscribeProgress indicates an expected call of UpdateBucketMigrateGCSubscribeProgress. -func (mr *MockSPDBMockRecorder) UpdateBucketMigrateGCSubscribeProgress(blockHeight interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateBucketMigrateGCSubscribeProgress(blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrateGCSubscribeProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrateGCSubscribeProgress), blockHeight) } @@ -930,7 +1095,7 @@ func (m *MockSPDB) UpdateBucketMigrateSubscribeProgress(blockHeight uint64) erro } // UpdateBucketMigrateSubscribeProgress indicates an expected call of UpdateBucketMigrateSubscribeProgress. -func (mr *MockSPDBMockRecorder) UpdateBucketMigrateSubscribeProgress(blockHeight interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateBucketMigrateSubscribeProgress(blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrateSubscribeProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrateSubscribeProgress), blockHeight) } @@ -944,7 +1109,7 @@ func (m *MockSPDB) UpdateBucketMigrationGCProgress(progressMeta MigrateBucketPro } // UpdateBucketMigrationGCProgress indicates an expected call of UpdateBucketMigrationGCProgress. -func (mr *MockSPDBMockRecorder) UpdateBucketMigrationGCProgress(progressMeta interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationGCProgress(progressMeta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationGCProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationGCProgress), progressMeta) } @@ -958,7 +1123,7 @@ func (m *MockSPDB) UpdateBucketMigrationMigratingProgress(bucketID uint64, gvgUn } // UpdateBucketMigrationMigratingProgress indicates an expected call of UpdateBucketMigrationMigratingProgress. -func (mr *MockSPDBMockRecorder) UpdateBucketMigrationMigratingProgress(bucketID, gvgUnits, gvgUnitsFinished interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationMigratingProgress(bucketID, gvgUnits, gvgUnitsFinished any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationMigratingProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationMigratingProgress), bucketID, gvgUnits, gvgUnitsFinished) } @@ -972,7 +1137,7 @@ func (m *MockSPDB) UpdateBucketMigrationPreDeductedQuota(bucketID, deductedQuota } // UpdateBucketMigrationPreDeductedQuota indicates an expected call of UpdateBucketMigrationPreDeductedQuota. -func (mr *MockSPDBMockRecorder) UpdateBucketMigrationPreDeductedQuota(bucketID, deductedQuota, state interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationPreDeductedQuota(bucketID, deductedQuota, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationPreDeductedQuota", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationPreDeductedQuota), bucketID, deductedQuota, state) } @@ -986,7 +1151,7 @@ func (m *MockSPDB) UpdateBucketMigrationProgress(bucketID uint64, migrateState i } // UpdateBucketMigrationProgress indicates an expected call of UpdateBucketMigrationProgress. -func (mr *MockSPDBMockRecorder) UpdateBucketMigrationProgress(bucketID, migrateState interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationProgress(bucketID, migrateState any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationProgress), bucketID, migrateState) } @@ -1000,7 +1165,7 @@ func (m *MockSPDB) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota uint64 } // UpdateBucketMigrationRecoupQuota indicates an expected call of UpdateBucketMigrationRecoupQuota. -func (mr *MockSPDBMockRecorder) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota, state interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationRecoupQuota", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketMigrationRecoupQuota), bucketID, recoupQuota, state) } @@ -1014,7 +1179,7 @@ func (m *MockSPDB) UpdateBucketTraffic(bucketID uint64, update *BucketTraffic) e } // UpdateBucketTraffic indicates an expected call of UpdateBucketTraffic. -func (mr *MockSPDBMockRecorder) UpdateBucketTraffic(bucketID, update interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateBucketTraffic(bucketID, update any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketTraffic", reflect.TypeOf((*MockSPDB)(nil).UpdateBucketTraffic), bucketID, update) } @@ -1028,7 +1193,7 @@ func (m *MockSPDB) UpdateExtraQuota(bucketID, extraQuota uint64, yearMonth strin } // UpdateExtraQuota indicates an expected call of UpdateExtraQuota. -func (mr *MockSPDBMockRecorder) UpdateExtraQuota(bucketID, extraQuota, yearMonth interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateExtraQuota(bucketID, extraQuota, yearMonth any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExtraQuota", reflect.TypeOf((*MockSPDB)(nil).UpdateExtraQuota), bucketID, extraQuota, yearMonth) } @@ -1042,7 +1207,7 @@ func (m *MockSPDB) UpdateGCObjectProgress(gcMeta *GCObjectMeta) error { } // UpdateGCObjectProgress indicates an expected call of UpdateGCObjectProgress. -func (mr *MockSPDBMockRecorder) UpdateGCObjectProgress(gcMeta interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateGCObjectProgress(gcMeta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGCObjectProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateGCObjectProgress), gcMeta) } @@ -1056,7 +1221,7 @@ func (m *MockSPDB) UpdateIntegrityChecksum(integrity *IntegrityMeta) error { } // UpdateIntegrityChecksum indicates an expected call of UpdateIntegrityChecksum. -func (mr *MockSPDBMockRecorder) UpdateIntegrityChecksum(integrity interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateIntegrityChecksum(integrity any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIntegrityChecksum", reflect.TypeOf((*MockSPDB)(nil).UpdateIntegrityChecksum), integrity) } @@ -1070,7 +1235,7 @@ func (m *MockSPDB) UpdateMigrateGVGMigratedBytesSize(migrateKey string, migrated } // UpdateMigrateGVGMigratedBytesSize indicates an expected call of UpdateMigrateGVGMigratedBytesSize. -func (mr *MockSPDBMockRecorder) UpdateMigrateGVGMigratedBytesSize(migrateKey, migratedBytes interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateMigrateGVGMigratedBytesSize(migrateKey, migratedBytes any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGMigratedBytesSize", reflect.TypeOf((*MockSPDB)(nil).UpdateMigrateGVGMigratedBytesSize), migrateKey, migratedBytes) } @@ -1084,7 +1249,7 @@ func (m *MockSPDB) UpdateMigrateGVGRetryCount(migrateKey string, retryTime int) } // UpdateMigrateGVGRetryCount indicates an expected call of UpdateMigrateGVGRetryCount. -func (mr *MockSPDBMockRecorder) UpdateMigrateGVGRetryCount(migrateKey, retryTime interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateMigrateGVGRetryCount(migrateKey, retryTime any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGRetryCount", reflect.TypeOf((*MockSPDB)(nil).UpdateMigrateGVGRetryCount), migrateKey, retryTime) } @@ -1098,7 +1263,7 @@ func (m *MockSPDB) UpdateMigrateGVGUnitLastMigrateObjectID(migrateKey string, la } // UpdateMigrateGVGUnitLastMigrateObjectID indicates an expected call of UpdateMigrateGVGUnitLastMigrateObjectID. -func (mr *MockSPDBMockRecorder) UpdateMigrateGVGUnitLastMigrateObjectID(migrateKey, lastMigrateObjectID interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateMigrateGVGUnitLastMigrateObjectID(migrateKey, lastMigrateObjectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGUnitLastMigrateObjectID", reflect.TypeOf((*MockSPDB)(nil).UpdateMigrateGVGUnitLastMigrateObjectID), migrateKey, lastMigrateObjectID) } @@ -1112,7 +1277,7 @@ func (m *MockSPDB) UpdateMigrateGVGUnitStatus(migrateKey string, migrateStatus i } // UpdateMigrateGVGUnitStatus indicates an expected call of UpdateMigrateGVGUnitStatus. -func (mr *MockSPDBMockRecorder) UpdateMigrateGVGUnitStatus(migrateKey, migrateStatus interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateMigrateGVGUnitStatus(migrateKey, migrateStatus any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGUnitStatus", reflect.TypeOf((*MockSPDB)(nil).UpdateMigrateGVGUnitStatus), migrateKey, migrateStatus) } @@ -1126,11 +1291,39 @@ func (m *MockSPDB) UpdatePieceChecksum(objectID uint64, redundancyIndex int32, c } // UpdatePieceChecksum indicates an expected call of UpdatePieceChecksum. -func (mr *MockSPDBMockRecorder) UpdatePieceChecksum(objectID, redundancyIndex, checksum interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdatePieceChecksum(objectID, redundancyIndex, checksum any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePieceChecksum", reflect.TypeOf((*MockSPDB)(nil).UpdatePieceChecksum), objectID, redundancyIndex, checksum) } +// UpdateRecoverFailedObject mocks base method. +func (m *MockSPDB) UpdateRecoverFailedObject(object *RecoverFailedObject) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRecoverFailedObject", object) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateRecoverFailedObject indicates an expected call of UpdateRecoverFailedObject. +func (mr *MockSPDBMockRecorder) UpdateRecoverFailedObject(object any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRecoverFailedObject", reflect.TypeOf((*MockSPDB)(nil).UpdateRecoverFailedObject), object) +} + +// UpdateRecoverGVGStats mocks base method. +func (m *MockSPDB) UpdateRecoverGVGStats(stats *RecoverGVGStats) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRecoverGVGStats", stats) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateRecoverGVGStats indicates an expected call of UpdateRecoverGVGStats. +func (mr *MockSPDBMockRecorder) UpdateRecoverGVGStats(stats any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRecoverGVGStats", reflect.TypeOf((*MockSPDB)(nil).UpdateRecoverGVGStats), stats) +} + // UpdateSPExitSubscribeProgress mocks base method. func (m *MockSPDB) UpdateSPExitSubscribeProgress(blockHeight uint64) error { m.ctrl.T.Helper() @@ -1140,7 +1333,7 @@ func (m *MockSPDB) UpdateSPExitSubscribeProgress(blockHeight uint64) error { } // UpdateSPExitSubscribeProgress indicates an expected call of UpdateSPExitSubscribeProgress. -func (mr *MockSPDBMockRecorder) UpdateSPExitSubscribeProgress(blockHeight interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateSPExitSubscribeProgress(blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSPExitSubscribeProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateSPExitSubscribeProgress), blockHeight) } @@ -1154,7 +1347,7 @@ func (m *MockSPDB) UpdateSwapOutSubscribeProgress(blockHeight uint64) error { } // UpdateSwapOutSubscribeProgress indicates an expected call of UpdateSwapOutSubscribeProgress. -func (mr *MockSPDBMockRecorder) UpdateSwapOutSubscribeProgress(blockHeight interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateSwapOutSubscribeProgress(blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSwapOutSubscribeProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateSwapOutSubscribeProgress), blockHeight) } @@ -1168,7 +1361,7 @@ func (m *MockSPDB) UpdateSwapOutUnitCompletedGVGList(swapOutKey string, complete } // UpdateSwapOutUnitCompletedGVGList indicates an expected call of UpdateSwapOutUnitCompletedGVGList. -func (mr *MockSPDBMockRecorder) UpdateSwapOutUnitCompletedGVGList(swapOutKey, completedGVGList interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateSwapOutUnitCompletedGVGList(swapOutKey, completedGVGList any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSwapOutUnitCompletedGVGList", reflect.TypeOf((*MockSPDB)(nil).UpdateSwapOutUnitCompletedGVGList), swapOutKey, completedGVGList) } @@ -1182,7 +1375,7 @@ func (m *MockSPDB) UpdateUploadProgress(uploadMeta *UploadObjectMeta) error { } // UpdateUploadProgress indicates an expected call of UpdateUploadProgress. -func (mr *MockSPDBMockRecorder) UpdateUploadProgress(uploadMeta interface{}) *gomock.Call { +func (mr *MockSPDBMockRecorder) UpdateUploadProgress(uploadMeta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUploadProgress", reflect.TypeOf((*MockSPDB)(nil).UpdateUploadProgress), uploadMeta) } @@ -1219,7 +1412,7 @@ func (m *MockUploadObjectProgressDB) DeleteUploadProgress(objectID uint64) error } // DeleteUploadProgress indicates an expected call of DeleteUploadProgress. -func (mr *MockUploadObjectProgressDBMockRecorder) DeleteUploadProgress(objectID interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) DeleteUploadProgress(objectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUploadProgress", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).DeleteUploadProgress), objectID) } @@ -1234,7 +1427,7 @@ func (m *MockUploadObjectProgressDB) GetUploadMetasToRejectUnsealByRangeTS(limit } // GetUploadMetasToRejectUnsealByRangeTS indicates an expected call of GetUploadMetasToRejectUnsealByRangeTS. -func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToRejectUnsealByRangeTS(limit, startTimeStamp, endTimeStamp interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToRejectUnsealByRangeTS(limit, startTimeStamp, endTimeStamp any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToRejectUnsealByRangeTS", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).GetUploadMetasToRejectUnsealByRangeTS), limit, startTimeStamp, endTimeStamp) } @@ -1249,7 +1442,7 @@ func (m *MockUploadObjectProgressDB) GetUploadMetasToReplicate(limit int, timeou } // GetUploadMetasToReplicate indicates an expected call of GetUploadMetasToReplicate. -func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToReplicate(limit, timeout interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToReplicate(limit, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToReplicate", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).GetUploadMetasToReplicate), limit, timeout) } @@ -1264,7 +1457,7 @@ func (m *MockUploadObjectProgressDB) GetUploadMetasToReplicateByStartTS(limit in } // GetUploadMetasToReplicateByStartTS indicates an expected call of GetUploadMetasToReplicateByStartTS. -func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToReplicateByStartTS(limit, startTimeStamp interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToReplicateByStartTS(limit, startTimeStamp any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToReplicateByStartTS", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).GetUploadMetasToReplicateByStartTS), limit, startTimeStamp) } @@ -1279,7 +1472,7 @@ func (m *MockUploadObjectProgressDB) GetUploadMetasToSeal(limit int, timeout int } // GetUploadMetasToSeal indicates an expected call of GetUploadMetasToSeal. -func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToSeal(limit, timeout interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToSeal(limit, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToSeal", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).GetUploadMetasToSeal), limit, timeout) } @@ -1294,7 +1487,7 @@ func (m *MockUploadObjectProgressDB) GetUploadMetasToSealByStartTS(limit int, st } // GetUploadMetasToSealByStartTS indicates an expected call of GetUploadMetasToSealByStartTS. -func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToSealByStartTS(limit, startTimeStamp interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadMetasToSealByStartTS(limit, startTimeStamp any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadMetasToSealByStartTS", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).GetUploadMetasToSealByStartTS), limit, startTimeStamp) } @@ -1310,7 +1503,7 @@ func (m *MockUploadObjectProgressDB) GetUploadState(objectID uint64) (types.Task } // GetUploadState indicates an expected call of GetUploadState. -func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadState(objectID interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) GetUploadState(objectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadState", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).GetUploadState), objectID) } @@ -1324,7 +1517,7 @@ func (m *MockUploadObjectProgressDB) InsertPutEvent(task task.Task) error { } // InsertPutEvent indicates an expected call of InsertPutEvent. -func (mr *MockUploadObjectProgressDBMockRecorder) InsertPutEvent(task interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) InsertPutEvent(task any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPutEvent", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).InsertPutEvent), task) } @@ -1338,7 +1531,7 @@ func (m *MockUploadObjectProgressDB) InsertUploadProgress(objectID uint64) error } // InsertUploadProgress indicates an expected call of InsertUploadProgress. -func (mr *MockUploadObjectProgressDBMockRecorder) InsertUploadProgress(objectID interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) InsertUploadProgress(objectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertUploadProgress", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).InsertUploadProgress), objectID) } @@ -1352,7 +1545,7 @@ func (m *MockUploadObjectProgressDB) UpdateUploadProgress(uploadMeta *UploadObje } // UpdateUploadProgress indicates an expected call of UpdateUploadProgress. -func (mr *MockUploadObjectProgressDBMockRecorder) UpdateUploadProgress(uploadMeta interface{}) *gomock.Call { +func (mr *MockUploadObjectProgressDBMockRecorder) UpdateUploadProgress(uploadMeta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUploadProgress", reflect.TypeOf((*MockUploadObjectProgressDB)(nil).UpdateUploadProgress), uploadMeta) } @@ -1389,7 +1582,7 @@ func (m *MockGCObjectProgressDB) DeleteGCObjectProgress(taskKey string) error { } // DeleteGCObjectProgress indicates an expected call of DeleteGCObjectProgress. -func (mr *MockGCObjectProgressDBMockRecorder) DeleteGCObjectProgress(taskKey interface{}) *gomock.Call { +func (mr *MockGCObjectProgressDBMockRecorder) DeleteGCObjectProgress(taskKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGCObjectProgress", reflect.TypeOf((*MockGCObjectProgressDB)(nil).DeleteGCObjectProgress), taskKey) } @@ -1404,7 +1597,7 @@ func (m *MockGCObjectProgressDB) GetGCMetasToGC(limit int) ([]*GCObjectMeta, err } // GetGCMetasToGC indicates an expected call of GetGCMetasToGC. -func (mr *MockGCObjectProgressDBMockRecorder) GetGCMetasToGC(limit interface{}) *gomock.Call { +func (mr *MockGCObjectProgressDBMockRecorder) GetGCMetasToGC(limit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGCMetasToGC", reflect.TypeOf((*MockGCObjectProgressDB)(nil).GetGCMetasToGC), limit) } @@ -1418,7 +1611,7 @@ func (m *MockGCObjectProgressDB) InsertGCObjectProgress(gcMeta *GCObjectMeta) er } // InsertGCObjectProgress indicates an expected call of InsertGCObjectProgress. -func (mr *MockGCObjectProgressDBMockRecorder) InsertGCObjectProgress(gcMeta interface{}) *gomock.Call { +func (mr *MockGCObjectProgressDBMockRecorder) InsertGCObjectProgress(gcMeta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertGCObjectProgress", reflect.TypeOf((*MockGCObjectProgressDB)(nil).InsertGCObjectProgress), gcMeta) } @@ -1432,7 +1625,7 @@ func (m *MockGCObjectProgressDB) UpdateGCObjectProgress(gcMeta *GCObjectMeta) er } // UpdateGCObjectProgress indicates an expected call of UpdateGCObjectProgress. -func (mr *MockGCObjectProgressDBMockRecorder) UpdateGCObjectProgress(gcMeta interface{}) *gomock.Call { +func (mr *MockGCObjectProgressDBMockRecorder) UpdateGCObjectProgress(gcMeta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGCObjectProgress", reflect.TypeOf((*MockGCObjectProgressDB)(nil).UpdateGCObjectProgress), gcMeta) } @@ -1469,7 +1662,7 @@ func (m *MockSignatureDB) DeleteAllReplicatePieceChecksum(objectID uint64, redun } // DeleteAllReplicatePieceChecksum indicates an expected call of DeleteAllReplicatePieceChecksum. -func (mr *MockSignatureDBMockRecorder) DeleteAllReplicatePieceChecksum(objectID, redundancyIdx, pieceCount interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) DeleteAllReplicatePieceChecksum(objectID, redundancyIdx, pieceCount any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllReplicatePieceChecksum", reflect.TypeOf((*MockSignatureDB)(nil).DeleteAllReplicatePieceChecksum), objectID, redundancyIdx, pieceCount) } @@ -1483,7 +1676,7 @@ func (m *MockSignatureDB) DeleteAllReplicatePieceChecksumOptimized(objectID uint } // DeleteAllReplicatePieceChecksumOptimized indicates an expected call of DeleteAllReplicatePieceChecksumOptimized. -func (mr *MockSignatureDBMockRecorder) DeleteAllReplicatePieceChecksumOptimized(objectID, redundancyIdx interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) DeleteAllReplicatePieceChecksumOptimized(objectID, redundancyIdx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllReplicatePieceChecksumOptimized", reflect.TypeOf((*MockSignatureDB)(nil).DeleteAllReplicatePieceChecksumOptimized), objectID, redundancyIdx) } @@ -1497,7 +1690,7 @@ func (m *MockSignatureDB) DeleteObjectIntegrity(objectID uint64, redundancyIndex } // DeleteObjectIntegrity indicates an expected call of DeleteObjectIntegrity. -func (mr *MockSignatureDBMockRecorder) DeleteObjectIntegrity(objectID, redundancyIndex interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) DeleteObjectIntegrity(objectID, redundancyIndex any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectIntegrity", reflect.TypeOf((*MockSignatureDB)(nil).DeleteObjectIntegrity), objectID, redundancyIndex) } @@ -1511,7 +1704,7 @@ func (m *MockSignatureDB) DeleteReplicatePieceChecksum(objectID uint64, segmentI } // DeleteReplicatePieceChecksum indicates an expected call of DeleteReplicatePieceChecksum. -func (mr *MockSignatureDBMockRecorder) DeleteReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) DeleteReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicatePieceChecksum", reflect.TypeOf((*MockSignatureDB)(nil).DeleteReplicatePieceChecksum), objectID, segmentIdx, redundancyIdx) } @@ -1526,7 +1719,7 @@ func (m *MockSignatureDB) GetAllReplicatePieceChecksum(objectID uint64, redundan } // GetAllReplicatePieceChecksum indicates an expected call of GetAllReplicatePieceChecksum. -func (mr *MockSignatureDBMockRecorder) GetAllReplicatePieceChecksum(objectID, redundancyIdx, pieceCount interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) GetAllReplicatePieceChecksum(objectID, redundancyIdx, pieceCount any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllReplicatePieceChecksum", reflect.TypeOf((*MockSignatureDB)(nil).GetAllReplicatePieceChecksum), objectID, redundancyIdx, pieceCount) } @@ -1541,7 +1734,7 @@ func (m *MockSignatureDB) GetAllReplicatePieceChecksumOptimized(objectID uint64, } // GetAllReplicatePieceChecksumOptimized indicates an expected call of GetAllReplicatePieceChecksumOptimized. -func (mr *MockSignatureDBMockRecorder) GetAllReplicatePieceChecksumOptimized(objectID, redundancyIdx, pieceCount interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) GetAllReplicatePieceChecksumOptimized(objectID, redundancyIdx, pieceCount any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllReplicatePieceChecksumOptimized", reflect.TypeOf((*MockSignatureDB)(nil).GetAllReplicatePieceChecksumOptimized), objectID, redundancyIdx, pieceCount) } @@ -1556,11 +1749,26 @@ func (m *MockSignatureDB) GetObjectIntegrity(objectID uint64, redundancyIndex in } // GetObjectIntegrity indicates an expected call of GetObjectIntegrity. -func (mr *MockSignatureDBMockRecorder) GetObjectIntegrity(objectID, redundancyIndex interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) GetObjectIntegrity(objectID, redundancyIndex any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectIntegrity", reflect.TypeOf((*MockSignatureDB)(nil).GetObjectIntegrity), objectID, redundancyIndex) } +// GetReplicatePieceChecksum mocks base method. +func (m *MockSignatureDB) GetReplicatePieceChecksum(objectID uint64, segmentIdx uint32, redundancyIdx int32) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReplicatePieceChecksum", objectID, segmentIdx, redundancyIdx) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetReplicatePieceChecksum indicates an expected call of GetReplicatePieceChecksum. +func (mr *MockSignatureDBMockRecorder) GetReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicatePieceChecksum", reflect.TypeOf((*MockSignatureDB)(nil).GetReplicatePieceChecksum), objectID, segmentIdx, redundancyIdx) +} + // ListIntegrityMetaByObjectIDRange mocks base method. func (m *MockSignatureDB) ListIntegrityMetaByObjectIDRange(startObjectID, endObjectID int64, includePrivate bool) ([]*IntegrityMeta, error) { m.ctrl.T.Helper() @@ -1571,7 +1779,7 @@ func (m *MockSignatureDB) ListIntegrityMetaByObjectIDRange(startObjectID, endObj } // ListIntegrityMetaByObjectIDRange indicates an expected call of ListIntegrityMetaByObjectIDRange. -func (mr *MockSignatureDBMockRecorder) ListIntegrityMetaByObjectIDRange(startObjectID, endObjectID, includePrivate interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) ListIntegrityMetaByObjectIDRange(startObjectID, endObjectID, includePrivate any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIntegrityMetaByObjectIDRange", reflect.TypeOf((*MockSignatureDB)(nil).ListIntegrityMetaByObjectIDRange), startObjectID, endObjectID, includePrivate) } @@ -1586,7 +1794,7 @@ func (m *MockSignatureDB) ListReplicatePieceChecksumByObjectIDRange(startObjectI } // ListReplicatePieceChecksumByObjectIDRange indicates an expected call of ListReplicatePieceChecksumByObjectIDRange. -func (mr *MockSignatureDBMockRecorder) ListReplicatePieceChecksumByObjectIDRange(startObjectID, endObjectID interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) ListReplicatePieceChecksumByObjectIDRange(startObjectID, endObjectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReplicatePieceChecksumByObjectIDRange", reflect.TypeOf((*MockSignatureDB)(nil).ListReplicatePieceChecksumByObjectIDRange), startObjectID, endObjectID) } @@ -1600,7 +1808,7 @@ func (m *MockSignatureDB) SetObjectIntegrity(integrity *IntegrityMeta) error { } // SetObjectIntegrity indicates an expected call of SetObjectIntegrity. -func (mr *MockSignatureDBMockRecorder) SetObjectIntegrity(integrity interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) SetObjectIntegrity(integrity any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectIntegrity", reflect.TypeOf((*MockSignatureDB)(nil).SetObjectIntegrity), integrity) } @@ -1614,7 +1822,7 @@ func (m *MockSignatureDB) SetReplicatePieceChecksum(objectID uint64, segmentIdx } // SetReplicatePieceChecksum indicates an expected call of SetReplicatePieceChecksum. -func (mr *MockSignatureDBMockRecorder) SetReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx, checksum interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) SetReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx, checksum any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReplicatePieceChecksum", reflect.TypeOf((*MockSignatureDB)(nil).SetReplicatePieceChecksum), objectID, segmentIdx, redundancyIdx, checksum) } @@ -1628,7 +1836,7 @@ func (m *MockSignatureDB) UpdateIntegrityChecksum(integrity *IntegrityMeta) erro } // UpdateIntegrityChecksum indicates an expected call of UpdateIntegrityChecksum. -func (mr *MockSignatureDBMockRecorder) UpdateIntegrityChecksum(integrity interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) UpdateIntegrityChecksum(integrity any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIntegrityChecksum", reflect.TypeOf((*MockSignatureDB)(nil).UpdateIntegrityChecksum), integrity) } @@ -1642,7 +1850,7 @@ func (m *MockSignatureDB) UpdatePieceChecksum(objectID uint64, redundancyIndex i } // UpdatePieceChecksum indicates an expected call of UpdatePieceChecksum. -func (mr *MockSignatureDBMockRecorder) UpdatePieceChecksum(objectID, redundancyIndex, checksum interface{}) *gomock.Call { +func (mr *MockSignatureDBMockRecorder) UpdatePieceChecksum(objectID, redundancyIndex, checksum any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePieceChecksum", reflect.TypeOf((*MockSignatureDB)(nil).UpdatePieceChecksum), objectID, redundancyIndex, checksum) } @@ -1679,7 +1887,7 @@ func (m *MockTrafficDB) CheckQuotaAndAddReadRecord(record *ReadRecord, quota *Bu } // CheckQuotaAndAddReadRecord indicates an expected call of CheckQuotaAndAddReadRecord. -func (mr *MockTrafficDBMockRecorder) CheckQuotaAndAddReadRecord(record, quota interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) CheckQuotaAndAddReadRecord(record, quota any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckQuotaAndAddReadRecord", reflect.TypeOf((*MockTrafficDB)(nil).CheckQuotaAndAddReadRecord), record, quota) } @@ -1693,7 +1901,7 @@ func (m *MockTrafficDB) DeleteExpiredBucketTraffic(yearMonth string) error { } // DeleteExpiredBucketTraffic indicates an expected call of DeleteExpiredBucketTraffic. -func (mr *MockTrafficDBMockRecorder) DeleteExpiredBucketTraffic(yearMonth interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) DeleteExpiredBucketTraffic(yearMonth any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpiredBucketTraffic", reflect.TypeOf((*MockTrafficDB)(nil).DeleteExpiredBucketTraffic), yearMonth) } @@ -1707,7 +1915,7 @@ func (m *MockTrafficDB) DeleteExpiredReadRecord(ts, limit uint64) error { } // DeleteExpiredReadRecord indicates an expected call of DeleteExpiredReadRecord. -func (mr *MockTrafficDBMockRecorder) DeleteExpiredReadRecord(ts, limit interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) DeleteExpiredReadRecord(ts, limit any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpiredReadRecord", reflect.TypeOf((*MockTrafficDB)(nil).DeleteExpiredReadRecord), ts, limit) } @@ -1722,7 +1930,7 @@ func (m *MockTrafficDB) GetBucketReadRecord(bucketID uint64, timeRange *TrafficT } // GetBucketReadRecord indicates an expected call of GetBucketReadRecord. -func (mr *MockTrafficDBMockRecorder) GetBucketReadRecord(bucketID, timeRange interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) GetBucketReadRecord(bucketID, timeRange any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReadRecord", reflect.TypeOf((*MockTrafficDB)(nil).GetBucketReadRecord), bucketID, timeRange) } @@ -1737,7 +1945,7 @@ func (m *MockTrafficDB) GetBucketTraffic(bucketID uint64, yearMonth string) (*Bu } // GetBucketTraffic indicates an expected call of GetBucketTraffic. -func (mr *MockTrafficDBMockRecorder) GetBucketTraffic(bucketID, yearMonth interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) GetBucketTraffic(bucketID, yearMonth any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTraffic", reflect.TypeOf((*MockTrafficDB)(nil).GetBucketTraffic), bucketID, yearMonth) } @@ -1752,7 +1960,7 @@ func (m *MockTrafficDB) GetLatestBucketTraffic(bucketID uint64) (*BucketTraffic, } // GetLatestBucketTraffic indicates an expected call of GetLatestBucketTraffic. -func (mr *MockTrafficDBMockRecorder) GetLatestBucketTraffic(bucketID interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) GetLatestBucketTraffic(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestBucketTraffic", reflect.TypeOf((*MockTrafficDB)(nil).GetLatestBucketTraffic), bucketID) } @@ -1767,7 +1975,7 @@ func (m *MockTrafficDB) GetObjectReadRecord(objectID uint64, timeRange *TrafficT } // GetObjectReadRecord indicates an expected call of GetObjectReadRecord. -func (mr *MockTrafficDBMockRecorder) GetObjectReadRecord(objectID, timeRange interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) GetObjectReadRecord(objectID, timeRange any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectReadRecord", reflect.TypeOf((*MockTrafficDB)(nil).GetObjectReadRecord), objectID, timeRange) } @@ -1782,7 +1990,7 @@ func (m *MockTrafficDB) GetReadRecord(timeRange *TrafficTimeRange) ([]*ReadRecor } // GetReadRecord indicates an expected call of GetReadRecord. -func (mr *MockTrafficDBMockRecorder) GetReadRecord(timeRange interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) GetReadRecord(timeRange any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReadRecord", reflect.TypeOf((*MockTrafficDB)(nil).GetReadRecord), timeRange) } @@ -1797,7 +2005,7 @@ func (m *MockTrafficDB) GetUserReadRecord(userAddress string, timeRange *Traffic } // GetUserReadRecord indicates an expected call of GetUserReadRecord. -func (mr *MockTrafficDBMockRecorder) GetUserReadRecord(userAddress, timeRange interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) GetUserReadRecord(userAddress, timeRange any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserReadRecord", reflect.TypeOf((*MockTrafficDB)(nil).GetUserReadRecord), userAddress, timeRange) } @@ -1811,7 +2019,7 @@ func (m *MockTrafficDB) InitBucketTraffic(record *ReadRecord, quota *BucketQuota } // InitBucketTraffic indicates an expected call of InitBucketTraffic. -func (mr *MockTrafficDBMockRecorder) InitBucketTraffic(record, quota interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) InitBucketTraffic(record, quota any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitBucketTraffic", reflect.TypeOf((*MockTrafficDB)(nil).InitBucketTraffic), record, quota) } @@ -1825,7 +2033,7 @@ func (m *MockTrafficDB) UpdateBucketTraffic(bucketID uint64, update *BucketTraff } // UpdateBucketTraffic indicates an expected call of UpdateBucketTraffic. -func (mr *MockTrafficDBMockRecorder) UpdateBucketTraffic(bucketID, update interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) UpdateBucketTraffic(bucketID, update any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketTraffic", reflect.TypeOf((*MockTrafficDB)(nil).UpdateBucketTraffic), bucketID, update) } @@ -1839,7 +2047,7 @@ func (m *MockTrafficDB) UpdateExtraQuota(bucketID, extraQuota uint64, yearMonth } // UpdateExtraQuota indicates an expected call of UpdateExtraQuota. -func (mr *MockTrafficDBMockRecorder) UpdateExtraQuota(bucketID, extraQuota, yearMonth interface{}) *gomock.Call { +func (mr *MockTrafficDBMockRecorder) UpdateExtraQuota(bucketID, extraQuota, yearMonth any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExtraQuota", reflect.TypeOf((*MockTrafficDB)(nil).UpdateExtraQuota), bucketID, extraQuota, yearMonth) } @@ -1870,7 +2078,7 @@ func (m *MockSPInfoDB) EXPECT() *MockSPInfoDBMockRecorder { // FetchAllSp mocks base method. func (m *MockSPInfoDB) FetchAllSp(status ...types0.Status) ([]*types0.StorageProvider, error) { m.ctrl.T.Helper() - varargs := []interface{}{} + varargs := []any{} for _, a := range status { varargs = append(varargs, a) } @@ -1881,7 +2089,7 @@ func (m *MockSPInfoDB) FetchAllSp(status ...types0.Status) ([]*types0.StoragePro } // FetchAllSp indicates an expected call of FetchAllSp. -func (mr *MockSPInfoDBMockRecorder) FetchAllSp(status ...interface{}) *gomock.Call { +func (mr *MockSPInfoDBMockRecorder) FetchAllSp(status ...any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchAllSp", reflect.TypeOf((*MockSPInfoDB)(nil).FetchAllSp), status...) } @@ -1889,7 +2097,7 @@ func (mr *MockSPInfoDBMockRecorder) FetchAllSp(status ...interface{}) *gomock.Ca // FetchAllSpWithoutOwnSp mocks base method. func (m *MockSPInfoDB) FetchAllSpWithoutOwnSp(status ...types0.Status) ([]*types0.StorageProvider, error) { m.ctrl.T.Helper() - varargs := []interface{}{} + varargs := []any{} for _, a := range status { varargs = append(varargs, a) } @@ -1900,7 +2108,7 @@ func (m *MockSPInfoDB) FetchAllSpWithoutOwnSp(status ...types0.Status) ([]*types } // FetchAllSpWithoutOwnSp indicates an expected call of FetchAllSpWithoutOwnSp. -func (mr *MockSPInfoDBMockRecorder) FetchAllSpWithoutOwnSp(status ...interface{}) *gomock.Call { +func (mr *MockSPInfoDBMockRecorder) FetchAllSpWithoutOwnSp(status ...any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchAllSpWithoutOwnSp", reflect.TypeOf((*MockSPInfoDB)(nil).FetchAllSpWithoutOwnSp), status...) } @@ -1930,7 +2138,7 @@ func (m *MockSPInfoDB) GetSpByAddress(address string, addressType SpAddressType) } // GetSpByAddress indicates an expected call of GetSpByAddress. -func (mr *MockSPInfoDBMockRecorder) GetSpByAddress(address, addressType interface{}) *gomock.Call { +func (mr *MockSPInfoDBMockRecorder) GetSpByAddress(address, addressType any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpByAddress", reflect.TypeOf((*MockSPInfoDB)(nil).GetSpByAddress), address, addressType) } @@ -1945,7 +2153,7 @@ func (m *MockSPInfoDB) GetSpByEndpoint(endpoint string) (*types0.StorageProvider } // GetSpByEndpoint indicates an expected call of GetSpByEndpoint. -func (mr *MockSPInfoDBMockRecorder) GetSpByEndpoint(endpoint interface{}) *gomock.Call { +func (mr *MockSPInfoDBMockRecorder) GetSpByEndpoint(endpoint any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpByEndpoint", reflect.TypeOf((*MockSPInfoDB)(nil).GetSpByEndpoint), endpoint) } @@ -1960,7 +2168,7 @@ func (m *MockSPInfoDB) GetSpByID(id uint32) (*types0.StorageProvider, error) { } // GetSpByID indicates an expected call of GetSpByID. -func (mr *MockSPInfoDBMockRecorder) GetSpByID(id interface{}) *gomock.Call { +func (mr *MockSPInfoDBMockRecorder) GetSpByID(id any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpByID", reflect.TypeOf((*MockSPInfoDB)(nil).GetSpByID), id) } @@ -1974,7 +2182,7 @@ func (m *MockSPInfoDB) SetOwnSpInfo(sp *types0.StorageProvider) error { } // SetOwnSpInfo indicates an expected call of SetOwnSpInfo. -func (mr *MockSPInfoDBMockRecorder) SetOwnSpInfo(sp interface{}) *gomock.Call { +func (mr *MockSPInfoDBMockRecorder) SetOwnSpInfo(sp any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOwnSpInfo", reflect.TypeOf((*MockSPInfoDB)(nil).SetOwnSpInfo), sp) } @@ -1988,7 +2196,7 @@ func (m *MockSPInfoDB) UpdateAllSp(spList []*types0.StorageProvider) error { } // UpdateAllSp indicates an expected call of UpdateAllSp. -func (mr *MockSPInfoDBMockRecorder) UpdateAllSp(spList interface{}) *gomock.Call { +func (mr *MockSPInfoDBMockRecorder) UpdateAllSp(spList any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAllSp", reflect.TypeOf((*MockSPInfoDB)(nil).UpdateAllSp), spList) } @@ -2026,7 +2234,7 @@ func (m *MockOffChainAuthKeyDB) GetAuthKey(userAddress, domain string) (*OffChai } // GetAuthKey indicates an expected call of GetAuthKey. -func (mr *MockOffChainAuthKeyDBMockRecorder) GetAuthKey(userAddress, domain interface{}) *gomock.Call { +func (mr *MockOffChainAuthKeyDBMockRecorder) GetAuthKey(userAddress, domain any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthKey", reflect.TypeOf((*MockOffChainAuthKeyDB)(nil).GetAuthKey), userAddress, domain) } @@ -2040,7 +2248,7 @@ func (m *MockOffChainAuthKeyDB) InsertAuthKey(newRecord *OffChainAuthKey) error } // InsertAuthKey indicates an expected call of InsertAuthKey. -func (mr *MockOffChainAuthKeyDBMockRecorder) InsertAuthKey(newRecord interface{}) *gomock.Call { +func (mr *MockOffChainAuthKeyDBMockRecorder) InsertAuthKey(newRecord any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAuthKey", reflect.TypeOf((*MockOffChainAuthKeyDB)(nil).InsertAuthKey), newRecord) } @@ -2054,7 +2262,7 @@ func (m *MockOffChainAuthKeyDB) UpdateAuthKey(userAddress, domain string, oldNon } // UpdateAuthKey indicates an expected call of UpdateAuthKey. -func (mr *MockOffChainAuthKeyDBMockRecorder) UpdateAuthKey(userAddress, domain, oldNonce, newNonce, newPublicKey, newExpiryDate interface{}) *gomock.Call { +func (mr *MockOffChainAuthKeyDBMockRecorder) UpdateAuthKey(userAddress, domain, oldNonce, newNonce, newPublicKey, newExpiryDate any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthKey", reflect.TypeOf((*MockOffChainAuthKeyDB)(nil).UpdateAuthKey), userAddress, domain, oldNonce, newNonce, newPublicKey, newExpiryDate) } @@ -2091,7 +2299,7 @@ func (m *MockMigrateDB) DeleteMigrateBucket(bucketID uint64) error { } // DeleteMigrateBucket indicates an expected call of DeleteMigrateBucket. -func (mr *MockMigrateDBMockRecorder) DeleteMigrateBucket(bucketID interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) DeleteMigrateBucket(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMigrateBucket", reflect.TypeOf((*MockMigrateDB)(nil).DeleteMigrateBucket), bucketID) } @@ -2105,7 +2313,7 @@ func (m *MockMigrateDB) DeleteMigrateGVGUnit(meta *MigrateGVGUnitMeta) error { } // DeleteMigrateGVGUnit indicates an expected call of DeleteMigrateGVGUnit. -func (mr *MockMigrateDBMockRecorder) DeleteMigrateGVGUnit(meta interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) DeleteMigrateGVGUnit(meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMigrateGVGUnit", reflect.TypeOf((*MockMigrateDB)(nil).DeleteMigrateGVGUnit), meta) } @@ -2119,7 +2327,7 @@ func (m *MockMigrateDB) DeleteMigrateGVGUnitsByBucketID(bucketID uint64) error { } // DeleteMigrateGVGUnitsByBucketID indicates an expected call of DeleteMigrateGVGUnitsByBucketID. -func (mr *MockMigrateDBMockRecorder) DeleteMigrateGVGUnitsByBucketID(bucketID interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) DeleteMigrateGVGUnitsByBucketID(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMigrateGVGUnitsByBucketID", reflect.TypeOf((*MockMigrateDB)(nil).DeleteMigrateGVGUnitsByBucketID), bucketID) } @@ -2133,7 +2341,7 @@ func (m *MockMigrateDB) InsertMigrateGVGUnit(meta *MigrateGVGUnitMeta) error { } // InsertMigrateGVGUnit indicates an expected call of InsertMigrateGVGUnit. -func (mr *MockMigrateDBMockRecorder) InsertMigrateGVGUnit(meta interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) InsertMigrateGVGUnit(meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMigrateGVGUnit", reflect.TypeOf((*MockMigrateDB)(nil).InsertMigrateGVGUnit), meta) } @@ -2147,7 +2355,7 @@ func (m *MockMigrateDB) InsertSwapOutUnit(meta *SwapOutMeta) error { } // InsertSwapOutUnit indicates an expected call of InsertSwapOutUnit. -func (mr *MockMigrateDBMockRecorder) InsertSwapOutUnit(meta interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) InsertSwapOutUnit(meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertSwapOutUnit", reflect.TypeOf((*MockMigrateDB)(nil).InsertSwapOutUnit), meta) } @@ -2162,7 +2370,7 @@ func (m *MockMigrateDB) ListBucketMigrationToConfirm(migrationStates []int) ([]* } // ListBucketMigrationToConfirm indicates an expected call of ListBucketMigrationToConfirm. -func (mr *MockMigrateDBMockRecorder) ListBucketMigrationToConfirm(migrationStates interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) ListBucketMigrationToConfirm(migrationStates any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMigrationToConfirm", reflect.TypeOf((*MockMigrateDB)(nil).ListBucketMigrationToConfirm), migrationStates) } @@ -2192,7 +2400,7 @@ func (m *MockMigrateDB) ListMigrateGVGUnitsByBucketID(bucketID uint64) ([]*Migra } // ListMigrateGVGUnitsByBucketID indicates an expected call of ListMigrateGVGUnitsByBucketID. -func (mr *MockMigrateDBMockRecorder) ListMigrateGVGUnitsByBucketID(bucketID interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) ListMigrateGVGUnitsByBucketID(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMigrateGVGUnitsByBucketID", reflect.TypeOf((*MockMigrateDB)(nil).ListMigrateGVGUnitsByBucketID), bucketID) } @@ -2222,7 +2430,7 @@ func (m *MockMigrateDB) QueryMigrateBucketProgress(bucketID uint64) (*MigrateBuc } // QueryMigrateBucketProgress indicates an expected call of QueryMigrateBucketProgress. -func (mr *MockMigrateDBMockRecorder) QueryMigrateBucketProgress(bucketID interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) QueryMigrateBucketProgress(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateBucketProgress", reflect.TypeOf((*MockMigrateDB)(nil).QueryMigrateBucketProgress), bucketID) } @@ -2237,7 +2445,7 @@ func (m *MockMigrateDB) QueryMigrateBucketState(bucketID uint64) (int, error) { } // QueryMigrateBucketState indicates an expected call of QueryMigrateBucketState. -func (mr *MockMigrateDBMockRecorder) QueryMigrateBucketState(bucketID interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) QueryMigrateBucketState(bucketID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateBucketState", reflect.TypeOf((*MockMigrateDB)(nil).QueryMigrateBucketState), bucketID) } @@ -2252,7 +2460,7 @@ func (m *MockMigrateDB) QueryMigrateGVGUnit(migrateKey string) (*MigrateGVGUnitM } // QueryMigrateGVGUnit indicates an expected call of QueryMigrateGVGUnit. -func (mr *MockMigrateDBMockRecorder) QueryMigrateGVGUnit(migrateKey interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) QueryMigrateGVGUnit(migrateKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMigrateGVGUnit", reflect.TypeOf((*MockMigrateDB)(nil).QueryMigrateGVGUnit), migrateKey) } @@ -2297,7 +2505,7 @@ func (m *MockMigrateDB) QuerySwapOutUnitInSrcSP(swapOutKey string) (*SwapOutMeta } // QuerySwapOutUnitInSrcSP indicates an expected call of QuerySwapOutUnitInSrcSP. -func (mr *MockMigrateDBMockRecorder) QuerySwapOutUnitInSrcSP(swapOutKey interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) QuerySwapOutUnitInSrcSP(swapOutKey any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySwapOutUnitInSrcSP", reflect.TypeOf((*MockMigrateDB)(nil).QuerySwapOutUnitInSrcSP), swapOutKey) } @@ -2311,7 +2519,7 @@ func (m *MockMigrateDB) UpdateBucketMigrateGCSubscribeProgress(blockHeight uint6 } // UpdateBucketMigrateGCSubscribeProgress indicates an expected call of UpdateBucketMigrateGCSubscribeProgress. -func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrateGCSubscribeProgress(blockHeight interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrateGCSubscribeProgress(blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrateGCSubscribeProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrateGCSubscribeProgress), blockHeight) } @@ -2325,7 +2533,7 @@ func (m *MockMigrateDB) UpdateBucketMigrateSubscribeProgress(blockHeight uint64) } // UpdateBucketMigrateSubscribeProgress indicates an expected call of UpdateBucketMigrateSubscribeProgress. -func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrateSubscribeProgress(blockHeight interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrateSubscribeProgress(blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrateSubscribeProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrateSubscribeProgress), blockHeight) } @@ -2339,7 +2547,7 @@ func (m *MockMigrateDB) UpdateBucketMigrationGCProgress(progressMeta MigrateBuck } // UpdateBucketMigrationGCProgress indicates an expected call of UpdateBucketMigrationGCProgress. -func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationGCProgress(progressMeta interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationGCProgress(progressMeta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationGCProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationGCProgress), progressMeta) } @@ -2353,7 +2561,7 @@ func (m *MockMigrateDB) UpdateBucketMigrationMigratingProgress(bucketID uint64, } // UpdateBucketMigrationMigratingProgress indicates an expected call of UpdateBucketMigrationMigratingProgress. -func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationMigratingProgress(bucketID, gvgUnits, gvgUnitsFinished interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationMigratingProgress(bucketID, gvgUnits, gvgUnitsFinished any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationMigratingProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationMigratingProgress), bucketID, gvgUnits, gvgUnitsFinished) } @@ -2367,7 +2575,7 @@ func (m *MockMigrateDB) UpdateBucketMigrationPreDeductedQuota(bucketID, deducted } // UpdateBucketMigrationPreDeductedQuota indicates an expected call of UpdateBucketMigrationPreDeductedQuota. -func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationPreDeductedQuota(bucketID, deductedQuota, state interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationPreDeductedQuota(bucketID, deductedQuota, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationPreDeductedQuota", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationPreDeductedQuota), bucketID, deductedQuota, state) } @@ -2381,7 +2589,7 @@ func (m *MockMigrateDB) UpdateBucketMigrationProgress(bucketID uint64, migrateSt } // UpdateBucketMigrationProgress indicates an expected call of UpdateBucketMigrationProgress. -func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationProgress(bucketID, migrateState interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationProgress(bucketID, migrateState any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationProgress), bucketID, migrateState) } @@ -2395,7 +2603,7 @@ func (m *MockMigrateDB) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota u } // UpdateBucketMigrationRecoupQuota indicates an expected call of UpdateBucketMigrationRecoupQuota. -func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota, state interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateBucketMigrationRecoupQuota(bucketID, recoupQuota, state any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBucketMigrationRecoupQuota", reflect.TypeOf((*MockMigrateDB)(nil).UpdateBucketMigrationRecoupQuota), bucketID, recoupQuota, state) } @@ -2409,7 +2617,7 @@ func (m *MockMigrateDB) UpdateMigrateGVGMigratedBytesSize(migrateKey string, mig } // UpdateMigrateGVGMigratedBytesSize indicates an expected call of UpdateMigrateGVGMigratedBytesSize. -func (mr *MockMigrateDBMockRecorder) UpdateMigrateGVGMigratedBytesSize(migrateKey, migratedBytes interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateMigrateGVGMigratedBytesSize(migrateKey, migratedBytes any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGMigratedBytesSize", reflect.TypeOf((*MockMigrateDB)(nil).UpdateMigrateGVGMigratedBytesSize), migrateKey, migratedBytes) } @@ -2423,7 +2631,7 @@ func (m *MockMigrateDB) UpdateMigrateGVGRetryCount(migrateKey string, retryTime } // UpdateMigrateGVGRetryCount indicates an expected call of UpdateMigrateGVGRetryCount. -func (mr *MockMigrateDBMockRecorder) UpdateMigrateGVGRetryCount(migrateKey, retryTime interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateMigrateGVGRetryCount(migrateKey, retryTime any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGRetryCount", reflect.TypeOf((*MockMigrateDB)(nil).UpdateMigrateGVGRetryCount), migrateKey, retryTime) } @@ -2437,7 +2645,7 @@ func (m *MockMigrateDB) UpdateMigrateGVGUnitLastMigrateObjectID(migrateKey strin } // UpdateMigrateGVGUnitLastMigrateObjectID indicates an expected call of UpdateMigrateGVGUnitLastMigrateObjectID. -func (mr *MockMigrateDBMockRecorder) UpdateMigrateGVGUnitLastMigrateObjectID(migrateKey, lastMigrateObjectID interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateMigrateGVGUnitLastMigrateObjectID(migrateKey, lastMigrateObjectID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGUnitLastMigrateObjectID", reflect.TypeOf((*MockMigrateDB)(nil).UpdateMigrateGVGUnitLastMigrateObjectID), migrateKey, lastMigrateObjectID) } @@ -2451,7 +2659,7 @@ func (m *MockMigrateDB) UpdateMigrateGVGUnitStatus(migrateKey string, migrateSta } // UpdateMigrateGVGUnitStatus indicates an expected call of UpdateMigrateGVGUnitStatus. -func (mr *MockMigrateDBMockRecorder) UpdateMigrateGVGUnitStatus(migrateKey, migrateStatus interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateMigrateGVGUnitStatus(migrateKey, migrateStatus any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMigrateGVGUnitStatus", reflect.TypeOf((*MockMigrateDB)(nil).UpdateMigrateGVGUnitStatus), migrateKey, migrateStatus) } @@ -2465,7 +2673,7 @@ func (m *MockMigrateDB) UpdateSPExitSubscribeProgress(blockHeight uint64) error } // UpdateSPExitSubscribeProgress indicates an expected call of UpdateSPExitSubscribeProgress. -func (mr *MockMigrateDBMockRecorder) UpdateSPExitSubscribeProgress(blockHeight interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateSPExitSubscribeProgress(blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSPExitSubscribeProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateSPExitSubscribeProgress), blockHeight) } @@ -2479,7 +2687,7 @@ func (m *MockMigrateDB) UpdateSwapOutSubscribeProgress(blockHeight uint64) error } // UpdateSwapOutSubscribeProgress indicates an expected call of UpdateSwapOutSubscribeProgress. -func (mr *MockMigrateDBMockRecorder) UpdateSwapOutSubscribeProgress(blockHeight interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateSwapOutSubscribeProgress(blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSwapOutSubscribeProgress", reflect.TypeOf((*MockMigrateDB)(nil).UpdateSwapOutSubscribeProgress), blockHeight) } @@ -2493,7 +2701,204 @@ func (m *MockMigrateDB) UpdateSwapOutUnitCompletedGVGList(swapOutKey string, com } // UpdateSwapOutUnitCompletedGVGList indicates an expected call of UpdateSwapOutUnitCompletedGVGList. -func (mr *MockMigrateDBMockRecorder) UpdateSwapOutUnitCompletedGVGList(swapOutKey, completedGVGList interface{}) *gomock.Call { +func (mr *MockMigrateDBMockRecorder) UpdateSwapOutUnitCompletedGVGList(swapOutKey, completedGVGList any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSwapOutUnitCompletedGVGList", reflect.TypeOf((*MockMigrateDB)(nil).UpdateSwapOutUnitCompletedGVGList), swapOutKey, completedGVGList) } + +// MockExitRecoverDB is a mock of ExitRecoverDB interface. +type MockExitRecoverDB struct { + ctrl *gomock.Controller + recorder *MockExitRecoverDBMockRecorder +} + +// MockExitRecoverDBMockRecorder is the mock recorder for MockExitRecoverDB. +type MockExitRecoverDBMockRecorder struct { + mock *MockExitRecoverDB +} + +// NewMockExitRecoverDB creates a new mock instance. +func NewMockExitRecoverDB(ctrl *gomock.Controller) *MockExitRecoverDB { + mock := &MockExitRecoverDB{ctrl: ctrl} + mock.recorder = &MockExitRecoverDBMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockExitRecoverDB) EXPECT() *MockExitRecoverDBMockRecorder { + return m.recorder +} + +// BatchGetRecoverGVGStats mocks base method. +func (m *MockExitRecoverDB) BatchGetRecoverGVGStats(gvgID []uint32) ([]*RecoverGVGStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetRecoverGVGStats", gvgID) + ret0, _ := ret[0].([]*RecoverGVGStats) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetRecoverGVGStats indicates an expected call of BatchGetRecoverGVGStats. +func (mr *MockExitRecoverDBMockRecorder) BatchGetRecoverGVGStats(gvgID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetRecoverGVGStats", reflect.TypeOf((*MockExitRecoverDB)(nil).BatchGetRecoverGVGStats), gvgID) +} + +// CountRecoverFailedObject mocks base method. +func (m *MockExitRecoverDB) CountRecoverFailedObject() (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CountRecoverFailedObject") + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CountRecoverFailedObject indicates an expected call of CountRecoverFailedObject. +func (mr *MockExitRecoverDBMockRecorder) CountRecoverFailedObject() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountRecoverFailedObject", reflect.TypeOf((*MockExitRecoverDB)(nil).CountRecoverFailedObject)) +} + +// DeleteRecoverFailedObject mocks base method. +func (m *MockExitRecoverDB) DeleteRecoverFailedObject(objectID uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRecoverFailedObject", objectID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteRecoverFailedObject indicates an expected call of DeleteRecoverFailedObject. +func (mr *MockExitRecoverDBMockRecorder) DeleteRecoverFailedObject(objectID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRecoverFailedObject", reflect.TypeOf((*MockExitRecoverDB)(nil).DeleteRecoverFailedObject), objectID) +} + +// DeleteRecoverGVGStats mocks base method. +func (m *MockExitRecoverDB) DeleteRecoverGVGStats(gvgID uint32) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRecoverGVGStats", gvgID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteRecoverGVGStats indicates an expected call of DeleteRecoverGVGStats. +func (mr *MockExitRecoverDBMockRecorder) DeleteRecoverGVGStats(gvgID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRecoverGVGStats", reflect.TypeOf((*MockExitRecoverDB)(nil).DeleteRecoverGVGStats), gvgID) +} + +// GetRecoverFailedObject mocks base method. +func (m *MockExitRecoverDB) GetRecoverFailedObject(objectID uint64) (*RecoverFailedObject, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecoverFailedObject", objectID) + ret0, _ := ret[0].(*RecoverFailedObject) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecoverFailedObject indicates an expected call of GetRecoverFailedObject. +func (mr *MockExitRecoverDBMockRecorder) GetRecoverFailedObject(objectID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecoverFailedObject", reflect.TypeOf((*MockExitRecoverDB)(nil).GetRecoverFailedObject), objectID) +} + +// GetRecoverFailedObjects mocks base method. +func (m *MockExitRecoverDB) GetRecoverFailedObjects(retry, limit uint32) ([]*RecoverFailedObject, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecoverFailedObjects", retry, limit) + ret0, _ := ret[0].([]*RecoverFailedObject) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecoverFailedObjects indicates an expected call of GetRecoverFailedObjects. +func (mr *MockExitRecoverDBMockRecorder) GetRecoverFailedObjects(retry, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecoverFailedObjects", reflect.TypeOf((*MockExitRecoverDB)(nil).GetRecoverFailedObjects), retry, limit) +} + +// GetRecoverFailedObjectsByRetryTime mocks base method. +func (m *MockExitRecoverDB) GetRecoverFailedObjectsByRetryTime(retry uint32) ([]*RecoverFailedObject, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecoverFailedObjectsByRetryTime", retry) + ret0, _ := ret[0].([]*RecoverFailedObject) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecoverFailedObjectsByRetryTime indicates an expected call of GetRecoverFailedObjectsByRetryTime. +func (mr *MockExitRecoverDBMockRecorder) GetRecoverFailedObjectsByRetryTime(retry any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecoverFailedObjectsByRetryTime", reflect.TypeOf((*MockExitRecoverDB)(nil).GetRecoverFailedObjectsByRetryTime), retry) +} + +// GetRecoverGVGStats mocks base method. +func (m *MockExitRecoverDB) GetRecoverGVGStats(gvgID uint32) (*RecoverGVGStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecoverGVGStats", gvgID) + ret0, _ := ret[0].(*RecoverGVGStats) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecoverGVGStats indicates an expected call of GetRecoverGVGStats. +func (mr *MockExitRecoverDBMockRecorder) GetRecoverGVGStats(gvgID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecoverGVGStats", reflect.TypeOf((*MockExitRecoverDB)(nil).GetRecoverGVGStats), gvgID) +} + +// InsertRecoverFailedObject mocks base method. +func (m *MockExitRecoverDB) InsertRecoverFailedObject(object *RecoverFailedObject) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InsertRecoverFailedObject", object) + ret0, _ := ret[0].(error) + return ret0 +} + +// InsertRecoverFailedObject indicates an expected call of InsertRecoverFailedObject. +func (mr *MockExitRecoverDBMockRecorder) InsertRecoverFailedObject(object any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertRecoverFailedObject", reflect.TypeOf((*MockExitRecoverDB)(nil).InsertRecoverFailedObject), object) +} + +// SetRecoverGVGStats mocks base method. +func (m *MockExitRecoverDB) SetRecoverGVGStats(stats []*RecoverGVGStats) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRecoverGVGStats", stats) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetRecoverGVGStats indicates an expected call of SetRecoverGVGStats. +func (mr *MockExitRecoverDBMockRecorder) SetRecoverGVGStats(stats any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRecoverGVGStats", reflect.TypeOf((*MockExitRecoverDB)(nil).SetRecoverGVGStats), stats) +} + +// UpdateRecoverFailedObject mocks base method. +func (m *MockExitRecoverDB) UpdateRecoverFailedObject(object *RecoverFailedObject) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRecoverFailedObject", object) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateRecoverFailedObject indicates an expected call of UpdateRecoverFailedObject. +func (mr *MockExitRecoverDBMockRecorder) UpdateRecoverFailedObject(object any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRecoverFailedObject", reflect.TypeOf((*MockExitRecoverDB)(nil).UpdateRecoverFailedObject), object) +} + +// UpdateRecoverGVGStats mocks base method. +func (m *MockExitRecoverDB) UpdateRecoverGVGStats(stats *RecoverGVGStats) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRecoverGVGStats", stats) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateRecoverGVGStats indicates an expected call of UpdateRecoverGVGStats. +func (mr *MockExitRecoverDBMockRecorder) UpdateRecoverGVGStats(stats any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRecoverGVGStats", reflect.TypeOf((*MockExitRecoverDB)(nil).UpdateRecoverGVGStats), stats) +} diff --git a/core/task/null_task.go b/core/task/null_task.go index cd7a2cee0..06933aad7 100644 --- a/core/task/null_task.go +++ b/core/task/null_task.go @@ -133,6 +133,7 @@ func (*NullTask) GetEcIdx() int32 { return 0 } func (*NullTask) SetSegmentIdx(uint32) {} func (*NullTask) GetRecovered() bool { return false } func (*NullTask) SetRecoverDone() {} +func (*NullTask) BySuccessorSP() bool { return false } func (*NullTask) GetRedundancyIdx() int32 { return 0 } func (*NullTask) SetRedundancyIdx(idx int32) {} func (*NullTask) GetIntegrityHash() []byte { return nil } @@ -190,3 +191,4 @@ func (*NullTask) SetGCFinishedGvgNum(gvgGcNum uint64) func (*NullTask) GetGCFinishedGvgNum() uint64 { return 0 } func (*NullTask) SetTotalGvgNum(gvgNum uint64) {} func (*NullTask) GetTotalGvgNum() uint64 { return 0 } +func (t *NullTask) GetGVGID() uint32 { return 0 } diff --git a/core/task/task.go b/core/task/task.go index b9a844d07..3e6f31493 100644 --- a/core/task/task.go +++ b/core/task/task.go @@ -540,6 +540,10 @@ type RecoveryPieceTask interface { GetRecovered() bool // SetRecoverDone set the recovery status as finish SetRecoverDone() + // BySuccessorSP returns whether the task is initial by a successor SP + BySuccessorSP() bool + // GetGVGID return gvg id + GetGVGID() uint32 } // MigrateGVGTask is an abstract interface to record migrate gvg information. diff --git a/core/task/task_mock.go b/core/task/task_mock.go index a27e6f0d2..7d16a7c3e 100644 --- a/core/task/task_mock.go +++ b/core/task/task_mock.go @@ -1,6 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: core/task/task.go - +// Source: ./task.go +// +// Generated by this command: +// +// mockgen -source=./task.go -destination=./task_mock.go -package=task +// // Package task is a generated GoMock package. package task @@ -44,7 +48,7 @@ func (m *MockTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockTask)(nil).AppendLog), log) } @@ -292,7 +296,7 @@ func (m *MockTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockTask)(nil).SetAddress), arg0) } @@ -304,7 +308,7 @@ func (m *MockTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockTask)(nil).SetCreateTime), arg0) } @@ -316,7 +320,7 @@ func (m *MockTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockTask)(nil).SetError), arg0) } @@ -328,7 +332,7 @@ func (m *MockTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockTask)(nil).SetLogs), logs) } @@ -340,7 +344,7 @@ func (m *MockTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockTask)(nil).SetMaxRetry), arg0) } @@ -352,7 +356,7 @@ func (m *MockTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockTask)(nil).SetPriority), arg0) } @@ -364,7 +368,7 @@ func (m *MockTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockTask)(nil).SetRetry), arg0) } @@ -376,7 +380,7 @@ func (m *MockTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockTask)(nil).SetTimeout), arg0) } @@ -388,7 +392,7 @@ func (m *MockTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockTask)(nil).SetUpdateTime), arg0) } @@ -400,7 +404,7 @@ func (m *MockTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockTask)(nil).SetUserAddress), arg0) } @@ -449,7 +453,7 @@ func (m *MockApprovalTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockApprovalTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalTask)(nil).AppendLog), log) } @@ -711,7 +715,7 @@ func (m *MockApprovalTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockApprovalTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalTask)(nil).SetAddress), arg0) } @@ -723,7 +727,7 @@ func (m *MockApprovalTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockApprovalTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalTask)(nil).SetCreateTime), arg0) } @@ -735,7 +739,7 @@ func (m *MockApprovalTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockApprovalTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalTask)(nil).SetError), arg0) } @@ -747,7 +751,7 @@ func (m *MockApprovalTask) SetExpiredHeight(arg0 uint64) { } // SetExpiredHeight indicates an expected call of SetExpiredHeight. -func (mr *MockApprovalTaskMockRecorder) SetExpiredHeight(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalTask)(nil).SetExpiredHeight), arg0) } @@ -759,7 +763,7 @@ func (m *MockApprovalTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockApprovalTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalTask)(nil).SetLogs), logs) } @@ -771,7 +775,7 @@ func (m *MockApprovalTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockApprovalTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalTask)(nil).SetMaxRetry), arg0) } @@ -783,7 +787,7 @@ func (m *MockApprovalTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockApprovalTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalTask)(nil).SetPriority), arg0) } @@ -795,7 +799,7 @@ func (m *MockApprovalTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockApprovalTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalTask)(nil).SetRetry), arg0) } @@ -807,7 +811,7 @@ func (m *MockApprovalTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockApprovalTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalTask)(nil).SetTimeout), arg0) } @@ -819,7 +823,7 @@ func (m *MockApprovalTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockApprovalTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalTask)(nil).SetUpdateTime), arg0) } @@ -831,7 +835,7 @@ func (m *MockApprovalTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockApprovalTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalTask)(nil).SetUserAddress), arg0) } @@ -880,7 +884,7 @@ func (m *MockApprovalCreateBucketTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockApprovalCreateBucketTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).AppendLog), log) } @@ -1142,7 +1146,7 @@ func (m *MockApprovalCreateBucketTask) InitApprovalCreateBucketTask(arg0 string, } // InitApprovalCreateBucketTask indicates an expected call of InitApprovalCreateBucketTask. -func (mr *MockApprovalCreateBucketTaskMockRecorder) InitApprovalCreateBucketTask(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) InitApprovalCreateBucketTask(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApprovalCreateBucketTask", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).InitApprovalCreateBucketTask), arg0, arg1, arg2, arg3) } @@ -1168,7 +1172,7 @@ func (m *MockApprovalCreateBucketTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetAddress), arg0) } @@ -1180,7 +1184,7 @@ func (m *MockApprovalCreateBucketTask) SetCreateBucketInfo(arg0 *types0.MsgCreat } // SetCreateBucketInfo indicates an expected call of SetCreateBucketInfo. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetCreateBucketInfo(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetCreateBucketInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateBucketInfo", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetCreateBucketInfo), arg0) } @@ -1192,7 +1196,7 @@ func (m *MockApprovalCreateBucketTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetCreateTime), arg0) } @@ -1204,7 +1208,7 @@ func (m *MockApprovalCreateBucketTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetError), arg0) } @@ -1216,7 +1220,7 @@ func (m *MockApprovalCreateBucketTask) SetExpiredHeight(arg0 uint64) { } // SetExpiredHeight indicates an expected call of SetExpiredHeight. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetExpiredHeight(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetExpiredHeight), arg0) } @@ -1228,7 +1232,7 @@ func (m *MockApprovalCreateBucketTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetLogs), logs) } @@ -1240,7 +1244,7 @@ func (m *MockApprovalCreateBucketTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetMaxRetry), arg0) } @@ -1252,7 +1256,7 @@ func (m *MockApprovalCreateBucketTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetPriority), arg0) } @@ -1264,7 +1268,7 @@ func (m *MockApprovalCreateBucketTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetRetry), arg0) } @@ -1276,7 +1280,7 @@ func (m *MockApprovalCreateBucketTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetTimeout), arg0) } @@ -1288,7 +1292,7 @@ func (m *MockApprovalCreateBucketTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetUpdateTime), arg0) } @@ -1300,7 +1304,7 @@ func (m *MockApprovalCreateBucketTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockApprovalCreateBucketTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateBucketTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetUserAddress), arg0) } @@ -1349,7 +1353,7 @@ func (m *MockApprovalMigrateBucketTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).AppendLog), log) } @@ -1611,7 +1615,7 @@ func (m *MockApprovalMigrateBucketTask) InitApprovalMigrateBucketTask(arg0 *type } // InitApprovalMigrateBucketTask indicates an expected call of InitApprovalMigrateBucketTask. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) InitApprovalMigrateBucketTask(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) InitApprovalMigrateBucketTask(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApprovalMigrateBucketTask", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).InitApprovalMigrateBucketTask), arg0, arg1) } @@ -1637,7 +1641,7 @@ func (m *MockApprovalMigrateBucketTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetAddress), arg0) } @@ -1649,7 +1653,7 @@ func (m *MockApprovalMigrateBucketTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetCreateTime), arg0) } @@ -1661,7 +1665,7 @@ func (m *MockApprovalMigrateBucketTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetError), arg0) } @@ -1673,7 +1677,7 @@ func (m *MockApprovalMigrateBucketTask) SetExpiredHeight(arg0 uint64) { } // SetExpiredHeight indicates an expected call of SetExpiredHeight. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetExpiredHeight(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetExpiredHeight), arg0) } @@ -1685,7 +1689,7 @@ func (m *MockApprovalMigrateBucketTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetLogs), logs) } @@ -1697,7 +1701,7 @@ func (m *MockApprovalMigrateBucketTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetMaxRetry), arg0) } @@ -1709,7 +1713,7 @@ func (m *MockApprovalMigrateBucketTask) SetMigrateBucketInfo(arg0 *types0.MsgMig } // SetMigrateBucketInfo indicates an expected call of SetMigrateBucketInfo. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetMigrateBucketInfo(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetMigrateBucketInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMigrateBucketInfo", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetMigrateBucketInfo), arg0) } @@ -1721,7 +1725,7 @@ func (m *MockApprovalMigrateBucketTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetPriority), arg0) } @@ -1733,7 +1737,7 @@ func (m *MockApprovalMigrateBucketTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetRetry), arg0) } @@ -1745,7 +1749,7 @@ func (m *MockApprovalMigrateBucketTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetTimeout), arg0) } @@ -1757,7 +1761,7 @@ func (m *MockApprovalMigrateBucketTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetUpdateTime), arg0) } @@ -1769,7 +1773,7 @@ func (m *MockApprovalMigrateBucketTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetUserAddress), arg0) } @@ -1818,7 +1822,7 @@ func (m *MockApprovalCreateObjectTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockApprovalCreateObjectTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).AppendLog), log) } @@ -2080,7 +2084,7 @@ func (m *MockApprovalCreateObjectTask) InitApprovalCreateObjectTask(arg0 string, } // InitApprovalCreateObjectTask indicates an expected call of InitApprovalCreateObjectTask. -func (mr *MockApprovalCreateObjectTaskMockRecorder) InitApprovalCreateObjectTask(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) InitApprovalCreateObjectTask(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApprovalCreateObjectTask", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).InitApprovalCreateObjectTask), arg0, arg1, arg2, arg3) } @@ -2106,7 +2110,7 @@ func (m *MockApprovalCreateObjectTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetAddress), arg0) } @@ -2118,7 +2122,7 @@ func (m *MockApprovalCreateObjectTask) SetCreateObjectInfo(arg0 *types0.MsgCreat } // SetCreateObjectInfo indicates an expected call of SetCreateObjectInfo. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetCreateObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetCreateObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateObjectInfo", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetCreateObjectInfo), arg0) } @@ -2130,7 +2134,7 @@ func (m *MockApprovalCreateObjectTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetCreateTime), arg0) } @@ -2142,7 +2146,7 @@ func (m *MockApprovalCreateObjectTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetError), arg0) } @@ -2154,7 +2158,7 @@ func (m *MockApprovalCreateObjectTask) SetExpiredHeight(arg0 uint64) { } // SetExpiredHeight indicates an expected call of SetExpiredHeight. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetExpiredHeight(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetExpiredHeight), arg0) } @@ -2166,7 +2170,7 @@ func (m *MockApprovalCreateObjectTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetLogs), logs) } @@ -2178,7 +2182,7 @@ func (m *MockApprovalCreateObjectTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetMaxRetry), arg0) } @@ -2190,7 +2194,7 @@ func (m *MockApprovalCreateObjectTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetPriority), arg0) } @@ -2202,7 +2206,7 @@ func (m *MockApprovalCreateObjectTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetRetry), arg0) } @@ -2214,7 +2218,7 @@ func (m *MockApprovalCreateObjectTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetTimeout), arg0) } @@ -2226,7 +2230,7 @@ func (m *MockApprovalCreateObjectTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetUpdateTime), arg0) } @@ -2238,7 +2242,7 @@ func (m *MockApprovalCreateObjectTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockApprovalCreateObjectTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalCreateObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetUserAddress), arg0) } @@ -2287,7 +2291,7 @@ func (m *MockApprovalReplicatePieceTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).AppendLog), log) } @@ -2661,7 +2665,7 @@ func (m *MockApprovalReplicatePieceTask) InitApprovalReplicatePieceTask(object * } // InitApprovalReplicatePieceTask indicates an expected call of InitApprovalReplicatePieceTask. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) InitApprovalReplicatePieceTask(object, params, priority, askOpAddress interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) InitApprovalReplicatePieceTask(object, params, priority, askOpAddress any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApprovalReplicatePieceTask", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).InitApprovalReplicatePieceTask), object, params, priority, askOpAddress) } @@ -2687,7 +2691,7 @@ func (m *MockApprovalReplicatePieceTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetAddress), arg0) } @@ -2699,7 +2703,7 @@ func (m *MockApprovalReplicatePieceTask) SetApprovedSignature(arg0 []byte) { } // SetApprovedSignature indicates an expected call of SetApprovedSignature. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSignature(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSignature(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetApprovedSignature", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetApprovedSignature), arg0) } @@ -2711,7 +2715,7 @@ func (m *MockApprovalReplicatePieceTask) SetApprovedSpApprovalAddress(arg0 strin } // SetApprovedSpApprovalAddress indicates an expected call of SetApprovedSpApprovalAddress. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSpApprovalAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSpApprovalAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetApprovedSpApprovalAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetApprovedSpApprovalAddress), arg0) } @@ -2723,7 +2727,7 @@ func (m *MockApprovalReplicatePieceTask) SetApprovedSpEndpoint(arg0 string) { } // SetApprovedSpEndpoint indicates an expected call of SetApprovedSpEndpoint. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSpEndpoint(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSpEndpoint(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetApprovedSpEndpoint", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetApprovedSpEndpoint), arg0) } @@ -2735,7 +2739,7 @@ func (m *MockApprovalReplicatePieceTask) SetApprovedSpOperatorAddress(arg0 strin } // SetApprovedSpOperatorAddress indicates an expected call of SetApprovedSpOperatorAddress. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSpOperatorAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSpOperatorAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetApprovedSpOperatorAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetApprovedSpOperatorAddress), arg0) } @@ -2747,7 +2751,7 @@ func (m *MockApprovalReplicatePieceTask) SetAskSignature(arg0 []byte) { } // SetAskSignature indicates an expected call of SetAskSignature. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetAskSignature(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetAskSignature(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAskSignature", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetAskSignature), arg0) } @@ -2759,7 +2763,7 @@ func (m *MockApprovalReplicatePieceTask) SetAskSpOperatorAddress(arg0 string) { } // SetAskSpOperatorAddress indicates an expected call of SetAskSpOperatorAddress. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetAskSpOperatorAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetAskSpOperatorAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAskSpOperatorAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetAskSpOperatorAddress), arg0) } @@ -2771,7 +2775,7 @@ func (m *MockApprovalReplicatePieceTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetCreateTime), arg0) } @@ -2783,7 +2787,7 @@ func (m *MockApprovalReplicatePieceTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetError), arg0) } @@ -2795,7 +2799,7 @@ func (m *MockApprovalReplicatePieceTask) SetExpiredHeight(arg0 uint64) { } // SetExpiredHeight indicates an expected call of SetExpiredHeight. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetExpiredHeight(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetExpiredHeight), arg0) } @@ -2807,7 +2811,7 @@ func (m *MockApprovalReplicatePieceTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetLogs), logs) } @@ -2819,7 +2823,7 @@ func (m *MockApprovalReplicatePieceTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetMaxRetry), arg0) } @@ -2831,7 +2835,7 @@ func (m *MockApprovalReplicatePieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetObjectInfo), arg0) } @@ -2843,7 +2847,7 @@ func (m *MockApprovalReplicatePieceTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetPriority), arg0) } @@ -2855,7 +2859,7 @@ func (m *MockApprovalReplicatePieceTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetRetry), arg0) } @@ -2867,7 +2871,7 @@ func (m *MockApprovalReplicatePieceTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetStorageParams), arg0) } @@ -2879,7 +2883,7 @@ func (m *MockApprovalReplicatePieceTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetTimeout), arg0) } @@ -2891,7 +2895,7 @@ func (m *MockApprovalReplicatePieceTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetUpdateTime), arg0) } @@ -2903,7 +2907,7 @@ func (m *MockApprovalReplicatePieceTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetUserAddress), arg0) } @@ -2952,7 +2956,7 @@ func (m *MockObjectTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockObjectTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockObjectTask)(nil).AppendLog), log) } @@ -3228,7 +3232,7 @@ func (m *MockObjectTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockObjectTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockObjectTask)(nil).SetAddress), arg0) } @@ -3240,7 +3244,7 @@ func (m *MockObjectTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockObjectTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockObjectTask)(nil).SetCreateTime), arg0) } @@ -3252,7 +3256,7 @@ func (m *MockObjectTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockObjectTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockObjectTask)(nil).SetError), arg0) } @@ -3264,7 +3268,7 @@ func (m *MockObjectTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockObjectTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockObjectTask)(nil).SetLogs), logs) } @@ -3276,7 +3280,7 @@ func (m *MockObjectTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockObjectTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockObjectTask)(nil).SetMaxRetry), arg0) } @@ -3288,7 +3292,7 @@ func (m *MockObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockObjectTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockObjectTask)(nil).SetObjectInfo), arg0) } @@ -3300,7 +3304,7 @@ func (m *MockObjectTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockObjectTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockObjectTask)(nil).SetPriority), arg0) } @@ -3312,7 +3316,7 @@ func (m *MockObjectTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockObjectTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockObjectTask)(nil).SetRetry), arg0) } @@ -3324,7 +3328,7 @@ func (m *MockObjectTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockObjectTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockObjectTask)(nil).SetStorageParams), arg0) } @@ -3336,7 +3340,7 @@ func (m *MockObjectTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockObjectTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockObjectTask)(nil).SetTimeout), arg0) } @@ -3348,7 +3352,7 @@ func (m *MockObjectTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockObjectTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockObjectTask)(nil).SetUpdateTime), arg0) } @@ -3360,7 +3364,7 @@ func (m *MockObjectTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockObjectTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockObjectTask)(nil).SetUserAddress), arg0) } @@ -3409,7 +3413,7 @@ func (m *MockUploadObjectTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockUploadObjectTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockUploadObjectTask)(nil).AppendLog), log) } @@ -3685,7 +3689,7 @@ func (m *MockUploadObjectTask) InitUploadObjectTask(vgfID uint32, object *types0 } // InitUploadObjectTask indicates an expected call of InitUploadObjectTask. -func (mr *MockUploadObjectTaskMockRecorder) InitUploadObjectTask(vgfID, object, params, timeout interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) InitUploadObjectTask(vgfID, object, params, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitUploadObjectTask", reflect.TypeOf((*MockUploadObjectTask)(nil).InitUploadObjectTask), vgfID, object, params, timeout) } @@ -3711,7 +3715,7 @@ func (m *MockUploadObjectTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockUploadObjectTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockUploadObjectTask)(nil).SetAddress), arg0) } @@ -3723,7 +3727,7 @@ func (m *MockUploadObjectTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockUploadObjectTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockUploadObjectTask)(nil).SetCreateTime), arg0) } @@ -3735,7 +3739,7 @@ func (m *MockUploadObjectTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockUploadObjectTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockUploadObjectTask)(nil).SetError), arg0) } @@ -3747,7 +3751,7 @@ func (m *MockUploadObjectTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockUploadObjectTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockUploadObjectTask)(nil).SetLogs), logs) } @@ -3759,7 +3763,7 @@ func (m *MockUploadObjectTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockUploadObjectTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockUploadObjectTask)(nil).SetMaxRetry), arg0) } @@ -3771,7 +3775,7 @@ func (m *MockUploadObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockUploadObjectTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockUploadObjectTask)(nil).SetObjectInfo), arg0) } @@ -3783,7 +3787,7 @@ func (m *MockUploadObjectTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockUploadObjectTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockUploadObjectTask)(nil).SetPriority), arg0) } @@ -3795,7 +3799,7 @@ func (m *MockUploadObjectTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockUploadObjectTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockUploadObjectTask)(nil).SetRetry), arg0) } @@ -3807,7 +3811,7 @@ func (m *MockUploadObjectTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockUploadObjectTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockUploadObjectTask)(nil).SetStorageParams), arg0) } @@ -3819,7 +3823,7 @@ func (m *MockUploadObjectTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockUploadObjectTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockUploadObjectTask)(nil).SetTimeout), arg0) } @@ -3831,7 +3835,7 @@ func (m *MockUploadObjectTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockUploadObjectTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockUploadObjectTask)(nil).SetUpdateTime), arg0) } @@ -3843,7 +3847,7 @@ func (m *MockUploadObjectTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockUploadObjectTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockUploadObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockUploadObjectTask)(nil).SetUserAddress), arg0) } @@ -3892,7 +3896,7 @@ func (m *MockResumableUploadObjectTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockResumableUploadObjectTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).AppendLog), log) } @@ -4196,7 +4200,7 @@ func (m *MockResumableUploadObjectTask) InitResumableUploadObjectTask(vgfID uint } // InitResumableUploadObjectTask indicates an expected call of InitResumableUploadObjectTask. -func (mr *MockResumableUploadObjectTaskMockRecorder) InitResumableUploadObjectTask(vgfID, object, params, timeout, complete, offset interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) InitResumableUploadObjectTask(vgfID, object, params, timeout, complete, offset any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitResumableUploadObjectTask", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).InitResumableUploadObjectTask), vgfID, object, params, timeout, complete, offset) } @@ -4222,7 +4226,7 @@ func (m *MockResumableUploadObjectTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetAddress), arg0) } @@ -4234,7 +4238,7 @@ func (m *MockResumableUploadObjectTask) SetCompleted(completed bool) { } // SetCompleted indicates an expected call of SetCompleted. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetCompleted(completed interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetCompleted(completed any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCompleted", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetCompleted), completed) } @@ -4246,7 +4250,7 @@ func (m *MockResumableUploadObjectTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetCreateTime), arg0) } @@ -4258,7 +4262,7 @@ func (m *MockResumableUploadObjectTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetError), arg0) } @@ -4270,7 +4274,7 @@ func (m *MockResumableUploadObjectTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetLogs), logs) } @@ -4282,7 +4286,7 @@ func (m *MockResumableUploadObjectTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetMaxRetry), arg0) } @@ -4294,7 +4298,7 @@ func (m *MockResumableUploadObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetObjectInfo), arg0) } @@ -4306,7 +4310,7 @@ func (m *MockResumableUploadObjectTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetPriority), arg0) } @@ -4318,7 +4322,7 @@ func (m *MockResumableUploadObjectTask) SetResumeOffset(offset uint64) { } // SetResumeOffset indicates an expected call of SetResumeOffset. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetResumeOffset(offset interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetResumeOffset(offset any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetResumeOffset", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetResumeOffset), offset) } @@ -4330,7 +4334,7 @@ func (m *MockResumableUploadObjectTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetRetry), arg0) } @@ -4342,7 +4346,7 @@ func (m *MockResumableUploadObjectTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetStorageParams), arg0) } @@ -4354,7 +4358,7 @@ func (m *MockResumableUploadObjectTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetTimeout), arg0) } @@ -4366,7 +4370,7 @@ func (m *MockResumableUploadObjectTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetUpdateTime), arg0) } @@ -4378,7 +4382,7 @@ func (m *MockResumableUploadObjectTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockResumableUploadObjectTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockResumableUploadObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetUserAddress), arg0) } @@ -4427,7 +4431,7 @@ func (m *MockReplicatePieceTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockReplicatePieceTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockReplicatePieceTask)(nil).AppendLog), log) } @@ -4773,7 +4777,7 @@ func (m *MockReplicatePieceTask) InitReplicatePieceTask(object *types0.ObjectInf } // InitReplicatePieceTask indicates an expected call of InitReplicatePieceTask. -func (mr *MockReplicatePieceTaskMockRecorder) InitReplicatePieceTask(object, params, priority, timeout, retry interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) InitReplicatePieceTask(object, params, priority, timeout, retry any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitReplicatePieceTask", reflect.TypeOf((*MockReplicatePieceTask)(nil).InitReplicatePieceTask), object, params, priority, timeout, retry) } @@ -4799,7 +4803,7 @@ func (m *MockReplicatePieceTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockReplicatePieceTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetAddress), arg0) } @@ -4811,7 +4815,7 @@ func (m *MockReplicatePieceTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockReplicatePieceTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetCreateTime), arg0) } @@ -4823,7 +4827,7 @@ func (m *MockReplicatePieceTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockReplicatePieceTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetError), arg0) } @@ -4835,7 +4839,7 @@ func (m *MockReplicatePieceTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockReplicatePieceTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetLogs), logs) } @@ -4847,7 +4851,7 @@ func (m *MockReplicatePieceTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockReplicatePieceTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetMaxRetry), arg0) } @@ -4859,7 +4863,7 @@ func (m *MockReplicatePieceTask) SetNotAvailableSpIdx(arg0 int32) { } // SetNotAvailableSpIdx indicates an expected call of SetNotAvailableSpIdx. -func (mr *MockReplicatePieceTaskMockRecorder) SetNotAvailableSpIdx(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetNotAvailableSpIdx(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNotAvailableSpIdx", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetNotAvailableSpIdx), arg0) } @@ -4871,7 +4875,7 @@ func (m *MockReplicatePieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockReplicatePieceTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetObjectInfo), arg0) } @@ -4883,7 +4887,7 @@ func (m *MockReplicatePieceTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockReplicatePieceTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetPriority), arg0) } @@ -4895,7 +4899,7 @@ func (m *MockReplicatePieceTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockReplicatePieceTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetRetry), arg0) } @@ -4907,7 +4911,7 @@ func (m *MockReplicatePieceTask) SetSealed(arg0 bool) { } // SetSealed indicates an expected call of SetSealed. -func (mr *MockReplicatePieceTaskMockRecorder) SetSealed(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetSealed(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSealed", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetSealed), arg0) } @@ -4919,7 +4923,7 @@ func (m *MockReplicatePieceTask) SetSecondaryAddresses(arg0 []string) { } // SetSecondaryAddresses indicates an expected call of SetSecondaryAddresses. -func (mr *MockReplicatePieceTaskMockRecorder) SetSecondaryAddresses(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetSecondaryAddresses(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecondaryAddresses", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetSecondaryAddresses), arg0) } @@ -4931,7 +4935,7 @@ func (m *MockReplicatePieceTask) SetSecondarySignatures(arg0 [][]byte) { } // SetSecondarySignatures indicates an expected call of SetSecondarySignatures. -func (mr *MockReplicatePieceTaskMockRecorder) SetSecondarySignatures(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetSecondarySignatures(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecondarySignatures", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetSecondarySignatures), arg0) } @@ -4943,7 +4947,7 @@ func (m *MockReplicatePieceTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockReplicatePieceTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetStorageParams), arg0) } @@ -4955,7 +4959,7 @@ func (m *MockReplicatePieceTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockReplicatePieceTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetTimeout), arg0) } @@ -4967,7 +4971,7 @@ func (m *MockReplicatePieceTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockReplicatePieceTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetUpdateTime), arg0) } @@ -4979,7 +4983,7 @@ func (m *MockReplicatePieceTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockReplicatePieceTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockReplicatePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetUserAddress), arg0) } @@ -5028,7 +5032,7 @@ func (m *MockReceivePieceTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockReceivePieceTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockReceivePieceTask)(nil).AppendLog), log) } @@ -5430,7 +5434,7 @@ func (m *MockReceivePieceTask) InitReceivePieceTask(vgfID uint32, object *types0 } // InitReceivePieceTask indicates an expected call of InitReceivePieceTask. -func (mr *MockReceivePieceTaskMockRecorder) InitReceivePieceTask(vgfID, object, params, priority, segmentIdx, redundancyIdx, pieceSize interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) InitReceivePieceTask(vgfID, object, params, priority, segmentIdx, redundancyIdx, pieceSize any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitReceivePieceTask", reflect.TypeOf((*MockReceivePieceTask)(nil).InitReceivePieceTask), vgfID, object, params, priority, segmentIdx, redundancyIdx, pieceSize) } @@ -5456,7 +5460,7 @@ func (m *MockReceivePieceTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockReceivePieceTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockReceivePieceTask)(nil).SetAddress), arg0) } @@ -5468,7 +5472,7 @@ func (m *MockReceivePieceTask) SetBucketMigration(arg0 bool) { } // SetBucketMigration indicates an expected call of SetBucketMigration. -func (mr *MockReceivePieceTaskMockRecorder) SetBucketMigration(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetBucketMigration(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketMigration", reflect.TypeOf((*MockReceivePieceTask)(nil).SetBucketMigration), arg0) } @@ -5480,7 +5484,7 @@ func (m *MockReceivePieceTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockReceivePieceTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockReceivePieceTask)(nil).SetCreateTime), arg0) } @@ -5492,7 +5496,7 @@ func (m *MockReceivePieceTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockReceivePieceTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockReceivePieceTask)(nil).SetError), arg0) } @@ -5504,7 +5508,7 @@ func (m *MockReceivePieceTask) SetFinished(arg0 bool) { } // SetFinished indicates an expected call of SetFinished. -func (mr *MockReceivePieceTaskMockRecorder) SetFinished(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetFinished(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinished", reflect.TypeOf((*MockReceivePieceTask)(nil).SetFinished), arg0) } @@ -5516,7 +5520,7 @@ func (m *MockReceivePieceTask) SetGlobalVirtualGroupID(arg0 uint32) { } // SetGlobalVirtualGroupID indicates an expected call of SetGlobalVirtualGroupID. -func (mr *MockReceivePieceTaskMockRecorder) SetGlobalVirtualGroupID(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetGlobalVirtualGroupID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGlobalVirtualGroupID", reflect.TypeOf((*MockReceivePieceTask)(nil).SetGlobalVirtualGroupID), arg0) } @@ -5528,7 +5532,7 @@ func (m *MockReceivePieceTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockReceivePieceTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockReceivePieceTask)(nil).SetLogs), logs) } @@ -5540,7 +5544,7 @@ func (m *MockReceivePieceTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockReceivePieceTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockReceivePieceTask)(nil).SetMaxRetry), arg0) } @@ -5552,7 +5556,7 @@ func (m *MockReceivePieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockReceivePieceTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockReceivePieceTask)(nil).SetObjectInfo), arg0) } @@ -5564,7 +5568,7 @@ func (m *MockReceivePieceTask) SetPieceChecksum(arg0 []byte) { } // SetPieceChecksum indicates an expected call of SetPieceChecksum. -func (mr *MockReceivePieceTaskMockRecorder) SetPieceChecksum(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetPieceChecksum(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPieceChecksum", reflect.TypeOf((*MockReceivePieceTask)(nil).SetPieceChecksum), arg0) } @@ -5576,7 +5580,7 @@ func (m *MockReceivePieceTask) SetPieceSize(arg0 int64) { } // SetPieceSize indicates an expected call of SetPieceSize. -func (mr *MockReceivePieceTaskMockRecorder) SetPieceSize(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetPieceSize(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPieceSize", reflect.TypeOf((*MockReceivePieceTask)(nil).SetPieceSize), arg0) } @@ -5588,7 +5592,7 @@ func (m *MockReceivePieceTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockReceivePieceTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockReceivePieceTask)(nil).SetPriority), arg0) } @@ -5600,7 +5604,7 @@ func (m *MockReceivePieceTask) SetRedundancyIdx(arg0 int32) { } // SetRedundancyIdx indicates an expected call of SetRedundancyIdx. -func (mr *MockReceivePieceTaskMockRecorder) SetRedundancyIdx(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetRedundancyIdx(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRedundancyIdx", reflect.TypeOf((*MockReceivePieceTask)(nil).SetRedundancyIdx), arg0) } @@ -5612,7 +5616,7 @@ func (m *MockReceivePieceTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockReceivePieceTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockReceivePieceTask)(nil).SetRetry), arg0) } @@ -5624,7 +5628,7 @@ func (m *MockReceivePieceTask) SetSealed(arg0 bool) { } // SetSealed indicates an expected call of SetSealed. -func (mr *MockReceivePieceTaskMockRecorder) SetSealed(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetSealed(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSealed", reflect.TypeOf((*MockReceivePieceTask)(nil).SetSealed), arg0) } @@ -5636,7 +5640,7 @@ func (m *MockReceivePieceTask) SetSegmentIdx(arg0 uint32) { } // SetSegmentIdx indicates an expected call of SetSegmentIdx. -func (mr *MockReceivePieceTaskMockRecorder) SetSegmentIdx(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetSegmentIdx(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSegmentIdx", reflect.TypeOf((*MockReceivePieceTask)(nil).SetSegmentIdx), arg0) } @@ -5648,7 +5652,7 @@ func (m *MockReceivePieceTask) SetSignature(arg0 []byte) { } // SetSignature indicates an expected call of SetSignature. -func (mr *MockReceivePieceTaskMockRecorder) SetSignature(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetSignature(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSignature", reflect.TypeOf((*MockReceivePieceTask)(nil).SetSignature), arg0) } @@ -5660,7 +5664,7 @@ func (m *MockReceivePieceTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockReceivePieceTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockReceivePieceTask)(nil).SetStorageParams), arg0) } @@ -5672,7 +5676,7 @@ func (m *MockReceivePieceTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockReceivePieceTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockReceivePieceTask)(nil).SetTimeout), arg0) } @@ -5684,7 +5688,7 @@ func (m *MockReceivePieceTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockReceivePieceTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockReceivePieceTask)(nil).SetUpdateTime), arg0) } @@ -5696,7 +5700,7 @@ func (m *MockReceivePieceTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockReceivePieceTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockReceivePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockReceivePieceTask)(nil).SetUserAddress), arg0) } @@ -5745,7 +5749,7 @@ func (m *MockSealObjectTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockSealObjectTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockSealObjectTask)(nil).AppendLog), log) } @@ -6049,7 +6053,7 @@ func (m *MockSealObjectTask) InitSealObjectTask(vgfID uint32, object *types0.Obj } // InitSealObjectTask indicates an expected call of InitSealObjectTask. -func (mr *MockSealObjectTaskMockRecorder) InitSealObjectTask(vgfID, object, params, priority, addresses, signatures, timeout, retry interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) InitSealObjectTask(vgfID, object, params, priority, addresses, signatures, timeout, retry any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitSealObjectTask", reflect.TypeOf((*MockSealObjectTask)(nil).InitSealObjectTask), vgfID, object, params, priority, addresses, signatures, timeout, retry) } @@ -6075,7 +6079,7 @@ func (m *MockSealObjectTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockSealObjectTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockSealObjectTask)(nil).SetAddress), arg0) } @@ -6087,7 +6091,7 @@ func (m *MockSealObjectTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockSealObjectTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockSealObjectTask)(nil).SetCreateTime), arg0) } @@ -6099,7 +6103,7 @@ func (m *MockSealObjectTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockSealObjectTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockSealObjectTask)(nil).SetError), arg0) } @@ -6111,7 +6115,7 @@ func (m *MockSealObjectTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockSealObjectTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockSealObjectTask)(nil).SetLogs), logs) } @@ -6123,7 +6127,7 @@ func (m *MockSealObjectTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockSealObjectTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockSealObjectTask)(nil).SetMaxRetry), arg0) } @@ -6135,7 +6139,7 @@ func (m *MockSealObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockSealObjectTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockSealObjectTask)(nil).SetObjectInfo), arg0) } @@ -6147,7 +6151,7 @@ func (m *MockSealObjectTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockSealObjectTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockSealObjectTask)(nil).SetPriority), arg0) } @@ -6159,7 +6163,7 @@ func (m *MockSealObjectTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockSealObjectTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockSealObjectTask)(nil).SetRetry), arg0) } @@ -6171,7 +6175,7 @@ func (m *MockSealObjectTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockSealObjectTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockSealObjectTask)(nil).SetStorageParams), arg0) } @@ -6183,7 +6187,7 @@ func (m *MockSealObjectTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockSealObjectTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockSealObjectTask)(nil).SetTimeout), arg0) } @@ -6195,7 +6199,7 @@ func (m *MockSealObjectTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockSealObjectTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockSealObjectTask)(nil).SetUpdateTime), arg0) } @@ -6207,7 +6211,7 @@ func (m *MockSealObjectTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockSealObjectTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockSealObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockSealObjectTask)(nil).SetUserAddress), arg0) } @@ -6256,7 +6260,7 @@ func (m *MockDownloadObjectTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockDownloadObjectTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockDownloadObjectTask)(nil).AppendLog), log) } @@ -6574,7 +6578,7 @@ func (m *MockDownloadObjectTask) InitDownloadObjectTask(object *types0.ObjectInf } // InitDownloadObjectTask indicates an expected call of InitDownloadObjectTask. -func (mr *MockDownloadObjectTaskMockRecorder) InitDownloadObjectTask(object, bucket, params, priority, userAddress, low, high, timeout, retry interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) InitDownloadObjectTask(object, bucket, params, priority, userAddress, low, high, timeout, retry any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitDownloadObjectTask", reflect.TypeOf((*MockDownloadObjectTask)(nil).InitDownloadObjectTask), object, bucket, params, priority, userAddress, low, high, timeout, retry) } @@ -6600,7 +6604,7 @@ func (m *MockDownloadObjectTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockDownloadObjectTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetAddress), arg0) } @@ -6612,7 +6616,7 @@ func (m *MockDownloadObjectTask) SetBucketInfo(arg0 *types0.BucketInfo) { } // SetBucketInfo indicates an expected call of SetBucketInfo. -func (mr *MockDownloadObjectTaskMockRecorder) SetBucketInfo(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetBucketInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketInfo", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetBucketInfo), arg0) } @@ -6624,7 +6628,7 @@ func (m *MockDownloadObjectTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockDownloadObjectTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetCreateTime), arg0) } @@ -6636,7 +6640,7 @@ func (m *MockDownloadObjectTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockDownloadObjectTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetError), arg0) } @@ -6648,7 +6652,7 @@ func (m *MockDownloadObjectTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockDownloadObjectTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetLogs), logs) } @@ -6660,7 +6664,7 @@ func (m *MockDownloadObjectTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockDownloadObjectTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetMaxRetry), arg0) } @@ -6672,7 +6676,7 @@ func (m *MockDownloadObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockDownloadObjectTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetObjectInfo), arg0) } @@ -6684,7 +6688,7 @@ func (m *MockDownloadObjectTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockDownloadObjectTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetPriority), arg0) } @@ -6696,7 +6700,7 @@ func (m *MockDownloadObjectTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockDownloadObjectTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetRetry), arg0) } @@ -6708,7 +6712,7 @@ func (m *MockDownloadObjectTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockDownloadObjectTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetStorageParams), arg0) } @@ -6720,7 +6724,7 @@ func (m *MockDownloadObjectTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockDownloadObjectTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetTimeout), arg0) } @@ -6732,7 +6736,7 @@ func (m *MockDownloadObjectTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockDownloadObjectTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetUpdateTime), arg0) } @@ -6744,7 +6748,7 @@ func (m *MockDownloadObjectTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockDownloadObjectTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetUserAddress), arg0) } @@ -6793,7 +6797,7 @@ func (m *MockDownloadPieceTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockDownloadPieceTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockDownloadPieceTask)(nil).AppendLog), log) } @@ -7153,7 +7157,7 @@ func (m *MockDownloadPieceTask) InitDownloadPieceTask(object *types0.ObjectInfo, } // InitDownloadPieceTask indicates an expected call of InitDownloadPieceTask. -func (mr *MockDownloadPieceTaskMockRecorder) InitDownloadPieceTask(object, bucket, params, priority, enableCheck, userAddress, totalSize, pieceKey, pieceOffset, pieceLength, timeout, maxRetry interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) InitDownloadPieceTask(object, bucket, params, priority, enableCheck, userAddress, totalSize, pieceKey, pieceOffset, pieceLength, timeout, maxRetry any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitDownloadPieceTask", reflect.TypeOf((*MockDownloadPieceTask)(nil).InitDownloadPieceTask), object, bucket, params, priority, enableCheck, userAddress, totalSize, pieceKey, pieceOffset, pieceLength, timeout, maxRetry) } @@ -7179,7 +7183,7 @@ func (m *MockDownloadPieceTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockDownloadPieceTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetAddress), arg0) } @@ -7191,7 +7195,7 @@ func (m *MockDownloadPieceTask) SetBucketInfo(arg0 *types0.BucketInfo) { } // SetBucketInfo indicates an expected call of SetBucketInfo. -func (mr *MockDownloadPieceTaskMockRecorder) SetBucketInfo(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetBucketInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketInfo", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetBucketInfo), arg0) } @@ -7203,7 +7207,7 @@ func (m *MockDownloadPieceTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockDownloadPieceTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetCreateTime), arg0) } @@ -7215,7 +7219,7 @@ func (m *MockDownloadPieceTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockDownloadPieceTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetError), arg0) } @@ -7227,7 +7231,7 @@ func (m *MockDownloadPieceTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockDownloadPieceTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetLogs), logs) } @@ -7239,7 +7243,7 @@ func (m *MockDownloadPieceTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockDownloadPieceTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetMaxRetry), arg0) } @@ -7251,7 +7255,7 @@ func (m *MockDownloadPieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockDownloadPieceTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetObjectInfo), arg0) } @@ -7263,7 +7267,7 @@ func (m *MockDownloadPieceTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockDownloadPieceTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetPriority), arg0) } @@ -7275,7 +7279,7 @@ func (m *MockDownloadPieceTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockDownloadPieceTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetRetry), arg0) } @@ -7287,7 +7291,7 @@ func (m *MockDownloadPieceTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockDownloadPieceTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetStorageParams), arg0) } @@ -7299,7 +7303,7 @@ func (m *MockDownloadPieceTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockDownloadPieceTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetTimeout), arg0) } @@ -7311,7 +7315,7 @@ func (m *MockDownloadPieceTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockDownloadPieceTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetUpdateTime), arg0) } @@ -7323,7 +7327,7 @@ func (m *MockDownloadPieceTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockDownloadPieceTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockDownloadPieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetUserAddress), arg0) } @@ -7372,7 +7376,7 @@ func (m *MockChallengePieceTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockChallengePieceTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockChallengePieceTask)(nil).AppendLog), log) } @@ -7718,7 +7722,7 @@ func (m *MockChallengePieceTask) InitChallengePieceTask(object *types0.ObjectInf } // InitChallengePieceTask indicates an expected call of InitChallengePieceTask. -func (mr *MockChallengePieceTaskMockRecorder) InitChallengePieceTask(object, bucket, params, priority, userAddress, replicateIdx, segmentIdx, timeout, retry interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) InitChallengePieceTask(object, bucket, params, priority, userAddress, replicateIdx, segmentIdx, timeout, retry any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitChallengePieceTask", reflect.TypeOf((*MockChallengePieceTask)(nil).InitChallengePieceTask), object, bucket, params, priority, userAddress, replicateIdx, segmentIdx, timeout, retry) } @@ -7744,7 +7748,7 @@ func (m *MockChallengePieceTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockChallengePieceTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockChallengePieceTask)(nil).SetAddress), arg0) } @@ -7756,7 +7760,7 @@ func (m *MockChallengePieceTask) SetBucketInfo(arg0 *types0.BucketInfo) { } // SetBucketInfo indicates an expected call of SetBucketInfo. -func (mr *MockChallengePieceTaskMockRecorder) SetBucketInfo(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetBucketInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketInfo", reflect.TypeOf((*MockChallengePieceTask)(nil).SetBucketInfo), arg0) } @@ -7768,7 +7772,7 @@ func (m *MockChallengePieceTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockChallengePieceTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockChallengePieceTask)(nil).SetCreateTime), arg0) } @@ -7780,7 +7784,7 @@ func (m *MockChallengePieceTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockChallengePieceTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockChallengePieceTask)(nil).SetError), arg0) } @@ -7792,7 +7796,7 @@ func (m *MockChallengePieceTask) SetIntegrityHash(arg0 []byte) { } // SetIntegrityHash indicates an expected call of SetIntegrityHash. -func (mr *MockChallengePieceTaskMockRecorder) SetIntegrityHash(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetIntegrityHash(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIntegrityHash", reflect.TypeOf((*MockChallengePieceTask)(nil).SetIntegrityHash), arg0) } @@ -7804,7 +7808,7 @@ func (m *MockChallengePieceTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockChallengePieceTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockChallengePieceTask)(nil).SetLogs), logs) } @@ -7816,7 +7820,7 @@ func (m *MockChallengePieceTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockChallengePieceTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockChallengePieceTask)(nil).SetMaxRetry), arg0) } @@ -7828,7 +7832,7 @@ func (m *MockChallengePieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockChallengePieceTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockChallengePieceTask)(nil).SetObjectInfo), arg0) } @@ -7840,7 +7844,7 @@ func (m *MockChallengePieceTask) SetPieceDataSize(arg0 int64) { } // SetPieceDataSize indicates an expected call of SetPieceDataSize. -func (mr *MockChallengePieceTaskMockRecorder) SetPieceDataSize(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetPieceDataSize(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPieceDataSize", reflect.TypeOf((*MockChallengePieceTask)(nil).SetPieceDataSize), arg0) } @@ -7852,7 +7856,7 @@ func (m *MockChallengePieceTask) SetPieceHash(arg0 [][]byte) { } // SetPieceHash indicates an expected call of SetPieceHash. -func (mr *MockChallengePieceTaskMockRecorder) SetPieceHash(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetPieceHash(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPieceHash", reflect.TypeOf((*MockChallengePieceTask)(nil).SetPieceHash), arg0) } @@ -7864,7 +7868,7 @@ func (m *MockChallengePieceTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockChallengePieceTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockChallengePieceTask)(nil).SetPriority), arg0) } @@ -7876,7 +7880,7 @@ func (m *MockChallengePieceTask) SetRedundancyIdx(idx int32) { } // SetRedundancyIdx indicates an expected call of SetRedundancyIdx. -func (mr *MockChallengePieceTaskMockRecorder) SetRedundancyIdx(idx interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetRedundancyIdx(idx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRedundancyIdx", reflect.TypeOf((*MockChallengePieceTask)(nil).SetRedundancyIdx), idx) } @@ -7888,7 +7892,7 @@ func (m *MockChallengePieceTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockChallengePieceTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockChallengePieceTask)(nil).SetRetry), arg0) } @@ -7900,7 +7904,7 @@ func (m *MockChallengePieceTask) SetSegmentIdx(arg0 uint32) { } // SetSegmentIdx indicates an expected call of SetSegmentIdx. -func (mr *MockChallengePieceTaskMockRecorder) SetSegmentIdx(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetSegmentIdx(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSegmentIdx", reflect.TypeOf((*MockChallengePieceTask)(nil).SetSegmentIdx), arg0) } @@ -7912,7 +7916,7 @@ func (m *MockChallengePieceTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockChallengePieceTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockChallengePieceTask)(nil).SetStorageParams), arg0) } @@ -7924,7 +7928,7 @@ func (m *MockChallengePieceTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockChallengePieceTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockChallengePieceTask)(nil).SetTimeout), arg0) } @@ -7936,7 +7940,7 @@ func (m *MockChallengePieceTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockChallengePieceTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockChallengePieceTask)(nil).SetUpdateTime), arg0) } @@ -7948,7 +7952,7 @@ func (m *MockChallengePieceTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockChallengePieceTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockChallengePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockChallengePieceTask)(nil).SetUserAddress), arg0) } @@ -7997,7 +8001,7 @@ func (m *MockGCTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockGCTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCTask)(nil).AppendLog), log) } @@ -8245,7 +8249,7 @@ func (m *MockGCTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockGCTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCTask)(nil).SetAddress), arg0) } @@ -8257,7 +8261,7 @@ func (m *MockGCTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockGCTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCTask)(nil).SetCreateTime), arg0) } @@ -8269,7 +8273,7 @@ func (m *MockGCTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockGCTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCTask)(nil).SetError), arg0) } @@ -8281,7 +8285,7 @@ func (m *MockGCTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockGCTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCTask)(nil).SetLogs), logs) } @@ -8293,7 +8297,7 @@ func (m *MockGCTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockGCTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCTask)(nil).SetMaxRetry), arg0) } @@ -8305,7 +8309,7 @@ func (m *MockGCTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockGCTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCTask)(nil).SetPriority), arg0) } @@ -8317,7 +8321,7 @@ func (m *MockGCTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockGCTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCTask)(nil).SetRetry), arg0) } @@ -8329,7 +8333,7 @@ func (m *MockGCTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockGCTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCTask)(nil).SetTimeout), arg0) } @@ -8341,7 +8345,7 @@ func (m *MockGCTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockGCTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCTask)(nil).SetUpdateTime), arg0) } @@ -8353,7 +8357,7 @@ func (m *MockGCTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockGCTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCTask)(nil).SetUserAddress), arg0) } @@ -8402,7 +8406,7 @@ func (m *MockGCObjectTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockGCObjectTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCObjectTask)(nil).AppendLog), log) } @@ -8707,7 +8711,7 @@ func (m *MockGCObjectTask) InitGCObjectTask(priority TPriority, start, end uint6 } // InitGCObjectTask indicates an expected call of InitGCObjectTask. -func (mr *MockGCObjectTaskMockRecorder) InitGCObjectTask(priority, start, end, timeout interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) InitGCObjectTask(priority, start, end, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGCObjectTask", reflect.TypeOf((*MockGCObjectTask)(nil).InitGCObjectTask), priority, start, end, timeout) } @@ -8733,7 +8737,7 @@ func (m *MockGCObjectTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockGCObjectTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCObjectTask)(nil).SetAddress), arg0) } @@ -8745,7 +8749,7 @@ func (m *MockGCObjectTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockGCObjectTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCObjectTask)(nil).SetCreateTime), arg0) } @@ -8757,7 +8761,7 @@ func (m *MockGCObjectTask) SetCurrentBlockNumber(arg0 uint64) { } // SetCurrentBlockNumber indicates an expected call of SetCurrentBlockNumber. -func (mr *MockGCObjectTaskMockRecorder) SetCurrentBlockNumber(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetCurrentBlockNumber(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentBlockNumber", reflect.TypeOf((*MockGCObjectTask)(nil).SetCurrentBlockNumber), arg0) } @@ -8769,7 +8773,7 @@ func (m *MockGCObjectTask) SetEndBlockNumber(arg0 uint64) { } // SetEndBlockNumber indicates an expected call of SetEndBlockNumber. -func (mr *MockGCObjectTaskMockRecorder) SetEndBlockNumber(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetEndBlockNumber(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEndBlockNumber", reflect.TypeOf((*MockGCObjectTask)(nil).SetEndBlockNumber), arg0) } @@ -8781,7 +8785,7 @@ func (m *MockGCObjectTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockGCObjectTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCObjectTask)(nil).SetError), arg0) } @@ -8793,7 +8797,7 @@ func (m *MockGCObjectTask) SetGCObjectProgress(arg0, arg1 uint64) { } // SetGCObjectProgress indicates an expected call of SetGCObjectProgress. -func (mr *MockGCObjectTaskMockRecorder) SetGCObjectProgress(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetGCObjectProgress(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGCObjectProgress", reflect.TypeOf((*MockGCObjectTask)(nil).SetGCObjectProgress), arg0, arg1) } @@ -8805,7 +8809,7 @@ func (m *MockGCObjectTask) SetLastDeletedObjectId(arg0 uint64) { } // SetLastDeletedObjectId indicates an expected call of SetLastDeletedObjectId. -func (mr *MockGCObjectTaskMockRecorder) SetLastDeletedObjectId(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetLastDeletedObjectId(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastDeletedObjectId", reflect.TypeOf((*MockGCObjectTask)(nil).SetLastDeletedObjectId), arg0) } @@ -8817,7 +8821,7 @@ func (m *MockGCObjectTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockGCObjectTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCObjectTask)(nil).SetLogs), logs) } @@ -8829,7 +8833,7 @@ func (m *MockGCObjectTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockGCObjectTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCObjectTask)(nil).SetMaxRetry), arg0) } @@ -8841,7 +8845,7 @@ func (m *MockGCObjectTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockGCObjectTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCObjectTask)(nil).SetPriority), arg0) } @@ -8853,7 +8857,7 @@ func (m *MockGCObjectTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockGCObjectTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCObjectTask)(nil).SetRetry), arg0) } @@ -8865,7 +8869,7 @@ func (m *MockGCObjectTask) SetStartBlockNumber(arg0 uint64) { } // SetStartBlockNumber indicates an expected call of SetStartBlockNumber. -func (mr *MockGCObjectTaskMockRecorder) SetStartBlockNumber(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetStartBlockNumber(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStartBlockNumber", reflect.TypeOf((*MockGCObjectTask)(nil).SetStartBlockNumber), arg0) } @@ -8877,7 +8881,7 @@ func (m *MockGCObjectTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockGCObjectTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCObjectTask)(nil).SetTimeout), arg0) } @@ -8889,7 +8893,7 @@ func (m *MockGCObjectTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockGCObjectTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCObjectTask)(nil).SetUpdateTime), arg0) } @@ -8901,7 +8905,7 @@ func (m *MockGCObjectTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockGCObjectTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCObjectTask)(nil).SetUserAddress), arg0) } @@ -8950,7 +8954,7 @@ func (m *MockGCZombiePieceTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockGCZombiePieceTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCZombiePieceTask)(nil).AppendLog), log) } @@ -9212,7 +9216,7 @@ func (m *MockGCZombiePieceTask) InitGCZombiePieceTask(priority TPriority, start, } // InitGCZombiePieceTask indicates an expected call of InitGCZombiePieceTask. -func (mr *MockGCZombiePieceTaskMockRecorder) InitGCZombiePieceTask(priority, start, end, timeout interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) InitGCZombiePieceTask(priority, start, end, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGCZombiePieceTask", reflect.TypeOf((*MockGCZombiePieceTask)(nil).InitGCZombiePieceTask), priority, start, end, timeout) } @@ -9238,7 +9242,7 @@ func (m *MockGCZombiePieceTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockGCZombiePieceTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetAddress), arg0) } @@ -9250,7 +9254,7 @@ func (m *MockGCZombiePieceTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockGCZombiePieceTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetCreateTime), arg0) } @@ -9262,7 +9266,7 @@ func (m *MockGCZombiePieceTask) SetEndObjectID(arg0 uint64) { } // SetEndObjectID indicates an expected call of SetEndObjectID. -func (mr *MockGCZombiePieceTaskMockRecorder) SetEndObjectID(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetEndObjectID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEndObjectID", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetEndObjectID), arg0) } @@ -9274,7 +9278,7 @@ func (m *MockGCZombiePieceTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockGCZombiePieceTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetError), arg0) } @@ -9286,7 +9290,7 @@ func (m *MockGCZombiePieceTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockGCZombiePieceTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetLogs), logs) } @@ -9298,7 +9302,7 @@ func (m *MockGCZombiePieceTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockGCZombiePieceTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetMaxRetry), arg0) } @@ -9310,7 +9314,7 @@ func (m *MockGCZombiePieceTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockGCZombiePieceTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetPriority), arg0) } @@ -9322,7 +9326,7 @@ func (m *MockGCZombiePieceTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockGCZombiePieceTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetRetry), arg0) } @@ -9334,7 +9338,7 @@ func (m *MockGCZombiePieceTask) SetStartObjectID(arg0 uint64) { } // SetStartObjectID indicates an expected call of SetStartObjectID. -func (mr *MockGCZombiePieceTaskMockRecorder) SetStartObjectID(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetStartObjectID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStartObjectID", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetStartObjectID), arg0) } @@ -9346,7 +9350,7 @@ func (m *MockGCZombiePieceTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockGCZombiePieceTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetTimeout), arg0) } @@ -9358,7 +9362,7 @@ func (m *MockGCZombiePieceTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockGCZombiePieceTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetUpdateTime), arg0) } @@ -9370,7 +9374,7 @@ func (m *MockGCZombiePieceTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockGCZombiePieceTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCZombiePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetUserAddress), arg0) } @@ -9419,7 +9423,7 @@ func (m *MockGCMetaTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockGCMetaTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCMetaTask)(nil).AppendLog), log) } @@ -9682,7 +9686,7 @@ func (m *MockGCMetaTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockGCMetaTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCMetaTask)(nil).SetAddress), arg0) } @@ -9694,7 +9698,7 @@ func (m *MockGCMetaTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockGCMetaTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCMetaTask)(nil).SetCreateTime), arg0) } @@ -9706,7 +9710,7 @@ func (m *MockGCMetaTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockGCMetaTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCMetaTask)(nil).SetError), arg0) } @@ -9718,7 +9722,7 @@ func (m *MockGCMetaTask) SetGCMetaStatus(arg0, arg1 uint64) { } // SetGCMetaStatus indicates an expected call of SetGCMetaStatus. -func (mr *MockGCMetaTaskMockRecorder) SetGCMetaStatus(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetGCMetaStatus(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGCMetaStatus", reflect.TypeOf((*MockGCMetaTask)(nil).SetGCMetaStatus), arg0, arg1) } @@ -9730,7 +9734,7 @@ func (m *MockGCMetaTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockGCMetaTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCMetaTask)(nil).SetLogs), logs) } @@ -9742,7 +9746,7 @@ func (m *MockGCMetaTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockGCMetaTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCMetaTask)(nil).SetMaxRetry), arg0) } @@ -9754,7 +9758,7 @@ func (m *MockGCMetaTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockGCMetaTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCMetaTask)(nil).SetPriority), arg0) } @@ -9766,7 +9770,7 @@ func (m *MockGCMetaTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockGCMetaTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCMetaTask)(nil).SetRetry), arg0) } @@ -9778,7 +9782,7 @@ func (m *MockGCMetaTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockGCMetaTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCMetaTask)(nil).SetTimeout), arg0) } @@ -9790,7 +9794,7 @@ func (m *MockGCMetaTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockGCMetaTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCMetaTask)(nil).SetUpdateTime), arg0) } @@ -9802,7 +9806,7 @@ func (m *MockGCMetaTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockGCMetaTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCMetaTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCMetaTask)(nil).SetUserAddress), arg0) } @@ -9851,11 +9855,25 @@ func (m *MockRecoveryPieceTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockRecoveryPieceTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockRecoveryPieceTask)(nil).AppendLog), log) } +// BySuccessorSP mocks base method. +func (m *MockRecoveryPieceTask) BySuccessorSP() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BySuccessorSP") + ret0, _ := ret[0].(bool) + return ret0 +} + +// BySuccessorSP indicates an expected call of BySuccessorSP. +func (mr *MockRecoveryPieceTaskMockRecorder) BySuccessorSP() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BySuccessorSP", reflect.TypeOf((*MockRecoveryPieceTask)(nil).BySuccessorSP)) +} + // Error mocks base method. func (m *MockRecoveryPieceTask) Error() error { m.ctrl.T.Helper() @@ -9968,6 +9986,20 @@ func (mr *MockRecoveryPieceTaskMockRecorder) GetEcIdx() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEcIdx", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetEcIdx)) } +// GetGVGID mocks base method. +func (m *MockRecoveryPieceTask) GetGVGID() uint32 { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGVGID") + ret0, _ := ret[0].(uint32) + return ret0 +} + +// GetGVGID indicates an expected call of GetGVGID. +func (mr *MockRecoveryPieceTaskMockRecorder) GetGVGID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGVGID", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetGVGID)) +} + // GetLogs mocks base method. func (m *MockRecoveryPieceTask) GetLogs() string { m.ctrl.T.Helper() @@ -10183,7 +10215,7 @@ func (m *MockRecoveryPieceTask) InitRecoverPieceTask(object *types0.ObjectInfo, } // InitRecoverPieceTask indicates an expected call of InitRecoverPieceTask. -func (mr *MockRecoveryPieceTaskMockRecorder) InitRecoverPieceTask(object, params, priority, pieceIdx, ecIdx, pieceSize, timeout, retry interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) InitRecoverPieceTask(object, params, priority, pieceIdx, ecIdx, pieceSize, timeout, retry any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitRecoverPieceTask", reflect.TypeOf((*MockRecoveryPieceTask)(nil).InitRecoverPieceTask), object, params, priority, pieceIdx, ecIdx, pieceSize, timeout, retry) } @@ -10209,7 +10241,7 @@ func (m *MockRecoveryPieceTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockRecoveryPieceTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetAddress), arg0) } @@ -10221,7 +10253,7 @@ func (m *MockRecoveryPieceTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockRecoveryPieceTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetCreateTime), arg0) } @@ -10233,7 +10265,7 @@ func (m *MockRecoveryPieceTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockRecoveryPieceTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetError), arg0) } @@ -10245,7 +10277,7 @@ func (m *MockRecoveryPieceTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockRecoveryPieceTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetLogs), logs) } @@ -10257,7 +10289,7 @@ func (m *MockRecoveryPieceTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockRecoveryPieceTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetMaxRetry), arg0) } @@ -10269,7 +10301,7 @@ func (m *MockRecoveryPieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) { } // SetObjectInfo indicates an expected call of SetObjectInfo. -func (mr *MockRecoveryPieceTaskMockRecorder) SetObjectInfo(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetObjectInfo), arg0) } @@ -10281,7 +10313,7 @@ func (m *MockRecoveryPieceTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockRecoveryPieceTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetPriority), arg0) } @@ -10305,7 +10337,7 @@ func (m *MockRecoveryPieceTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockRecoveryPieceTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetRetry), arg0) } @@ -10317,7 +10349,7 @@ func (m *MockRecoveryPieceTask) SetSignature(arg0 []byte) { } // SetSignature indicates an expected call of SetSignature. -func (mr *MockRecoveryPieceTaskMockRecorder) SetSignature(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetSignature(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSignature", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetSignature), arg0) } @@ -10329,7 +10361,7 @@ func (m *MockRecoveryPieceTask) SetStorageParams(arg0 *types0.Params) { } // SetStorageParams indicates an expected call of SetStorageParams. -func (mr *MockRecoveryPieceTaskMockRecorder) SetStorageParams(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetStorageParams), arg0) } @@ -10341,7 +10373,7 @@ func (m *MockRecoveryPieceTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockRecoveryPieceTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetTimeout), arg0) } @@ -10353,7 +10385,7 @@ func (m *MockRecoveryPieceTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockRecoveryPieceTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetUpdateTime), arg0) } @@ -10365,7 +10397,7 @@ func (m *MockRecoveryPieceTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockRecoveryPieceTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockRecoveryPieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetUserAddress), arg0) } @@ -10414,7 +10446,7 @@ func (m *MockMigrateGVGTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockMigrateGVGTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockMigrateGVGTask)(nil).AppendLog), log) } @@ -10774,7 +10806,7 @@ func (m *MockMigrateGVGTask) InitMigrateGVGTask(priority TPriority, bucketID uin } // InitMigrateGVGTask indicates an expected call of InitMigrateGVGTask. -func (mr *MockMigrateGVGTaskMockRecorder) InitMigrateGVGTask(priority, bucketID, srcGvg, redundancyIndex, srcSP, timeout, retry interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) InitMigrateGVGTask(priority, bucketID, srcGvg, redundancyIndex, srcSP, timeout, retry any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitMigrateGVGTask", reflect.TypeOf((*MockMigrateGVGTask)(nil).InitMigrateGVGTask), priority, bucketID, srcGvg, redundancyIndex, srcSP, timeout, retry) } @@ -10800,7 +10832,7 @@ func (m *MockMigrateGVGTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockMigrateGVGTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetAddress), arg0) } @@ -10812,7 +10844,7 @@ func (m *MockMigrateGVGTask) SetBucketID(arg0 uint64) { } // SetBucketID indicates an expected call of SetBucketID. -func (mr *MockMigrateGVGTaskMockRecorder) SetBucketID(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetBucketID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketID", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetBucketID), arg0) } @@ -10824,7 +10856,7 @@ func (m *MockMigrateGVGTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockMigrateGVGTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetCreateTime), arg0) } @@ -10836,7 +10868,7 @@ func (m *MockMigrateGVGTask) SetDestGvg(arg0 *types1.GlobalVirtualGroup) { } // SetDestGvg indicates an expected call of SetDestGvg. -func (mr *MockMigrateGVGTaskMockRecorder) SetDestGvg(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetDestGvg(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDestGvg", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetDestGvg), arg0) } @@ -10848,7 +10880,7 @@ func (m *MockMigrateGVGTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockMigrateGVGTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetError), arg0) } @@ -10860,7 +10892,7 @@ func (m *MockMigrateGVGTask) SetFinished(arg0 bool) { } // SetFinished indicates an expected call of SetFinished. -func (mr *MockMigrateGVGTaskMockRecorder) SetFinished(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetFinished(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinished", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetFinished), arg0) } @@ -10872,7 +10904,7 @@ func (m *MockMigrateGVGTask) SetLastMigratedObjectID(arg0 uint64) { } // SetLastMigratedObjectID indicates an expected call of SetLastMigratedObjectID. -func (mr *MockMigrateGVGTaskMockRecorder) SetLastMigratedObjectID(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetLastMigratedObjectID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastMigratedObjectID", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetLastMigratedObjectID), arg0) } @@ -10884,7 +10916,7 @@ func (m *MockMigrateGVGTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockMigrateGVGTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetLogs), logs) } @@ -10896,7 +10928,7 @@ func (m *MockMigrateGVGTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockMigrateGVGTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetMaxRetry), arg0) } @@ -10908,7 +10940,7 @@ func (m *MockMigrateGVGTask) SetMigratedBytesSize(arg0 uint64) { } // SetMigratedBytesSize indicates an expected call of SetMigratedBytesSize. -func (mr *MockMigrateGVGTaskMockRecorder) SetMigratedBytesSize(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetMigratedBytesSize(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMigratedBytesSize", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetMigratedBytesSize), arg0) } @@ -10920,7 +10952,7 @@ func (m *MockMigrateGVGTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockMigrateGVGTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetPriority), arg0) } @@ -10932,7 +10964,7 @@ func (m *MockMigrateGVGTask) SetRedundancyIdx(arg0 int32) { } // SetRedundancyIdx indicates an expected call of SetRedundancyIdx. -func (mr *MockMigrateGVGTaskMockRecorder) SetRedundancyIdx(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetRedundancyIdx(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRedundancyIdx", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetRedundancyIdx), arg0) } @@ -10944,7 +10976,7 @@ func (m *MockMigrateGVGTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockMigrateGVGTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetRetry), arg0) } @@ -10956,7 +10988,7 @@ func (m *MockMigrateGVGTask) SetSignature(arg0 []byte) { } // SetSignature indicates an expected call of SetSignature. -func (mr *MockMigrateGVGTaskMockRecorder) SetSignature(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetSignature(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSignature", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetSignature), arg0) } @@ -10968,7 +11000,7 @@ func (m *MockMigrateGVGTask) SetSrcGvg(arg0 *types1.GlobalVirtualGroup) { } // SetSrcGvg indicates an expected call of SetSrcGvg. -func (mr *MockMigrateGVGTaskMockRecorder) SetSrcGvg(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetSrcGvg(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSrcGvg", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetSrcGvg), arg0) } @@ -10980,7 +11012,7 @@ func (m *MockMigrateGVGTask) SetSrcSp(arg0 *types.StorageProvider) { } // SetSrcSp indicates an expected call of SetSrcSp. -func (mr *MockMigrateGVGTaskMockRecorder) SetSrcSp(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetSrcSp(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSrcSp", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetSrcSp), arg0) } @@ -10992,7 +11024,7 @@ func (m *MockMigrateGVGTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockMigrateGVGTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetTimeout), arg0) } @@ -11004,7 +11036,7 @@ func (m *MockMigrateGVGTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockMigrateGVGTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetUpdateTime), arg0) } @@ -11016,7 +11048,7 @@ func (m *MockMigrateGVGTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockMigrateGVGTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockMigrateGVGTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetUserAddress), arg0) } @@ -11065,7 +11097,7 @@ func (m *MockGCBucketMigrationTask) AppendLog(log string) { } // AppendLog indicates an expected call of AppendLog. -func (mr *MockGCBucketMigrationTaskMockRecorder) AppendLog(log interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) AppendLog(log any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).AppendLog), log) } @@ -11182,6 +11214,62 @@ func (mr *MockGCBucketMigrationTaskMockRecorder) GetCreateTime() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreateTime", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetCreateTime)) } +// GetFinished mocks base method. +func (m *MockGCBucketMigrationTask) GetFinished() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFinished") + ret0, _ := ret[0].(bool) + return ret0 +} + +// GetFinished indicates an expected call of GetFinished. +func (mr *MockGCBucketMigrationTaskMockRecorder) GetFinished() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinished", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetFinished)) +} + +// GetGCFinishedGvgNum mocks base method. +func (m *MockGCBucketMigrationTask) GetGCFinishedGvgNum() uint64 { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGCFinishedGvgNum") + ret0, _ := ret[0].(uint64) + return ret0 +} + +// GetGCFinishedGvgNum indicates an expected call of GetGCFinishedGvgNum. +func (mr *MockGCBucketMigrationTaskMockRecorder) GetGCFinishedGvgNum() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGCFinishedGvgNum", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetGCFinishedGvgNum)) +} + +// GetLastGCGvgID mocks base method. +func (m *MockGCBucketMigrationTask) GetLastGCGvgID() uint64 { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLastGCGvgID") + ret0, _ := ret[0].(uint64) + return ret0 +} + +// GetLastGCGvgID indicates an expected call of GetLastGCGvgID. +func (mr *MockGCBucketMigrationTaskMockRecorder) GetLastGCGvgID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastGCGvgID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetLastGCGvgID)) +} + +// GetLastGCObjectID mocks base method. +func (m *MockGCBucketMigrationTask) GetLastGCObjectID() uint64 { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLastGCObjectID") + ret0, _ := ret[0].(uint64) + return ret0 +} + +// GetLastGCObjectID indicates an expected call of GetLastGCObjectID. +func (mr *MockGCBucketMigrationTaskMockRecorder) GetLastGCObjectID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastGCObjectID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetLastGCObjectID)) +} + // GetLogs mocks base method. func (m *MockGCBucketMigrationTask) GetLogs() string { m.ctrl.T.Helper() @@ -11252,6 +11340,20 @@ func (mr *MockGCBucketMigrationTaskMockRecorder) GetTimeout() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeout", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetTimeout)) } +// GetTotalGvgNum mocks base method. +func (m *MockGCBucketMigrationTask) GetTotalGvgNum() uint64 { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTotalGvgNum") + ret0, _ := ret[0].(uint64) + return ret0 +} + +// GetTotalGvgNum indicates an expected call of GetTotalGvgNum. +func (mr *MockGCBucketMigrationTaskMockRecorder) GetTotalGvgNum() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTotalGvgNum", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetTotalGvgNum)) +} + // GetUpdateTime mocks base method. func (m *MockGCBucketMigrationTask) GetUpdateTime() int64 { m.ctrl.T.Helper() @@ -11313,7 +11415,7 @@ func (m *MockGCBucketMigrationTask) InitGCBucketMigrationTask(priority TPriority } // InitGCBucketMigrationTask indicates an expected call of InitGCBucketMigrationTask. -func (mr *MockGCBucketMigrationTaskMockRecorder) InitGCBucketMigrationTask(priority, bucketID, timeout, retry interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) InitGCBucketMigrationTask(priority, bucketID, timeout, retry any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGCBucketMigrationTask", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).InitGCBucketMigrationTask), priority, bucketID, timeout, retry) } @@ -11339,7 +11441,7 @@ func (m *MockGCBucketMigrationTask) SetAddress(arg0 string) { } // SetAddress indicates an expected call of SetAddress. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetAddress), arg0) } @@ -11351,7 +11453,7 @@ func (m *MockGCBucketMigrationTask) SetBucketID(arg0 uint64) { } // SetBucketID indicates an expected call of SetBucketID. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetBucketID(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetBucketID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetBucketID), arg0) } @@ -11363,7 +11465,7 @@ func (m *MockGCBucketMigrationTask) SetCreateTime(arg0 int64) { } // SetCreateTime indicates an expected call of SetCreateTime. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetCreateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetCreateTime), arg0) } @@ -11375,11 +11477,59 @@ func (m *MockGCBucketMigrationTask) SetError(arg0 error) { } // SetError indicates an expected call of SetError. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetError(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetError(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetError), arg0) } +// SetFinished mocks base method. +func (m *MockGCBucketMigrationTask) SetFinished(arg0 bool) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetFinished", arg0) +} + +// SetFinished indicates an expected call of SetFinished. +func (mr *MockGCBucketMigrationTaskMockRecorder) SetFinished(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinished", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetFinished), arg0) +} + +// SetGCFinishedGvgNum mocks base method. +func (m *MockGCBucketMigrationTask) SetGCFinishedGvgNum(gvgGcNum uint64) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetGCFinishedGvgNum", gvgGcNum) +} + +// SetGCFinishedGvgNum indicates an expected call of SetGCFinishedGvgNum. +func (mr *MockGCBucketMigrationTaskMockRecorder) SetGCFinishedGvgNum(gvgGcNum any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGCFinishedGvgNum", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetGCFinishedGvgNum), gvgGcNum) +} + +// SetLastGCGvgID mocks base method. +func (m *MockGCBucketMigrationTask) SetLastGCGvgID(arg0 uint64) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetLastGCGvgID", arg0) +} + +// SetLastGCGvgID indicates an expected call of SetLastGCGvgID. +func (mr *MockGCBucketMigrationTaskMockRecorder) SetLastGCGvgID(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastGCGvgID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetLastGCGvgID), arg0) +} + +// SetLastGCObjectID mocks base method. +func (m *MockGCBucketMigrationTask) SetLastGCObjectID(arg0 uint64) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetLastGCObjectID", arg0) +} + +// SetLastGCObjectID indicates an expected call of SetLastGCObjectID. +func (mr *MockGCBucketMigrationTaskMockRecorder) SetLastGCObjectID(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastGCObjectID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetLastGCObjectID), arg0) +} + // SetLogs mocks base method. func (m *MockGCBucketMigrationTask) SetLogs(logs string) { m.ctrl.T.Helper() @@ -11387,7 +11537,7 @@ func (m *MockGCBucketMigrationTask) SetLogs(logs string) { } // SetLogs indicates an expected call of SetLogs. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetLogs(logs interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetLogs(logs any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetLogs), logs) } @@ -11399,7 +11549,7 @@ func (m *MockGCBucketMigrationTask) SetMaxRetry(arg0 int64) { } // SetMaxRetry indicates an expected call of SetMaxRetry. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetMaxRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetMaxRetry), arg0) } @@ -11411,7 +11561,7 @@ func (m *MockGCBucketMigrationTask) SetPriority(arg0 TPriority) { } // SetPriority indicates an expected call of SetPriority. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetPriority(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetPriority(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetPriority), arg0) } @@ -11423,7 +11573,7 @@ func (m *MockGCBucketMigrationTask) SetRetry(arg0 int64) { } // SetRetry indicates an expected call of SetRetry. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetRetry(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetRetry(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetRetry), arg0) } @@ -11435,11 +11585,23 @@ func (m *MockGCBucketMigrationTask) SetTimeout(arg0 int64) { } // SetTimeout indicates an expected call of SetTimeout. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetTimeout(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetTimeout), arg0) } +// SetTotalGvgNum mocks base method. +func (m *MockGCBucketMigrationTask) SetTotalGvgNum(gvgNum uint64) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetTotalGvgNum", gvgNum) +} + +// SetTotalGvgNum indicates an expected call of SetTotalGvgNum. +func (mr *MockGCBucketMigrationTaskMockRecorder) SetTotalGvgNum(gvgNum any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTotalGvgNum", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetTotalGvgNum), gvgNum) +} + // SetUpdateTime mocks base method. func (m *MockGCBucketMigrationTask) SetUpdateTime(arg0 int64) { m.ctrl.T.Helper() @@ -11447,7 +11609,7 @@ func (m *MockGCBucketMigrationTask) SetUpdateTime(arg0 int64) { } // SetUpdateTime indicates an expected call of SetUpdateTime. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetUpdateTime(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetUpdateTime), arg0) } @@ -11459,7 +11621,7 @@ func (m *MockGCBucketMigrationTask) SetUserAddress(arg0 string) { } // SetUserAddress indicates an expected call of SetUserAddress. -func (mr *MockGCBucketMigrationTaskMockRecorder) SetUserAddress(arg0 interface{}) *gomock.Call { +func (mr *MockGCBucketMigrationTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetUserAddress), arg0) } diff --git a/core/vgmgr/virtual_group_manager_mock.go b/core/vgmgr/virtual_group_manager_mock.go index a0be78f1a..769a626ba 100644 --- a/core/vgmgr/virtual_group_manager_mock.go +++ b/core/vgmgr/virtual_group_manager_mock.go @@ -278,33 +278,33 @@ func (mr *MockVirtualGroupManagerMockRecorder) FreezeSPAndGVGs(spID, gvgs any) * } // GenerateGlobalVirtualGroupMeta mocks base method. -func (m *MockVirtualGroupManager) GenerateGlobalVirtualGroupMeta(genPolicy GenerateGVGSecondarySPsPolicy) (*GlobalVirtualGroupMeta, error) { +func (m *MockVirtualGroupManager) GenerateGlobalVirtualGroupMeta(genPolicy GenerateGVGSecondarySPsPolicy, excludeSPsFilter ExcludeFilter) (*GlobalVirtualGroupMeta, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GenerateGlobalVirtualGroupMeta", genPolicy) + ret := m.ctrl.Call(m, "GenerateGlobalVirtualGroupMeta", genPolicy, excludeSPsFilter) ret0, _ := ret[0].(*GlobalVirtualGroupMeta) ret1, _ := ret[1].(error) return ret0, ret1 } // GenerateGlobalVirtualGroupMeta indicates an expected call of GenerateGlobalVirtualGroupMeta. -func (mr *MockVirtualGroupManagerMockRecorder) GenerateGlobalVirtualGroupMeta(genPolicy any) *gomock.Call { +func (mr *MockVirtualGroupManagerMockRecorder) GenerateGlobalVirtualGroupMeta(genPolicy, excludeSPsFilter any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateGlobalVirtualGroupMeta", reflect.TypeOf((*MockVirtualGroupManager)(nil).GenerateGlobalVirtualGroupMeta), genPolicy) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateGlobalVirtualGroupMeta", reflect.TypeOf((*MockVirtualGroupManager)(nil).GenerateGlobalVirtualGroupMeta), genPolicy, excludeSPsFilter) } // PickGlobalVirtualGroup mocks base method. -func (m *MockVirtualGroupManager) PickGlobalVirtualGroup(vgfID uint32) (*GlobalVirtualGroupMeta, error) { +func (m *MockVirtualGroupManager) PickGlobalVirtualGroup(vgfID uint32, excludeGVGsFilter ExcludeFilter) (*GlobalVirtualGroupMeta, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PickGlobalVirtualGroup", vgfID) + ret := m.ctrl.Call(m, "PickGlobalVirtualGroup", vgfID, excludeGVGsFilter) ret0, _ := ret[0].(*GlobalVirtualGroupMeta) ret1, _ := ret[1].(error) return ret0, ret1 } // PickGlobalVirtualGroup indicates an expected call of PickGlobalVirtualGroup. -func (mr *MockVirtualGroupManagerMockRecorder) PickGlobalVirtualGroup(vgfID any) *gomock.Call { +func (mr *MockVirtualGroupManagerMockRecorder) PickGlobalVirtualGroup(vgfID, excludeGVGsFilter any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickGlobalVirtualGroup", reflect.TypeOf((*MockVirtualGroupManager)(nil).PickGlobalVirtualGroup), vgfID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickGlobalVirtualGroup", reflect.TypeOf((*MockVirtualGroupManager)(nil).PickGlobalVirtualGroup), vgfID, excludeGVGsFilter) } // PickGlobalVirtualGroupForBucketMigrate mocks base method. @@ -338,18 +338,18 @@ func (mr *MockVirtualGroupManagerMockRecorder) PickSPByFilter(filter any) *gomoc } // PickVirtualGroupFamily mocks base method. -func (m *MockVirtualGroupManager) PickVirtualGroupFamily() (*VirtualGroupFamilyMeta, error) { +func (m *MockVirtualGroupManager) PickVirtualGroupFamily(filterByGvgList *PickVGFByGVGFilter) (*VirtualGroupFamilyMeta, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PickVirtualGroupFamily") + ret := m.ctrl.Call(m, "PickVirtualGroupFamily", filterByGvgList) ret0, _ := ret[0].(*VirtualGroupFamilyMeta) ret1, _ := ret[1].(error) return ret0, ret1 } // PickVirtualGroupFamily indicates an expected call of PickVirtualGroupFamily. -func (mr *MockVirtualGroupManagerMockRecorder) PickVirtualGroupFamily() *gomock.Call { +func (mr *MockVirtualGroupManagerMockRecorder) PickVirtualGroupFamily(filterByGvgList any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickVirtualGroupFamily", reflect.TypeOf((*MockVirtualGroupManager)(nil).PickVirtualGroupFamily)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickVirtualGroupFamily", reflect.TypeOf((*MockVirtualGroupManager)(nil).PickVirtualGroupFamily), filterByGvgList) } // QuerySPByID mocks base method. diff --git a/go.mod b/go.mod index d2e00e5fc..71c45fcc2 100644 --- a/go.mod +++ b/go.mod @@ -10,7 +10,7 @@ require ( github.com/aliyun/credentials-go v1.3.0 github.com/avast/retry-go/v4 v4.3.1 github.com/aws/aws-sdk-go v1.44.159 - github.com/bnb-chain/greenfield v1.2.1-0.20231221015040-11071a6ee95b + github.com/bnb-chain/greenfield v1.2.1-0.20231222025347-fe3f98c6c389 github.com/bnb-chain/greenfield-common/go v0.0.0-20230906132736-eb2f0efea228 github.com/bytedance/gopkg v0.0.0-20221122125632-68358b8ecec6 github.com/cometbft/cometbft v0.37.2 @@ -124,7 +124,7 @@ require ( github.com/gogo/protobuf v1.3.2 // indirect github.com/golang-jwt/jwt/v4 v4.3.0 // indirect github.com/golang/glog v1.1.0 // indirect - github.com/golang/mock v1.6.0 + github.com/golang/mock v1.6.0 // indirect github.com/golang/protobuf v1.5.3 // indirect github.com/golang/snappy v0.0.4 // indirect github.com/google/btree v1.1.2 // indirect @@ -304,7 +304,7 @@ replace ( github.com/cometbft/cometbft => github.com/bnb-chain/greenfield-cometbft v0.0.0-20231030090949-99ef7dbd1e62 github.com/cometbft/cometbft-db => github.com/bnb-chain/greenfield-cometbft-db v0.8.1-alpha.1 github.com/confio/ics23/go => github.com/cosmos/cosmos-sdk/ics23/go v0.8.0 - github.com/cosmos/cosmos-sdk => github.com/bnb-chain/greenfield-cosmos-sdk v1.1.2-0.20231206043955-0855e0965bc8 + github.com/cosmos/cosmos-sdk => github.com/bnb-chain/greenfield-cosmos-sdk v1.0.2-0.20231214052136-c20e9a5452b6 github.com/cosmos/iavl => github.com/bnb-chain/greenfield-iavl v0.20.1 github.com/forbole/juno/v4 => github.com/bnb-chain/juno/v4 v4.0.0-20231212070215-5505a27a398b github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1 diff --git a/go.sum b/go.sum index d5c7c0cf7..211d6c0de 100644 --- a/go.sum +++ b/go.sum @@ -176,16 +176,16 @@ github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816/go.mod h1:+zsy github.com/bits-and-blooms/bitset v1.2.0 h1:Kn4yilvwNtMACtf1eYDlG8H77R07mZSPbMjLyS07ChA= github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40/go.mod h1:8rLXio+WjiTceGBHIoTvn60HIbs7Hm7bcHjyrSqYB9c= -github.com/bnb-chain/greenfield v1.2.1-0.20231221015040-11071a6ee95b h1:UBgGcMo5Sf+sCMqkB2zu0sfuuMGBQ+5Ib1QIJ0sLXes= -github.com/bnb-chain/greenfield v1.2.1-0.20231221015040-11071a6ee95b/go.mod h1:p8M80v/a6mRm+ZPbW8Hfjc1npWktO6BDtebr9/8ETRs= +github.com/bnb-chain/greenfield v1.2.1-0.20231222025347-fe3f98c6c389 h1:BjhAqkUjUNr2vcbCM9henDP0M3GY9MY3YzBJi3ZGHcM= +github.com/bnb-chain/greenfield v1.2.1-0.20231222025347-fe3f98c6c389/go.mod h1:bDpt7BVbCEhqK9WdYnMQVhs3wsJjIyIMvEpchyvNavU= github.com/bnb-chain/greenfield-cometbft v0.0.0-20231030090949-99ef7dbd1e62 h1:pakuREXV/XfWNwgsTXUQwYirem12Tt+2LGGHIar0z8o= github.com/bnb-chain/greenfield-cometbft v0.0.0-20231030090949-99ef7dbd1e62/go.mod h1:43yICrTxu90VjEUpQN23bsqi9mua5m5sFQq/ekHwN9s= github.com/bnb-chain/greenfield-cometbft-db v0.8.1-alpha.1 h1:XcWulGacHVRiSCx90Q8Y//ajOrLNBQWR/KDB89dy3cU= github.com/bnb-chain/greenfield-cometbft-db v0.8.1-alpha.1/go.mod h1:ey1CiK4bYo1RBNJLRiVbYr5CMdSxci9S/AZRINLtppI= github.com/bnb-chain/greenfield-common/go v0.0.0-20230906132736-eb2f0efea228 h1:WywBaew30hZuqDTOQbkRV3uBg6XHjNIE1s3AXVXbG+8= github.com/bnb-chain/greenfield-common/go v0.0.0-20230906132736-eb2f0efea228/go.mod h1:K9jK80fbahciC+FAvrch8Qsbw9ZkvVgjfKsqrzPTAVA= -github.com/bnb-chain/greenfield-cosmos-sdk v1.1.2-0.20231206043955-0855e0965bc8 h1:dg2n4pWpWfdrRHGHhSwm3mtZjOOJ32FqHnXvNhUC/Hc= -github.com/bnb-chain/greenfield-cosmos-sdk v1.1.2-0.20231206043955-0855e0965bc8/go.mod h1:Yrvq+J1Lsm7OHFX+M/AZWBTGt1TRHUTC4VYOMlvW3fs= +github.com/bnb-chain/greenfield-cosmos-sdk v1.0.2-0.20231214052136-c20e9a5452b6 h1:XO3cnv1E2vCSPfKw9467y3/8FL4r2XOI/h0C9NrFKTA= +github.com/bnb-chain/greenfield-cosmos-sdk v1.0.2-0.20231214052136-c20e9a5452b6/go.mod h1:Yrvq+J1Lsm7OHFX+M/AZWBTGt1TRHUTC4VYOMlvW3fs= github.com/bnb-chain/greenfield-cosmos-sdk/api v0.0.0-20231206043955-0855e0965bc8 h1:mUMOeNo3K0SZvAhiOHNKW4mmkrhOphBF8tDUyK6e1tY= github.com/bnb-chain/greenfield-cosmos-sdk/api v0.0.0-20231206043955-0855e0965bc8/go.mod h1:vhsZxXE9tYJeYB5JR4hPhd6Pc/uPf7j1T8IJ7p9FdeM= github.com/bnb-chain/greenfield-cosmos-sdk/math v0.0.0-20231206043955-0855e0965bc8 h1:1Ud7itq03c4Q9h0kBpw1FYlWKN3kco8cgj59vdd50UQ= diff --git a/modular/executor/execute_gc.go b/modular/executor/execute_gc.go index e69aa58f1..0d3a35a89 100644 --- a/modular/executor/execute_gc.go +++ b/modular/executor/execute_gc.go @@ -156,12 +156,32 @@ func (gc *GCWorker) checkGVGMatchSP(ctx context.Context, objectInfo *storagetype if redundancyIndex == piecestore.PrimarySPRedundancyIndex { if gvg.GetPrimarySpId() != spID { + swapInInfo, err := gc.e.baseApp.Consensus().QuerySwapInInfo(ctx, gvg.FamilyId, virtualgrouptypes.NoSpecifiedGVGId) + if err != nil { + if strings.Contains(err.Error(), "swap in info not exist") { + return ErrInvalidRedundancyIndex + } + return nil + } + if swapInInfo.SuccessorSpId == spID && swapInInfo.TargetSpId == gvg.PrimarySpId { + return nil + } log.CtxInfow(ctx, "the piece isn't in correct location, will be delete", "object_info", objectInfo, "redundancy_index", redundancyIndex, "gvg", gvg, "sp_id", spID) return ErrInvalidRedundancyIndex } } else { if gvg.GetSecondarySpIds()[redundancyIndex] != spID { + swapInInfo, err := gc.e.baseApp.Consensus().QuerySwapInInfo(ctx, 0, gvg.Id) + if err != nil { + if strings.Contains(err.Error(), "swap in info not exist") { + return ErrInvalidRedundancyIndex + } + return nil + } + if swapInInfo.SuccessorSpId == spID && swapInInfo.TargetSpId == gvg.GetSecondarySpIds()[redundancyIndex] { + return nil + } log.CtxInfow(ctx, "the piece isn't in correct location, will be delete", "object_info", objectInfo, "redundancy_index", redundancyIndex, "gvg", gvg, "sp_id", spID) return ErrInvalidRedundancyIndex diff --git a/modular/executor/execute_task.go b/modular/executor/execute_task.go index 4a73771d6..d5605ffad 100644 --- a/modular/executor/execute_task.go +++ b/modular/executor/execute_task.go @@ -266,8 +266,8 @@ func (e *ExecuteModular) HandleRecoverPieceTask(ctx context.Context, task coreta return } + // used by secondary SP or successor secondary SP for GVG if redundancyIdx >= 0 { - log.Info(1) // recover secondary SP data by the primary SP if err = e.recoverByPrimarySP(ctx, task); err != nil { // if failed to recover by the primary SP, try to recovery secondary SP data from the other secondary SPs @@ -281,6 +281,7 @@ func (e *ExecuteModular) HandleRecoverPieceTask(ctx context.Context, task coreta log.CtxDebugw(ctx, "secondary SP recovery successfully", "pieceKey:", recoveryKey) finishRecovery = true } else { + // used by Primary SP or successor primary SP for VGF // recover primarySP data by secondary SPs if recoverErr := e.recoverBySecondarySP(ctx, task, false); recoverErr != nil { err = recoverErr @@ -305,15 +306,23 @@ func (e *ExecuteModular) recoverByPrimarySP(ctx context.Context, task coretask.R if err != nil { return err } + signature, err := e.baseApp.GfSpClient().SignRecoveryTask(ctx, task) + if err != nil { + log.CtxErrorw(ctx, "failed to sign recovery task", "object", task.GetObjectInfo().GetObjectName(), "error", err) + return err + } + task.SetSignature(signature) pieceData, err = e.doRecoveryPiece(ctx, task, primarySPEndpoint) if err != nil { - log.CtxDebugw(ctx, "failed to recover secondary SP data from secondary SPs") + log.CtxDebugw(ctx, "failed to recover secondary SP data from primary SP") return err } // compare integrity hash - if err = e.checkRecoveryChecksum(ctx, task, hash.GenerateChecksum(pieceData)); err != nil { - return err + if !task.BySuccessorSP() { + if err = e.checkRecoveryChecksum(ctx, task, hash.GenerateChecksum(pieceData)); err != nil { + return err + } } recoveryKey := e.baseApp.PieceOp().ECPieceKey(objectId, segmentIdx, uint32(task.GetEcIdx())) @@ -323,7 +332,13 @@ func (e *ExecuteModular) recoverByPrimarySP(ctx context.Context, task coretask.R log.CtxErrorw(ctx, "EC recover data write piece fail", "pieceKey:", recoveryKey, "error", err) return err } - + if task.BySuccessorSP() { + err = e.setPieceMetadata(ctx, task, pieceData) + if err != nil { + log.CtxErrorw(ctx, "failed to set piece meta data to DB", "object_name:", task.GetObjectInfo().GetObjectName(), "segment_idx", task.GetSegmentIdx(), "redundancy_idx", task.GetEcIdx(), "error", err) + return err + } + } return nil } @@ -376,9 +391,18 @@ func (e *ExecuteModular) recoverBySecondarySP(ctx context.Context, task coretask executeEndpoint = spInfo.Endpoint } + signature, err := e.baseApp.GfSpClient().SignRecoveryTask(ctx, task) + if err != nil { + log.CtxErrorw(ctx, "failed to sign recovery task", "object", task.GetObjectInfo().GetObjectName(), "error", err) + return err + } + task.SetSignature(signature) + + childCtx, cancel := context.WithCancel(ctx) + defer cancel() for ecIdx := 0; ecIdx < secondaryCount; ecIdx++ { recoveryDataSources[ecIdx] = nil - go func(secondaryIndex int) { + go func(ctx context.Context, secondaryIndex int) { secondaryEndpoint := secondaryEndpoints[secondaryIndex] // if myself is secondary, bypass to send request to myself if isMyselfSecondary && secondaryEndpoint == executeEndpoint { @@ -398,7 +422,7 @@ func (e *ExecuteModular) recoverBySecondarySP(ctx context.Context, task coretask if atomic.AddInt32(&totalTaskNum, -1) == 0 { quitCh <- true } - }(ecIdx) + }(childCtx, ecIdx) } loop: @@ -408,9 +432,11 @@ loop: doneTaskNum++ // it is enough to recovery data with minRecoveryPieces EC data, no need to wait if doneTaskNum >= minRecoveryPieces { + cancel() break loop } case <-quitCh: // all the task finish + cancel() if doneTaskNum < minRecoveryPieces { // finish task num not enough log.CtxErrorw(ctx, "get piece from secondary not enough", "get secondary piece num:", doneTaskNum, "error", ErrRecoveryPieceNotEnough) return ErrRecoveryPieceNotEnough @@ -431,8 +457,10 @@ loop: // compare integrity hash if !isMyselfSecondary { - if err = e.checkRecoveryChecksum(ctx, task, hash.GenerateChecksum(recoverySegData)); err != nil { - return err + if !task.BySuccessorSP() { + if err = e.checkRecoveryChecksum(ctx, task, hash.GenerateChecksum(recoverySegData)); err != nil { + return err + } } // if the task is generated by primary SP, the recovery key is segment recoveryKey = e.baseApp.PieceOp().SegmentPieceKey(task.GetObjectInfo().Id.Uint64(), task.GetSegmentIdx()) @@ -447,8 +475,10 @@ loop: return err } // compare integrity hash - if err = e.checkRecoveryChecksum(ctx, task, hash.GenerateChecksum(recoveredPieceData)); err != nil { - return err + if !task.BySuccessorSP() { + if err = e.checkRecoveryChecksum(ctx, task, hash.GenerateChecksum(recoveredPieceData)); err != nil { + return err + } } } @@ -458,7 +488,14 @@ loop: return err } - log.CtxDebugw(ctx, "finish recovery from secondary SPs", "objectName:", task.GetObjectInfo().GetObjectName()) + if task.BySuccessorSP() { + err = e.setPieceMetadata(ctx, task, recoveredPieceData) + if err != nil { + log.CtxErrorw(ctx, "failed to set piece meta data to DB", "object_name:", task.GetObjectInfo().GetObjectName(), "segment_idx", task.GetSegmentIdx(), "error", err) + return err + } + } + log.CtxDebugw(ctx, "finish recovery from secondary SPs", "object_name:", task.GetObjectInfo().GetObjectName(), "segment_idx", task.GetSegmentIdx()) return nil } @@ -508,18 +545,12 @@ func (e *ExecuteModular) checkRecoveryChecksum(ctx context.Context, task coretas func (e *ExecuteModular) doRecoveryPiece(ctx context.Context, rTask coretask.RecoveryPieceTask, endpoint string) ( data []byte, err error) { - var ( - signature []byte - pieceData []byte - ) - signature, err = e.baseApp.GfSpClient().SignRecoveryTask(ctx, rTask) - if err != nil { - log.CtxErrorw(ctx, "failed to sign recovery task", "object", rTask.GetObjectInfo().GetObjectName(), "error", err) - return - } - rTask.SetSignature(signature) + var pieceData []byte + // timeout for single piece recover + ctxWithTimeout, cancel := context.WithTimeout(ctx, replicateTimeOut) + defer cancel() // recovery primary sp segment or secondary piece - respBody, err := e.baseApp.GfSpClient().GetPieceFromECChunks(ctx, endpoint, rTask) + respBody, err := e.baseApp.GfSpClient().GetPieceFromECChunks(ctxWithTimeout, endpoint, rTask) if err != nil { log.CtxErrorw(ctx, "failed to get piece from ec chunks", "objectID", rTask.GetObjectInfo().Id, "segment_idx", rTask.GetSegmentIdx(), "secondary endpoint", endpoint, "error", err) @@ -592,3 +623,48 @@ func (e *ExecuteModular) getBucketPrimarySPEndpoint(ctx context.Context, bucketN } return "", ErrPrimaryNotFound } + +func (e *ExecuteModular) setPieceMetadata(ctx context.Context, task coretask.RecoveryPieceTask, pieceData []byte) error { + objectID := task.GetObjectInfo().Id.Uint64() + segmentIdx := task.GetSegmentIdx() + redundancyIdx := task.GetEcIdx() + + pieceChecksum := hash.GenerateChecksum(pieceData) + + if err := e.baseApp.GfSpDB().SetReplicatePieceChecksum(objectID, segmentIdx, redundancyIdx, pieceChecksum); err != nil { + log.CtxErrorw(ctx, "failed to set replicate piece checksum", "object_id", objectID, + "segment_index", segmentIdx, "redundancy_index", redundancyIdx, "error", err) + detail := fmt.Sprintf("failed to set replicate piece checksum, object_id: %s, segment_index: %v, redundancy_index: %v, error: %s", + task.GetObjectInfo().Id.String(), segmentIdx, task.GetEcIdx(), err.Error()) + return ErrGfSpDBWithDetail(detail) + } + segmentCount := e.baseApp.PieceOp().SegmentPieceCount(task.GetObjectInfo().GetPayloadSize(), + task.GetStorageParams().VersionedParams.GetMaxSegmentSize()) + + pieceChecksums, err := e.baseApp.GfSpDB().GetAllReplicatePieceChecksumOptimized(task.GetObjectInfo().Id.Uint64(), task.GetEcIdx(), segmentCount) + if err != nil { + log.CtxInfow(ctx, "failed to get recover piece checksum", "object_id", objectID, + "segment_index", segmentIdx, "error", err) + return err + } + if len(pieceChecksums) == int(segmentCount) { + integrityChecksum := hash.GenerateIntegrityHash(pieceChecksums) + integrityMeta := &spdb.IntegrityMeta{ + ObjectID: task.GetObjectInfo().Id.Uint64(), + RedundancyIndex: task.GetEcIdx(), + IntegrityChecksum: integrityChecksum, + PieceChecksumList: pieceChecksums, + } + if err = e.baseApp.GfSpDB().SetObjectIntegrity(integrityMeta); err != nil { + log.CtxErrorw(ctx, "failed to set object integrity", "object_id", objectID, + "segment_index", segmentIdx, "error", err) + return err + } + err = e.baseApp.GfSpDB().DeleteAllReplicatePieceChecksum(objectID, task.GetEcIdx(), segmentCount) + if err != nil { + log.CtxErrorw(ctx, "failed to delete all recover piece checksum", "task", task, "error", err) + return err + } + } + return nil +} diff --git a/modular/executor/executor_task_test.go b/modular/executor/executor_task_test.go index 6ae603dce..fb194d928 100644 --- a/modular/executor/executor_task_test.go +++ b/modular/executor/executor_task_test.go @@ -756,6 +756,9 @@ func TestExecuteModular_HandleGCZombiePieceTask(t *testing.T) { consensusMock.EXPECT().QuerySP(gomock.Any(), gomock.Any()).Return(&sptypes.StorageProvider{Id: 1}, nil).Times(1) consensusMock.EXPECT().ListSPs(gomock.Any()).Return([]*sptypes.StorageProvider{ {Id: 1, Endpoint: "endpoint"}}, nil).Times(1) + consensusMock.EXPECT().QuerySwapInInfo(gomock.Any(), gomock.Any(), gomock.Any()).Return(&virtual_types.SwapInInfo{ + SuccessorSpId: 1, TargetSpId: 1}, nil).Times(1) + e.baseApp.SetConsensus(consensusMock) m2 := piecestore.NewMockPieceOp(ctrl) @@ -823,6 +826,8 @@ func TestExecuteModular_HandleGCZombiePieceTask(t *testing.T) { consensusMock.EXPECT().QuerySP(gomock.Any(), gomock.Any()).Return(&sptypes.StorageProvider{Id: 1}, nil).Times(1) consensusMock.EXPECT().ListSPs(gomock.Any()).Return([]*sptypes.StorageProvider{ {Id: 1, Endpoint: "endpoint"}}, nil).Times(1) + consensusMock.EXPECT().QuerySwapInInfo(gomock.Any(), gomock.Any(), gomock.Any()).Return(&virtual_types.SwapInInfo{ + SuccessorSpId: 1, TargetSpId: 1}, nil).Times(1) e.baseApp.SetConsensus(consensusMock) m2 := piecestore.NewMockPieceOp(ctrl) @@ -1171,26 +1176,12 @@ func TestExecuteModular_doRecoveryPiece(t *testing.T) { wantedIsErr bool wantedErr error }{ - { - name: "failed to sign recovery task", - fn: func() *ExecuteModular { - e := setup(t) - ctrl := gomock.NewController(t) - m := gfspclient.NewMockGfSpClientAPI(ctrl) - m.EXPECT().SignRecoveryTask(gomock.Any(), gomock.Any()).Return(nil, mockErr).Times(1) - e.baseApp.SetGfSpClient(m) - return e - }, - wantedIsErr: true, - wantedErr: mockErr, - }, { name: "failed to get piece from ec chunks", fn: func() *ExecuteModular { e := setup(t) ctrl := gomock.NewController(t) m := gfspclient.NewMockGfSpClientAPI(ctrl) - m.EXPECT().SignRecoveryTask(gomock.Any(), gomock.Any()).Return([]byte("mockSig"), nil).Times(1) m.EXPECT().GetPieceFromECChunks(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, mockErr).Times(1) e.baseApp.SetGfSpClient(m) return e @@ -1205,7 +1196,6 @@ func TestExecuteModular_doRecoveryPiece(t *testing.T) { ctrl := gomock.NewController(t) m := gfspclient.NewMockGfSpClientAPI(ctrl) e.baseApp.SetGfSpClient(m) - m.EXPECT().SignRecoveryTask(gomock.Any(), gomock.Any()).Return([]byte("mockSig"), nil).Times(1) m1 := gfspclient.NewMockstdLib(ctrl) m1.EXPECT().Read(gomock.Any()).Return(0, mockErr).Times(1) @@ -1223,7 +1213,6 @@ func TestExecuteModular_doRecoveryPiece(t *testing.T) { ctrl := gomock.NewController(t) m := gfspclient.NewMockGfSpClientAPI(ctrl) e.baseApp.SetGfSpClient(m) - m.EXPECT().SignRecoveryTask(gomock.Any(), gomock.Any()).Return([]byte("mockSig"), nil).Times(1) m.EXPECT().GetPieceFromECChunks(gomock.Any(), gomock.Any(), gomock.Any()).Return(io.NopCloser( strings.NewReader("body")), nil).Times(1) return e diff --git a/modular/gater/admin_handler.go b/modular/gater/admin_handler.go index b5f1b580f..bf10b198e 100644 --- a/modular/gater/admin_handler.go +++ b/modular/gater/admin_handler.go @@ -24,6 +24,7 @@ import ( "github.com/bnb-chain/greenfield-storage-provider/util" sptypes "github.com/bnb-chain/greenfield/x/sp/types" storagetypes "github.com/bnb-chain/greenfield/x/storage/types" + virtualgrouptypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" sdktypes "github.com/cosmos/cosmos-sdk/types" ) @@ -876,8 +877,27 @@ func (g *GateModular) getRecoverPiece(ctx context.Context, objectInfo *storagety sspAddress = append(sspAddress, sp.OperatorAddress) } + isSuccessor := false + var ( + successorSP *sptypes.StorageProvider + swapInInfo *virtualgrouptypes.SwapInInfo + ) + if recoveryTask.GetBySuccessorSp() { + swapInInfo, err = g.baseApp.Consensus().QuerySwapInInfo(ctx, gvg.FamilyId, 0) + if err != nil { + return nil, ErrConsensusWithDetail("query swapInInfo err: " + err.Error()) + } + successorSP, err = g.baseApp.Consensus().QuerySPByID(ctx, swapInInfo.SuccessorSpId) + if err != nil { + return nil, ErrConsensusWithDetail("query sp err: " + err.Error()) + } + if primarySp.Id == swapInInfo.TargetSpId && successorSP.OperatorAddress == signatureAddr.String() { + isSuccessor = true + } + } + // if myself is secondary, the sender of the request can be both of the primary SP or the secondary SP of the gvg - if primarySp.OperatorAddress != signatureAddr.String() { + if primarySp.OperatorAddress != signatureAddr.String() && !isSuccessor { log.CtxDebug(ctx, "recovery request not come from primary sp", "secondary sp", signatureAddr.String()) // judge if the sender is not one of the secondary SP isRequestFromSecondary := false @@ -936,7 +956,6 @@ func (g *GateModular) getRecoverSegment(ctx context.Context, objectInfo *storage params.GetMaxSegmentSize(), params.GetRedundantDataChunkNum()) // if the handler is not the primary SP of the object, return error - // TODO get sp id from config spID, err := g.getSPID() if err != nil { return nil, ErrConsensusWithDetail("getSPID error: " + err.Error()) @@ -955,21 +974,43 @@ func (g *GateModular) getRecoverSegment(ctx context.Context, objectInfo *storage if err != nil { return nil, ErrRecoverySP } - // if the sender is not one of the secondarySp, return err + // if the sender is not one of the secondarySp or the successor of the exiting secondary SP, return err isOneOfSecondary := false - var ECIndex int32 + isSuccessor := false + var ( + ECIndex int32 + swapInInfo *virtualgrouptypes.SwapInInfo + successorSP *sptypes.StorageProvider + ) + if recoveryTask.GetBySuccessorSp() { + swapInInfo, err = g.baseApp.Consensus().QuerySwapInInfo(ctx, 0, gvg.Id) + if err != nil { + return nil, ErrConsensusWithDetail("query swapInInfo err: " + err.Error()) + } + successorSP, err = g.baseApp.Consensus().QuerySPByID(ctx, swapInInfo.SuccessorSpId) + if err != nil { + return nil, ErrConsensusWithDetail("query sp err: " + err.Error()) + } + } + for idx, sspId := range gvg.GetSecondarySpIds() { ssp, err := g.baseApp.Consensus().QuerySPByID(ctx, sspId) if err != nil { + log.CtxErrorw(ctx, "failed to query SP by ID", "sp_id", sspId, "error", err) return nil, ErrConsensusWithDetail("QuerySPByID error: " + err.Error()) } + if ssp.OperatorAddress == signatureAddr.String() { isOneOfSecondary = true ECIndex = int32(idx) + } else if recoveryTask.GetBySuccessorSp() && ssp.Id == swapInInfo.TargetSpId && successorSP.OperatorAddress == signatureAddr.String() { + isSuccessor = true + ECIndex = int32(idx) } } redundancyIdx := recoveryTask.EcIdx - if !isOneOfSecondary || ECIndex != recoveryTask.EcIdx { + if (!isOneOfSecondary && !isSuccessor) || ECIndex != recoveryTask.EcIdx { + log.CtxErrorw(ctx, "failed to recover", "is_one_of_secondary", isOneOfSecondary, "EC_index", recoveryTask.EcIdx, "is_successor", isSuccessor) return nil, ErrRecoverySP } pieceTask := &gfsptask.GfSpDownloadPieceTask{} @@ -980,6 +1021,7 @@ func (g *GateModular) getRecoverSegment(ctx context.Context, objectInfo *storage // no need to check quota when recovering primary SP or secondary SP data bucketPrimarySp, err := g.baseApp.Consensus().QuerySPByID(ctx, bucketSPID) if err != nil { + log.CtxErrorw(ctx, "failed query SP by ID", "sp_id", bucketSPID, "error", err) return nil, err } if redundancyIdx < int32(params.GetRedundantDataChunkNum())-1 { diff --git a/modular/gater/admin_handler_test.go b/modular/gater/admin_handler_test.go index 6b04e8fc3..f92858ca9 100644 --- a/modular/gater/admin_handler_test.go +++ b/modular/gater/admin_handler_test.go @@ -2093,6 +2093,7 @@ func TestGateModular_getRecoverSegment(t *testing.T) { &virtualgrouptypes.GlobalVirtualGroupFamily{PrimarySpId: 1}, nil).Times(1) consensusMock.EXPECT().QuerySPByID(gomock.Any(), gomock.Any()).Return(&sptypes.StorageProvider{ Id: 1, OperatorAddress: "a"}, nil).Times(1) + g.baseApp.SetConsensus(consensusMock) pieceOpMock := piecestore.NewMockPieceOp(ctrl) diff --git a/modular/manager/manage_task.go b/modular/manager/manage_task.go index d2cfad019..37e4c919d 100644 --- a/modular/manager/manage_task.go +++ b/modular/manager/manage_task.go @@ -779,9 +779,19 @@ func (m *ManageModular) HandleRecoverPieceTask(ctx context.Context, task task.Re if task.GetRecovered() { m.recoveryQueue.PopByKey(task.Key()) + m.recoverMtx.Lock() delete(m.recoveryTaskMap, task.Key().String()) - log.CtxErrorw(ctx, "finished recovery", "task_info", task.Info()) - return nil + m.recoverMtx.Unlock() + log.CtxInfow(ctx, "finished recovery", "task_info", task.Info()) + + if task.BySuccessorSP() { + objectID := task.GetObjectInfo().Id.Uint64() + success := m.recoverObjectStats.addSegmentRecord(objectID, true, task.GetSegmentIdx()) + if !success { + return nil + } + return nil + } } if task.Error() != nil { @@ -799,8 +809,9 @@ func (m *ManageModular) HandleRecoverPieceTask(ctx context.Context, task task.Re log.CtxErrorw(ctx, "failed to push recovery object task to queue", "task_info", task.Info(), "error", err) return err } - + m.recoverMtx.Lock() m.recoveryTaskMap[task.Key().String()] = task.Key().String() + m.recoverMtx.Unlock() return nil } @@ -819,8 +830,31 @@ func (m *ManageModular) handleFailedRecoverPieceTask(ctx context.Context, handle if !slices.Contains(m.recoveryFailedList, handleTask.GetObjectInfo().ObjectName) { m.recoveryFailedList = append(m.recoveryFailedList, handleTask.GetObjectInfo().ObjectName) } + m.recoverMtx.Lock() delete(m.recoveryTaskMap, handleTask.Key().String()) - log.CtxErrorw(ctx, "delete expired confirm recovery piece task", "task_info", handleTask.Info()) + m.recoverMtx.Unlock() + + if handleTask.BySuccessorSP() { + objectID := handleTask.GetObjectInfo().Id.Uint64() + success := m.recoverObjectStats.addSegmentRecord(objectID, false, handleTask.GetSegmentIdx()) + if !success { + return nil + } + + if m.recoverObjectStats.isRecoverFailed(objectID) { + object := &spdb.RecoverFailedObject{ + ObjectID: handleTask.GetObjectInfo().Id.Uint64(), + VirtualGroupID: handleTask.GetGVGID(), + RedundancyIndex: handleTask.GetEcIdx(), + } + err := m.baseApp.GfSpDB().InsertRecoverFailedObject(object) + if err != nil { + log.CtxErrorw(ctx, "failed to insert recover failed object entry", "task_info", handleTask.Info(), "error", err) + return ErrGfSpDBWithDetail("failed to insert recover failed object entry, task_info: " + handleTask.Info() + ", error: " + err.Error()) + } + } + return nil + } } return nil } diff --git a/modular/manager/manager.go b/modular/manager/manager.go index 98ef48233..64b687454 100644 --- a/modular/manager/manager.go +++ b/modular/manager/manager.go @@ -114,8 +114,15 @@ type ManageModular struct { gvgPreferSPList []uint32 - recoveryFailedList []string - recoveryTaskMap map[string]string + recoveryFailedList []string + + recoverMtx sync.RWMutex + recoveryTaskMap map[string]string + + recoverObjectStats *ObjectsSegmentsStats // objectId -> ObjectSegmentsStats + recoverProcessCount atomic.Int64 + verifyTerminationSignal atomic.Int64 + spBlackList []uint32 gvgBlackList vgmgr.IDSet enableHealthyChecker bool @@ -202,12 +209,6 @@ func (m *ManageModular) delayStartMigrateScheduler() { continue } } - if m.spExitScheduler == nil { - if m.spExitScheduler, err = NewSPExitScheduler(m); err != nil { - log.Errorw("failed to new sp exit scheduler", "error", err) - continue - } - } log.Info("succeed to start migrate scheduler") return } @@ -593,7 +594,10 @@ func (m *ManageModular) GCRecoverQueue(qTask task.Task) bool { if !slices.Contains(m.recoveryFailedList, task.GetObjectInfo().ObjectName) { m.recoveryFailedList = append(m.recoveryFailedList, task.GetObjectInfo().ObjectName) } + m.recoverMtx.Lock() delete(m.recoveryTaskMap, task.Key().String()) + m.recoverMtx.Unlock() + } return GcConditionMet } @@ -990,3 +994,102 @@ func (m *ManageModular) ResetRecoveryFailedList(_ context.Context) []string { m.recoveryFailedList = m.recoveryFailedList[:0] return m.recoveryFailedList } + +func (m *ManageModular) TriggerRecoverForSuccessorSP(ctx context.Context, vgfID, gvgID uint32, redundancyIndex int32) error { + return m.startRecoverSchedulers(vgfID, gvgID, redundancyIndex) +} + +// start the loop, failed object will be +func (m *ManageModular) startRecoverSchedulers(vgfID, gvgID uint32, redundancyIndex int32) (err error) { + m.verifyTerminationSignal.Store(0) + if vgfID != 0 { + recoverVGFScheduler, err := NewRecoverVGFScheduler(m, vgfID) + if err != nil { + log.Errorw("failed to NewRecoverVGFScheduler", "error", err) + return err + } + recoverFailedObjectScheduler := NewRecoverFailedObjectScheduler(m) + m.recoverProcessCount.Store(int64(len(recoverVGFScheduler.RecoverSchedulers))) + m.verifyTerminationSignal.Add(int64(len(recoverVGFScheduler.VerifySchedulers))) + go recoverVGFScheduler.Start() + go recoverFailedObjectScheduler.Start() + } else { + recoverGVGScheduler, err := NewRecoverGVGScheduler(m, vgfID, gvgID, redundancyIndex) + if err != nil { + log.Errorw("failed to create RecoverGVGScheduler", "error", err) + return err + } + recoverFailedObjectScheduler := NewRecoverFailedObjectScheduler(m) + verifyScheduler, err := NewVerifyGVGScheduler(m, vgfID, gvgID, redundancyIndex) + if err != nil { + log.Errorw("failed to create VerifyGVGScheduler", "error", err) + return err + } + m.recoverProcessCount.Store(1) + m.verifyTerminationSignal.Add(1) + go recoverGVGScheduler.Start() + go recoverFailedObjectScheduler.Start() + go verifyScheduler.Start() + } + return nil +} + +func (m *ManageModular) QueryRecoverProcess(ctx context.Context, vgfID, gvgID uint32) ([]*gfspserver.RecoverProcess, bool, error) { + gvgIds := make([]uint32, 0) + if vgfID != 0 { + vgfInfo, err := m.baseApp.Consensus().QueryVirtualGroupFamily(ctx, vgfID) + if err != nil { + log.Errorw("failed to GetVirtualGroupFamily", "error", err) + return nil, false, err + } + gvgIds = vgfInfo.GetGlobalVirtualGroupIds() + } else { + gvgIds = append(gvgIds, gvgID) + } + gvgStatsList, err := m.baseApp.GfSpDB().BatchGetRecoverGVGStats(gvgIds) + if err != nil { + log.Errorw("failed to BatchGetRecoverGVGStats", "error", err) + return nil, false, err + } + // get failed total count + failedCount, err := m.baseApp.GfSpDB().CountRecoverFailedObject() + if err != nil { + log.Errorw("failed to CountRecoverFailedObject", "error", err) + return nil, false, err + } + // get record retry time > 5 + failedRecords, err := m.baseApp.GfSpDB().GetRecoverFailedObjectsByRetryTime(5) + if err != nil { + log.Errorw("failed to CountRecoverFailedObject", "error", err) + return nil, false, err + } + failedObjects := make([]*gfspserver.FailedRecoverObject, 0, len(failedRecords)) + for _, r := range failedRecords { + meta, _ := m.baseApp.GfSpDB().GetObjectIntegrity(r.ObjectID, r.RedundancyIndex) + if meta == nil { + failedObjects = append(failedObjects, &gfspserver.FailedRecoverObject{ + ObjectId: r.ObjectID, + VirtualGroupId: r.VirtualGroupID, + RedundancyIndex: r.RedundancyIndex, + RetryTime: int32(r.RetryTime), + }) + } + } + + res := make([]*gfspserver.RecoverProcess, 0, len(gvgStatsList)) + for _, gvgStats := range gvgStatsList { + res = append(res, &gfspserver.RecoverProcess{ + VirtualGroupId: gvgStats.VirtualGroupID, + VirtualGroupFamilyId: gvgStats.VirtualGroupFamilyID, + RedundancyIndex: gvgStats.RedundancyIndex, + StartAfter: gvgStats.StartAfter, + Limit: gvgStats.Limit, + Status: int32(gvgStats.Status), + ObjectCount: gvgStats.ObjectCount, + FailedObjectTotalCount: uint64(failedCount), + RecoverFailedObject: failedObjects, + }) + } + flag := m.recoverProcessCount.Load() > 0 + return res, flag, nil +} diff --git a/modular/manager/manager_options.go b/modular/manager/manager_options.go index dd7a96b23..c7c53bb88 100644 --- a/modular/manager/manager_options.go +++ b/modular/manager/manager_options.go @@ -41,7 +41,7 @@ const ( DefaultGlobalGCBucketMigrationParallel int = 1 // DefaultGlobalRecoveryPieceParallel defines the default max parallel recovery objects in SP // system. - DefaultGlobalRecoveryPieceParallel int = 7 + DefaultGlobalRecoveryPieceParallel int = 100 // DefaultGlobalMigrateGVGParallel defines the default max parallel migrating gvg in SP system. DefaultGlobalMigrateGVGParallel int = 200 // DefaultGlobalDownloadObjectTaskCacheSize defines the default max cache the download @@ -289,6 +289,8 @@ func DefaultManagerOptions(manager *ManageModular, cfg *gfspconfig.GfSpConfig) ( manager.spBlackList = cfg.Manager.SPBlackList + manager.recoverObjectStats = NewObjectsSegmentsStats() + manager.enableTaskRetryScheduler = cfg.Manager.EnableTaskRetryScheduler manager.rejectUnsealThresholdSecond = cfg.Manager.RejectUnsealThresholdSecond diff --git a/modular/manager/recover_scheduler.go b/modular/manager/recover_scheduler.go new file mode 100644 index 000000000..99d01f6b0 --- /dev/null +++ b/modular/manager/recover_scheduler.go @@ -0,0 +1,737 @@ +package manager + +import ( + "context" + "errors" + "fmt" + "strings" + "sync" + "time" + + "github.com/bnb-chain/greenfield-storage-provider/base/gfspapp" + "github.com/bnb-chain/greenfield-storage-provider/base/gfsptqueue" + "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsptask" + "github.com/bnb-chain/greenfield-storage-provider/core/piecestore" + "github.com/bnb-chain/greenfield-storage-provider/core/spdb" + coretask "github.com/bnb-chain/greenfield-storage-provider/core/task" + "github.com/bnb-chain/greenfield-storage-provider/core/vgmgr" + "github.com/bnb-chain/greenfield-storage-provider/pkg/log" + "github.com/bnb-chain/greenfield-storage-provider/util" + "github.com/bnb-chain/greenfield/x/storage/types" + types2 "github.com/bnb-chain/greenfield/x/virtualgroup/types" + "gorm.io/gorm" +) + +const ( + recoverBatchSize = 10 + maxRecoveryRetry = 5 + MaxRecoveryTime = 50 + + recoverInterval = 30 * time.Second + verifyInterval = 1 * time.Minute + verifyGVGQueryLimit = uint32(50) + + recoverFailedObjectInterval = 1 * time.Minute + + monitorRecoverTimeOut = float64(10) // 10 minute +) + +type RecoverVGFScheduler struct { + manager *ManageModular + RecoverSchedulers []*RecoverGVGScheduler + VerifySchedulers []*VerifyGVGScheduler +} + +func NewRecoverVGFScheduler(m *ManageModular, vgfID uint32) (*RecoverVGFScheduler, error) { + vgf, err := m.baseApp.Consensus().QueryVirtualGroupFamily(context.Background(), vgfID) + if err != nil { + log.Errorw("failed to query virtual group family", "vgf_id", vgfID, "error", err) + return nil, err + } + if vgf == nil { + log.Errorw("vgf not exist") + return nil, fmt.Errorf("vgf not exist") + } + recoveryGVG := make([]*spdb.RecoverGVGStats, 0, len(vgf.GetGlobalVirtualGroupIds())) + gvgSchedulers := make([]*RecoverGVGScheduler, 0, len(vgf.GetGlobalVirtualGroupIds())) + verifySchedulers := make([]*VerifyGVGScheduler, 0, len(vgf.GetGlobalVirtualGroupIds())) + + for _, gvgID := range vgf.GetGlobalVirtualGroupIds() { + recoveryGVG = append(recoveryGVG, &spdb.RecoverGVGStats{ + VirtualGroupFamilyID: vgfID, + VirtualGroupID: gvgID, + RedundancyIndex: piecestore.PrimarySPRedundancyIndex, + StartAfter: 0, + Limit: recoverBatchSize, + ObjectCount: 0, + }) + gvgScheduler, err := NewRecoverGVGScheduler(m, vgfID, gvgID, piecestore.PrimarySPRedundancyIndex) + if err != nil { + log.Errorw("failed to create RecoverGVGScheduler", "vgf_id", vgfID, "gvg_id", gvgID, "error", err) + return nil, err + } + gvgSchedulers = append(gvgSchedulers, gvgScheduler) + + verifyScheduler, err := NewVerifyGVGScheduler(m, vgfID, gvgID, piecestore.PrimarySPRedundancyIndex) + if err != nil { + log.Errorw("failed to create VerifyGVGScheduler", "vgf_id", vgfID, "gvg_id", gvgID, "error", err) + return nil, err + } + verifySchedulers = append(verifySchedulers, verifyScheduler) + } + err = m.baseApp.GfSpDB().SetRecoverGVGStats(recoveryGVG) + if err != nil { + log.Errorw("failed to set recover gvg stats", "vgf_id", vgfID, "error", err) + return nil, err + } + return &RecoverVGFScheduler{ + manager: m, + RecoverSchedulers: gvgSchedulers, + VerifySchedulers: verifySchedulers, + }, nil +} + +func (s *RecoverVGFScheduler) Start() { + for _, g := range s.RecoverSchedulers { + log.Infow("started recover scheduler for %d", "gvg_id", g.gvgID) + go g.Start() + } + for _, v := range s.VerifySchedulers { + log.Infow("started verify gvg scheduler for %d", "gvg_id", v.gvgID) + go v.Start() + } +} + +// ObjectSegmentsStats is used to record the object's segments piece recovery progress. used by the +// RecoverGVGScheduler +type ObjectSegmentsStats struct { + SegmentCount int + FailedSegments vgmgr.IDSet + SucceedSegments vgmgr.IDSet +} + +type ObjectsSegmentsStats struct { + mux sync.RWMutex + stats map[uint64]*ObjectSegmentsStats +} + +func NewObjectsSegmentsStats() *ObjectsSegmentsStats { + return &ObjectsSegmentsStats{ + stats: make(map[uint64]*ObjectSegmentsStats, 0), + } +} + +func (s *ObjectsSegmentsStats) put(objectID uint64, segmentCount uint32) { + s.mux.Lock() + defer s.mux.Unlock() + s.stats[objectID] = &ObjectSegmentsStats{ + SegmentCount: int(segmentCount), + FailedSegments: make(map[uint32]struct{}), + SucceedSegments: make(map[uint32]struct{}), + } +} + +func (s *ObjectsSegmentsStats) has(objectID uint64) bool { + s.mux.RLock() + defer s.mux.RUnlock() + _, ok := s.stats[objectID] + return ok +} + +func (s *ObjectsSegmentsStats) remove(objectID uint64) { + s.mux.Lock() + defer s.mux.Unlock() + delete(s.stats, objectID) +} + +func (s *ObjectsSegmentsStats) addSegmentRecord(objectID uint64, success bool, segmentIdx uint32) bool { + s.mux.Lock() + defer s.mux.Unlock() + stats, ok := s.stats[objectID] + if !ok { + return false + } + if success { + stats.SucceedSegments[segmentIdx] = struct{}{} + } else { + stats.FailedSegments[segmentIdx] = struct{}{} + } + return true +} + +func (s *ObjectsSegmentsStats) isObjectProcessed(objectID uint64) bool { + s.mux.RLock() + defer s.mux.RUnlock() + stats, ok := s.stats[objectID] + if !ok { + return false + } + return len(stats.SucceedSegments)+len(stats.FailedSegments) == stats.SegmentCount +} + +func (s *ObjectsSegmentsStats) isRecoverFailed(objectID uint64) bool { + s.mux.RLock() + defer s.mux.RUnlock() + stats, ok := s.stats[objectID] + if !ok { + return true + } + return len(stats.SucceedSegments)+len(stats.FailedSegments) == stats.SegmentCount && len(stats.FailedSegments) > 0 +} + +type RecoverGVGScheduler struct { + manager *ManageModular + currentBatchObjectIDs map[uint64]struct{} + vgfID uint32 + gvgID uint32 + redundancyIndex int32 + curStartAfter uint64 +} + +func NewRecoverGVGScheduler(m *ManageModular, vgfID, gvgID uint32, redundancyIndex int32) (*RecoverGVGScheduler, error) { + if vgfID == 0 { + err := m.baseApp.GfSpDB().SetRecoverGVGStats([]*spdb.RecoverGVGStats{{ + VirtualGroupFamilyID: vgfID, + VirtualGroupID: gvgID, + RedundancyIndex: redundancyIndex, + StartAfter: 0, + Limit: recoverBatchSize, // TODO + }}) + if err != nil { + return nil, err + } + } + return &RecoverGVGScheduler{ + manager: m, + currentBatchObjectIDs: make(map[uint64]struct{}), + vgfID: vgfID, + gvgID: gvgID, + redundancyIndex: redundancyIndex, + }, nil +} + +func (s *RecoverGVGScheduler) Start() { + defer s.manager.recoverProcessCount.Add(-1) + storageParams, err := s.manager.baseApp.Consensus().QueryStorageParams(context.Background()) + if err != nil { + log.Errorw("failed to get storage params", "err", err) + return + } + maxSegmentSize := storageParams.GetMaxSegmentSize() + + gvgStats, err := s.manager.baseApp.GfSpDB().GetRecoverGVGStats(s.gvgID) + if err != nil { + log.Errorw("failed to get gvg stats", "err", err) + return + } + if gvgStats.Status != spdb.Processing { + log.Infow("the gvg is already processed") + return + } + recoverTicker := time.NewTicker(recoverInterval) + defer recoverTicker.Stop() + + var startAfter uint64 + limit := gvgStats.Limit + + recoveryCompacity := s.manager.recoveryQueue.Cap() + + for range recoverTicker.C { + log.Infow("looping") + gvgStats, err = s.manager.baseApp.GfSpDB().GetRecoverGVGStats(s.gvgID) + if err != nil { + log.Errorw("failed to get gvg stats", "err", err) + continue + } + if gvgStats.Status != spdb.Processing { + log.Infow("the gvg is already processed", "gvg_id", s.gvgID) + return + } + + startAfter = gvgStats.StartAfter + + log.Infow("processing the batch that after object id", "start_after", s.curStartAfter) + objects, err := s.manager.baseApp.GfSpClient().ListObjectsInGVG(context.Background(), gvgStats.VirtualGroupID, startAfter, uint32(limit)) + if err != nil { + log.Errorw("failed to list objects in gvg", "start_after_object_id", startAfter, "limit", limit) + continue + } + + log.Debugw("list objects in GVG", "start_after", startAfter, "limit", limit, "objects_count", len(objects), "curStartAfter", s.curStartAfter) + + if len(objects) == 0 { + log.Infow("all objects in gvg have been processed", "start_after_object_id", startAfter, "limit", limit) + gvgStats.Status = spdb.Processed + log.Infow("updating GVG stats status to processed", "gvgStats", gvgStats) + err = s.manager.baseApp.GfSpDB().UpdateRecoverGVGStats(gvgStats) + if err != nil { + log.Error("failed to update GVG stats to processed status", "gvgStats", gvgStats) + continue + } + break + } + + exceedLimit := false + out: + for _, object := range objects { + objectInfo := object.Object.ObjectInfo + objectID := objectInfo.Id.Uint64() + segmentCount := segmentPieceCount(objectInfo.PayloadSize, maxSegmentSize) + _, ok := s.currentBatchObjectIDs[objectID] + if ok { + log.Infow("the object is in processing", "object_id", objectID, "segment_count", segmentCount) + continue + } + + log.Infow("starting to recover object", "object_id", objectID, "segment_count", segmentCount) + + curRecoveryTaskNum := s.manager.recoveryQueue.Len() + if int(segmentCount) >= recoveryCompacity { + o := &spdb.RecoverFailedObject{ + ObjectID: objectID, + VirtualGroupID: object.Gvg.Id, + RedundancyIndex: gvgStats.RedundancyIndex, + } + err = s.manager.baseApp.GfSpDB().InsertRecoverFailedObject(o) + if err != nil { + log.Errorw("failed to insert recover_failed_object", "object_id", objectID, "error", err) + break + } + log.Infow("inserted recover failed object record to DB", "object_id", o.ObjectID) + continue + } + + if curRecoveryTaskNum+int(segmentCount) >= recoveryCompacity { + log.Errorw("exceeding recovery limit", "object_id", objectID, "cur_task_num", curRecoveryTaskNum, "segment_num", segmentCount, "max", recoveryCompacity) + exceedLimit = true + break + } + + for segmentIdx := uint32(0); segmentIdx < segmentCount; segmentIdx++ { + task := &gfsptask.GfSpRecoverPieceTask{} + task.InitRecoverPieceTask(objectInfo, storageParams, coretask.DefaultSmallerPriority, segmentIdx, s.redundancyIndex, maxSegmentSize, MaxRecoveryTime, maxRecoveryRetry) + task.SetBySuccessorSP(true) + task.SetGVGID(s.gvgID) + err = s.manager.recoveryQueue.Push(task) + if err != nil { + log.Errorw("failed to push to recovery queue", "object_id", objectInfo.Id, "segmentIdx", segmentIdx, "error", err) + if errors.Is(err, ErrRepeatedTask) { + continue + } + if errors.Is(err, gfsptqueue.ErrTaskQueueExceed) { + exceedLimit = true + break out + } + } + } + if !s.manager.recoverObjectStats.has(objectID) { + s.manager.recoverObjectStats.put(objectID, segmentCount) + } + s.currentBatchObjectIDs[objectID] = struct{}{} + } + + // if exceed the queue limit, wait for a while + if exceedLimit { + continue + } + + // once monitoring all objects related recovered piece tasks got response from executor, regardless success or failed, + // the scheduler will update the StartAfter in recover gvg stats and jump to the next batch of objects to recover + s.monitorBatch() + } +} + +func (s *RecoverGVGScheduler) monitorBatch() { + ticker := time.NewTicker(recoverInterval) + + startTime := time.Now() + for range ticker.C { + log.Infow("monitoring for current batch objects", "object_ids", s.currentBatchObjectIDs) + exceedTimeOut := time.Since(startTime).Minutes() > monitorRecoverTimeOut + processed := true + for objectID := range s.currentBatchObjectIDs { + if !s.manager.recoverObjectStats.isObjectProcessed(objectID) { + if !exceedTimeOut { + processed = false + break + } + log.Errorw("object has not been processed, exceeding the timeout.", "start_time", startTime.Unix(), "object_id", objectID) + failedObject := &spdb.RecoverFailedObject{ + ObjectID: objectID, + VirtualGroupID: s.gvgID, + RedundancyIndex: s.redundancyIndex, + } + if err := s.manager.baseApp.GfSpDB().InsertRecoverFailedObject(failedObject); err != nil { + log.Errorw("failed to insert recover_failed_object", "object_id", objectID, "error", err) + break + } + } else { + log.Debugw("removing object stats", "object_id", objectID) + s.manager.recoverObjectStats.remove(objectID) + delete(s.currentBatchObjectIDs, objectID) + } + } + if !processed { + continue + } + // all objects in the batch are processed. + gvgStats, err := s.manager.baseApp.GfSpDB().GetRecoverGVGStats(s.gvgID) + if err != nil { + continue + } + gvgStats.StartAfter = gvgStats.StartAfter + gvgStats.Limit + err = s.manager.baseApp.GfSpDB().UpdateRecoverGVGStats(gvgStats) + if err != nil { + log.Errorw("failed to update recover gvg status") + continue + } + s.currentBatchObjectIDs = make(map[uint64]struct{}) + return + } +} + +// RecoverFailedObjectScheduler is used to scan the failed_object table for failed object entries, and retry the object recovery +// the entries are inserted from +// (1) RecoverGVGScheduler: Objects failed to recover. +// (2) VerifyGVGScheduler: Objects are found to be missed when re-verify by calling api ListObjectsInGVG that verifying the object existence by querying integrate +// +// A GVG is marked as completed from Processed only when all objects pass the verification. +type RecoverFailedObjectScheduler struct { + manager *ManageModular +} + +func NewRecoverFailedObjectScheduler(m *ManageModular) *RecoverFailedObjectScheduler { + return &RecoverFailedObjectScheduler{ + manager: m, + } +} + +func (s *RecoverFailedObjectScheduler) Start() { + storageParams, err := s.manager.baseApp.Consensus().QueryStorageParams(context.Background()) + if err != nil { + return + } + maxSegmentSize := storageParams.GetMaxSegmentSize() + + ticker := time.NewTicker(recoverFailedObjectInterval) + defer func() { + ticker.Stop() + }() + + for range ticker.C { + if s.manager.verifyTerminationSignal.Load() == 0 { + log.Errorw("all Verify process exited") + break + } + recoverFailedObjects, err := s.manager.baseApp.GfSpDB().GetRecoverFailedObjects(maxRecoveryRetry, recoverBatchSize) + if err != nil { + log.Errorw("failed to get recover failed object from DB") + continue + } + if len(recoverFailedObjects) == 0 { + log.Debug("no failed object to be recovered") + continue + } + log.Debugw("retrieved recover failed object", "recoverFailedObjects", recoverFailedObjects) + out: + for _, o := range recoverFailedObjects { + objectInfo, err := s.manager.baseApp.GfSpClient().GetObjectByID(context.Background(), o.ObjectID) + if err != nil { + log.Errorw("failed to get object info", "object_id", o.ObjectID, "err", err) + continue + } + segmentCount := segmentPieceCount(objectInfo.PayloadSize, maxSegmentSize) + + verified, err := verifyIntegrity(s.manager, objectInfo, o.RedundancyIndex) + if err != nil { + log.Errorw("failed to verify Integrity for object", "object_id", o.ObjectID, "err", err) + continue + } + if verified { + log.Infow("object has been recovered", "object", objectInfo) + err = s.manager.baseApp.GfSpDB().DeleteRecoverFailedObject(o.ObjectID) + if err != nil { + log.Errorw("failed to delete recover failed object entry", "object_id", o.ObjectID) + continue + } + continue + } + + for segmentIdx := uint32(0); segmentIdx < segmentCount; segmentIdx++ { + _, err := s.manager.baseApp.GfSpDB().GetReplicatePieceChecksum(objectInfo.Id.Uint64(), segmentIdx, o.RedundancyIndex) + if err == nil { + log.Infow("piece is already recovered,", "object_id", objectInfo.Id, "segmentIdx", segmentIdx, "error", err) + continue + } + if err != gorm.ErrRecordNotFound { + log.Infow("failed to get piece hash fro DB", "object_id", objectInfo.Id, "segmentIdx", segmentIdx, "error", err) + break out + } + task := &gfsptask.GfSpRecoverPieceTask{} + task.InitRecoverPieceTask(objectInfo, storageParams, coretask.DefaultSmallerPriority, segmentIdx, o.RedundancyIndex, maxSegmentSize, MaxRecoveryTime, maxRecoveryRetry) + task.SetBySuccessorSP(true) + task.SetGVGID(o.VirtualGroupID) + err = s.manager.recoveryQueue.Push(task) + if err != nil { + log.Errorw("failed to push to recovery queue", "object_id", objectInfo.Id, "segmentIdx", segmentIdx, "error", err) + if errors.Is(err, ErrRepeatedTask) { + continue + } + if errors.Is(err, gfsptqueue.ErrTaskQueueExceed) { + break out + } + } + log.Errorw("pushed piece to recover queue", "object_id", objectInfo.Id, "segmentIdx", segmentIdx) + } + o.RetryTime++ + err = s.manager.baseApp.GfSpDB().UpdateRecoverFailedObject(o) + if err != nil { + log.Errorw("failed to update the recover failed object", "object_id", objectInfo.Id) + break + } + } + } + +} + +// VerifyGVGScheduler Verify that objects in GVG are recovered successfully or not. +// +// verifying the object existence by querying integrate and piece_hash. +// a recover GVG unit is marked as completed from Processed only when all objects pass the verification. +type VerifyGVGScheduler struct { + manager *ManageModular + vgfID uint32 + gvgID uint32 + redundancyIndex int32 + curStartAfter uint64 + verifyFailedObjects map[uint64]struct{} + verifySuccessObjects map[uint64]struct{} // cache +} + +func NewVerifyGVGScheduler(m *ManageModular, vgfID, gvgID uint32, redundancyIndex int32) (*VerifyGVGScheduler, error) { + return &VerifyGVGScheduler{ + manager: m, + vgfID: vgfID, + gvgID: gvgID, + redundancyIndex: redundancyIndex, + verifyFailedObjects: make(map[uint64]struct{}), + verifySuccessObjects: make(map[uint64]struct{}), + }, nil +} + +func (s *VerifyGVGScheduler) Start() { + verifyTicker := time.NewTicker(verifyInterval) + defer func() { + s.manager.verifyTerminationSignal.Add(-1) + log.Infow("finished verify GVG") + verifyTicker.Stop() + }() + + for range verifyTicker.C { + log.Infow("verify gvg scheduler") + gvgStats, err := s.manager.baseApp.GfSpDB().GetRecoverGVGStats(s.gvgID) + if err != nil { + log.Errorw("failed to get recover gvg stats", "err", err) + continue + } + if gvgStats.Status != spdb.Processed { + log.Infow("Wait for all objects in GVG to be processed") + continue + } + + objects, err := s.manager.baseApp.GfSpClient().ListObjectsInGVG(context.Background(), gvgStats.VirtualGroupID, s.curStartAfter, verifyGVGQueryLimit) + if err != nil { + log.Errorw("failed to list object in GVG", "err", err) + continue + } + + log.Infow("list objects in GVG", "start_after", s.curStartAfter, "limit", verifyGVGQueryLimit) + + // Once iterate all objects in GVG, check all recorded recover-failed objects have been recovered. + // If there is any object that does not exceed the max retry, will re-start from the beginning object in GVG. + if len(objects) == 0 { + s.curStartAfter = 0 + recoverFailedObjectsCount := len(s.verifyFailedObjects) + needDiscontinueCount := 0 + for objectID := range s.verifyFailedObjects { + // check if verified failed object is enqueued in DB + recoverFailedObject, err := s.manager.baseApp.GfSpDB().GetRecoverFailedObject(objectID) + if err != nil { + log.Errorw("failed to get recover failed object", "object_id", objectID, "error", err) + if errors.Is(err, gorm.ErrRecordNotFound) { + log.Infow("the object is already recovered", "object_id", objectID) + delete(s.verifyFailedObjects, objectID) + recoverFailedObjectsCount-- + } + continue + } + + _, err = s.manager.baseApp.Consensus().QueryObjectInfoByID(context.Background(), util.Uint64ToString(objectID)) + if err != nil { + log.Errorw("failed to get object info from chain", "object_id", objectID, "error", err) + if strings.Contains(err.Error(), "No such object") { + log.Infow("the object has been deleted from chain") + err = s.manager.baseApp.GfSpDB().DeleteRecoverFailedObject(objectID) + if err != nil { + log.Errorw("failed to delete recover failed object record from DB", "error", err) + } + delete(s.verifyFailedObjects, objectID) + recoverFailedObjectsCount-- + } + continue + } + if recoverFailedObject.RetryTime < maxRecoveryRetry { + log.Errorw("object has not been recovered yet", "object_id", objectID, "retry", recoverFailedObject.RetryTime, "max_recovery_retry", maxRecoveryRetry) + continue + } + // if an object exceeds the max recover retry, will not process further, the SP should manually trigger the discontinue object tx. + objectMeta, err := s.manager.baseApp.GfSpClient().GetObjectByID(context.Background(), objectID) + if err != nil { + log.Errorw("failed to get object by id from meta", "object", objectMeta, "error", err) + continue + } + + // confirm the object is not recovered. + verified, err := verifyIntegrity(s.manager, objectMeta, s.redundancyIndex) + if err != nil { + log.Errorw("failed to verify integrity and piece hash", "object", objectMeta, "error", err) + continue + } + if verified { + log.Infow("object has been recovered", "object_id", objectID) + err = s.manager.baseApp.GfSpDB().DeleteRecoverFailedObject(objectID) + if err != nil { + log.Errorw("failed to delete recover failed object entry", "object_id", objectID) + } + recoverFailedObjectsCount-- + delete(s.verifyFailedObjects, objectID) + } else { + needDiscontinueCount++ + } + } + + if recoverFailedObjectsCount == 0 { + if s.vgfID != 0 { + _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), s.vgfID, 0) + } else { + _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), 0, s.gvgID) + } + log.Debugw("query swapIn info", "vgf_id", s.vgfID, "gvg_id", s.gvgID, "error", err) + if err != nil { + if strings.Contains(err.Error(), "swap in info not exist") { + log.Infow("SwapIn is already completed", "vgf_id", s.vgfID, "gvg_id", s.gvgID) + return + } + continue + } + log.Infow("start to send complete swap in tx", "vgf_id", s.vgfID, "gvg_id", s.gvgID) + var msgCompleteSwapIn *types2.MsgCompleteSwapIn + if s.vgfID != 0 { + msgCompleteSwapIn = &types2.MsgCompleteSwapIn{ + GlobalVirtualGroupFamilyId: s.vgfID, + } + } else { + msgCompleteSwapIn = &types2.MsgCompleteSwapIn{ + GlobalVirtualGroupId: s.gvgID, + } + } + err := SendAndConfirmCompleteSwapInTx(s.manager.baseApp, msgCompleteSwapIn) + if err != nil { + log.Errorw("failed to send complete swap in", "complete_swap_in_msg", msgCompleteSwapIn, "error", err) + continue + } + log.Info("succeed to complete swap in tx") + if s.vgfID != 0 { + _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), s.vgfID, 0) + } else { + _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), 0, s.gvgID) + } + log.Debugw("query swapIn info", "vgf_id", s.vgfID, "gvg_id", s.gvgID, "error", err) + if err == nil { + continue + } + if strings.Contains(err.Error(), "swap in info not exist") { + gvgStats.Status = spdb.Completed + err = s.manager.baseApp.GfSpDB().UpdateRecoverGVGStats(gvgStats) + if err != nil { + log.Error("failed to update GVG stats to complete status", "gvgStats", gvgStats) + continue + } + return + } + continue + } else if recoverFailedObjectsCount == needDiscontinueCount { + log.Error("remaining objects need to be discontinue", "objects_count", needDiscontinueCount) + return + } + } + + for _, o := range objects { + objectInfo := o.Object.ObjectInfo + objectID := objectInfo.Id.Uint64() + _, ok := s.verifySuccessObjects[objectID] + if ok { + log.Debugw("the object has been verified previously", "object", objectID) + continue + } + verified, err := verifyIntegrity(s.manager, objectInfo, s.redundancyIndex) + if err != nil { + log.Errorw("failed to verify integrity", "object", objectInfo, "error", err) + break + } + if !verified { + s.verifyFailedObjects[objectID] = struct{}{} + log.Errorw("verified object has not been recovered yet", "object", objectInfo) + failedObject := &spdb.RecoverFailedObject{ + ObjectID: objectID, + VirtualGroupID: s.gvgID, + RedundancyIndex: s.redundancyIndex, + } + if err = s.manager.baseApp.GfSpDB().InsertRecoverFailedObject(failedObject); err != nil { + log.Errorw("failed to insert recover_failed_object", "object_id", objectID, "error", err) + break + } + continue + } + s.verifySuccessObjects[o.Object.ObjectInfo.Id.Uint64()] = struct{}{} + } + + s.curStartAfter = s.curStartAfter + uint64(verifyGVGQueryLimit) + } +} + +func verifyIntegrity(m *ManageModular, object *types.ObjectInfo, redundancyIndex int32) (bool, error) { + _, err := m.baseApp.GfSpDB().GetObjectIntegrity(object.Id.Uint64(), redundancyIndex) + if err != nil { + if err == gorm.ErrRecordNotFound { + log.Errorw("failed to verify the integrity, record not exist", "object_id", object.Id) + return false, nil + } + log.Errorw("failed to get object integrity hash", "objectName:", object.ObjectName, "error", err) + return false, err + } + return true, nil +} + +func segmentPieceCount(payloadSize uint64, maxSegmentSize uint64) uint32 { + count := payloadSize / maxSegmentSize + if payloadSize%maxSegmentSize > 0 { + count++ + } + return uint32(count) +} + +func SendAndConfirmCompleteSwapInTx(baseApp *gfspapp.GfSpBaseApp, msg *types2.MsgCompleteSwapIn) error { + return SendAndConfirmTx(baseApp.Consensus(), + func() (string, error) { + var ( + txHash string + txErr error + ) + if txHash, txErr = baseApp.GfSpClient().CompleteSwapIn(context.Background(), msg); txErr != nil && !isAlreadyExists(txErr) { + log.Errorw("failed to send complete swap in", "complete_swap_in_msg", msg, "error", txErr) + return "", txErr + } + return txHash, nil + }) +} diff --git a/modular/signer/signer.go b/modular/signer/signer.go index a5d1668d1..b097cd598 100644 --- a/modular/signer/signer.go +++ b/modular/signer/signer.go @@ -36,6 +36,9 @@ var ( ErrRejectMigrateBucketOnChain = gfsperrors.Register(module.SignModularName, http.StatusBadRequest, 120013, "send reject migrate bucket failed") ErrDepositOnChain = gfsperrors.Register(module.SignModularName, http.StatusBadRequest, 120014, "send deposit failed") ErrDeleteGVGOnChain = gfsperrors.Register(module.SignModularName, http.StatusBadRequest, 120015, "send delete GVG failed") + ErrReserveSwapIn = gfsperrors.Register(module.SignModularName, http.StatusBadRequest, 120016, "send reserve swap in failed") + ErrCompleteSwapIn = gfsperrors.Register(module.SignModularName, http.StatusBadRequest, 120017, "send complete swap in failed") + ErrCancelSwapIn = gfsperrors.Register(module.SignModularName, http.StatusBadRequest, 120018, "send cancel swap in failed") ) var _ module.Signer = &SignModular{} @@ -229,6 +232,18 @@ func (s *SignModular) RejectMigrateBucket(ctx context.Context, rejectMigrateBuck return s.client.RejectMigrateBucket(ctx, SignOperator, rejectMigrateBucket) } +func (s *SignModular) ReserveSwapIn(ctx context.Context, reserveSwapIn *virtualgrouptypes.MsgReserveSwapIn) (string, error) { + return s.client.ReserveSwapIn(ctx, SignOperator, reserveSwapIn) +} + +func (s *SignModular) CompleteSwapIn(ctx context.Context, completeSwapIn *virtualgrouptypes.MsgCompleteSwapIn) (string, error) { + return s.client.CompleteSwapIn(ctx, SignOperator, completeSwapIn) +} + +func (s *SignModular) CancelSwapIn(ctx context.Context, cancelSwapIn *virtualgrouptypes.MsgCancelSwapIn) (string, error) { + return s.client.CancelSwapIn(ctx, SignOperator, cancelSwapIn) +} + func (s *SignModular) Deposit(ctx context.Context, deposit *virtualgrouptypes.MsgDeposit) (string, error) { return s.client.Deposit(ctx, SignOperator, deposit) } diff --git a/modular/signer/signer_client.go b/modular/signer/signer_client.go index 32cc80836..a2b2f3ab8 100644 --- a/modular/signer/signer_client.go +++ b/modular/signer/signer_client.go @@ -726,23 +726,21 @@ func (client *GreenfieldChainSignClient) CompleteSPExit(ctx context.Context, sco log.CtxError(ctx, "complete sp exit msg pointer dangling") return "", ErrDanglingPointer } - km, err := client.greenfieldClients[scope].GetKeyManager() - if err != nil { - log.CtxErrorw(ctx, "failed to get private key", "error", err) - return "", ErrSignMsg - } client.opLock.Lock() defer client.opLock.Unlock() - msgCompleteSPExit := virtualgrouptypes.NewMsgCompleteStorageProviderExit(km.GetAddr()) + msgCompleteSPExit := &virtualgrouptypes.MsgCompleteStorageProviderExit{ + StorageProvider: completeSPExit.StorageProvider, + Operator: completeSPExit.Operator, + } mode := tx.BroadcastMode_BROADCAST_MODE_SYNC var ( - txHash string - nonce uint64 - nonceErr error + txHash string + nonce uint64 + err, nonceErr error ) for i := 0; i < BroadcastTxRetry; i++ { nonce = client.operatorAccNonce @@ -966,3 +964,162 @@ func (client *GreenfieldChainSignClient) broadcastTx(ctx context.Context, gnfdCl } return resp.TxResponse.TxHash, nil } + +func (client *GreenfieldChainSignClient) ReserveSwapIn(ctx context.Context, scope SignType, + msg *virtualgrouptypes.MsgReserveSwapIn) (string, error) { + log.Infow("signer starts to reserve swap in", "scope", scope) + if msg == nil { + log.CtxError(ctx, "reserve swap in msg pointer dangling") + return "", ErrDanglingPointer + } + km, err := client.greenfieldClients[scope].GetKeyManager() + if err != nil { + log.CtxErrorw(ctx, "failed to get private key", "error", err) + return "", ErrSignMsg + } + + client.opLock.Lock() + defer client.opLock.Unlock() + + msgReserveSwapIn := virtualgrouptypes.NewMsgReserveSwapIn(km.GetAddr(), msg.GetTargetSpId(), msg.GetGlobalVirtualGroupFamilyId(), msg.GetGlobalVirtualGroupId()) + + var ( + txHash string + nonce uint64 + nonceErr error + ) + for i := 0; i < BroadcastTxRetry; i++ { + nonce = client.operatorAccNonce + txOpt := &ctypes.TxOption{ + Nonce: nonce, + } + txHash, err = client.broadcastTx(ctx, client.greenfieldClients[scope], []sdk.Msg{msgReserveSwapIn}, txOpt) + if errors.IsOf(err, sdkErrors.ErrWrongSequence) { + // if nonce mismatches, waiting for next block, reset nonce by querying the nonce on chain + nonce, nonceErr = client.getNonceOnChain(ctx, client.greenfieldClients[scope]) + if nonceErr != nil { + log.CtxErrorw(ctx, "failed to get operator account nonce", "error", err) + ErrReserveSwapIn.SetError(fmt.Errorf("failed to get operator account nonce, error: %v", err)) + return "", ErrReserveSwapIn + } + client.operatorAccNonce = nonce + } + if err != nil { + log.CtxErrorw(ctx, "failed to broadcast reserve swap in tx", "retry_number", i, "error", err) + continue + } + client.operatorAccNonce = nonce + 1 + log.CtxDebugw(ctx, "succeed to broadcast reserve swap in tx", "tx_hash", txHash, "reserve_swap_in_msg", msgReserveSwapIn) + return txHash, nil + } + + // failed to broadcast tx + ErrReserveSwapIn.SetError(fmt.Errorf("failed to broadcast reserve swap in, error: %v", err)) + return "", ErrReserveSwapIn +} + +func (client *GreenfieldChainSignClient) CompleteSwapIn(ctx context.Context, scope SignType, + msg *virtualgrouptypes.MsgCompleteSwapIn) (string, error) { + log.Infow("signer starts to complete swap in", "scope", scope) + if msg == nil { + log.CtxError(ctx, "complete swap in msg pointer dangling") + return "", ErrDanglingPointer + } + km, err := client.greenfieldClients[scope].GetKeyManager() + if err != nil { + log.CtxErrorw(ctx, "failed to get private key", "error", err) + return "", ErrSignMsg + } + + client.opLock.Lock() + defer client.opLock.Unlock() + + msgCompleteSwapIn := virtualgrouptypes.NewMsgCompleteSwapIn(km.GetAddr(), msg.GetGlobalVirtualGroupFamilyId(), msg.GetGlobalVirtualGroupId()) + + var ( + txHash string + nonce uint64 + nonceErr error + ) + for i := 0; i < BroadcastTxRetry; i++ { + nonce = client.operatorAccNonce + txOpt := &ctypes.TxOption{ + Nonce: nonce, + } + txHash, err = client.broadcastTx(ctx, client.greenfieldClients[scope], []sdk.Msg{msgCompleteSwapIn}, txOpt) + if errors.IsOf(err, sdkErrors.ErrWrongSequence) { + // if nonce mismatches, waiting for next block, reset nonce by querying the nonce on chain + nonce, nonceErr = client.getNonceOnChain(ctx, client.greenfieldClients[scope]) + if nonceErr != nil { + log.CtxErrorw(ctx, "failed to get operator account nonce", "error", err) + ErrCompleteSwapIn.SetError(fmt.Errorf("failed to get operator account nonce, error: %v", err)) + return "", ErrCompleteSwapIn + } + client.operatorAccNonce = nonce + } + if err != nil { + log.CtxErrorw(ctx, "failed to broadcast complete swap in tx", "retry_number", i, "error", err) + continue + } + client.operatorAccNonce = nonce + 1 + log.CtxDebugw(ctx, "succeed to broadcast complete swap in tx", "tx_hash", txHash, "complete_swap_in_msg", msgCompleteSwapIn) + return txHash, nil + } + + // failed to broadcast tx + ErrCompleteSwapIn.SetError(fmt.Errorf("failed to broadcast rcomplete swap in, error: %v", err)) + return "", ErrCompleteSwapIn +} + +func (client *GreenfieldChainSignClient) CancelSwapIn(ctx context.Context, scope SignType, + msg *virtualgrouptypes.MsgCancelSwapIn) (string, error) { + log.Infow("signer starts to cancel swap in", "scope", scope) + if msg == nil { + log.CtxError(ctx, "cancel swap in msg pointer dangling") + return "", ErrDanglingPointer + } + km, err := client.greenfieldClients[scope].GetKeyManager() + if err != nil { + log.CtxErrorw(ctx, "failed to get private key", "error", err) + return "", ErrSignMsg + } + + client.opLock.Lock() + defer client.opLock.Unlock() + + msgCancelSwapIn := virtualgrouptypes.NewMsgCancelSwapIn(km.GetAddr(), msg.GetGlobalVirtualGroupFamilyId(), msg.GetGlobalVirtualGroupId()) + + var ( + txHash string + nonce uint64 + nonceErr error + ) + for i := 0; i < BroadcastTxRetry; i++ { + nonce = client.operatorAccNonce + txOpt := &ctypes.TxOption{ + Nonce: nonce, + } + txHash, err = client.broadcastTx(ctx, client.greenfieldClients[scope], []sdk.Msg{msgCancelSwapIn}, txOpt) + if errors.IsOf(err, sdkErrors.ErrWrongSequence) { + // if nonce mismatches, waiting for next block, reset nonce by querying the nonce on chain + nonce, nonceErr = client.getNonceOnChain(ctx, client.greenfieldClients[scope]) + if nonceErr != nil { + log.CtxErrorw(ctx, "failed to get operator account nonce", "error", err) + ErrCompleteSwapIn.SetError(fmt.Errorf("failed to get operator account nonce, error: %v", err)) + return "", ErrCompleteSwapIn + } + client.operatorAccNonce = nonce + } + if err != nil { + log.CtxErrorw(ctx, "failed to broadcast cancel swap in tx", "retry_number", i, "error", err) + continue + } + client.operatorAccNonce = nonce + 1 + log.CtxDebugw(ctx, "succeed to broadcast cancel swap in tx", "tx_hash", txHash, "cancel_swap_in_msg", msgCancelSwapIn) + return txHash, nil + } + + // failed to broadcast tx + ErrCancelSwapIn.SetError(fmt.Errorf("failed to broadcast cancel swap in, error: %v", err)) + return "", ErrCancelSwapIn +} diff --git a/proto/base/types/gfspserver/manage.proto b/proto/base/types/gfspserver/manage.proto index 7163da111..f30d55d19 100644 --- a/proto/base/types/gfspserver/manage.proto +++ b/proto/base/types/gfspserver/manage.proto @@ -146,6 +146,46 @@ message GfSpResetRecoveryFailedListResponse { repeated string recovery_failed_list = 1; } +message GfSpTriggerRecoverForSuccessorSPRequest { + uint32 vgf_id = 1; + uint32 gvg_id = 2; + int32 replicate_index = 3; +} + +message GfSpTriggerRecoverForSuccessorSPResponse { + base.types.gfsperrors.GfSpError err = 1; +} + +message GfSpQueryRecoverProcessRequest { + uint32 vgf_id = 1; + uint32 gvg_id = 2; +} + +message FailedRecoverObject { + uint64 object_id = 1; + uint32 virtual_group_id = 2; + int32 redundancy_index = 3; + int32 retry_time = 4; +} + +message RecoverProcess { + uint32 virtual_group_id = 1; + uint32 virtual_group_family_id = 2; + int32 redundancy_index = 3; + uint64 start_after = 4; + uint64 limit = 5; + int32 status = 6; + uint64 object_count = 7; + uint64 failed_object_total_count = 8; + repeated FailedRecoverObject recover_failed_object = 9; +} + +message GfSpQueryRecoverProcessResponse { + base.types.gfsperrors.GfSpError err = 1; + repeated RecoverProcess recover_processes = 2; + bool executing = 3; +} + service GfSpManageService { rpc GfSpBeginTask(GfSpBeginTaskRequest) returns (GfSpBeginTaskResponse) {} rpc GfSpAskTask(GfSpAskTaskRequest) returns (GfSpAskTaskResponse) {} @@ -157,4 +197,6 @@ service GfSpManageService { rpc GfSpNotifyPreMigrateBucketAndDeductQuota(GfSpNotifyPreMigrateBucketRequest) returns (GfSpNotifyPreMigrateBucketResponse) {} rpc GfSpNotifyPostMigrateAndRecoupQuota(GfSpNotifyPostMigrateBucketRequest) returns (GfSpNotifyPostMigrateBucketResponse) {} rpc GfSpResetRecoveryFailedList(GfSpResetRecoveryFailedListRequest) returns (GfSpResetRecoveryFailedListResponse) {} + rpc GfSpTriggerRecoverForSuccessorSP(GfSpTriggerRecoverForSuccessorSPRequest) returns (GfSpTriggerRecoverForSuccessorSPResponse) {} + rpc GfSpQueryRecoverProcess(GfSpQueryRecoverProcessRequest) returns (GfSpQueryRecoverProcessResponse) {} } diff --git a/proto/base/types/gfspserver/sign.proto b/proto/base/types/gfspserver/sign.proto index 2f96ec192..208475dc8 100644 --- a/proto/base/types/gfspserver/sign.proto +++ b/proto/base/types/gfspserver/sign.proto @@ -55,6 +55,9 @@ message GfSpSignRequest { greenfield.storage.MsgRejectMigrateBucket reject_migrate_bucket = 25; greenfield.virtualgroup.MsgDeposit deposit = 26; greenfield.virtualgroup.MsgDeleteGlobalVirtualGroup delete_global_virtual_group = 27; + greenfield.virtualgroup.MsgReserveSwapIn reserve_swap_in = 28; + greenfield.virtualgroup.MsgCompleteSwapIn complete_swap_in = 29; + greenfield.virtualgroup.MsgCancelSwapIn cancel_swap_in = 30; } } diff --git a/proto/base/types/gfsptask/task.proto b/proto/base/types/gfsptask/task.proto index d90bb7b27..8859efc50 100644 --- a/proto/base/types/gfsptask/task.proto +++ b/proto/base/types/gfsptask/task.proto @@ -91,6 +91,8 @@ message GfSpRecoverPieceTask { uint64 piece_size = 6; bytes signature = 7; bool recovered = 8; + bool by_successor_sp = 9; + uint32 gvg_id = 10; } message GfSpReceivePieceTask { diff --git a/proto/buf.lock b/proto/buf.lock index e513ecd23..c93dc7032 100644 --- a/proto/buf.lock +++ b/proto/buf.lock @@ -4,8 +4,8 @@ deps: - remote: buf.build owner: bnb-chain repository: greenfield - commit: e686e506f91f428188e4dac367b9d7dc - digest: shake256:baeab16ca3fb230e909cce88842204b308de769c5337cd1434d353c08f02977e1370b91cd49e649cc95443eb81a1171e81fc1c028b09b60037de57061be8064a + commit: fb6d340760a24875b94a36369d979a9f + digest: shake256:f9909cac3372e0593e397f0a6d79e0b668e7c778d52ab27b185df63e5ce84b82a2e4e0eaf4075f4fa83c4775fba8126001f505d80b16bd7348f31497de6a6ed3 - remote: buf.build owner: cosmos repository: cosmos-proto diff --git a/store/bsdb/database_mock.go b/store/bsdb/database_mock.go index 3d50a5232..e1028dfd5 100644 --- a/store/bsdb/database_mock.go +++ b/store/bsdb/database_mock.go @@ -658,7 +658,7 @@ func (mr *MockMetadataMockRecorder) ListBucketsByVgfID(vgfIDs, startAfter, limit // ListCompleteMigrationBucket mocks base method. func (m *MockMetadata) ListCompleteMigrationBucket(srcSpID uint32, filters ...func(*gorm.DB) *gorm.DB) ([]*EventCompleteMigrationBucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{srcSpID} + varargs := []any{srcSpID} for _, a := range filters { varargs = append(varargs, a) } @@ -669,9 +669,9 @@ func (m *MockMetadata) ListCompleteMigrationBucket(srcSpID uint32, filters ...fu } // ListCompleteMigrationBucket indicates an expected call of ListCompleteMigrationBucket. -func (mr *MockMetadataMockRecorder) ListCompleteMigrationBucket(srcSpID interface{}, filters ...interface{}) *gomock.Call { +func (mr *MockMetadataMockRecorder) ListCompleteMigrationBucket(srcSpID any, filters ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{srcSpID}, filters...) + varargs := append([]any{srcSpID}, filters...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompleteMigrationBucket", reflect.TypeOf((*MockMetadata)(nil).ListCompleteMigrationBucket), varargs...) } @@ -1696,7 +1696,7 @@ func (mr *MockBSDBMockRecorder) ListBucketsByVgfID(vgfIDs, startAfter, limit any // ListCompleteMigrationBucket mocks base method. func (m *MockBSDB) ListCompleteMigrationBucket(srcSpID uint32, filters ...func(*gorm.DB) *gorm.DB) ([]*EventCompleteMigrationBucket, error) { m.ctrl.T.Helper() - varargs := []interface{}{srcSpID} + varargs := []any{srcSpID} for _, a := range filters { varargs = append(varargs, a) } @@ -1707,9 +1707,9 @@ func (m *MockBSDB) ListCompleteMigrationBucket(srcSpID uint32, filters ...func(* } // ListCompleteMigrationBucket indicates an expected call of ListCompleteMigrationBucket. -func (mr *MockBSDBMockRecorder) ListCompleteMigrationBucket(srcSpID interface{}, filters ...interface{}) *gomock.Call { +func (mr *MockBSDBMockRecorder) ListCompleteMigrationBucket(srcSpID any, filters ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{srcSpID}, filters...) + varargs := append([]any{srcSpID}, filters...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompleteMigrationBucket", reflect.TypeOf((*MockBSDB)(nil).ListCompleteMigrationBucket), varargs...) } diff --git a/store/sqldb/const.go b/store/sqldb/const.go index d19a23a43..ab11cce80 100644 --- a/store/sqldb/const.go +++ b/store/sqldb/const.go @@ -44,6 +44,10 @@ const ( SwapOutTableName = "swap_out_unit" // MigrateGVGTableName defines the progress of subscribe migrate event. MigrateGVGTableName = "migrate_gvg" + // RecoverGVGStatsTableName is for successor SP to keep track of recovering objects in a virtual group family + RecoverGVGStatsTableName = "recover_gvg_stats" + + RecoverFailedObjectTableName = "recover_failed_object" // MigrateBucketProgressTableName defines the progress of migrate bucket. MigrateBucketProgressTableName = "migrate_bucket_progress" ) diff --git a/store/sqldb/exit_recover.go b/store/sqldb/exit_recover.go new file mode 100644 index 000000000..256bdf5d3 --- /dev/null +++ b/store/sqldb/exit_recover.go @@ -0,0 +1,200 @@ +package sqldb + +import ( + "fmt" + + "github.com/bnb-chain/greenfield-storage-provider/core/spdb" +) + +func (s *SpDBImpl) GetRecoverGVGStats(gvgID uint32) (*spdb.RecoverGVGStats, error) { + var queryReturn RecoverGVGStatsTable + if err := s.db.Model(&RecoverGVGStatsTable{}). + Where("virtual_group_id = ?", gvgID). + First(&queryReturn).Error; err != nil { + return nil, err + } + return &spdb.RecoverGVGStats{ + VirtualGroupFamilyID: queryReturn.VirtualGroupFamilyID, + VirtualGroupID: queryReturn.VirtualGroupID, + RedundancyIndex: queryReturn.RedundancyIndex, + Status: spdb.RecoverStatus(queryReturn.Status), + StartAfter: queryReturn.StartAfter, + Limit: uint64(queryReturn.Limit), + ObjectCount: queryReturn.ObjectCount, + }, nil +} + +func (s *SpDBImpl) BatchGetRecoverGVGStats(gvgIDs []uint32) ([]*spdb.RecoverGVGStats, error) { + var queryReturn []*RecoverGVGStatsTable + if err := s.db.Model(&RecoverGVGStatsTable{}). + Where("virtual_group_id IN ?", gvgIDs). + Find(&queryReturn).Error; err != nil { + return nil, err + } + res := make([]*spdb.RecoverGVGStats, 0, len(queryReturn)) + for _, ret := range queryReturn { + res = append(res, &spdb.RecoverGVGStats{ + VirtualGroupFamilyID: ret.VirtualGroupFamilyID, + VirtualGroupID: ret.VirtualGroupID, + RedundancyIndex: ret.RedundancyIndex, + StartAfter: ret.StartAfter, + Status: spdb.RecoverStatus(ret.Status), + Limit: uint64(ret.Limit), + ObjectCount: ret.ObjectCount, + }) + } + return res, nil +} + +func (s *SpDBImpl) SetRecoverGVGStats(stats []*spdb.RecoverGVGStats) error { + saveGVG := make([]*RecoverGVGStatsTable, 0) + for _, g := range stats { + gt := &RecoverGVGStatsTable{ + VirtualGroupFamilyID: g.VirtualGroupFamilyID, + VirtualGroupID: g.VirtualGroupID, + RedundancyIndex: g.RedundancyIndex, + StartAfter: g.StartAfter, + Limit: uint32(g.Limit), + Status: int(g.Status), + } + saveGVG = append(saveGVG, gt) + } + + err := s.db.CreateInBatches(saveGVG, len(saveGVG)).Error + if err != nil && MysqlErrCode(err) == ErrDuplicateEntryCode { + return nil + } + if err != nil { + return fmt.Errorf("failed to set gvg recover stats record: %s", err.Error()) + } + return nil +} + +func (s *SpDBImpl) UpdateRecoverGVGStats(stats *spdb.RecoverGVGStats) (err error) { + result := s.db.Table(RecoverGVGStatsTableName).Where("virtual_group_id = ?", stats.VirtualGroupID). + Updates(&RecoverGVGStatsTable{ + Status: int(stats.Status), + StartAfter: stats.StartAfter, + ObjectCount: stats.ObjectCount, + }) + if result.Error != nil { + return fmt.Errorf("failed to update the GVG status for recover_stats table: %s", result.Error) + } + return nil +} + +func (s *SpDBImpl) DeleteRecoverGVGStats(gvgID uint32) (err error) { + err = s.db.Table(RecoverGVGStatsTableName).Delete(&RecoverGVGStatsTable{ + VirtualGroupID: gvgID, + }).Error + return err +} + +func (s *SpDBImpl) InsertRecoverFailedObject(object *spdb.RecoverFailedObject) error { + result := s.db.Create(&RecoverFailedObjectTable{ + ObjectID: object.ObjectID, + VirtualGroupID: object.VirtualGroupID, + RedundancyIndex: object.RedundancyIndex, + }) + if result.Error != nil && MysqlErrCode(result.Error) == ErrDuplicateEntryCode { + return nil + } + if result.Error != nil || result.RowsAffected != 1 { + return fmt.Errorf("failed to set recover object record: %s", result.Error) + } + return nil +} + +func (s *SpDBImpl) DeleteRecoverFailedObject(objectID uint64) (err error) { + err = s.db.Table(RecoverFailedObjectTableName).Delete(&RecoverFailedObjectTable{ + ObjectID: objectID, + }).Error + return err +} + +func (s *SpDBImpl) GetRecoverFailedObject(objectID uint64) (*spdb.RecoverFailedObject, error) { + var queryReturn RecoverFailedObjectTable + if err := s.db.Model(&RecoverFailedObjectTable{}). + Where("object_id = ?", objectID). + First(&queryReturn).Error; err != nil { + return nil, err + } + return &spdb.RecoverFailedObject{ + ObjectID: objectID, + VirtualGroupID: queryReturn.VirtualGroupID, + RedundancyIndex: queryReturn.RedundancyIndex, + RetryTime: queryReturn.Retry, + }, nil +} + +func (s *SpDBImpl) GetRecoverFailedObjects(retry, limit uint32) ([]*spdb.RecoverFailedObject, error) { + var ( + recoverObjects []*RecoverFailedObjectTable + returnObjects []*spdb.RecoverFailedObject + err error + ) + + err = s.db.Table(RecoverFailedObjectTableName). + Select("*"). + Where("retry <= ?", retry). + Order("object_id asc"). + Limit(int(limit)). + Find(&recoverObjects).Error + if err != nil { + return nil, err + } + for _, object := range recoverObjects { + returnObjects = append(returnObjects, &spdb.RecoverFailedObject{ + ObjectID: object.ObjectID, + VirtualGroupID: object.VirtualGroupID, + RedundancyIndex: object.RedundancyIndex, + RetryTime: object.Retry, + }) + } + return returnObjects, nil +} + +func (s *SpDBImpl) GetRecoverFailedObjectsByRetryTime(retry uint32) ([]*spdb.RecoverFailedObject, error) { + var ( + recoverObjects []*RecoverFailedObjectTable + returnObjects []*spdb.RecoverFailedObject + err error + ) + + err = s.db.Table(RecoverFailedObjectTableName). + Select("*"). + Where("retry >= ?", retry). + Order("object_id asc"). + Find(&recoverObjects).Error + if err != nil { + return nil, err + } + for _, object := range recoverObjects { + returnObjects = append(returnObjects, &spdb.RecoverFailedObject{ + ObjectID: object.ObjectID, + VirtualGroupID: object.VirtualGroupID, + RedundancyIndex: object.RedundancyIndex, + RetryTime: object.Retry, + }) + } + return returnObjects, nil +} + +func (s *SpDBImpl) UpdateRecoverFailedObject(object *spdb.RecoverFailedObject) (err error) { + result := s.db.Table(RecoverFailedObjectTableName).Where("object_id = ?", object.ObjectID). + Updates(&RecoverFailedObjectTable{ + Retry: object.RetryTime, + }) + if result.Error != nil { + return fmt.Errorf("failed to VerifyGVGProgress%s", result.Error) + } + return nil +} + +func (s *SpDBImpl) CountRecoverFailedObject() (count int64, err error) { + result := s.db.Table(RecoverFailedObjectTableName).Count(&count) + if result.Error != nil { + return 0, fmt.Errorf("failed to count recover failed object%s", result.Error) + } + return +} diff --git a/store/sqldb/exit_recover_schema.go b/store/sqldb/exit_recover_schema.go new file mode 100644 index 000000000..a702f7fed --- /dev/null +++ b/store/sqldb/exit_recover_schema.go @@ -0,0 +1,26 @@ +package sqldb + +type RecoverGVGStatsTable struct { + VirtualGroupID uint32 `gorm:"primary_key"` + VirtualGroupFamilyID uint32 + RedundancyIndex int32 `gorm:"index:redundancy_index"` + StartAfter uint64 + Limit uint32 + Status int + ObjectCount uint64 +} + +func (RecoverGVGStatsTable) TableName() string { + return RecoverGVGStatsTableName +} + +type RecoverFailedObjectTable struct { + ObjectID uint64 `gorm:"primary_key"` + VirtualGroupID uint32 `gorm:"index:idx_gvg"` + RedundancyIndex int32 + Retry int `gorm:"index:retry"` +} + +func (RecoverFailedObjectTable) TableName() string { + return RecoverFailedObjectTableName +} diff --git a/store/sqldb/store.go b/store/sqldb/store.go index c79e7cedd..5dea644b0 100644 --- a/store/sqldb/store.go +++ b/store/sqldb/store.go @@ -165,6 +165,13 @@ func InitDB(config *config.SQLDBConfig) (*gorm.DB, error) { log.Errorw("failed to migrate gvg table", "error", err) return nil, err } + if err = db.AutoMigrate(&RecoverGVGStatsTable{}); err != nil && !isAlreadyExists(err) { + log.Errorw("failed to create recover gvg table", "error", err) + return nil, err + } + if err = db.AutoMigrate(&RecoverFailedObjectTable{}); err != nil && !isAlreadyExists(err) { + log.Errorw("failed to create recover fail object gvg table", "error", err) + } if err = db.AutoMigrate(&MigrateBucketProgressTable{}); err != nil && !isAlreadyExists(err) { log.Errorw("failed to migrate bucket table", "error", err) return nil, err From 532023b23d2b6843a1a8061fde895fcd7f2f0e4f Mon Sep 17 00:00:00 2001 From: Alexxxxxx <118710506+alexgao001@users.noreply.github.com> Date: Thu, 28 Dec 2023 09:49:19 +0800 Subject: [PATCH 07/27] feat: whitelist recovers data from secondary as successor secondary (#1287) --- base/gfspvgmgr/virtual_group_manager.go | 9 ++- core/spdb/entity.go | 1 + modular/gater/admin_handler.go | 43 +++++++++----- modular/manager/manage_task.go | 11 +--- modular/manager/recover_scheduler.go | 76 ++++++++++++++++--------- store/sqldb/exit_recover.go | 10 +++- store/sqldb/exit_recover_schema.go | 1 + 7 files changed, 97 insertions(+), 54 deletions(-) diff --git a/base/gfspvgmgr/virtual_group_manager.go b/base/gfspvgmgr/virtual_group_manager.go index 960d76bea..fe3352b0b 100644 --- a/base/gfspvgmgr/virtual_group_manager.go +++ b/base/gfspvgmgr/virtual_group_manager.go @@ -527,8 +527,15 @@ func (vgm *virtualGroupManager) FreezeSPAndGVGs(spID uint32, gvgs []*virtualgrou func (vgm *virtualGroupManager) releaseSPAndGVGLoop() { ticker := time.NewTicker(ReleaseSPJobInterval) for range ticker.C { - vgm.freezeSPPool.ReleaseSP() + vgm.mutex.RLock() + if vgm.spManager == nil { + log.Warnw("failed to init sp manager") + vgm.mutex.RUnlock() + continue + } + vgm.mutex.RUnlock() + vgm.freezeSPPool.ReleaseSP() vgm.mutex.RLock() aliveSP := make([]*sptypes.StorageProvider, 0) for _, sp := range vgm.spManager.otherSPs { diff --git a/core/spdb/entity.go b/core/spdb/entity.go index e1603f4ae..0f2cc4ec2 100644 --- a/core/spdb/entity.go +++ b/core/spdb/entity.go @@ -145,6 +145,7 @@ type RecoverGVGStats struct { VirtualGroupFamilyID uint32 RedundancyIndex int32 StartAfter uint64 + NextStartAfter uint64 Limit uint64 Status RecoverStatus ObjectCount uint64 diff --git a/modular/gater/admin_handler.go b/modular/gater/admin_handler.go index bf10b198e..5ea7cec5a 100644 --- a/modular/gater/admin_handler.go +++ b/modular/gater/admin_handler.go @@ -877,27 +877,42 @@ func (g *GateModular) getRecoverPiece(ctx context.Context, objectInfo *storagety sspAddress = append(sspAddress, sp.OperatorAddress) } - isSuccessor := false var ( - successorSP *sptypes.StorageProvider - swapInInfo *virtualgrouptypes.SwapInInfo + isSuccessorPrimary bool + isSuccessorSecondary bool + successorSP *sptypes.StorageProvider + swapInInfo *virtualgrouptypes.SwapInInfo ) if recoveryTask.GetBySuccessorSp() { - swapInInfo, err = g.baseApp.Consensus().QuerySwapInInfo(ctx, gvg.FamilyId, 0) - if err != nil { - return nil, ErrConsensusWithDetail("query swapInInfo err: " + err.Error()) - } - successorSP, err = g.baseApp.Consensus().QuerySPByID(ctx, swapInInfo.SuccessorSpId) - if err != nil { - return nil, ErrConsensusWithDetail("query sp err: " + err.Error()) - } - if primarySp.Id == swapInInfo.TargetSpId && successorSP.OperatorAddress == signatureAddr.String() { - isSuccessor = true + swapInInfo, err = g.baseApp.Consensus().QuerySwapInInfo(ctx, gvg.FamilyId, virtualgrouptypes.NoSpecifiedGVGId) + if err == nil { + successorSP, err = g.baseApp.Consensus().QuerySPByID(ctx, swapInInfo.SuccessorSpId) + if err != nil { + return nil, ErrConsensusWithDetail("query sp err: " + err.Error()) + } + if primarySp.Id == swapInInfo.TargetSpId && successorSP.OperatorAddress == signatureAddr.String() { + isSuccessorPrimary = true + } + } else { + swapInInfo, err = g.baseApp.Consensus().QuerySwapInInfo(ctx, virtualgrouptypes.NoSpecifiedFamilyId, gvg.Id) + if err != nil { + return nil, ErrConsensusWithDetail("query swapInInfo err: " + err.Error()) + } + successorSP, err = g.baseApp.Consensus().QuerySPByID(ctx, swapInInfo.SuccessorSpId) + if err != nil { + return nil, ErrConsensusWithDetail("query sp err: " + err.Error()) + } + for _, sspID := range gvg.SecondarySpIds { + if sspID == swapInInfo.TargetSpId && successorSP.OperatorAddress == signatureAddr.String() { + isSuccessorSecondary = true + break + } + } } } // if myself is secondary, the sender of the request can be both of the primary SP or the secondary SP of the gvg - if primarySp.OperatorAddress != signatureAddr.String() && !isSuccessor { + if primarySp.OperatorAddress != signatureAddr.String() && !isSuccessorPrimary && !isSuccessorSecondary { log.CtxDebug(ctx, "recovery request not come from primary sp", "secondary sp", signatureAddr.String()) // judge if the sender is not one of the secondary SP isRequestFromSecondary := false diff --git a/modular/manager/manage_task.go b/modular/manager/manage_task.go index 37e4c919d..8abdedbef 100644 --- a/modular/manager/manage_task.go +++ b/modular/manager/manage_task.go @@ -786,10 +786,7 @@ func (m *ManageModular) HandleRecoverPieceTask(ctx context.Context, task task.Re if task.BySuccessorSP() { objectID := task.GetObjectInfo().Id.Uint64() - success := m.recoverObjectStats.addSegmentRecord(objectID, true, task.GetSegmentIdx()) - if !success { - return nil - } + m.recoverObjectStats.addSegmentRecord(objectID, true, task.GetSegmentIdx()) return nil } } @@ -836,11 +833,7 @@ func (m *ManageModular) handleFailedRecoverPieceTask(ctx context.Context, handle if handleTask.BySuccessorSP() { objectID := handleTask.GetObjectInfo().Id.Uint64() - success := m.recoverObjectStats.addSegmentRecord(objectID, false, handleTask.GetSegmentIdx()) - if !success { - return nil - } - + m.recoverObjectStats.addSegmentRecord(objectID, false, handleTask.GetSegmentIdx()) if m.recoverObjectStats.isRecoverFailed(objectID) { object := &spdb.RecoverFailedObject{ ObjectID: handleTask.GetObjectInfo().Id.Uint64(), diff --git a/modular/manager/recover_scheduler.go b/modular/manager/recover_scheduler.go index 99d01f6b0..a9f87ad8c 100644 --- a/modular/manager/recover_scheduler.go +++ b/modular/manager/recover_scheduler.go @@ -28,8 +28,8 @@ const ( MaxRecoveryTime = 50 recoverInterval = 30 * time.Second - verifyInterval = 1 * time.Minute - verifyGVGQueryLimit = uint32(50) + verifyInterval = 10 * time.Second + verifyGVGQueryLimit = uint32(100) recoverFailedObjectInterval = 1 * time.Minute @@ -62,6 +62,7 @@ func NewRecoverVGFScheduler(m *ManageModular, vgfID uint32) (*RecoverVGFSchedule VirtualGroupID: gvgID, RedundancyIndex: piecestore.PrimarySPRedundancyIndex, StartAfter: 0, + NextStartAfter: 0, Limit: recoverBatchSize, ObjectCount: 0, }) @@ -144,19 +145,18 @@ func (s *ObjectsSegmentsStats) remove(objectID uint64) { delete(s.stats, objectID) } -func (s *ObjectsSegmentsStats) addSegmentRecord(objectID uint64, success bool, segmentIdx uint32) bool { +func (s *ObjectsSegmentsStats) addSegmentRecord(objectID uint64, success bool, segmentIdx uint32) { s.mux.Lock() defer s.mux.Unlock() stats, ok := s.stats[objectID] if !ok { - return false + return } if success { stats.SucceedSegments[segmentIdx] = struct{}{} } else { stats.FailedSegments[segmentIdx] = struct{}{} } - return true } func (s *ObjectsSegmentsStats) isObjectProcessed(objectID uint64) bool { @@ -166,7 +166,14 @@ func (s *ObjectsSegmentsStats) isObjectProcessed(objectID uint64) bool { if !ok { return false } - return len(stats.SucceedSegments)+len(stats.FailedSegments) == stats.SegmentCount + processIDs := make(map[uint32]struct{}, 0) + for id := range stats.SucceedSegments { + processIDs[id] = struct{}{} + } + for id := range stats.FailedSegments { + processIDs[id] = struct{}{} + } + return len(processIDs) == stats.SegmentCount } func (s *ObjectsSegmentsStats) isRecoverFailed(objectID uint64) bool { @@ -176,7 +183,17 @@ func (s *ObjectsSegmentsStats) isRecoverFailed(objectID uint64) bool { if !ok { return true } - return len(stats.SucceedSegments)+len(stats.FailedSegments) == stats.SegmentCount && len(stats.FailedSegments) > 0 + if len(stats.SucceedSegments) == stats.SegmentCount { + return false + } + processIDs := make(map[uint32]struct{}, 0) + for id := range stats.SucceedSegments { + processIDs[id] = struct{}{} + } + for id := range stats.FailedSegments { + processIDs[id] = struct{}{} + } + return len(processIDs) == stats.SegmentCount && len(stats.FailedSegments) > 0 } type RecoverGVGScheduler struct { @@ -185,7 +202,6 @@ type RecoverGVGScheduler struct { vgfID uint32 gvgID uint32 redundancyIndex int32 - curStartAfter uint64 } func NewRecoverGVGScheduler(m *ManageModular, vgfID, gvgID uint32, redundancyIndex int32) (*RecoverGVGScheduler, error) { @@ -195,7 +211,8 @@ func NewRecoverGVGScheduler(m *ManageModular, vgfID, gvgID uint32, redundancyInd VirtualGroupID: gvgID, RedundancyIndex: redundancyIndex, StartAfter: 0, - Limit: recoverBatchSize, // TODO + NextStartAfter: 0, + Limit: recoverBatchSize, }}) if err != nil { return nil, err @@ -230,14 +247,11 @@ func (s *RecoverGVGScheduler) Start() { } recoverTicker := time.NewTicker(recoverInterval) defer recoverTicker.Stop() - - var startAfter uint64 limit := gvgStats.Limit recoveryCompacity := s.manager.recoveryQueue.Cap() for range recoverTicker.C { - log.Infow("looping") gvgStats, err = s.manager.baseApp.GfSpDB().GetRecoverGVGStats(s.gvgID) if err != nil { log.Errorw("failed to get gvg stats", "err", err) @@ -248,19 +262,16 @@ func (s *RecoverGVGScheduler) Start() { return } - startAfter = gvgStats.StartAfter - - log.Infow("processing the batch that after object id", "start_after", s.curStartAfter) - objects, err := s.manager.baseApp.GfSpClient().ListObjectsInGVG(context.Background(), gvgStats.VirtualGroupID, startAfter, uint32(limit)) + objects, err := s.manager.baseApp.GfSpClient().ListObjectsInGVG(context.Background(), gvgStats.VirtualGroupID, gvgStats.StartAfter, uint32(limit)) if err != nil { - log.Errorw("failed to list objects in gvg", "start_after_object_id", startAfter, "limit", limit) + log.Errorw("failed to list objects in gvg", "start_after_object_id", gvgStats.StartAfter, "limit", limit) continue } - log.Debugw("list objects in GVG", "start_after", startAfter, "limit", limit, "objects_count", len(objects), "curStartAfter", s.curStartAfter) + log.Infow("list objects in GVG", "start_after", gvgStats.StartAfter, "limit", limit, "object_num", len(objects)) if len(objects) == 0 { - log.Infow("all objects in gvg have been processed", "start_after_object_id", startAfter, "limit", limit) + log.Infow("all objects in gvg have been processed", "start_after_object_id", gvgStats.StartAfter, "limit", limit) gvgStats.Status = spdb.Processed log.Infow("updating GVG stats status to processed", "gvgStats", gvgStats) err = s.manager.baseApp.GfSpDB().UpdateRecoverGVGStats(gvgStats) @@ -271,6 +282,16 @@ func (s *RecoverGVGScheduler) Start() { break } + lastObjectID := objects[len(objects)-1].Object.ObjectInfo.Id.Uint64() + if lastObjectID != gvgStats.NextStartAfter { + gvgStats.NextStartAfter = lastObjectID + err = s.manager.baseApp.GfSpDB().UpdateRecoverGVGStats(gvgStats) + if err != nil { + log.Error("failed to update GVG stats", "lastObjectID", lastObjectID) + continue + } + } + exceedLimit := false out: for _, object := range objects { @@ -379,7 +400,7 @@ func (s *RecoverGVGScheduler) monitorBatch() { if err != nil { continue } - gvgStats.StartAfter = gvgStats.StartAfter + gvgStats.Limit + gvgStats.StartAfter = gvgStats.NextStartAfter err = s.manager.baseApp.GfSpDB().UpdateRecoverGVGStats(gvgStats) if err != nil { log.Errorw("failed to update recover gvg status") @@ -545,7 +566,7 @@ func (s *VerifyGVGScheduler) Start() { continue } - log.Infow("list objects in GVG", "start_after", s.curStartAfter, "limit", verifyGVGQueryLimit) + log.Infow("list objects in GVG", "start_after", s.curStartAfter, "limit", verifyGVGQueryLimit, "object_num", len(objects)) // Once iterate all objects in GVG, check all recorded recover-failed objects have been recovered. // If there is any object that does not exceed the max retry, will re-start from the beginning object in GVG. @@ -554,18 +575,18 @@ func (s *VerifyGVGScheduler) Start() { recoverFailedObjectsCount := len(s.verifyFailedObjects) needDiscontinueCount := 0 for objectID := range s.verifyFailedObjects { - // check if verified failed object is enqueued in DB + // the object might have been recovered. recoverFailedObject, err := s.manager.baseApp.GfSpDB().GetRecoverFailedObject(objectID) if err != nil { log.Errorw("failed to get recover failed object", "object_id", objectID, "error", err) if errors.Is(err, gorm.ErrRecordNotFound) { - log.Infow("the object is already recovered", "object_id", objectID) + log.Infow("the object is already recovered, record has been removed", "object_id", objectID) delete(s.verifyFailedObjects, objectID) recoverFailedObjectsCount-- } continue } - + // the object might have been deleted or discontinued _, err = s.manager.baseApp.Consensus().QueryObjectInfoByID(context.Background(), util.Uint64ToString(objectID)) if err != nil { log.Errorw("failed to get object info from chain", "object_id", objectID, "error", err) @@ -580,8 +601,9 @@ func (s *VerifyGVGScheduler) Start() { } continue } + if recoverFailedObject.RetryTime < maxRecoveryRetry { - log.Errorw("object has not been recovered yet", "object_id", objectID, "retry", recoverFailedObject.RetryTime, "max_recovery_retry", maxRecoveryRetry) + log.Infow("object is sill being recovered", "object_id", objectID, "retry", recoverFailedObject.RetryTime, "max_recovery_retry", maxRecoveryRetry) continue } // if an object exceeds the max recover retry, will not process further, the SP should manually trigger the discontinue object tx. @@ -666,6 +688,7 @@ func (s *VerifyGVGScheduler) Start() { } } + nextStartAfter := objects[len(objects)-1].Object.ObjectInfo.Id.Uint64() for _, o := range objects { objectInfo := o.Object.ObjectInfo objectID := objectInfo.Id.Uint64() @@ -695,8 +718,7 @@ func (s *VerifyGVGScheduler) Start() { } s.verifySuccessObjects[o.Object.ObjectInfo.Id.Uint64()] = struct{}{} } - - s.curStartAfter = s.curStartAfter + uint64(verifyGVGQueryLimit) + s.curStartAfter = nextStartAfter } } diff --git a/store/sqldb/exit_recover.go b/store/sqldb/exit_recover.go index 256bdf5d3..7c9bbea81 100644 --- a/store/sqldb/exit_recover.go +++ b/store/sqldb/exit_recover.go @@ -19,6 +19,7 @@ func (s *SpDBImpl) GetRecoverGVGStats(gvgID uint32) (*spdb.RecoverGVGStats, erro RedundancyIndex: queryReturn.RedundancyIndex, Status: spdb.RecoverStatus(queryReturn.Status), StartAfter: queryReturn.StartAfter, + NextStartAfter: queryReturn.NextStartAfter, Limit: uint64(queryReturn.Limit), ObjectCount: queryReturn.ObjectCount, }, nil @@ -38,6 +39,7 @@ func (s *SpDBImpl) BatchGetRecoverGVGStats(gvgIDs []uint32) ([]*spdb.RecoverGVGS VirtualGroupID: ret.VirtualGroupID, RedundancyIndex: ret.RedundancyIndex, StartAfter: ret.StartAfter, + NextStartAfter: ret.NextStartAfter, Status: spdb.RecoverStatus(ret.Status), Limit: uint64(ret.Limit), ObjectCount: ret.ObjectCount, @@ -54,6 +56,7 @@ func (s *SpDBImpl) SetRecoverGVGStats(stats []*spdb.RecoverGVGStats) error { VirtualGroupID: g.VirtualGroupID, RedundancyIndex: g.RedundancyIndex, StartAfter: g.StartAfter, + NextStartAfter: g.NextStartAfter, Limit: uint32(g.Limit), Status: int(g.Status), } @@ -73,9 +76,10 @@ func (s *SpDBImpl) SetRecoverGVGStats(stats []*spdb.RecoverGVGStats) error { func (s *SpDBImpl) UpdateRecoverGVGStats(stats *spdb.RecoverGVGStats) (err error) { result := s.db.Table(RecoverGVGStatsTableName).Where("virtual_group_id = ?", stats.VirtualGroupID). Updates(&RecoverGVGStatsTable{ - Status: int(stats.Status), - StartAfter: stats.StartAfter, - ObjectCount: stats.ObjectCount, + Status: int(stats.Status), + StartAfter: stats.StartAfter, + NextStartAfter: stats.NextStartAfter, + ObjectCount: stats.ObjectCount, }) if result.Error != nil { return fmt.Errorf("failed to update the GVG status for recover_stats table: %s", result.Error) diff --git a/store/sqldb/exit_recover_schema.go b/store/sqldb/exit_recover_schema.go index a702f7fed..a6c0068f1 100644 --- a/store/sqldb/exit_recover_schema.go +++ b/store/sqldb/exit_recover_schema.go @@ -5,6 +5,7 @@ type RecoverGVGStatsTable struct { VirtualGroupFamilyID uint32 RedundancyIndex int32 `gorm:"index:redundancy_index"` StartAfter uint64 + NextStartAfter uint64 Limit uint32 Status int ObjectCount uint64 From cc98ac735360305c4d3cdccbd14a20d15e37e651 Mon Sep 17 00:00:00 2001 From: constwz <122766871+constwz@users.noreply.github.com> Date: Fri, 5 Jan 2024 16:19:37 +0800 Subject: [PATCH 08/27] perf:query empty vgf recover process (#1293) --- cmd/command/swap_in.go | 34 +++++++++++++++++++++++++++- modular/manager/manager.go | 3 +++ modular/manager/recover_scheduler.go | 8 +++++++ 3 files changed, 44 insertions(+), 1 deletion(-) diff --git a/cmd/command/swap_in.go b/cmd/command/swap_in.go index 237e87ccd..b8af3c49a 100644 --- a/cmd/command/swap_in.go +++ b/cmd/command/swap_in.go @@ -316,14 +316,46 @@ func QueryRecoverProcessAction(ctx *cli.Context) error { println(err.Error()) return err } - spClient := utils.MakeGfSpClient(cfg) + gvgID := ctx.Uint64(gvgIDFlag.Name) gvgfID := ctx.Uint64(vgfIDFlag.Name) + + if gvgfID != 0 { + // get client + chainClient, err := utils.MakeGnfd(cfg) + if err != nil { + println(err.Error()) + return err + } + familyInfo, err := chainClient.QueryVirtualGroupFamily(ctx.Context, uint32(gvgfID)) + if err != nil { + println(err.Error()) + return err + } + + if len(familyInfo.GetGlobalVirtualGroupIds()) == 0 { + spInfo, err := chainClient.QuerySP(ctx.Context, cfg.SpAccount.SpOperatorAddress) + if err != nil { + println(err.Error()) + return err + } + if familyInfo.GetPrimarySpId() == spInfo.GetId() { + println("recover gvg family complete") + return nil + } else { + println("please execute completeSwapIn cmd") + return nil + } + } + } + + spClient := utils.MakeGfSpClient(cfg) gvgstatsList, executing, err := spClient.QueryRecoverProcess(ctx.Context, uint32(gvgfID), uint32(gvgID)) if err != nil { println(err.Error()) return err } + if executing { println("Please Wait, recover executing") } else { diff --git a/modular/manager/manager.go b/modular/manager/manager.go index 64b687454..2a52cef6a 100644 --- a/modular/manager/manager.go +++ b/modular/manager/manager.go @@ -1008,6 +1008,9 @@ func (m *ManageModular) startRecoverSchedulers(vgfID, gvgID uint32, redundancyIn log.Errorw("failed to NewRecoverVGFScheduler", "error", err) return err } + if recoverVGFScheduler == nil { + return nil + } recoverFailedObjectScheduler := NewRecoverFailedObjectScheduler(m) m.recoverProcessCount.Store(int64(len(recoverVGFScheduler.RecoverSchedulers))) m.verifyTerminationSignal.Add(int64(len(recoverVGFScheduler.VerifySchedulers))) diff --git a/modular/manager/recover_scheduler.go b/modular/manager/recover_scheduler.go index a9f87ad8c..3e6bbb2d5 100644 --- a/modular/manager/recover_scheduler.go +++ b/modular/manager/recover_scheduler.go @@ -52,6 +52,14 @@ func NewRecoverVGFScheduler(m *ManageModular, vgfID uint32) (*RecoverVGFSchedule log.Errorw("vgf not exist") return nil, fmt.Errorf("vgf not exist") } + if len(vgf.GetGlobalVirtualGroupIds()) == 0 { + _, err = m.baseApp.GfSpClient().CompleteSwapIn(context.Background(), &types2.MsgCompleteSwapIn{ + GlobalVirtualGroupFamilyId: vgfID, + GlobalVirtualGroupId: 0, + StorageProvider: m.baseApp.OperatorAddress(), + }) + return nil, err + } recoveryGVG := make([]*spdb.RecoverGVGStats, 0, len(vgf.GetGlobalVirtualGroupIds())) gvgSchedulers := make([]*RecoverGVGScheduler, 0, len(vgf.GetGlobalVirtualGroupIds())) verifySchedulers := make([]*VerifyGVGScheduler, 0, len(vgf.GetGlobalVirtualGroupIds())) From 8928f5cc0227d7ec4da6726ef01ed3b01e0feff3 Mon Sep 17 00:00:00 2001 From: Alexxxxxx <118710506+alexgao001@users.noreply.github.com> Date: Tue, 9 Jan 2024 19:38:26 +0800 Subject: [PATCH 09/27] fix: recover scheduler set offset (#1296) --- modular/manager/recover_scheduler.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/modular/manager/recover_scheduler.go b/modular/manager/recover_scheduler.go index 3e6bbb2d5..241ef284d 100644 --- a/modular/manager/recover_scheduler.go +++ b/modular/manager/recover_scheduler.go @@ -691,12 +691,13 @@ func (s *VerifyGVGScheduler) Start() { } continue } else if recoverFailedObjectsCount == needDiscontinueCount { - log.Error("remaining objects need to be discontinue", "objects_count", needDiscontinueCount) + log.Errorw("remaining objects need to be discontinue", "objects_count", needDiscontinueCount) return } + } else { + s.curStartAfter = objects[len(objects)-1].Object.ObjectInfo.Id.Uint64() } - nextStartAfter := objects[len(objects)-1].Object.ObjectInfo.Id.Uint64() for _, o := range objects { objectInfo := o.Object.ObjectInfo objectID := objectInfo.Id.Uint64() @@ -726,7 +727,6 @@ func (s *VerifyGVGScheduler) Start() { } s.verifySuccessObjects[o.Object.ObjectInfo.Id.Uint64()] = struct{}{} } - s.curStartAfter = nextStartAfter } } From 73c668d21defe92f400bd8285c48aa6dc02a2239 Mon Sep 17 00:00:00 2001 From: constwz <122766871+constwz@users.noreply.github.com> Date: Wed, 10 Jan 2024 13:37:48 +0800 Subject: [PATCH 10/27] perf:sp exit cmd print (#1297) --- cmd/command/swap_in.go | 61 ++++++++++++++++++++++++++-- modular/manager/manager.go | 10 +---- modular/manager/recover_scheduler.go | 2 +- 3 files changed, 61 insertions(+), 12 deletions(-) diff --git a/cmd/command/swap_in.go b/cmd/command/swap_in.go index b8af3c49a..d260c6220 100644 --- a/cmd/command/swap_in.go +++ b/cmd/command/swap_in.go @@ -14,6 +14,12 @@ import ( const swapInCommands = "SwapIn Commands" +const ( + ProcessStatus_Recovering = "Recovering" + ProcessStatus_Verifying = "Verifying" + ProcessStatus_Complete = "Successful" +) + var gvgIDFlag = &cli.Uint64Flag{ Name: "gvgId", Usage: "assign global virtual group id", @@ -140,6 +146,25 @@ var ListVirtualGroupFamiliesBySpIDCmd = &cli.Command{ Description: `get VirtualGroupFamily List By SpID`, } +type FailedRecoverObject struct { + ObjectId uint64 `protobuf:"varint,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"` + VirtualGroupId uint32 `protobuf:"varint,2,opt,name=virtual_group_id,json=virtualGroupId,proto3" json:"virtual_group_id,omitempty"` + RedundancyIndex int32 `protobuf:"varint,3,opt,name=redundancy_index,json=redundancyIndex,proto3" json:"redundancy_index,omitempty"` + RetryTime int32 `protobuf:"varint,4,opt,name=retry_time,json=retryTime,proto3" json:"retry_time,omitempty"` +} + +type ProcessResult struct { + VirtualGroupId uint32 `json:"virtual_group_id"` + VirtualGroupFamilyId uint32 `json:"virtual_group_family_id"` + RedundancyIndex int32 `json:"redundancy_index"` + StartAfter uint64 `json:"start_after"` + Limit uint64 `json:"limit"` + Status string `json:"status"` + ObjectCount uint64 `json:"object_count"` + FailedObjectTotalCount uint64 `json:"failed_object_total_count"` + RecoverFailedObject []*FailedRecoverObject `json:"recover_failed_object"` +} + func SwapInAction(ctx *cli.Context) error { cfg, err := utils.MakeConfig(ctx) if err != nil { @@ -362,12 +387,42 @@ func QueryRecoverProcessAction(ctx *cli.Context) error { println("recover progress：") } - res, err := json.Marshal(gvgstatsList) + result := make([]*ProcessResult, 0, len(gvgstatsList)) + for _, gvgStats := range gvgstatsList { + res := &ProcessResult{ + VirtualGroupId: gvgStats.VirtualGroupId, + VirtualGroupFamilyId: gvgStats.VirtualGroupFamilyId, + RedundancyIndex: gvgStats.RedundancyIndex, + StartAfter: gvgStats.StartAfter, + Limit: gvgStats.Limit, + ObjectCount: gvgStats.ObjectCount, + FailedObjectTotalCount: gvgStats.FailedObjectTotalCount, + RecoverFailedObject: make([]*FailedRecoverObject, 0, len(gvgStats.RecoverFailedObject)), + } + switch gvgStats.Status { + case 0: + res.Status = ProcessStatus_Recovering + case 1: + res.Status = ProcessStatus_Verifying + case 2: + res.Status = ProcessStatus_Complete + } + for _, obj := range gvgStats.RecoverFailedObject { + res.RecoverFailedObject = append(res.RecoverFailedObject, &FailedRecoverObject{ + ObjectId: obj.ObjectId, + VirtualGroupId: obj.VirtualGroupId, + RedundancyIndex: obj.RedundancyIndex, + RetryTime: obj.RetryTime, + }) + } + result = append(result, res) + } + resString, err := json.Marshal(result) if err != nil { println(err.Error()) return err } - println(string(res)) + println(string(resString)) // create file f, err := os.Create("recover_process.json") if err != nil { @@ -375,7 +430,7 @@ func QueryRecoverProcessAction(ctx *cli.Context) error { return err } - _, err = fmt.Fprintln(f, string(res)) + _, err = fmt.Fprintln(f, string(resString)) if err != nil { println(err.Error()) return err diff --git a/modular/manager/manager.go b/modular/manager/manager.go index 2a52cef6a..9cae00124 100644 --- a/modular/manager/manager.go +++ b/modular/manager/manager.go @@ -1054,12 +1054,6 @@ func (m *ManageModular) QueryRecoverProcess(ctx context.Context, vgfID, gvgID ui log.Errorw("failed to BatchGetRecoverGVGStats", "error", err) return nil, false, err } - // get failed total count - failedCount, err := m.baseApp.GfSpDB().CountRecoverFailedObject() - if err != nil { - log.Errorw("failed to CountRecoverFailedObject", "error", err) - return nil, false, err - } // get record retry time > 5 failedRecords, err := m.baseApp.GfSpDB().GetRecoverFailedObjectsByRetryTime(5) if err != nil { @@ -1089,10 +1083,10 @@ func (m *ManageModular) QueryRecoverProcess(ctx context.Context, vgfID, gvgID ui Limit: gvgStats.Limit, Status: int32(gvgStats.Status), ObjectCount: gvgStats.ObjectCount, - FailedObjectTotalCount: uint64(failedCount), + FailedObjectTotalCount: uint64(len(failedObjects)), RecoverFailedObject: failedObjects, }) } - flag := m.recoverProcessCount.Load() > 0 + flag := m.recoverProcessCount.Load() > 0 || m.verifyTerminationSignal.Load() > 0 return res, flag, nil } diff --git a/modular/manager/recover_scheduler.go b/modular/manager/recover_scheduler.go index 241ef284d..ff3a3c4e7 100644 --- a/modular/manager/recover_scheduler.go +++ b/modular/manager/recover_scheduler.go @@ -31,7 +31,7 @@ const ( verifyInterval = 10 * time.Second verifyGVGQueryLimit = uint32(100) - recoverFailedObjectInterval = 1 * time.Minute + recoverFailedObjectInterval = 30 * time.Second monitorRecoverTimeOut = float64(10) // 10 minute ) From b77bc5fe813dadf8adee97d7373d93236b6a2ac4 Mon Sep 17 00:00:00 2001 From: Chris Li Date: Wed, 10 Jan 2024 14:29:08 +0800 Subject: [PATCH 11/27] feat: clean HealthChecker's sp before addSP (#1295) --- base/gfspvgmgr/virtual_group_manager.go | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/base/gfspvgmgr/virtual_group_manager.go b/base/gfspvgmgr/virtual_group_manager.go index 2d4dfc5d3..a340ce087 100644 --- a/base/gfspvgmgr/virtual_group_manager.go +++ b/base/gfspvgmgr/virtual_group_manager.go @@ -321,6 +321,9 @@ func (vgm *virtualGroupManager) refreshGVGMeta(byChain bool) { sort.Slice(spList, func(i, j int) bool { return spList[i].Id < spList[j].Id }) + if vgm.healthChecker != nil { + vgm.healthChecker.cleanSPs() + } for _, sp := range spList { spMap[sp.Id] = sp if vgm.healthChecker != nil { @@ -662,6 +665,13 @@ func NewHealthChecker(chainClient consensus.Consensus) *HealthChecker { return &HealthChecker{sps: sps, unhealthySPs: unhealthySPs, chainClient: chainClient} } +func (checker *HealthChecker) cleanSPs() { + checker.mutex.Lock() + defer checker.mutex.Unlock() + + checker.sps = make(map[uint32]*sptypes.StorageProvider) +} + func (checker *HealthChecker) addSP(sp *sptypes.StorageProvider) { checker.mutex.Lock() defer checker.mutex.Unlock() @@ -748,9 +758,6 @@ func (checker *HealthChecker) checkAllSPHealth() { } if unhealthyCnt == 0 { // only update checker.sps and return, this is fast-path. - checker.mutex.Lock() - checker.sps = spTemp - checker.mutex.Unlock() log.Infow("there is no unhealthy sp, only update sps", "unhealthy_sps", checker.unhealthySPs, "sps", checker.sps, "unhealthy_sp_cnt", unhealthyCnt) return @@ -759,7 +766,6 @@ func (checker *HealthChecker) checkAllSPHealth() { // Only when more than defaultMinAvailableSPThreshold valid sp, the check is valid if len(spTemp)-unhealthyCnt >= 1+int(params.GetRedundantDataChunkNum()+params.GetRedundantParityChunkNum()) { checker.mutex.Lock() - checker.sps = spTemp checker.unhealthySPs = unhealthyTemp checker.mutex.Unlock() log.Infow("succeed to place these sp into unhealthy status", "unhealthy_sps", checker.unhealthySPs, @@ -772,6 +778,11 @@ func (checker *HealthChecker) checkAllSPHealth() { } func (checker *HealthChecker) checkSPHealth(sp *sptypes.StorageProvider) bool { + if !sp.IsInService() { + log.CtxInfow(context.Background(), "the sp is not in service,sp is treated as unhealthy", "sp", sp) + return false + } + ctxTimeout, cancel := context.WithTimeout(context.Background(), defaultSPCheckTimeout) defer cancel() endpoint := sp.GetEndpoint() From 7cfe8982e0f1633c7d337881f762ad2976b4a9ea Mon Sep 17 00:00:00 2001 From: Alexxxxxx <118710506+alexgao001@users.noreply.github.com> Date: Fri, 12 Jan 2024 14:46:39 +0800 Subject: [PATCH 12/27] fix: fix gvg not exist (#1300) --- modular/manager/task_retry_scheduler.go | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/modular/manager/task_retry_scheduler.go b/modular/manager/task_retry_scheduler.go index 97bd58468..84bbabc06 100644 --- a/modular/manager/task_retry_scheduler.go +++ b/modular/manager/task_retry_scheduler.go @@ -202,8 +202,27 @@ func (s *TaskRetryScheduler) retryReplicateTask(meta *spdb.UploadObjectMeta) err replicateTask = &gfsptask.GfSpReplicatePieceTask{} replicateTask.InitReplicatePieceTask(objectInfo, storageParams, s.manager.baseApp.TaskPriority(replicateTask), s.manager.baseApp.TaskTimeout(replicateTask, objectInfo.GetPayloadSize()), s.manager.baseApp.TaskMaxRetry(replicateTask)) - replicateTask.GlobalVirtualGroupId = meta.GlobalVirtualGroupID - replicateTask.SecondaryEndpoints = meta.SecondaryEndpoints + + // for objects that have been uploaded but not starting the replication yet, it doesn't have the GVG info the UploadObjectMeta, + // so it needs to pick one to start the replicate task. + if meta.GlobalVirtualGroupID == 0 { + bucketInfo, err := s.manager.baseApp.GfSpClient().GetBucketByBucketName(context.Background(), objectInfo.BucketName, true) + if err != nil || bucketInfo == nil { + log.Errorw("failed to get bucket by bucket name", "bucket", bucketInfo, "error", err) + return err + } + gvgMeta, err := s.manager.pickGlobalVirtualGroup(context.Background(), bucketInfo.BucketInfo.GlobalVirtualGroupFamilyId, storageParams) + log.Infow("pick global virtual group", "gvg_meta", gvgMeta, "error", err) + if err != nil { + return err + } + replicateTask.GlobalVirtualGroupId = gvgMeta.ID + replicateTask.SecondaryEndpoints = gvgMeta.SecondarySPEndpoints + } else { + replicateTask.GlobalVirtualGroupId = meta.GlobalVirtualGroupID + replicateTask.SecondaryEndpoints = meta.SecondaryEndpoints + } + err = s.manager.replicateQueue.Push(replicateTask) if err != nil { if errors.Is(err, gfsptqueue.ErrTaskQueueExceed) { From 88fd4f44f05ad3cd67e69e0528c23ac3c6e2b0ce Mon Sep 17 00:00:00 2001 From: Chris Li Date: Fri, 12 Jan 2024 02:02:35 -0500 Subject: [PATCH 13/27] fix: unhealthy sps clean bug (#1299) --- base/gfspvgmgr/virtual_group_manager.go | 21 +++++++++++++++------ deployment/localup/localup.sh | 1 + 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/base/gfspvgmgr/virtual_group_manager.go b/base/gfspvgmgr/virtual_group_manager.go index a340ce087..392264fb8 100644 --- a/base/gfspvgmgr/virtual_group_manager.go +++ b/base/gfspvgmgr/virtual_group_manager.go @@ -321,9 +321,6 @@ func (vgm *virtualGroupManager) refreshGVGMeta(byChain bool) { sort.Slice(spList, func(i, j int) bool { return spList[i].Id < spList[j].Id }) - if vgm.healthChecker != nil { - vgm.healthChecker.cleanSPs() - } for _, sp := range spList { spMap[sp.Id] = sp if vgm.healthChecker != nil { @@ -342,6 +339,13 @@ func (vgm *virtualGroupManager) refreshGVGMeta(byChain bool) { otherSPs: otherSPList, } // log.Infow("list sp info", "primary_sp", primarySP, "secondary_sps", secondarySPList, "sp_map", spMap) + // add other SP list into health checker, except self sp, self sp should always be healthy + if vgm.healthChecker != nil { + vgm.healthChecker.cleanSPs() + for _, sp := range otherSPList { + vgm.healthChecker.addSP(sp) + } + } if spID == 0 { log.Error("failed to refresh due to current sp is not in sp list") @@ -539,6 +543,7 @@ func (vgm *virtualGroupManager) releaseSPAndGVGLoop() { vgm.mutex.RUnlock() vgm.freezeSPPool.ReleaseSP() + vgm.mutex.RLock() aliveSP := make([]*sptypes.StorageProvider, 0) for _, sp := range vgm.spManager.otherSPs { @@ -751,20 +756,24 @@ func (checker *HealthChecker) checkAllSPHealth() { } } + // First clear the unhealthy sp to prevent the subsequent fast-path from causing the unhealthy sp to not be cleared + checker.mutex.Lock() + checker.unhealthySPs = make(map[uint32]*sptypes.StorageProvider) + checker.mutex.Unlock() params, err := checker.chainClient.QueryStorageParamsByTimestamp(context.Background(), time.Now().Unix()) if err != nil { log.Errorw("failed to query storage params from chain", "error", err) return } if unhealthyCnt == 0 { - // only update checker.sps and return, this is fast-path. - log.Infow("there is no unhealthy sp, only update sps", "unhealthy_sps", checker.unhealthySPs, + // quickly return, this is fast-path. + log.Infow("all SPs are healthy", "unhealthy_sps", checker.unhealthySPs, "sps", checker.sps, "unhealthy_sp_cnt", unhealthyCnt) return } // Only when more than defaultMinAvailableSPThreshold valid sp, the check is valid - if len(spTemp)-unhealthyCnt >= 1+int(params.GetRedundantDataChunkNum()+params.GetRedundantParityChunkNum()) { + if len(spTemp)-unhealthyCnt >= int(params.GetRedundantDataChunkNum()+params.GetRedundantParityChunkNum()) { checker.mutex.Lock() checker.unhealthySPs = unhealthyTemp checker.mutex.Unlock() diff --git a/deployment/localup/localup.sh b/deployment/localup/localup.sh index cca2c7662..70043c626 100644 --- a/deployment/localup/localup.sh +++ b/deployment/localup/localup.sh @@ -164,6 +164,7 @@ function make_config() { sed -i -e "s/GCZombiePieceObjectIDInterval = .*/GCZombiePieceObjectIDInterval = 5/g" config.toml sed -i -e "s/EnableTaskRetryScheduler = .*/EnableTaskRetryScheduler = true/g" config.toml sed -i -e "s/RejectUnsealThresholdSecond = .*/RejectUnsealThresholdSecond = 600/g" config.toml + sed -i -e "s/EnableHealthyChecker = .*/EnableHealthyChecker = true/g" config.toml echo "succeed to generate config.toml in "${sp_dir} cd - >/dev/null From 85d0b3121685323241cc2f83cb3d3d1de8c6ee47 Mon Sep 17 00:00:00 2001 From: Alexxxxxx <118710506+alexgao001@users.noreply.github.com> Date: Fri, 12 Jan 2024 16:09:35 +0800 Subject: [PATCH 14/27] chore: add changelog (#1302) --- CHANGELOG.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 69dcf87a0..f31a25e43 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,21 @@ # Changelog +## v1.2.4 +This release contains 2 bugfixes. + +BUGFIXES +* [#1230](https://github.com/bnb-chain/greenfield-storage-provider/pull/1230) fix: fix gvg not exist +* [#1299](https://github.com/bnb-chain/greenfield-storage-provider/pull/1299) fix: fix: unhealthy sps clean bug + +## v1.2.3 +This release contains 1 bugfix and 1 feature. + +BUGFIXES +* [#1289](https://github.com/bnb-chain/greenfield-storage-provider/pull/1289) fix: replicate failed sp idx not included in local task + +FEATURES +* [#1291](https://github.com/bnb-chain/greenfield-storage-provider/pull/1291) feat: add more log + ## v1.2.2 BUGFIXES * [#1284](https://github.com/bnb-chain/greenfield-storage-provider/pull/1284) fix: remove tags field when creating object/group/bucket From 95cac3872e958510253cd062e96e579d19ebbcb6 Mon Sep 17 00:00:00 2001 From: Chris Li Date: Fri, 12 Jan 2024 17:55:09 +0800 Subject: [PATCH 15/27] fix: fix sp unhealthy bug (#1304) --- base/gfspvgmgr/virtual_group_manager.go | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/base/gfspvgmgr/virtual_group_manager.go b/base/gfspvgmgr/virtual_group_manager.go index a340ce087..8e71deb43 100644 --- a/base/gfspvgmgr/virtual_group_manager.go +++ b/base/gfspvgmgr/virtual_group_manager.go @@ -676,9 +676,6 @@ func (checker *HealthChecker) addSP(sp *sptypes.StorageProvider) { checker.mutex.Lock() defer checker.mutex.Unlock() - if !sp.IsInService() { - return - } if _, exists := checker.sps[sp.GetId()]; !exists { checker.sps[sp.GetId()] = sp } @@ -697,7 +694,7 @@ func (checker *HealthChecker) isSPHealthy(spID uint32) bool { return true } } - log.CtxInfow(context.Background(), "the sp isn't exist in sps map, is treated as healthy", "sps", checker.sps, "unhealthy_sps", checker.unhealthySPs) + log.CtxInfow(context.Background(), "the sp isn't exist in sps map, is treated as healthy", "check_sp_id", spID, "sps", checker.sps, "unhealthy_sps", checker.unhealthySPs) return true } From 27c799c27459231a74129b28e05102e1307ecf70 Mon Sep 17 00:00:00 2001 From: Alexgao001 Date: Mon, 15 Jan 2024 13:42:24 +0800 Subject: [PATCH 16/27] fix: calibrate recover objects frequency --- modular/manager/recover_scheduler.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/modular/manager/recover_scheduler.go b/modular/manager/recover_scheduler.go index ff3a3c4e7..c26878847 100644 --- a/modular/manager/recover_scheduler.go +++ b/modular/manager/recover_scheduler.go @@ -27,13 +27,13 @@ const ( maxRecoveryRetry = 5 MaxRecoveryTime = 50 - recoverInterval = 30 * time.Second + recoverInterval = 10 * time.Second verifyInterval = 10 * time.Second verifyGVGQueryLimit = uint32(100) recoverFailedObjectInterval = 30 * time.Second - monitorRecoverTimeOut = float64(10) // 10 minute + monitorRecoverTimeOut = float64(5) // 10 minute ) type RecoverVGFScheduler struct { @@ -276,7 +276,7 @@ func (s *RecoverGVGScheduler) Start() { continue } - log.Infow("list objects in GVG", "start_after", gvgStats.StartAfter, "limit", limit, "object_num", len(objects)) + log.Infow("list objects in GVG", "gvg_id", gvgStats.VirtualGroupID, "start_after", gvgStats.StartAfter, "limit", limit, "object_num", len(objects)) if len(objects) == 0 { log.Infow("all objects in gvg have been processed", "start_after_object_id", gvgStats.StartAfter, "limit", limit) @@ -574,7 +574,7 @@ func (s *VerifyGVGScheduler) Start() { continue } - log.Infow("list objects in GVG", "start_after", s.curStartAfter, "limit", verifyGVGQueryLimit, "object_num", len(objects)) + log.Infow("list objects in GVG", "gvg_id", gvgStats.VirtualGroupID, "start_after", s.curStartAfter, "limit", verifyGVGQueryLimit, "object_num", len(objects)) // Once iterate all objects in GVG, check all recorded recover-failed objects have been recovered. // If there is any object that does not exceed the max retry, will re-start from the beginning object in GVG. From 5f55dfda43bf364e68ba3535c5e0aa790ba42ac2 Mon Sep 17 00:00:00 2001 From: Barry <122767193+BarryTong65@users.noreply.github.com> Date: Mon, 15 Jan 2024 14:41:43 +0800 Subject: [PATCH 17/27] feat: invalid object name (#1298) * feat: check invalid object name * fix: add UT --- modular/gater/admin_handler.go | 15 +++++++++++++++ modular/gater/admin_handler_test.go | 22 ++++++++++++++++++++++ modular/gater/errors.go | 6 ++++++ util/string.go | 26 ++++++++++++++++++++++++++ 4 files changed, 69 insertions(+) diff --git a/modular/gater/admin_handler.go b/modular/gater/admin_handler.go index 5ea7cec5a..2059cdf01 100644 --- a/modular/gater/admin_handler.go +++ b/modular/gater/admin_handler.go @@ -196,6 +196,21 @@ func (g *GateModular) getApprovalHandler(w http.ResponseWriter, r *http.Request) err = ErrValidateMsg return } + // This code block checks for unsupported or potentially risky formats in object names. + // The checks are essential for ensuring the security and compatibility of the object names within the system. + // 1. ".." in object names: Checked to prevent path traversal attacks which might access directories outside the intended scope. + // 2. Object name being "/": The root directory should not be used as an object name due to potential security risks and ambiguity. + // 3. "\\" in object names: Backslashes are checked because they are often not supported in UNIX-like file systems and can cause issues in path parsing. + // 4. SQL Injection patterns in object names: Ensures that the object name does not contain patterns that could be used for SQL injection attacks, maintaining the integrity of the database. + if strings.Contains(createObjectApproval.GetObjectName(), "..") || + createObjectApproval.GetObjectName() == "/" || + strings.Contains(createObjectApproval.GetObjectName(), "\\") || + util.IsSQLInjection(createObjectApproval.GetObjectName()) { + log.Errorw("failed to check object name", "object_approval_msg", + createObjectApproval, "error", err) + err = ErrInvalidObjectName + return + } if err = g.checkSPAndBucketStatus(reqCtx.Context(), createObjectApproval.GetBucketName(), createObjectApproval.Creator); err != nil { log.Errorw("create object approval failed to check sp and bucket status", "error", err) return diff --git a/modular/gater/admin_handler_test.go b/modular/gater/admin_handler_test.go index f92858ca9..95f2f28e8 100644 --- a/modular/gater/admin_handler_test.go +++ b/modular/gater/admin_handler_test.go @@ -601,6 +601,28 @@ func TestGateModular_getApprovalHandlerCreateObjectApproval(t *testing.T) { }, wantedResult: "gnfd msg validate error", }, + { + name: "failed to invalid object approval msg", + fn: func() *GateModular { + g := setup(t) + ctrl := gomock.NewController(t) + clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) + clientMock.EXPECT().VerifyGNFD1EddsaSignature(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), + gomock.Any()).Return(false, nil).Times(1) + g.baseApp.SetGfSpClient(clientMock) + return g + }, + request: func() *http.Request { + path := fmt.Sprintf("%s%s%s?%s=%s", scheme, testDomain, GetApprovalPath, ActionQuery, createObjectApprovalAction) + req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) + validExpiryDateStr := time.Now().Add(time.Hour * 60).Format(ExpiryDateFormat) + req.Header.Set(commonhttp.HTTPHeaderExpiryTimestamp, validExpiryDateStr) + req.Header.Set(GnfdAuthorizationHeader, "GNFD1-EDDSA,Signature=48656c6c6f20476f7068657221") + req.Header.Set(GnfdUnsignedApprovalMsgHeader, "0a7b0a20202263726561746f72223a2022307831433743384136363865323361454432393166373866433266336231383635416363383762364635222c0a2020226275636b65745f6e616d65223a20226d6f636b2d6275636b65742d6e616d65222c0a2020226f626a6563745f6e616d65223a202278783b73656c656374202a2066726f6d206f626a65637473222c0a2020227061796c6f61645f73697a65223a202230222c0a2020227669736962696c697479223a20225649534942494c4954595f545950455f494e4845524954222c0a202022636f6e74656e745f74797065223a20226170706c69636174696f6e2f6a736f6e222c0a2020227072696d6172795f73705f617070726f76616c223a207b0a2020202022657870697265645f686569676874223a20223130222c0a2020202022676c6f62616c5f7669727475616c5f67726f75705f66616d696c795f6964223a20302c0a2020202022736967223a206e756c6c0a20207d2c0a2020226578706563745f636865636b73756d73223a205b5d2c0a202022726564756e64616e63795f74797065223a2022524544554e44414e43595f45435f54595045220a7d0a") + return req + }, + wantedResult: "invalid object name", + }, { name: "failed to check sp and bucket status", fn: func() *GateModular { diff --git a/modular/gater/errors.go b/modular/gater/errors.go index 1eec00784..11a3b91ab 100644 --- a/modular/gater/errors.go +++ b/modular/gater/errors.go @@ -55,6 +55,12 @@ var ( ErrPrimaryMismatch = gfsperrors.Register(module.GateModularName, http.StatusNotAcceptable, 50041, "primary sp mismatch") ErrNotCreatedState = gfsperrors.Register(module.GateModularName, http.StatusBadRequest, 50042, "object has not been created state") ErrNotSealedState = gfsperrors.Register(module.GateModularName, http.StatusBadRequest, 50043, "object has not been sealed state") + // ErrInvalidObjectName is triggered in the following cases, indicating the object name is not compliant: + // 1. Contains "..": Suggests potential directory traversal. + // 2. Equals "/": Direct reference to the root directory, which is usually unsafe. + // 3. Contains "\": May indicate an attempt at illegal path or file operations, especially in Windows systems. + // 4. Fails SQL Injection Test (util.IsSQLInjection): Object name contains patterns that might be used for SQL injection, like ';select', 'xxx;insert', etc., or SQL comment patterns. + ErrInvalidObjectName = gfsperrors.Register(module.GateModularName, http.StatusBadRequest, 50044, "invalid object name") ) func ErrEncodeResponseWithDetail(detail string) *gfsperrors.GfSpError { diff --git a/util/string.go b/util/string.go index 88044bfcb..b575dbad7 100644 --- a/util/string.go +++ b/util/string.go @@ -4,6 +4,7 @@ import ( "encoding/hex" "errors" "math" + "regexp" "strconv" "strings" @@ -158,3 +159,28 @@ func StringArrayToUint32Slice(arr pq.StringArray) ([]uint32, error) { } return uint32Slice, nil } + +func IsSQLInjection(input string) bool { + // define patterns that may indicate SQL injection, especially those with a semicolon followed by common SQL keywords + patterns := []string{ + "(?i).*;.*select", // Matches any string with a semicolon followed by "select" + "(?i).*;.*insert", // Matches any string with a semicolon followed by "insert" + "(?i).*;.*update", // Matches any string with a semicolon followed by "update" + "(?i).*;.*delete", // Matches any string with a semicolon followed by "delete" + "(?i).*;.*drop", // Matches any string with a semicolon followed by "drop" + "(?i).*;.*alter", // Matches any string with a semicolon followed by "alter" + "/\\*.*\\*/", // Matches SQL block comment + } + + for _, pattern := range patterns { + matched, err := regexp.MatchString(pattern, input) + if err != nil { + return false + } + if matched { + return true + } + } + + return false +} From de2d6283af1de5e1ce02f33e62fa36056c18214f Mon Sep 17 00:00:00 2001 From: Alexxxxxx <118710506+alexgao001@users.noreply.github.com> Date: Tue, 16 Jan 2024 14:56:09 +0800 Subject: [PATCH 18/27] fix: fix health check (#1311) * fix: fix the health check * fix: fix commnet --- base/gfspvgmgr/virtual_group_manager.go | 43 ++++++++++--------------- modular/manager/manage_task.go | 1 + 2 files changed, 18 insertions(+), 26 deletions(-) diff --git a/base/gfspvgmgr/virtual_group_manager.go b/base/gfspvgmgr/virtual_group_manager.go index b72c06a69..7349565b7 100644 --- a/base/gfspvgmgr/virtual_group_manager.go +++ b/base/gfspvgmgr/virtual_group_manager.go @@ -34,7 +34,7 @@ const ( additionalGVGStakingStorageSize = uint64(1) * 1024 * 1024 * 1024 * 1024 // 1TB defaultSPCheckTimeout = 3 * time.Second - defaultSPHealthCheckerInterval = 5 * time.Second + defaultSPHealthCheckerInterval = 10 * time.Second httpStatusPath = "/status" emptyGVGSafeDeletePeriod = int64(60) * 60 * 24 @@ -338,10 +338,7 @@ func (vgm *virtualGroupManager) refreshGVGMeta(byChain bool) { // log.Infow("list sp info", "primary_sp", primarySP, "secondary_sps", secondarySPList, "sp_map", spMap) // add other SP list into health checker, except self sp, self sp should always be healthy if vgm.healthChecker != nil { - vgm.healthChecker.cleanSPs() - for _, sp := range otherSPList { - vgm.healthChecker.addSP(sp) - } + vgm.healthChecker.addAllSP(otherSPList) } if spID == 0 { @@ -666,19 +663,12 @@ func NewHealthChecker(chainClient consensus.Consensus) *HealthChecker { return &HealthChecker{sps: sps, unhealthySPs: unhealthySPs, chainClient: chainClient} } -func (checker *HealthChecker) cleanSPs() { +func (checker *HealthChecker) addAllSP(sps []*sptypes.StorageProvider) { checker.mutex.Lock() defer checker.mutex.Unlock() - checker.sps = make(map[uint32]*sptypes.StorageProvider) -} - -func (checker *HealthChecker) addSP(sp *sptypes.StorageProvider) { - checker.mutex.Lock() - defer checker.mutex.Unlock() - - if _, exists := checker.sps[sp.GetId()]; !exists { - checker.sps[sp.GetId()] = sp + for _, sp := range sps { + checker.sps[sp.Id] = sp } } @@ -688,10 +678,10 @@ func (checker *HealthChecker) isSPHealthy(spID uint32) bool { if sp, exists := checker.sps[spID]; exists { if _, unhealthyExists := checker.unhealthySPs[spID]; unhealthyExists { - log.CtxErrorw(context.Background(), "the sp is treated as unhealthy", "sps", checker.sps, "unhealthy_sps", checker.unhealthySPs, "sp", sp) + log.CtxErrorw(context.Background(), "the sp is treated as unhealthy", "sp", sp, "sps", checker.sps, "unhealthy_sps", checker.unhealthySPs) return false } else { - log.CtxInfow(context.Background(), "the sp isn't exist in unhealthy sp map, is treated as healthy", "sps", checker.sps, "unhealthy_sps", checker.unhealthySPs, "sp", sp) + log.CtxInfow(context.Background(), "the sp isn't exist in unhealthy sp map, is treated as healthy", "sp", sp, "sps", checker.sps, "unhealthy_sps", checker.unhealthySPs) return true } } @@ -746,18 +736,14 @@ func (checker *HealthChecker) checkAllSPHealth() { if !checker.checkSPHealth(sp) { unhealthyCnt++ unhealthyTemp[sp.GetId()] = sp + } else { + checker.mutex.Lock() + // an SP is removed from unhealthy pool only when it is confirmed back to normal + delete(checker.unhealthySPs, sp.Id) + checker.mutex.Unlock() } } - // First clear the unhealthy sp to prevent the subsequent fast-path from causing the unhealthy sp to not be cleared - checker.mutex.Lock() - checker.unhealthySPs = make(map[uint32]*sptypes.StorageProvider) - checker.mutex.Unlock() - params, err := checker.chainClient.QueryStorageParamsByTimestamp(context.Background(), time.Now().Unix()) - if err != nil { - log.Errorw("failed to query storage params from chain", "error", err) - return - } if unhealthyCnt == 0 { // quickly return, this is fast-path. log.Infow("all SPs are healthy", "unhealthy_sps", checker.unhealthySPs, @@ -765,6 +751,11 @@ func (checker *HealthChecker) checkAllSPHealth() { return } + params, err := checker.chainClient.QueryStorageParamsByTimestamp(context.Background(), time.Now().Unix()) + if err != nil { + log.Errorw("failed to query storage params from chain", "error", err) + return + } // Only when more than defaultMinAvailableSPThreshold valid sp, the check is valid if len(spTemp)-unhealthyCnt >= int(params.GetRedundantDataChunkNum()+params.GetRedundantParityChunkNum()) { checker.mutex.Lock() diff --git a/modular/manager/manage_task.go b/modular/manager/manage_task.go index bd9d8c633..434ffc818 100644 --- a/modular/manager/manage_task.go +++ b/modular/manager/manage_task.go @@ -252,6 +252,7 @@ func (m *ManageModular) HandleDoneResumableUploadObjectTask(ctx context.Context, startPickGVGTime := time.Now() gvgMeta, err := m.pickGlobalVirtualGroup(ctx, task.GetVirtualGroupFamilyId(), task.GetStorageParams()) + log.CtxInfow(ctx, "pick global virtual group", "time_cost", time.Since(startPickGVGTime).Seconds(), "gvg_meta", gvgMeta, "error", err) if err != nil { log.CtxErrorw(ctx, "failed to pick global virtual group", "time_cost", time.Since(startPickGVGTime).Seconds(), "error", err) return err From cde7a654aafeeb85df785ae369ceef109eac5e35 Mon Sep 17 00:00:00 2001 From: constwz <122766871+constwz@users.noreply.github.com> Date: Wed, 17 Jan 2024 15:13:44 +0800 Subject: [PATCH 19/27] perf: blocksyncer sql commit (#1312) * perf: blocksyncer sql commit --------- Co-authored-by: Alexxxxxx <118710506+alexgao001@users.noreply.github.com> --- base/gfspconfig/config.go | 1 + modular/blocksyncer/blocksyncer.go | 1 + modular/blocksyncer/blocksyncer_indexer.go | 58 ++++++++++++---------- modular/blocksyncer/blocksyncer_options.go | 6 ++- modular/blocksyncer/database/bucket.go | 2 - modular/manager/recover_scheduler.go | 10 ++-- 6 files changed, 45 insertions(+), 33 deletions(-) diff --git a/base/gfspconfig/config.go b/base/gfspconfig/config.go index cf5399b70..ff245ed45 100644 --- a/base/gfspconfig/config.go +++ b/base/gfspconfig/config.go @@ -259,6 +259,7 @@ type LogConfig struct { type BlockSyncerConfig struct { Modules []string `comment:"required"` Workers uint `comment:"required"` + CommitNumber uint64 `comment:"optional"` BsDBWriteAddress string `comment:"optional"` } diff --git a/modular/blocksyncer/blocksyncer.go b/modular/blocksyncer/blocksyncer.go index 9ef3a71b7..fcbcdd07f 100644 --- a/modular/blocksyncer/blocksyncer.go +++ b/modular/blocksyncer/blocksyncer.go @@ -38,6 +38,7 @@ const ( MaxHeightGapFactor = 4 ObjectsNumberOfShards = 64 MinChargeSize = 128000 + CommitNumber = 2000 ) type MigrateDBKey struct{} diff --git a/modular/blocksyncer/blocksyncer_indexer.go b/modular/blocksyncer/blocksyncer_indexer.go index 66bb3f35f..645fe7e72 100644 --- a/modular/blocksyncer/blocksyncer_indexer.go +++ b/modular/blocksyncer/blocksyncer_indexer.go @@ -7,8 +7,6 @@ import ( "sync/atomic" "time" - "gorm.io/gorm" - abci "github.com/cometbft/cometbft/abci/types" cometbfttypes "github.com/cometbft/cometbft/abci/types" coretypes "github.com/cometbft/cometbft/rpc/core/types" @@ -22,13 +20,14 @@ import ( "github.com/forbole/juno/v4/node" "github.com/forbole/juno/v4/parser" "github.com/forbole/juno/v4/types" + "gorm.io/gorm" localDB "github.com/bnb-chain/greenfield-storage-provider/modular/blocksyncer/database" "github.com/bnb-chain/greenfield-storage-provider/pkg/log" "github.com/bnb-chain/greenfield-storage-provider/pkg/metrics" ) -func NewIndexer(codec codec.Codec, proxy node.Node, db database.Database, modules []modules.Module, serviceName string) parser.Indexer { +func NewIndexer(codec codec.Codec, proxy node.Node, db database.Database, modules []modules.Module, serviceName string, commitNumber uint64) parser.Indexer { return &Impl{ codec: codec, Node: proxy, @@ -36,7 +35,7 @@ func NewIndexer(codec codec.Codec, proxy node.Node, db database.Database, module Modules: modules, ServiceName: serviceName, ProcessedHeight: 0, - eventTypeCount: 8, + CommitNumber: commitNumber, } } @@ -49,7 +48,7 @@ type Impl struct { LatestBlockHeight atomic.Value ProcessedHeight uint64 - eventTypeCount int + CommitNumber uint64 ServiceName string } @@ -184,31 +183,41 @@ func (i *Impl) Process(height uint64) error { sql: val, }) - finalSQL := "" - finalVal := make([]interface{}, 0) - for _, m := range allSQL { - for k, v := range m { - finalSQL += fmt.Sprintf("%s; ", k) - finalVal = append(finalVal, v...) - } - } - sqlCount := len(allSQL) - + log.Infof("height :%d tx count:%d sql count:%d", height, txCount, sqlCount) metrics.BlocksyncerLogicTime.Set(float64(time.Since(startTime).Milliseconds())) + step := 0 dbStartTime := time.Now() - tx := i.DB.Begin(context.TODO()) - if txErr := tx.Db.Session(&gorm.Session{DryRun: false}).Exec(finalSQL, finalVal...).Error; txErr != nil { - log.Errorw("failed to exec sql", "error", txErr) - tx.Rollback() - return txErr - } + for step < sqlCount { + finalSQL := "" + finalVal := make([]interface{}, 0) + left := step + right := step + int(i.CommitNumber) + if right > sqlCount { + right = sqlCount + } + for _, m := range allSQL[left:right] { + for k, v := range m { + finalSQL += fmt.Sprintf("%s; ", k) + finalVal = append(finalVal, v...) + } + } + tx := i.DB.Begin(context.TODO()) + if txErr := tx.Db.Session(&gorm.Session{DryRun: false}).Exec(finalSQL, finalVal...).Error; txErr != nil { + log.Errorw("failed to exec sql", "error", txErr) + tx.Rollback() + return txErr + } - if txErr := tx.Commit(); txErr != nil { - log.Errorw("failed to commit db", "error", txErr) - return txErr + if txErr := tx.Commit(); txErr != nil { + log.Errorw("failed to commit db", "error", txErr) + return txErr + } + step = right + log.Infof("%d - %d commit", left, right) } + metrics.BlocksyncerWriteDBTime.Set(float64(time.Since(dbStartTime).Milliseconds())) log.Infof("height :%d tx count:%d sql count:%d", height, txCount, sqlCount) metrics.BlockEventCount.Set(float64(sqlCount)) @@ -237,7 +246,6 @@ func (i *Impl) Process(height uint64) error { // SaveEpoch accept a block result data and persist basic info into db to record current sync progress func (i *Impl) SaveEpoch(block *coretypes.ResultBlock) (string, []interface{}) { - log.Infof(common.BytesToHash(block.BlockID.Hash).String()) return localDB.Cast(i.DB).SaveEpochToSQL(context.Background(), &models.Epoch{ OneRowId: true, BlockHeight: block.Block.Height, diff --git a/modular/blocksyncer/blocksyncer_options.go b/modular/blocksyncer/blocksyncer_options.go index f6d0d31cf..0b1b2339e 100644 --- a/modular/blocksyncer/blocksyncer_options.go +++ b/modular/blocksyncer/blocksyncer_options.go @@ -124,11 +124,15 @@ func (b *BlockSyncerModular) initClient(cfg *gfspconfig.GfSpConfig) error { } b.parserCtx = ctx log.Infof("blocksyncer dsn : %s", config.Cfg.Database.DSN) + commitNumber := uint64(CommitNumber) + if cfg.BlockSyncer.CommitNumber != 0 { + commitNumber = cfg.BlockSyncer.CommitNumber + } b.parserCtx.Indexer = NewIndexer(ctx.EncodingConfig.Marshaler, ctx.Node, ctx.Database, ctx.Modules, - b.Name()) + b.Name(), commitNumber) return nil } diff --git a/modular/blocksyncer/database/bucket.go b/modular/blocksyncer/database/bucket.go index f016f56e1..24703c94b 100644 --- a/modular/blocksyncer/database/bucket.go +++ b/modular/blocksyncer/database/bucket.go @@ -10,7 +10,6 @@ import ( "gorm.io/gorm" "gorm.io/gorm/clause" - "github.com/bnb-chain/greenfield-storage-provider/pkg/log" "github.com/bnb-chain/greenfield-storage-provider/store/bsdb" ) @@ -112,6 +111,5 @@ func (db *DB) UpdateChargeSizeToSQL(ctx context.Context, objectID common.Hash, b sql := `UPDATE buckets SET charge_size = charge_size %s CASE WHEN (CAST((SELECT payload_size FROM %s WHERE object_id = ?)AS DECIMAL(65,0)) < 128000) THEN CAST(128000 AS DECIMAL(65,0)) ELSE CAST((SELECT payload_size FROM %s WHERE object_id = ?) AS DECIMAL(65,0)) END WHERE bucket_name = ?` vars := []interface{}{objectID, objectID, bucketName} finalSql := fmt.Sprintf(sql, operation, tableName, tableName) - log.Infof("AddChargeSizeToSQL sql:%s", finalSql) return finalSql, vars } diff --git a/modular/manager/recover_scheduler.go b/modular/manager/recover_scheduler.go index c26878847..9848b9f72 100644 --- a/modular/manager/recover_scheduler.go +++ b/modular/manager/recover_scheduler.go @@ -23,17 +23,17 @@ import ( ) const ( - recoverBatchSize = 10 + recoverBatchSize = 50 maxRecoveryRetry = 5 MaxRecoveryTime = 50 recoverInterval = 10 * time.Second - verifyInterval = 10 * time.Second - verifyGVGQueryLimit = uint32(100) + verifyInterval = 3 * time.Second + verifyGVGQueryLimit = uint32(50) - recoverFailedObjectInterval = 30 * time.Second + recoverFailedObjectInterval = 20 * time.Second - monitorRecoverTimeOut = float64(5) // 10 minute + monitorRecoverTimeOut = float64(2) // 2 minute ) type RecoverVGFScheduler struct { From 66d3b3601535020118ac5c10b6dc78223e900745 Mon Sep 17 00:00:00 2001 From: Alexxxxxx <118710506+alexgao001@users.noreply.github.com> Date: Wed, 17 Jan 2024 17:50:40 +0800 Subject: [PATCH 20/27] fix: fix complete swap in (#1316) --- modular/manager/manager.go | 6 +- modular/manager/recover_scheduler.go | 136 ++++++++++++++++----------- 2 files changed, 83 insertions(+), 59 deletions(-) diff --git a/modular/manager/manager.go b/modular/manager/manager.go index 9cae00124..f73c1eaaf 100644 --- a/modular/manager/manager.go +++ b/modular/manager/manager.go @@ -1011,7 +1011,7 @@ func (m *ManageModular) startRecoverSchedulers(vgfID, gvgID uint32, redundancyIn if recoverVGFScheduler == nil { return nil } - recoverFailedObjectScheduler := NewRecoverFailedObjectScheduler(m) + recoverFailedObjectScheduler := NewRecoverFailedObjectScheduler(m, vgfID, gvgID) m.recoverProcessCount.Store(int64(len(recoverVGFScheduler.RecoverSchedulers))) m.verifyTerminationSignal.Add(int64(len(recoverVGFScheduler.VerifySchedulers))) go recoverVGFScheduler.Start() @@ -1022,8 +1022,8 @@ func (m *ManageModular) startRecoverSchedulers(vgfID, gvgID uint32, redundancyIn log.Errorw("failed to create RecoverGVGScheduler", "error", err) return err } - recoverFailedObjectScheduler := NewRecoverFailedObjectScheduler(m) - verifyScheduler, err := NewVerifyGVGScheduler(m, vgfID, gvgID, redundancyIndex) + recoverFailedObjectScheduler := NewRecoverFailedObjectScheduler(m, vgfID, gvgID) + verifyScheduler, err := NewVerifyGVGScheduler(m, gvgID, redundancyIndex) if err != nil { log.Errorw("failed to create VerifyGVGScheduler", "error", err) return err diff --git a/modular/manager/recover_scheduler.go b/modular/manager/recover_scheduler.go index 9848b9f72..5d8c903f8 100644 --- a/modular/manager/recover_scheduler.go +++ b/modular/manager/recover_scheduler.go @@ -81,7 +81,7 @@ func NewRecoverVGFScheduler(m *ManageModular, vgfID uint32) (*RecoverVGFSchedule } gvgSchedulers = append(gvgSchedulers, gvgScheduler) - verifyScheduler, err := NewVerifyGVGScheduler(m, vgfID, gvgID, piecestore.PrimarySPRedundancyIndex) + verifyScheduler, err := NewVerifyGVGScheduler(m, gvgID, piecestore.PrimarySPRedundancyIndex) if err != nil { log.Errorw("failed to create VerifyGVGScheduler", "vgf_id", vgfID, "gvg_id", gvgID, "error", err) return nil, err @@ -207,7 +207,6 @@ func (s *ObjectsSegmentsStats) isRecoverFailed(objectID uint64) bool { type RecoverGVGScheduler struct { manager *ManageModular currentBatchObjectIDs map[uint64]struct{} - vgfID uint32 gvgID uint32 redundancyIndex int32 } @@ -229,7 +228,6 @@ func NewRecoverGVGScheduler(m *ManageModular, vgfID, gvgID uint32, redundancyInd return &RecoverGVGScheduler{ manager: m, currentBatchObjectIDs: make(map[uint64]struct{}), - vgfID: vgfID, gvgID: gvgID, redundancyIndex: redundancyIndex, }, nil @@ -427,11 +425,15 @@ func (s *RecoverGVGScheduler) monitorBatch() { // A GVG is marked as completed from Processed only when all objects pass the verification. type RecoverFailedObjectScheduler struct { manager *ManageModular + vgfID uint32 + gvgID uint32 } -func NewRecoverFailedObjectScheduler(m *ManageModular) *RecoverFailedObjectScheduler { +func NewRecoverFailedObjectScheduler(m *ManageModular, vgfID, gvgID uint32) *RecoverFailedObjectScheduler { return &RecoverFailedObjectScheduler{ manager: m, + vgfID: vgfID, + gvgID: gvgID, } } @@ -449,8 +451,71 @@ func (s *RecoverFailedObjectScheduler) Start() { for range ticker.C { if s.manager.verifyTerminationSignal.Load() == 0 { - log.Errorw("all Verify process exited") - break + log.Infow("all Verify process exited") + if s.vgfID != 0 { + _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), s.vgfID, 0) + } else { + _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), 0, s.gvgID) + } + log.Debugw("query swapIn info", "vgf_id", s.vgfID, "gvg_id", s.gvgID, "error", err) + if err != nil { + if strings.Contains(err.Error(), "swap in info not exist") { + log.Infow("SwapIn is already completed", "vgf_id", s.vgfID, "gvg_id", s.gvgID) + return + } + continue + } + + var msgCompleteSwapIn *types2.MsgCompleteSwapIn + // confirmed vgf or gvg are all completed. + if s.vgfID != 0 { + vgf, err := s.manager.baseApp.Consensus().QueryVirtualGroupFamily(context.Background(), s.vgfID) + if err != nil { + log.Errorw("failed to query virtual group family", "vgf_id", s.vgfID, "error", err) + continue + } + gvgIDs := vgf.GetGlobalVirtualGroupIds() + if len(gvgIDs) == 0 { + log.Debugw("there is no gvg in family", "vgf", s.vgfID) + return + } + for _, gvgID := range gvgIDs { + gvgStats, err := s.manager.baseApp.GfSpDB().GetRecoverGVGStats(gvgID) + if err != nil { + log.Errorw("failed to get gvg stats", "err", err) + return + } + // if there is gvg not completed yet, should not send the complete swap in tx for vgf + if gvgStats.Status != spdb.Completed { + log.Errorw("the gvg is not completed yet", "gvg_id", gvgID) + return + } + } + msgCompleteSwapIn = &types2.MsgCompleteSwapIn{ + GlobalVirtualGroupFamilyId: s.vgfID, + } + } else { + gvgStats, err := s.manager.baseApp.GfSpDB().GetRecoverGVGStats(s.gvgID) + if err != nil { + log.Errorw("failed to get gvg stats", "err", err) + return + } + if gvgStats.Status != spdb.Completed { + log.Errorw("the gvg is not completed yet", "gvg_id", s.gvgID) + return + } + msgCompleteSwapIn = &types2.MsgCompleteSwapIn{ + GlobalVirtualGroupId: s.gvgID, + } + } + log.Infow("start to send complete swap in tx", "vgf_id", s.vgfID, "gvg_id", s.gvgID) + err := SendAndConfirmCompleteSwapInTx(s.manager.baseApp, msgCompleteSwapIn) + if err != nil { + log.Errorw("failed to send complete swap in", "complete_swap_in_msg", msgCompleteSwapIn, "error", err) + continue + } + log.Infow("succeed to complete swap in tx", "vgf_id", s.vgfID, "gvg_id", s.gvgID) + return } recoverFailedObjects, err := s.manager.baseApp.GfSpDB().GetRecoverFailedObjects(maxRecoveryRetry, recoverBatchSize) if err != nil { @@ -529,7 +594,6 @@ func (s *RecoverFailedObjectScheduler) Start() { // a recover GVG unit is marked as completed from Processed only when all objects pass the verification. type VerifyGVGScheduler struct { manager *ManageModular - vgfID uint32 gvgID uint32 redundancyIndex int32 curStartAfter uint64 @@ -537,10 +601,9 @@ type VerifyGVGScheduler struct { verifySuccessObjects map[uint64]struct{} // cache } -func NewVerifyGVGScheduler(m *ManageModular, vgfID, gvgID uint32, redundancyIndex int32) (*VerifyGVGScheduler, error) { +func NewVerifyGVGScheduler(m *ManageModular, gvgID uint32, redundancyIndex int32) (*VerifyGVGScheduler, error) { return &VerifyGVGScheduler{ manager: m, - vgfID: vgfID, gvgID: gvgID, redundancyIndex: redundancyIndex, verifyFailedObjects: make(map[uint64]struct{}), @@ -563,11 +626,14 @@ func (s *VerifyGVGScheduler) Start() { log.Errorw("failed to get recover gvg stats", "err", err) continue } + if gvgStats.Status == spdb.Completed { + log.Infow("this gvg has been verified", "gvg_id", s.gvgID) + return + } if gvgStats.Status != spdb.Processed { log.Infow("Wait for all objects in GVG to be processed") continue } - objects, err := s.manager.baseApp.GfSpClient().ListObjectsInGVG(context.Background(), gvgStats.VirtualGroupID, s.curStartAfter, verifyGVGQueryLimit) if err != nil { log.Errorw("failed to list object in GVG", "err", err) @@ -641,55 +707,13 @@ func (s *VerifyGVGScheduler) Start() { } if recoverFailedObjectsCount == 0 { - if s.vgfID != 0 { - _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), s.vgfID, 0) - } else { - _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), 0, s.gvgID) - } - log.Debugw("query swapIn info", "vgf_id", s.vgfID, "gvg_id", s.gvgID, "error", err) - if err != nil { - if strings.Contains(err.Error(), "swap in info not exist") { - log.Infow("SwapIn is already completed", "vgf_id", s.vgfID, "gvg_id", s.gvgID) - return - } - continue - } - log.Infow("start to send complete swap in tx", "vgf_id", s.vgfID, "gvg_id", s.gvgID) - var msgCompleteSwapIn *types2.MsgCompleteSwapIn - if s.vgfID != 0 { - msgCompleteSwapIn = &types2.MsgCompleteSwapIn{ - GlobalVirtualGroupFamilyId: s.vgfID, - } - } else { - msgCompleteSwapIn = &types2.MsgCompleteSwapIn{ - GlobalVirtualGroupId: s.gvgID, - } - } - err := SendAndConfirmCompleteSwapInTx(s.manager.baseApp, msgCompleteSwapIn) + gvgStats.Status = spdb.Completed + err = s.manager.baseApp.GfSpDB().UpdateRecoverGVGStats(gvgStats) if err != nil { - log.Errorw("failed to send complete swap in", "complete_swap_in_msg", msgCompleteSwapIn, "error", err) - continue - } - log.Info("succeed to complete swap in tx") - if s.vgfID != 0 { - _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), s.vgfID, 0) - } else { - _, err = s.manager.baseApp.Consensus().QuerySwapInInfo(context.Background(), 0, s.gvgID) - } - log.Debugw("query swapIn info", "vgf_id", s.vgfID, "gvg_id", s.gvgID, "error", err) - if err == nil { + log.Error("failed to update GVG stats to complete status", "gvgStats", gvgStats) continue } - if strings.Contains(err.Error(), "swap in info not exist") { - gvgStats.Status = spdb.Completed - err = s.manager.baseApp.GfSpDB().UpdateRecoverGVGStats(gvgStats) - if err != nil { - log.Error("failed to update GVG stats to complete status", "gvgStats", gvgStats) - continue - } - return - } - continue + return } else if recoverFailedObjectsCount == needDiscontinueCount { log.Errorw("remaining objects need to be discontinue", "objects_count", needDiscontinueCount) return From e50284cc6ae620c6d2b9e5a67b742080653c938f Mon Sep 17 00:00:00 2001 From: constwz <122766871+constwz@users.noreply.github.com> Date: Thu, 18 Jan 2024 10:59:42 +0800 Subject: [PATCH 21/27] fix: blocksyncer sequential processing (#1315) * fix: blocksyncer sequential processing --- modular/blocksyncer/blocksyncer.go | 8 +++++--- modular/blocksyncer/blocksyncer_indexer.go | 20 ++++++++++++++++---- modular/blocksyncer/blocksyncer_options.go | 2 ++ modular/blocksyncer/test/case.json | 7 ++++++- modular/blocksyncer/test/verify.go | 15 ++++++++++++++- 5 files changed, 43 insertions(+), 9 deletions(-) diff --git a/modular/blocksyncer/blocksyncer.go b/modular/blocksyncer/blocksyncer.go index fcbcdd07f..7232946bc 100644 --- a/modular/blocksyncer/blocksyncer.go +++ b/modular/blocksyncer/blocksyncer.go @@ -25,6 +25,7 @@ var ( ErrDSNNotSet = errors.New("dsn config is not set in environment") ErrBlockNotFound = errors.New("failed to get block from map need retry") ErrHandleEvent = errors.New("failed to handle event") + ErrEventNotFound = errors.New("failed to get event from tx map") ) const ( @@ -56,9 +57,10 @@ type BlockSyncerModular struct { // Read concurrency required global variables var ( - blockMap *sync.Map - eventMap *sync.Map - txMap *sync.Map + blockMap *sync.Map + eventMap *sync.Map + txMap *sync.Map + txHashMap *sync.Map RealTimeStart *atomic.Bool CatchEndBlock *atomic.Int64 diff --git a/modular/blocksyncer/blocksyncer_indexer.go b/modular/blocksyncer/blocksyncer_indexer.go index 645fe7e72..3230f5a60 100644 --- a/modular/blocksyncer/blocksyncer_indexer.go +++ b/modular/blocksyncer/blocksyncer_indexer.go @@ -93,6 +93,7 @@ func (i *Impl) Process(height uint64) error { var block *coretypes.ResultBlock var events *coretypes.ResultBlockResults var txs map[common.Hash][]abci.Event + var txHash tmtypes.Txs var err error realTimeMode := RealTimeStart.Load() @@ -113,6 +114,7 @@ func (i *Impl) Process(height uint64) error { return err } metrics.ChainRPCTime.Set(float64(time.Since(rpcStartTime).Milliseconds())) + txHash = block.Block.Data.Txs txs = make(map[common.Hash][]cometbfttypes.Event) for idx := 0; idx < len(events.TxsResults); idx++ { k := block.Block.Data.Txs[idx] @@ -123,10 +125,12 @@ func (i *Impl) Process(height uint64) error { blockAny, okb := blockMap.Load(heightKey) eventsAny, oke := eventMap.Load(heightKey) txsAny, okt := txMap.Load(heightKey) + txHashAny, okth := txHashMap.Load(heightKey) block, _ = blockAny.(*coretypes.ResultBlock) events, _ = eventsAny.(*coretypes.ResultBlockResults) txs, _ = txsAny.(map[common.Hash][]abci.Event) - if !okb || !oke || !okt { + txHash, _ = txHashAny.(tmtypes.Txs) + if !okb || !oke || !okt || !okth { log.Warnf("failed to get map data height: %d", height) return ErrBlockNotFound } @@ -157,7 +161,7 @@ func (i *Impl) Process(height uint64) error { } // 2. handle events in txs - sqls, err := i.ExportEventsInTxs(ctx, block, txs) + sqls, err := i.ExportEventsInTxs(ctx, block, txs, txHash) if err != nil { log.Errorf("failed to export events in txs: %s", err) return err @@ -232,6 +236,7 @@ func (i *Impl) Process(height uint64) error { blockMap.Delete(heightKey) eventMap.Delete(heightKey) txMap.Delete(heightKey) + txHashMap.Delete(heightKey) } // after each block height ends, clear the corresponding key value in ctx @@ -293,9 +298,15 @@ type TxHashEvent struct { } // ExportEventsInTxs accepts a slice of events in tx in order to save in database. -func (i *Impl) ExportEventsInTxs(ctx context.Context, block *coretypes.ResultBlock, txs map[common.Hash][]abci.Event) ([]map[string][]interface{}, error) { +func (i *Impl) ExportEventsInTxs(ctx context.Context, block *coretypes.ResultBlock, txs map[common.Hash][]abci.Event, txHash tmtypes.Txs) ([]map[string][]interface{}, error) { allSQL := make([]map[string][]interface{}, 0) - for k, v := range txs { + for _, t := range txHash { + k := common.BytesToHash(t.Hash()) + v, ok := txs[k] + if !ok { + log.Errorw("tx_hash:%v", k.String()) + return nil, ErrEventNotFound + } for _, event := range v { sqls, err := i.ExtractEvent(ctx, block, k, sdk.Event(event)) if err != nil { @@ -366,6 +377,7 @@ func (i *Impl) Processed(ctx context.Context, height uint64) (bool, error) { blockMap.Delete(heightKey) eventMap.Delete(heightKey) txMap.Delete(heightKey) + txHashMap.Delete(heightKey) } return ep.BlockHeight > int64(height), nil } diff --git a/modular/blocksyncer/blocksyncer_options.go b/modular/blocksyncer/blocksyncer_options.go index 0b1b2339e..cfc794cb1 100644 --- a/modular/blocksyncer/blocksyncer_options.go +++ b/modular/blocksyncer/blocksyncer_options.go @@ -50,6 +50,7 @@ func NewBlockSyncerModular(app *gfspapp.GfSpBaseApp, cfg *gfspconfig.GfSpConfig) blockMap = new(sync.Map) eventMap = new(sync.Map) txMap = new(sync.Map) + txHashMap = new(sync.Map) RealTimeStart = &atomic.Bool{} RealTimeStart.Store(false) @@ -344,6 +345,7 @@ func (b *BlockSyncerModular) fetchData(start, end uint64) { blockMap.Store(heightKey, block) eventMap.Store(heightKey, events) txMap.Store(heightKey, txs) + txHashMap.Store(heightKey, block.Block.Data.Txs) break } }(i) diff --git a/modular/blocksyncer/test/case.json b/modular/blocksyncer/test/case.json index 2a218f0d7..bf96ad32b 100644 --- a/modular/blocksyncer/test/case.json +++ b/modular/blocksyncer/test/case.json @@ -11,7 +11,7 @@ }, { "name": "delete bucket", - "block": "{\"block\":{\"header\":{\"height\":\"3\",\"time\":\"2023-08-24T17:09:07.49508671Z\"},\"data\":{\"txs\":[\"CvoBCvcBCiMvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ0NyZWF0ZUJ1Y2tldBLPAQoqMHg4NjljNDBkNDk2YTc5NjM0QkVmNDNhZjhFRWI4MTdGMmI4QTFDQjJjEihmdWxsLW5vZGUtdjEtYWNjMDAwMDAwMDA3Mi1idWMwMDAwMDAwMDAwGAIqKjB4MzM0NEVFYTlGQkQ3ZERBMWM3MWJhZTgzYkY3MjNDODVEOTRlODY1OTJJCPCeDBARGkF1QxEUgocG3uzLeeSImESkzZrlsD9RznBjdMSkQsbRKmAfhTBiV5VDpSpwCzOotaZcCcvH7+i8uGQ/hDw7g28EARJ2ClgKTQomL2Nvc21vcy5jcnlwdG8uZXRoLmV0aHNlY3AyNTZrMS5QdWJLZXkSIwohAjPGjCB4AldgyL0SXau5XO9VPOWF0Am7LH3CMogJhcwxEgUKAwjIBRg0EhoKFQoDQk5CEg4xMjAwMDAwMDAwMDAwMBDgEhpBJYtn8jCJvroTA72YUcY0CdkJlVth7xJvt+voqLZi+MlE845j+GX1tvXCpyCPQjcQHs7pibXQPImBrupKxENk5QA=\"]}}}", + "block": "{\"block\":{\"header\":{\"height\":\"3\",\"time\":\"2023-08-24T17:09:07.49508671Z\"},\"data\":{\"txs\":[]}}}", "block_results": "{\"height\":\"3\",\"end_block_events\":[{\"type\":\"greenfield.storage.EventDeleteBucket\",\"attributes\":[{\"key\":\"bucket_id\",\"value\":\"\\\"649851\\\"\",\"index\":true},{\"key\":\"bucket_name\",\"value\":\"\\\"full-node-v1-acc0000000072-buc0000000000\\\"\",\"index\":true},{\"key\":\"global_virtual_group_family_id\",\"value\":\"17\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x3344EEa9FBD7dDA1c71bae83bF723C85D94e8659\\\"\",\"index\":true},{\"key\":\"owner\",\"value\":\"\\\"0x869c40d496a79634BEf43af8EEb817F2b8A1CB2c\\\"\",\"index\":true}]}]}" }, { @@ -313,5 +313,10 @@ "name": "delete and create same object in same block", "block": "{\"block\":{\"header\":{\"height\":\"63\",\"time\":\"2023-08-24T17:09:07.49508671Z\"},\"data\":{\"txs\":[\"CvoBCvcBCiMvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ0NyZWF0ZUJ1Y2tldBLPAQoqMHg4NjljNDBkNDk2YTc5NjM0QkVmNDNhZjhFRWI4MTdGMmI4QTFDQjJjEihmdWxsLW5vZGUtdjEtYWNjMDAwMDAwMDA3Mi1idWMwMDAwMDAwMDAwGAIqKjB4MzM0NEVFYTlGQkQ3ZERBMWM3MWJhZTgzYkY3MjNDODVEOTRlODY1OTJJCPCeDBARGkF1QxEUgocG3uzLeeSImESkzZrlsD9RznBjdMSkQsbRKmAfhTBiV5VDpSpwCzOotaZcCcvH7+i8uGQ/hDw7g28EARJ2ClgKTQomL2Nvc21vcy5jcnlwdG8uZXRoLmV0aHNlY3AyNTZrMS5QdWJLZXkSIwohAjPGjCB4AldgyL0SXau5XO9VPOWF0Am7LH3CMogJhcwxEgUKAwjIBRg0EhoKFQoDQk5CEg4xMjAwMDAwMDAwMDAwMBDgEhpBJYtn8jCJvroTA72YUcY0CdkJlVth7xJvt+voqLZi+MlE845j+GX1tvXCpyCPQjcQHs7pibXQPImBrupKxENk5QA=\"]}}}", "block_results": "{\"height\":\"63\",\"txs_results\":[{\"events\":[{\"type\":\"greenfield.storage.EventDeleteObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"cxz\\\"\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"0\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"1401\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"/coco/data/123.txt\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x3344EEa9FBD7dDA1c71bae83bF723C85D94e8659\\\"\",\"index\":true}]},{\"type\":\"greenfield.storage.EventCreateObject\",\"attributes\":[{\"key\":\"bucket_id\",\"value\":\"\\\"649851\\\"\",\"index\":true},{\"key\":\"bucket_name\",\"value\":\"\\\"cxz\\\"\",\"index\":true},{\"key\":\"checksums\",\"value\":\"[\\\"OpIu9mWQ9SuHkFIgqW3ZaHYQ5BtuXxd64+OocR/hA1c=\\\",\\\"SiUVQ+Te2cTyCaH+5dIa+yHOAwmQYaA6K/V3Nfb8gn4=\\\",\\\"vLW23p/VzslF7tNPdz3GQ/RUPyg2GN2a73sKTRzxvG8=\\\",\\\"vB2IRZJ+FzkzJDsJg7Kdkyz+eX6mRngll7gmkfKfkAE=\\\",\\\"e6OOvf7Kv+ZJSCyexotwYoN4hG6EG4ImK5uyGwO3fBg=\\\",\\\"XsGcWLUcDhTCyFCwdSSoCwTB+buKWbNWY3D0PHqeP7I=\\\",\\\"DBWKPxvZ3YBy4K++2U8lNcU9CtN2xIckgslcpS+ZbAk=\\\"]\",\"index\":true},{\"key\":\"content_type\",\"value\":\"\\\"application/octet-stream\\\"\",\"index\":true},{\"key\":\"create_at\",\"value\":\"\\\"1692577044\\\"\",\"index\":true},{\"key\":\"creator\",\"value\":\"\\\"0xC56259Acb9c37F96a4476875d486D478a32Dbc26\\\"\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"1501\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"/coco/data/123.txt\\\"\",\"index\":true},{\"key\":\"owner\",\"value\":\"\\\"0xC56259Acb9c37F96a4476875d486D478a32Dbc26\\\"\",\"index\":true},{\"key\":\"payload_size\",\"value\":\"\\\"1024\\\"\",\"index\":true},{\"key\":\"primary_sp_id\",\"value\":\"3\",\"index\":true},{\"key\":\"redundancy_type\",\"value\":\"\\\"REDUNDANCY_EC_TYPE\\\"\",\"index\":true},{\"key\":\"source_type\",\"value\":\"\\\"SOURCE_TYPE_ORIGIN\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_CREATED\\\"\",\"index\":true},{\"key\":\"visibility\",\"value\":\"\\\"VISIBILITY_TYPE_INHERIT\\\"\",\"index\":true}]}]}]}" + }, + { + "name": "create and seal in same block", + "block": "{\"block\":{\"header\":{\"height\":\"64\",\"time\":\"2024-01-17T06:18:31.636521739Z\"},\"data\":{\"txs\":[\"CpcCCpQCCiEvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ1NlYWxPYmplY3QS7gEKKjB4MDNBYmJFZThFNDI2Qzk4ODdBOGFlM0MzNDYwMkFiQ0E0MmFlREZhMBIVc2VsZi1jdXN0b2R5LWJ1Y2tldC03GkU1NWQyYjI3MzAxNjE0NTFlYjZmMjA2YjFhMGE3ODE3NS1kODYzMzkwNC1mMzRiLTQ5YmEtODhmOS04ZjM2NTZhMDkzOTAgCypglkUBON8qb+1WqHy67xy8AeijYOrZm1tAnky/9kp6vdjmAheXW4ChmO8wtlZ04c38EX0yUlT/xNQFk41aOqGIZ0ltUZv3lBxbtaC5H5JwJ010MbXLbQKIIE/7OmTBxlJOEnYKWgpNCiYvY29zbW9zLmNyeXB0by5ldGguZXRoc2VjcDI1NmsxLlB1YktleRIjCiECEwQrQI2xiJpqgXxl9dOIdkzKliO7+eh5tz/e4YLMQEISBQoDCMgFGIedEhIYChQKA0JOQhINNjAwMDAwMDAwMDAwMBAGGkEOtrLoypCQYaOAc8nEkPa0IAryNGIm5iXPXD7nsHIbPlA0UuUSlJJb0vpJcI2Idma1BeCt6bgbJF8+ostDaVA0AA==\",\"Co4ECosECiMvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ0NyZWF0ZU9iamVjdBLjAwoqMHhBNzNjREQxMkY4YTNjMzZBNmUwNEFlQmJkOGNDMjhiQTg3QzAzMjY2EhZzZWxmLWN1c3RvZHktYnVja2V0LTEwGkUyODcwNTI2MWNhM2I0MTQ2YjIwMTRhZjEwNjEyNDc2ZS01QUYwNDhDOS1DNjhFLTQyNjYtQkYyMy00MEREQ0E3RjU4OTcg+7MCKAMyGGFwcGxpY2F0aW9uL29jdGV0LXN0cmVhbTpICKuD0wEaQZQ6Pz+eUYWKynPleyQA6S//RZubv7RI/At2XO/QtlQeRL0Ftt0YyQ7ENU7ATZrRetgI5aw+lwKYtoub073X2YMBQiAhwbhQr3da+9aRT6f1BQjDcwLXkE/CBr53QUpjI/co+0IgccKEGppHMiO7WMhnb+s2ZxeP9bz34BuYLw9kVtLz56tCIEeNQhN1Gfigj+b5heYBpOLv49/y93LJQZyLmUJpvNFyQiDlwCcE4XtvD4bKgPZpBh+Z+MLfmqCmAl06zW7973GIQ0IgJ7Y2Cu2B19ztOEYfD77SM+Pv9RNC/TYl4oWcwEU0inBCIKUyypW703d17b2k3gQVH6imAFoRMKeIBh0I5UhhG86XQiBjUvhK1p9EeC/H567GYry8Qx6ijivuYLpgcbKOaVDrchJ3CloKTQomL2Nvc21vcy5jcnlwdG8uZXRoLmV0aHNlY3AyNTZrMS5QdWJLZXkSIwohAxgdFcED8jcw66vEaQe+TR0In87qYrHUyLLrRI6HxeiBEgUKAwjIBRiQwAESGQoUCgNCTkISDTYwMDAwMDAwMDAwMDAQsAkaQVoUaD8Z4AJ1QneyK9BvoGrbbpo07FNIViqEBJqmpocGEb/ZkkNeuSoFxKd7VH+q2llC9DTJrOP69+RUA/acqUkA\",\"CpgCCpUCCiEvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ1NlYWxPYmplY3QS7wEKKjB4MDNBYmJFZThFNDI2Qzk4ODdBOGFlM0MzNDYwMkFiQ0E0MmFlREZhMBIWc2VsZi1jdXN0b2R5LWJ1Y2tldC0xMBpFMjg3MDUyNjFjYTNiNDE0NmIyMDE0YWYxMDYxMjQ3NmUtNUFGMDQ4QzktQzY4RS00MjY2LUJGMjMtNDBERENBN0Y1ODk3IAwqYLIzi67giWyouUa/TVYRQ6ubehBqA7AsrsMujykcNJroYxnQ4KykIrOPd/pjMFMQfBZTBUid/odXjRyN3allHdkxRo99ivepKFT7wsiUZF7lkVi0DHVj6WKFS0qM5AOkmhJ2CloKTQomL2Nvc21vcy5jcnlwdG8uZXRoLmV0aHNlY3AyNTZrMS5QdWJLZXkSIwohAhMEK0CNsYiaaoF8ZfXTiHZMypYju/noebc/3uGCzEBCEgUKAwjIBRiInRISGAoUCgNCTkISDTYwMDAwMDAwMDAwMDAQBhpBOV6sOEYaSrHsS9i0UlIXBC4YkdYQbbjJ4yh8VuOehvIf9Q+Cl9qbbzf+OokDmpjyHE9H1DsyfGzWPWwNyamhVQE=\",\"Co0ECooECiMvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ0NyZWF0ZU9iamVjdBLiAwoqMHg0NjUzNzkwNjI3MWIyM0IxNUVhYThkMEUxY2MwZkMyRTE2M2U2RDA5EhVzZWxmLWN1c3RvZHktYnVja2V0LTkaRWY1MzZiYWY0MGZhMTRiMzQ4YTQ1MjY2OGQ1OTMzODhmLTU0OTM5MzdjLTcyMTgtNDJjYi1iZWM5LWM3MGJkOGI5OWQyMCDyrwIoAzIYYXBwbGljYXRpb24vb2N0ZXQtc3RyZWFtOkgIrYPTARpB5aiFvtklfemZ8bc+vaZ5/hj4hVfAZu7eimD0lsXpCOBc/vSkQjixkstEhmCqxssTukaqdVCr4za8T8ac3B6OgQBCIMgZjpHe5ymKMY3z4M8r+Oa8QT1qGvLRQtlVjVexOzlVQiC/xKSICavgZpm/4Ol8EXdDojCKSnxiSdnj9XdeUF2T9EIgoX1+Lp8XXnE1iDxb0H3CoMFwIRw/IRe/Pio1Hjd1i2RCIIXYeSZJDQYmkrsCFC0iqirPHsXjOsAI+CfiD8piqb0uQiAWePwX/UzwfH4AkNd4a7ZEAw8zld9+AZKtKbgJM84UOkIgBGLx/WOY7dP9TjcDCbJ20DJAEvK1T+0aXviK8f/NZdNCIMqP6gVlIxJLWD6M7vT1JV6EwGsE9MaksMaos/enVhtLEncKWgpNCiYvY29zbW9zLmNyeXB0by5ldGguZXRoc2VjcDI1NmsxLlB1YktleRIjCiEC76poUGfR9Uun6ccZVDT37IdW5XM76jvQd+Kq10hCRbkSBQoDCMgFGOLCARIZChQKA0JOQhINNjAwMDAwMDAwMDAwMBCwCRpBeUbLGxq39q36KEtg9wqEd1k44bxQyx6gUGssG4cuZupRojl2Fd52Ui5oVCQeaLjF4dC/r8e6EzMNo28tPmYucAA=\",\"CpcCCpQCCiEvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ1NlYWxPYmplY3QS7gEKKjB4MDNBYmJFZThFNDI2Qzk4ODdBOGFlM0MzNDYwMkFiQ0E0MmFlREZhMBIVc2VsZi1jdXN0b2R5LWJ1Y2tldC05GkVmNTM2YmFmNDBmYTE0YjM0OGE0NTI2NjhkNTkzMzg4Zi01NDkzOTM3Yy03MjE4LTQyY2ItYmVjOS1jNzBiZDhiOTlkMjAgCipgqPE+2qAOv3XfyFJ++aT701bx7olo1fWOxCiTNLJrCnhob6biKqoe/wTTnGUSoFNpAHtB7yt4BxX+VvwEvlq+noNCAuKz6p2fZ4q9JX0QClqUKivyCpJfx6YeZ+nrxNBIEnYKWgpNCiYvY29zbW9zLmNyeXB0by5ldGguZXRoc2VjcDI1NmsxLlB1YktleRIjCiECEwQrQI2xiJpqgXxl9dOIdkzKliO7+eh5tz/e4YLMQEISBQoDCMgFGImdEhIYChQKA0JOQhINNjAwMDAwMDAwMDAwMBAGGkF5p/79CcvBFc0LQI8Gx+N2a3fqjlEOOIuWL2aOPW0b0zZscxDuWKDgsIqop8mcqQ7qipUnQJvnJdnUQpujZGMbAQ==\",\"Co0ECooECiMvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ0NyZWF0ZU9iamVjdBLiAwoqMHhlZjQzQTgyNDBDQzIxMDE4NGRlQjg5NDUzMTI1NjFGQ2E5NTY5YTM3EhVzZWxmLWN1c3RvZHktYnVja2V0LTIaRWU3NjdlY2RmYzA5NTQyYTJhNTUyODliNzlmNWE4OTc3LWQ3MGUzNjU1LTFmNDEtNDUzZC05MzdhLWFkNjYzZDE3M2U4ZiDqrwIoAzIYYXBwbGljYXRpb24vb2N0ZXQtc3RyZWFtOkgIs4PTARpBkeU0eQ6w+tZHOsVCo+cAn+X+Egw05tWZn2qOVZTOjT1DQV4hr0OD2ww9oVqux2s76a8XqVHqTgEWaJQGgXFe8AFCIGxIHFWHbJhUTus487Vyk/Ru+JiV2WstqY30plsadzcbQiCGF7zWSOxpXREENfqCioY//PxvyuE6CKSFb5H0V1VMJkIgfv4xP12J2gJ6RuyFJZbrrCNfO0B41VLtIW9Nl7N5yEpCIDsF1AEkuBequo4s9oYEiOaskfbea0JUakB3KCIYC2i3QiB7CoKf5dV4rxcvzdBSC4H3kI3M88HUPOFblA16yP9MtUIggIJ1XmN7XLUbjpsy5Hj1575WKIp6vmvFoiEBFHIMm5RCIA49z3xQMDfw6VjT7Lo2DIz8U3cTVWBquCpwGVHUO5XYEncKWgpNCiYvY29zbW9zLmNyeXB0by5ldGguZXRoc2VjcDI1NmsxLlB1YktleRIjCiEDu0UYJOxAgvZklM2cHKw08Xz1YnDfSyHdHBVR1Bm4NrISBQoDCMgFGPbCARIZChQKA0JOQhINNjAwMDAwMDAwMDAwMBCwCRpBxhePwv8Ow6G6ps3p6Sk6h6rYFi88wjI0zTs/TdPDm0R479AMt/d7lxHq5cxEQCPJdsY5MNuos2srP94QtaRtNQA=\",\"CpcCCpQCCiEvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ1NlYWxPYmplY3QS7gEKKjB4MDNBYmJFZThFNDI2Qzk4ODdBOGFlM0MzNDYwMkFiQ0E0MmFlREZhMBIVc2VsZi1jdXN0b2R5LWJ1Y2tldC0yGkVlNzY3ZWNkZmMwOTU0MmEyYTU1Mjg5Yjc5ZjVhODk3Ny1kNzBlMzY1NS0xZjQxLTQ1M2QtOTM3YS1hZDY2M2QxNzNlOGYgDCpgtlzmHhsyx3FH4ggajmWy49HMzG6GkaVP9vtlCJuAmUA10Is43h5GjIQwT+pTIlZhD/+CFeAoSMJq22abdU51wjqa3UJYF/9OfzFv300aV4qaK5amTD0TF9O4hqfS8f8DEnYKWgpNCiYvY29zbW9zLmNyeXB0by5ldGguZXRoc2VjcDI1NmsxLlB1YktleRIjCiECEwQrQI2xiJpqgXxl9dOIdkzKliO7+eh5tz/e4YLMQEISBQoDCMgFGIqdEhIYChQKA0JOQhINNjAwMDAwMDAwMDAwMBAGGkFyEeLachnbV33llZDT+KZKOVk7svO6UhC6hJumXF0clybvZzay5u+OlgV4XerSaWYNGSl3FAuemgYQEc3fSGliAQ==\",\"Co0ECooECiMvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ0NyZWF0ZU9iamVjdBLiAwoqMHhkNzcwYkUzNjU3MDI5N0ViQzgwMjhEQjQ1ZUNkRjMxY2UyNTBhNDRkEhVzZWxmLWN1c3RvZHktYnVja2V0LTgaRTJlZjUxNzM0OWE3ZTRkMTNiYWIyNzE5YzE1NjJkZjdlLUREOTI0OEQwLUVERUUtNDc4NC1BNUY1LTU0OUU3ODk2NjlDMCD3swIoAzIYYXBwbGljYXRpb24vb2N0ZXQtc3RyZWFtOkgItoPTARpBFv+kJHUsFi7PGHLgIi3Yuf46BUvvD+IsM6evLMHxMGUG7FaQD19/Q3xkZ/zPKQmSVZVPsjAHRFTNc+obbkgLeQBCICoVt2jZHUodt3M0R7zKh7+o65WO1M3Gs00j2OzHE5yVQiBX5/enngQhUskcP7PUshBJHb5+bvzxGv3CxZogWpsn4UIgV2CmIiEAiVzlBl0tNKFIiWdQ5WLirSCHtS1Go0yQ9DFCINbzj6UcUJwuHGr+lirWetYfGFj+n1yzNhvT2Isp3y5yQiA+jfR3xfENQlEBUNFNsnmz4i4ELFDbriwTWUBVHei6DEIg8YXLP5NL+KoTW13AD7ywhAoWm4d4YWsoXAlSpYr8SJVCIMu3dHfmyMv9gGPcekbsKbQci6omWRx07BWjoTto/PyNEncKWgpNCiYvY29zbW9zLmNyeXB0by5ldGguZXRoc2VjcDI1NmsxLlB1YktleRIjCiEC16L+9H3zk+EeIQeIatk8DHsOAVwXA+xiXTHMC9S4wCsSBQoDCMgFGLPCARIZChQKA0JOQhINNjAwMDAwMDAwMDAwMBCwCRpB4+TTta+1YQqyyGLWyR9fXKMFNP/JsRjh5jLWLbzDrcRh2VhEAVQzb/DWfNBWxmvpJLMeBzT3vIyp1WefhxfioAE=\",\"CpcCCpQCCiEvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ1NlYWxPYmplY3QS7gEKKjB4MDNBYmJFZThFNDI2Qzk4ODdBOGFlM0MzNDYwMkFiQ0E0MmFlREZhMBIVc2VsZi1jdXN0b2R5LWJ1Y2tldC04GkUyZWY1MTczNDlhN2U0ZDEzYmFiMjcxOWMxNTYyZGY3ZS1ERDkyNDhEMC1FREVFLTQ3ODQtQTVGNS01NDlFNzg5NjY5QzAgAipglsqEHJosA7cgxfjT43riGYYMn2NRRTK3TvUkbPNT7k8hk863cEDs6PxDr6A6ONuNEcKnGpw8aCICq6cuyWAqqXVip85YDDL3v1APc6g4mR7N09zqvuXwhgv4Rt72dsh0EnYKWgpNCiYvY29zbW9zLmNyeXB0by5ldGguZXRoc2VjcDI1NmsxLlB1YktleRIjCiECEwQrQI2xiJpqgXxl9dOIdkzKliO7+eh5tz/e4YLMQEISBQoDCMgFGIudEhIYChQKA0JOQhINNjAwMDAwMDAwMDAwMBAGGkGBVy7SUTotP2VhoyF7ivJrb9iZNruMR32GezIp/ZR8MmQTW4pUaZm2OcZnquGg79xzO5eNbUFmYSlkqMO646soAA==\",\"Co0ECooECiMvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ0NyZWF0ZU9iamVjdBLiAwoqMHhhQ2U0MTg1NGY5QjFlQmMzYzU0YjI1NTk2MDViNDM0OEZhOTBENUFkEhVzZWxmLWN1c3RvZHktYnVja2V0LTQaRWJkZWIwNmE4ZjJiZDQ4M2ViMDYxNGQ1NzYwZDg0YWE0LTg0Y2M4ZjIwLTBhZjctNDdkMi04OGExLTJhYzA5OGJkYTQ2OCDmrwIoAzIYYXBwbGljYXRpb24vb2N0ZXQtc3RyZWFtOkgIuYPTARpBl7PPeMjAhb2mhxDXTVGev4GQsm+GI9MoEuRpF8oE+oMF2Kl90fyGmwzUEerxqsFfT9B1HpMoV+3auCn1NYbyYwFCIDDiQzoWYR4hahTUHtdPw9qU97woKuaPWdkTtHk9LPbZQiB9f8jHeVqq/xu4YlOfGA13nVx/Ea98JbiNvbZ1zgG43kIgGkABoB7ruyrO5W5cVMSb3npR3A5OwsbUsrSi3B+vSWhCIMz2+2xPplS7o6SpZaRCg6p+bXOgAtA4mwDMRLPa6bpVQiCpyayBx6MMJy5p6ackLFvhAU+3M88tJmdCp9fOpmbNN0IgNubwRYFTRDb6rgg/0tZDfGQdy+d8DOopNHHyzrHS1iZCILBDocYItYvhANAUVLi33FigtBndWUv9H2CuI3fMAXaLEncKWgpNCiYvY29zbW9zLmNyeXB0by5ldGguZXRoc2VjcDI1NmsxLlB1YktleRIjCiEDFZ2SUKc2wW+heq4ppk8DGhJN9o4mowCdi9keV+SYoDYSBQoDCMgFGNm+ARIZChQKA0JOQhINNjAwMDAwMDAwMDAwMBCwCRpBtR1ZG+Eh0Pa912o4d0Wb2wVxjizgv2bCURPN7HhTWxhGOILk7VvnZK+qSdIv6igqDji8o8byS8SUpomVejKqvgA=\",\"CpcCCpQCCiEvZ3JlZW5maWVsZC5zdG9yYWdlLk1zZ1NlYWxPYmplY3QS7gEKKjB4MDNBYmJFZThFNDI2Qzk4ODdBOGFlM0MzNDYwMkFiQ0E0MmFlREZhMBIVc2VsZi1jdXN0b2R5LWJ1Y2tldC00GkViZGViMDZhOGYyYmQ0ODNlYjA2MTRkNTc2MGQ4NGFhNC04NGNjOGYyMC0wYWY3LTQ3ZDItODhhMS0yYWMwOThiZGE0NjggDCpgptoo9keIcEGLxpFq4ctExRmdFqV/I4zuRUHqe4f7C306pjQ2J+XVQ0R4GP1c9FLnFGTFQNEydfIBRdSH5KcGTPrKqPQmxLcUJuJBPWLmitUZjNxVjpq5jQ5/l8XRBkQ+EnYKWgpNCiYvY29zbW9zLmNyeXB0by5ldGguZXRoc2VjcDI1NmsxLlB1YktleRIjCiECEwQrQI2xiJpqgXxl9dOIdkzKliO7+eh5tz/e4YLMQEISBQoDCMgFGIydEhIYChQKA0JOQhINNjAwMDAwMDAwMDAwMBAGGkF/1BsLHLw526ypw+OuABoXc7dNX5EPwABwvLPCsu7tZSjicJ5kHxXw8qzc0z6mFVkBX0n1c0tHhbh6vSK9UIOEAA==\"]}}}", + "block_results": "{\"height\":\"64\",\"txs_results\":[{\"events\":[{\"type\":\"greenfield.storage.EventCreateObject\",\"attributes\":[{\"key\":\"bucket_id\",\"value\":\"\\\"1583\\\"\",\"index\":true},{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"checksums\",\"value\":\"[\\\"IcG4UK93WvvWkU+n9QUIw3MC15BPwga+d0FKYyP3KPs=\\\",\\\"ccKEGppHMiO7WMhnb+s2ZxeP9bz34BuYLw9kVtLz56s=\\\",\\\"R41CE3UZ+KCP5vmF5gGk4u/j3/L3cslBnIuZQmm80XI=\\\",\\\"5cAnBOF7bw+GyoD2aQYfmfjC35qgpgJdOs1u/e9xiEM=\\\",\\\"J7Y2Cu2B19ztOEYfD77SM+Pv9RNC/TYl4oWcwEU0inA=\\\",\\\"pTLKlbvTd3XtvaTeBBUfqKYAWhEwp4gGHQjlSGEbzpc=\\\",\\\"Y1L4StafRHgvx+euxmK8vEMeoo4r7mC6YHGyjmlQ63I=\\\"]\",\"index\":true},{\"key\":\"content_type\",\"value\":\"\\\"application/octet-stream\\\"\",\"index\":true},{\"key\":\"create_at\",\"value\":\"\\\"1705472311\\\"\",\"index\":true},{\"key\":\"creator\",\"value\":\"\\\"0xA73cDD12F8a3c36A6e04AeBbd8cC28bA87C03266\\\"\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"0\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"owner\",\"value\":\"\\\"0xA73cDD12F8a3c36A6e04AeBbd8cC28bA87C03266\\\"\",\"index\":true},{\"key\":\"payload_size\",\"value\":\"\\\"39419\\\"\",\"index\":true},{\"key\":\"primary_sp_id\",\"value\":\"1\",\"index\":true},{\"key\":\"redundancy_type\",\"value\":\"\\\"REDUNDANCY_EC_TYPE\\\"\",\"index\":true},{\"key\":\"source_type\",\"value\":\"\\\"SOURCE_TYPE_ORIGIN\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_CREATED\\\"\",\"index\":true},{\"key\":\"visibility\",\"value\":\"\\\"VISIBILITY_TYPE_INHERIT\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"11\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"1\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"12\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"2\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"13\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"3\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"14\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"4\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"15\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"5\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"16\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"6\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"17\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"7\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"18\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"8\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"19\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"9\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]},{\"events\":[{\"type\":\"greenfield.storage.EventSealObject\",\"attributes\":[{\"key\":\"bucket_name\",\"value\":\"\\\"self-custody-bucket-10\\\"\",\"index\":true},{\"key\":\"global_virtual_group_id\",\"value\":\"20\",\"index\":true},{\"key\":\"local_virtual_group_id\",\"value\":\"10\",\"index\":true},{\"key\":\"object_id\",\"value\":\"\\\"308118\\\"\",\"index\":true},{\"key\":\"object_name\",\"value\":\"\\\"28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897\\\"\",\"index\":true},{\"key\":\"operator\",\"value\":\"\\\"0x03AbbEe8E426C9887A8ae3C34602AbCA42aeDFa0\\\"\",\"index\":true},{\"key\":\"status\",\"value\":\"\\\"OBJECT_STATUS_SEALED\\\"\",\"index\":true}]}]}]}" } ] \ No newline at end of file diff --git a/modular/blocksyncer/test/verify.go b/modular/blocksyncer/test/verify.go index 2260835aa..88b7f4eaa 100644 --- a/modular/blocksyncer/test/verify.go +++ b/modular/blocksyncer/test/verify.go @@ -27,7 +27,7 @@ var verifyFuncs = []func(t *testing.T, db *gorm.DB) error{ verify31, verify32, verify33, verify34, verify35, verify36, verify37, verify38, verify39, verify40, verify41, verify42, verify43, verify44, verify45, verify46, verify47, verify48, verify49, verify50, verify51, verify52, verify53, verify54, verify55, verify56, verify57, verify58, verify59, verify60, - verify61, verify62, verify63, + verify61, verify62, verify63, verify64, } func Verify(t *testing.T) error { @@ -660,6 +660,19 @@ func verify63(t *testing.T, db *gorm.DB) error { return nil } +func verify64(t *testing.T, db *gorm.DB) error { + table := GetObjectsTableName("self-custody-bucket-10") + var o models.Object + if err := db.Table(table).Where("bucket_name=? and object_name = ?", "self-custody-bucket-10", "28705261ca3b4146b2014af10612476e-5AF048C9-C68E-4266-BF23-40DDCA7F5897").Find(&o).Error; err != nil { + assert.NoError(t, err) + } + if o.LocalVirtualGroupId != 10 { + return errors.New("object status error") + } + + return nil +} + const ObjectsNumberOfShards = 64 const ObjectTableName = "objects" From 8703c41082ba1f0363de711d709a217dae5c5e79 Mon Sep 17 00:00:00 2001 From: Barry <122767193+BarryTong65@users.noreply.github.com> Date: Fri, 19 Jan 2024 11:34:22 +0800 Subject: [PATCH 22/27] fix: special object download issue (#1314) * fix: special object download issue --- modular/gater/helper_test.go | 13 ++++--- modular/gater/object_handler.go | 5 ++- modular/gater/object_handler_test.go | 57 +++++++++++++++++++++++++++- 3 files changed, 65 insertions(+), 10 deletions(-) diff --git a/modular/gater/helper_test.go b/modular/gater/helper_test.go index f683a6923..9ce7a97a4 100644 --- a/modular/gater/helper_test.go +++ b/modular/gater/helper_test.go @@ -8,12 +8,13 @@ import ( ) const ( - testDomain = "www.route-test.com" - scheme = "https://" - mockBucketName = "mock-bucket-name" - mockObjectName = "mock-object-name" - invalidBucketName = "1" - invalidObjectName = ".." + testDomain = "www.route-test.com" + scheme = "https://" + mockBucketName = "mock-bucket-name" + mockObjectName = "mock-object-name" + mockSpecialObjecttName = "?limit=1%2520--hello$world!~@#$%%^&*(){}:<>`test" + invalidBucketName = "1" + invalidObjectName = ".." ) var mockErr = errors.New("mock error") diff --git a/modular/gater/object_handler.go b/modular/gater/object_handler.go index 707c0e4c1..350c8edeb 100644 --- a/modular/gater/object_handler.go +++ b/modular/gater/object_handler.go @@ -5,6 +5,7 @@ import ( "encoding/xml" "fmt" "net/http" + "net/url" "strconv" "strings" "time" @@ -454,7 +455,7 @@ func (g *GateModular) getObjectHandler(w http.ResponseWriter, r *http.Request) { reqCtx.account = account.String() reqCtxErr = nil // default set content-disposition to download, if specified in query param as view, then set to view - w.Header().Set(ContentDispositionHeader, ContentDispositionAttachmentValue+"; filename=\""+reqCtx.objectName+"\"") + w.Header().Set(ContentDispositionHeader, ContentDispositionAttachmentValue+"; filename=\""+url.QueryEscape(reqCtx.objectName)+"\"") offChainAuthViewParam := queryParams.Get(OffChainAuthViewQuery) isView, _ := strconv.ParseBool(offChainAuthViewParam) if isView { @@ -942,7 +943,7 @@ func (g *GateModular) getObjectByUniversalEndpointHandler(w http.ResponseWriter, } if isDownload { - w.Header().Set(ContentDispositionHeader, ContentDispositionAttachmentValue+"; filename=\""+reqCtx.objectName+"\"") + w.Header().Set(ContentDispositionHeader, ContentDispositionAttachmentValue+"; filename=\""+url.QueryEscape(reqCtx.objectName)+"\"") } else { w.Header().Set(ContentDispositionHeader, ContentDispositionInlineValue) } diff --git a/modular/gater/object_handler_test.go b/modular/gater/object_handler_test.go index 744738274..335f3c24b 100644 --- a/modular/gater/object_handler_test.go +++ b/modular/gater/object_handler_test.go @@ -5,6 +5,7 @@ import ( "fmt" "net/http" "net/http/httptest" + "net/url" "strings" "testing" "time" @@ -2062,14 +2063,66 @@ func TestGateModular_getObjectByUniversalEndpointHandler(t *testing.T) { return g }, request: func() *http.Request { - path := fmt.Sprintf("%s%s/download/%s/%s", scheme, testDomain, mockBucketName, mockObjectName) + path := fmt.Sprintf("%s%s/download/%s/%s", scheme, testDomain, mockBucketName, url.QueryEscape(mockObjectName)) + req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) + req.Header.Set("User-Agent", "Chrome") + return req + }, + wantedResult: "", + wantedResponseHeader: map[string]string{ + ContentDispositionHeader: ContentDispositionAttachmentValue + "; filename=\"" + "mock-object-name" + "\"", + }, + }, + { + name: "download special name object", + fn: func() *GateModular { + g := setup(t) + ctrl := gomock.NewController(t) + clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) + clientMock.EXPECT().GetBucketByBucketName(gomock.Any(), gomock.Any(), gomock.Any()).Return( + &metadatatypes.Bucket{BucketInfo: &storagetypes.BucketInfo{}}, nil).Times(1) + clientMock.EXPECT().GetObjectMeta(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return( + &metadatatypes.Object{ObjectInfo: &storagetypes.ObjectInfo{ObjectStatus: storagetypes.OBJECT_STATUS_SEALED, Visibility: storagetypes.VISIBILITY_TYPE_PUBLIC_READ}}, + nil).Times(1) + var a = permissiontypes.EFFECT_ALLOW + clientMock.EXPECT().VerifyPermission(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()). + Return(&a, nil).Times(0) // public file, so no need to verify permission + clientMock.EXPECT().GetPiece(gomock.Any(), gomock.Any()).Return([]byte("a"), nil).AnyTimes() + g.baseApp.SetGfSpClient(clientMock) + + consensusMock := consensus.NewMockConsensus(ctrl) + consensusMock.EXPECT().QuerySP(gomock.Any(), gomock.Any()).Return(&sptypes.StorageProvider{Id: 1}, nil).Times(1) + consensusMock.EXPECT().QueryVirtualGroupFamily(gomock.Any(), gomock.Any()).Return( + &virtualgrouptypes.GlobalVirtualGroupFamily{PrimarySpId: 1}, nil).Times(1) + g.baseApp.SetConsensus(consensusMock) + + consensusMock.EXPECT().QueryObjectInfo(gomock.Any(), gomock.Any(), gomock.Any()).Return( + &storagetypes.ObjectInfo{ + Id: sdkmath.NewUint(1), + PayloadSize: 10, + }, nil).Times(1) + consensusMock.EXPECT().QueryBucketInfo(gomock.Any(), gomock.Any()).Return(&storagetypes.BucketInfo{ + Id: sdkmath.NewUint(2)}, nil).Times(1) + consensusMock.EXPECT().QueryStorageParamsByTimestamp(gomock.Any(), gomock.Any()).Return( + &storagetypes.Params{MaxPayloadSize: 10}, nil).Times(1) + g.baseApp.SetConsensus(consensusMock) + + pieceOpMock := piecestore.NewMockPieceOp(ctrl) + g.baseApp.SetPieceOp(pieceOpMock) + pieceOpMock.EXPECT().SegmentPieceCount(gomock.Any(), gomock.Any()).Return(uint32(1)).Times(1) + pieceOpMock.EXPECT().SegmentPieceKey(gomock.Any(), gomock.Any()).Return("test").AnyTimes() + + return g + }, + request: func() *http.Request { + path := fmt.Sprintf("%s%s/download/%s/%s", scheme, testDomain, mockBucketName, url.QueryEscape(mockSpecialObjecttName)) req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) req.Header.Set("User-Agent", "Chrome") return req }, wantedResult: "", wantedResponseHeader: map[string]string{ - ContentDispositionHeader: ContentDispositionAttachmentValue + "; filename=\"" + mockObjectName + "\"", + ContentDispositionHeader: ContentDispositionAttachmentValue + "; filename=\"" + "%3Flimit%3D1%252520--hello%24world%21~%40%23%24%25%25%5E%26%2A%28%29%7B%7D%3A%3C%3E%60test" + "\"", }, }, { From 15592c20c87cdd2bd9a1f11e984bcb9249b56523 Mon Sep 17 00:00:00 2001 From: Barry <122767193+BarryTong65@users.noreply.github.com> Date: Sat, 20 Jan 2024 11:08:18 +0800 Subject: [PATCH 23/27] fix: revert object commits (#1317) This reverts commit 5f55dfda43bf364e68ba3535c5e0aa790ba42ac2. --- modular/gater/admin_handler.go | 15 -------- modular/gater/admin_handler_test.go | 22 ----------- modular/gater/errors.go | 6 --- modular/gater/helper_test.go | 13 +++---- modular/gater/object_handler.go | 5 +-- modular/gater/object_handler_test.go | 57 +--------------------------- util/string.go | 26 ------------- 7 files changed, 10 insertions(+), 134 deletions(-) diff --git a/modular/gater/admin_handler.go b/modular/gater/admin_handler.go index 30e436c47..3e0fdce2d 100644 --- a/modular/gater/admin_handler.go +++ b/modular/gater/admin_handler.go @@ -200,21 +200,6 @@ func (g *GateModular) getApprovalHandler(w http.ResponseWriter, r *http.Request) err = ErrValidateMsg return } - // This code block checks for unsupported or potentially risky formats in object names. - // The checks are essential for ensuring the security and compatibility of the object names within the system. - // 1. ".." in object names: Checked to prevent path traversal attacks which might access directories outside the intended scope. - // 2. Object name being "/": The root directory should not be used as an object name due to potential security risks and ambiguity. - // 3. "\\" in object names: Backslashes are checked because they are often not supported in UNIX-like file systems and can cause issues in path parsing. - // 4. SQL Injection patterns in object names: Ensures that the object name does not contain patterns that could be used for SQL injection attacks, maintaining the integrity of the database. - if strings.Contains(createObjectApproval.GetObjectName(), "..") || - createObjectApproval.GetObjectName() == "/" || - strings.Contains(createObjectApproval.GetObjectName(), "\\") || - util.IsSQLInjection(createObjectApproval.GetObjectName()) { - log.Errorw("failed to check object name", "object_approval_msg", - createObjectApproval, "error", err) - err = ErrInvalidObjectName - return - } if err = g.checkSPAndBucketStatus(reqCtx.Context(), createObjectApproval.GetBucketName(), createObjectApproval.Creator); err != nil { log.Errorw("create object approval failed to check sp and bucket status", "error", err) return diff --git a/modular/gater/admin_handler_test.go b/modular/gater/admin_handler_test.go index c10527c11..d217dd0f7 100644 --- a/modular/gater/admin_handler_test.go +++ b/modular/gater/admin_handler_test.go @@ -601,28 +601,6 @@ func TestGateModular_getApprovalHandlerCreateObjectApproval(t *testing.T) { }, wantedResult: "gnfd msg validate error", }, - { - name: "failed to invalid object approval msg", - fn: func() *GateModular { - g := setup(t) - ctrl := gomock.NewController(t) - clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) - clientMock.EXPECT().VerifyGNFD1EddsaSignature(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), - gomock.Any()).Return(false, nil).Times(1) - g.baseApp.SetGfSpClient(clientMock) - return g - }, - request: func() *http.Request { - path := fmt.Sprintf("%s%s%s?%s=%s", scheme, testDomain, GetApprovalPath, ActionQuery, createObjectApprovalAction) - req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) - validExpiryDateStr := time.Now().Add(time.Hour * 60).Format(ExpiryDateFormat) - req.Header.Set(commonhttp.HTTPHeaderExpiryTimestamp, validExpiryDateStr) - req.Header.Set(GnfdAuthorizationHeader, "GNFD1-EDDSA,Signature=48656c6c6f20476f7068657221") - req.Header.Set(GnfdUnsignedApprovalMsgHeader, "0a7b0a20202263726561746f72223a2022307831433743384136363865323361454432393166373866433266336231383635416363383762364635222c0a2020226275636b65745f6e616d65223a20226d6f636b2d6275636b65742d6e616d65222c0a2020226f626a6563745f6e616d65223a202278783b73656c656374202a2066726f6d206f626a65637473222c0a2020227061796c6f61645f73697a65223a202230222c0a2020227669736962696c697479223a20225649534942494c4954595f545950455f494e4845524954222c0a202022636f6e74656e745f74797065223a20226170706c69636174696f6e2f6a736f6e222c0a2020227072696d6172795f73705f617070726f76616c223a207b0a2020202022657870697265645f686569676874223a20223130222c0a2020202022676c6f62616c5f7669727475616c5f67726f75705f66616d696c795f6964223a20302c0a2020202022736967223a206e756c6c0a20207d2c0a2020226578706563745f636865636b73756d73223a205b5d2c0a202022726564756e64616e63795f74797065223a2022524544554e44414e43595f45435f54595045220a7d0a") - return req - }, - wantedResult: "invalid object name", - }, { name: "failed to check sp and bucket status", fn: func() *GateModular { diff --git a/modular/gater/errors.go b/modular/gater/errors.go index 11a3b91ab..1eec00784 100644 --- a/modular/gater/errors.go +++ b/modular/gater/errors.go @@ -55,12 +55,6 @@ var ( ErrPrimaryMismatch = gfsperrors.Register(module.GateModularName, http.StatusNotAcceptable, 50041, "primary sp mismatch") ErrNotCreatedState = gfsperrors.Register(module.GateModularName, http.StatusBadRequest, 50042, "object has not been created state") ErrNotSealedState = gfsperrors.Register(module.GateModularName, http.StatusBadRequest, 50043, "object has not been sealed state") - // ErrInvalidObjectName is triggered in the following cases, indicating the object name is not compliant: - // 1. Contains "..": Suggests potential directory traversal. - // 2. Equals "/": Direct reference to the root directory, which is usually unsafe. - // 3. Contains "\": May indicate an attempt at illegal path or file operations, especially in Windows systems. - // 4. Fails SQL Injection Test (util.IsSQLInjection): Object name contains patterns that might be used for SQL injection, like ';select', 'xxx;insert', etc., or SQL comment patterns. - ErrInvalidObjectName = gfsperrors.Register(module.GateModularName, http.StatusBadRequest, 50044, "invalid object name") ) func ErrEncodeResponseWithDetail(detail string) *gfsperrors.GfSpError { diff --git a/modular/gater/helper_test.go b/modular/gater/helper_test.go index 9ce7a97a4..f683a6923 100644 --- a/modular/gater/helper_test.go +++ b/modular/gater/helper_test.go @@ -8,13 +8,12 @@ import ( ) const ( - testDomain = "www.route-test.com" - scheme = "https://" - mockBucketName = "mock-bucket-name" - mockObjectName = "mock-object-name" - mockSpecialObjecttName = "?limit=1%2520--hello$world!~@#$%%^&*(){}:<>`test" - invalidBucketName = "1" - invalidObjectName = ".." + testDomain = "www.route-test.com" + scheme = "https://" + mockBucketName = "mock-bucket-name" + mockObjectName = "mock-object-name" + invalidBucketName = "1" + invalidObjectName = ".." ) var mockErr = errors.New("mock error") diff --git a/modular/gater/object_handler.go b/modular/gater/object_handler.go index 350c8edeb..707c0e4c1 100644 --- a/modular/gater/object_handler.go +++ b/modular/gater/object_handler.go @@ -5,7 +5,6 @@ import ( "encoding/xml" "fmt" "net/http" - "net/url" "strconv" "strings" "time" @@ -455,7 +454,7 @@ func (g *GateModular) getObjectHandler(w http.ResponseWriter, r *http.Request) { reqCtx.account = account.String() reqCtxErr = nil // default set content-disposition to download, if specified in query param as view, then set to view - w.Header().Set(ContentDispositionHeader, ContentDispositionAttachmentValue+"; filename=\""+url.QueryEscape(reqCtx.objectName)+"\"") + w.Header().Set(ContentDispositionHeader, ContentDispositionAttachmentValue+"; filename=\""+reqCtx.objectName+"\"") offChainAuthViewParam := queryParams.Get(OffChainAuthViewQuery) isView, _ := strconv.ParseBool(offChainAuthViewParam) if isView { @@ -943,7 +942,7 @@ func (g *GateModular) getObjectByUniversalEndpointHandler(w http.ResponseWriter, } if isDownload { - w.Header().Set(ContentDispositionHeader, ContentDispositionAttachmentValue+"; filename=\""+url.QueryEscape(reqCtx.objectName)+"\"") + w.Header().Set(ContentDispositionHeader, ContentDispositionAttachmentValue+"; filename=\""+reqCtx.objectName+"\"") } else { w.Header().Set(ContentDispositionHeader, ContentDispositionInlineValue) } diff --git a/modular/gater/object_handler_test.go b/modular/gater/object_handler_test.go index 335f3c24b..744738274 100644 --- a/modular/gater/object_handler_test.go +++ b/modular/gater/object_handler_test.go @@ -5,7 +5,6 @@ import ( "fmt" "net/http" "net/http/httptest" - "net/url" "strings" "testing" "time" @@ -2063,66 +2062,14 @@ func TestGateModular_getObjectByUniversalEndpointHandler(t *testing.T) { return g }, request: func() *http.Request { - path := fmt.Sprintf("%s%s/download/%s/%s", scheme, testDomain, mockBucketName, url.QueryEscape(mockObjectName)) - req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) - req.Header.Set("User-Agent", "Chrome") - return req - }, - wantedResult: "", - wantedResponseHeader: map[string]string{ - ContentDispositionHeader: ContentDispositionAttachmentValue + "; filename=\"" + "mock-object-name" + "\"", - }, - }, - { - name: "download special name object", - fn: func() *GateModular { - g := setup(t) - ctrl := gomock.NewController(t) - clientMock := gfspclient.NewMockGfSpClientAPI(ctrl) - clientMock.EXPECT().GetBucketByBucketName(gomock.Any(), gomock.Any(), gomock.Any()).Return( - &metadatatypes.Bucket{BucketInfo: &storagetypes.BucketInfo{}}, nil).Times(1) - clientMock.EXPECT().GetObjectMeta(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return( - &metadatatypes.Object{ObjectInfo: &storagetypes.ObjectInfo{ObjectStatus: storagetypes.OBJECT_STATUS_SEALED, Visibility: storagetypes.VISIBILITY_TYPE_PUBLIC_READ}}, - nil).Times(1) - var a = permissiontypes.EFFECT_ALLOW - clientMock.EXPECT().VerifyPermission(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()). - Return(&a, nil).Times(0) // public file, so no need to verify permission - clientMock.EXPECT().GetPiece(gomock.Any(), gomock.Any()).Return([]byte("a"), nil).AnyTimes() - g.baseApp.SetGfSpClient(clientMock) - - consensusMock := consensus.NewMockConsensus(ctrl) - consensusMock.EXPECT().QuerySP(gomock.Any(), gomock.Any()).Return(&sptypes.StorageProvider{Id: 1}, nil).Times(1) - consensusMock.EXPECT().QueryVirtualGroupFamily(gomock.Any(), gomock.Any()).Return( - &virtualgrouptypes.GlobalVirtualGroupFamily{PrimarySpId: 1}, nil).Times(1) - g.baseApp.SetConsensus(consensusMock) - - consensusMock.EXPECT().QueryObjectInfo(gomock.Any(), gomock.Any(), gomock.Any()).Return( - &storagetypes.ObjectInfo{ - Id: sdkmath.NewUint(1), - PayloadSize: 10, - }, nil).Times(1) - consensusMock.EXPECT().QueryBucketInfo(gomock.Any(), gomock.Any()).Return(&storagetypes.BucketInfo{ - Id: sdkmath.NewUint(2)}, nil).Times(1) - consensusMock.EXPECT().QueryStorageParamsByTimestamp(gomock.Any(), gomock.Any()).Return( - &storagetypes.Params{MaxPayloadSize: 10}, nil).Times(1) - g.baseApp.SetConsensus(consensusMock) - - pieceOpMock := piecestore.NewMockPieceOp(ctrl) - g.baseApp.SetPieceOp(pieceOpMock) - pieceOpMock.EXPECT().SegmentPieceCount(gomock.Any(), gomock.Any()).Return(uint32(1)).Times(1) - pieceOpMock.EXPECT().SegmentPieceKey(gomock.Any(), gomock.Any()).Return("test").AnyTimes() - - return g - }, - request: func() *http.Request { - path := fmt.Sprintf("%s%s/download/%s/%s", scheme, testDomain, mockBucketName, url.QueryEscape(mockSpecialObjecttName)) + path := fmt.Sprintf("%s%s/download/%s/%s", scheme, testDomain, mockBucketName, mockObjectName) req := httptest.NewRequest(http.MethodGet, path, strings.NewReader("")) req.Header.Set("User-Agent", "Chrome") return req }, wantedResult: "", wantedResponseHeader: map[string]string{ - ContentDispositionHeader: ContentDispositionAttachmentValue + "; filename=\"" + "%3Flimit%3D1%252520--hello%24world%21~%40%23%24%25%25%5E%26%2A%28%29%7B%7D%3A%3C%3E%60test" + "\"", + ContentDispositionHeader: ContentDispositionAttachmentValue + "; filename=\"" + mockObjectName + "\"", }, }, { diff --git a/util/string.go b/util/string.go index b575dbad7..88044bfcb 100644 --- a/util/string.go +++ b/util/string.go @@ -4,7 +4,6 @@ import ( "encoding/hex" "errors" "math" - "regexp" "strconv" "strings" @@ -159,28 +158,3 @@ func StringArrayToUint32Slice(arr pq.StringArray) ([]uint32, error) { } return uint32Slice, nil } - -func IsSQLInjection(input string) bool { - // define patterns that may indicate SQL injection, especially those with a semicolon followed by common SQL keywords - patterns := []string{ - "(?i).*;.*select", // Matches any string with a semicolon followed by "select" - "(?i).*;.*insert", // Matches any string with a semicolon followed by "insert" - "(?i).*;.*update", // Matches any string with a semicolon followed by "update" - "(?i).*;.*delete", // Matches any string with a semicolon followed by "delete" - "(?i).*;.*drop", // Matches any string with a semicolon followed by "drop" - "(?i).*;.*alter", // Matches any string with a semicolon followed by "alter" - "/\\*.*\\*/", // Matches SQL block comment - } - - for _, pattern := range patterns { - matched, err := regexp.MatchString(pattern, input) - if err != nil { - return false - } - if matched { - return true - } - } - - return false -} From 7d326934ab45a6ca267cee256c0d950a10868dc4 Mon Sep 17 00:00:00 2001 From: constwz <122766871+constwz@users.noreply.github.com> Date: Mon, 22 Jan 2024 14:48:02 +0800 Subject: [PATCH 24/27] docs: release for v1.3.0 (#1318) --- CHANGELOG.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index f31a25e43..0a9f3d9db 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,16 @@ # Changelog +## v1.3.0 +This release contains 2 bugfix and 2 feature. + +BUGFIXES +* [#1304](https://github.com/bnb-chain/greenfield-storage-provider/pull/1304) fix: fix sp unhealthy bug +* [#1311](https://github.com/bnb-chain/greenfield-storage-provider/pull/1311) fix: fix health check + +FEATURES +* [#1279](https://github.com/bnb-chain/greenfield-storage-provider/pull/1279) feat: re-implementation of sp exit +* [#1312](https://github.com/bnb-chain/greenfield-storage-provider/pull/1312) perf: blocksyncer sql commit + ## v1.2.4 This release contains 2 bugfixes. From cd71b7e43e3712ebbd906c7efa026f5e64c01432 Mon Sep 17 00:00:00 2001 From: constwz <122766871+constwz@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:22:43 +0800 Subject: [PATCH 25/27] feat:update go mod (#1319) --- go.mod | 6 +++--- go.sum | 12 ++++++------ 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/go.mod b/go.mod index 71c45fcc2..495f44c6d 100644 --- a/go.mod +++ b/go.mod @@ -10,7 +10,7 @@ require ( github.com/aliyun/credentials-go v1.3.0 github.com/avast/retry-go/v4 v4.3.1 github.com/aws/aws-sdk-go v1.44.159 - github.com/bnb-chain/greenfield v1.2.1-0.20231222025347-fe3f98c6c389 + github.com/bnb-chain/greenfield v1.3.0 github.com/bnb-chain/greenfield-common/go v0.0.0-20230906132736-eb2f0efea228 github.com/bytedance/gopkg v0.0.0-20221122125632-68358b8ecec6 github.com/cometbft/cometbft v0.37.2 @@ -301,10 +301,10 @@ replace ( cosmossdk.io/api => github.com/bnb-chain/greenfield-cosmos-sdk/api v0.0.0-20231206043955-0855e0965bc8 cosmossdk.io/math => github.com/bnb-chain/greenfield-cosmos-sdk/math v0.0.0-20231206043955-0855e0965bc8 github.com/btcsuite/btcd => github.com/btcsuite/btcd v0.23.0 - github.com/cometbft/cometbft => github.com/bnb-chain/greenfield-cometbft v0.0.0-20231030090949-99ef7dbd1e62 + github.com/cometbft/cometbft => github.com/bnb-chain/greenfield-cometbft v1.1.0 github.com/cometbft/cometbft-db => github.com/bnb-chain/greenfield-cometbft-db v0.8.1-alpha.1 github.com/confio/ics23/go => github.com/cosmos/cosmos-sdk/ics23/go v0.8.0 - github.com/cosmos/cosmos-sdk => github.com/bnb-chain/greenfield-cosmos-sdk v1.0.2-0.20231214052136-c20e9a5452b6 + github.com/cosmos/cosmos-sdk => github.com/bnb-chain/greenfield-cosmos-sdk v1.3.0 github.com/cosmos/iavl => github.com/bnb-chain/greenfield-iavl v0.20.1 github.com/forbole/juno/v4 => github.com/bnb-chain/juno/v4 v4.0.0-20231212070215-5505a27a398b github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1 diff --git a/go.sum b/go.sum index 211d6c0de..3848bca44 100644 --- a/go.sum +++ b/go.sum @@ -176,16 +176,16 @@ github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816/go.mod h1:+zsy github.com/bits-and-blooms/bitset v1.2.0 h1:Kn4yilvwNtMACtf1eYDlG8H77R07mZSPbMjLyS07ChA= github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40/go.mod h1:8rLXio+WjiTceGBHIoTvn60HIbs7Hm7bcHjyrSqYB9c= -github.com/bnb-chain/greenfield v1.2.1-0.20231222025347-fe3f98c6c389 h1:BjhAqkUjUNr2vcbCM9henDP0M3GY9MY3YzBJi3ZGHcM= -github.com/bnb-chain/greenfield v1.2.1-0.20231222025347-fe3f98c6c389/go.mod h1:bDpt7BVbCEhqK9WdYnMQVhs3wsJjIyIMvEpchyvNavU= -github.com/bnb-chain/greenfield-cometbft v0.0.0-20231030090949-99ef7dbd1e62 h1:pakuREXV/XfWNwgsTXUQwYirem12Tt+2LGGHIar0z8o= -github.com/bnb-chain/greenfield-cometbft v0.0.0-20231030090949-99ef7dbd1e62/go.mod h1:43yICrTxu90VjEUpQN23bsqi9mua5m5sFQq/ekHwN9s= +github.com/bnb-chain/greenfield v1.3.0 h1:9CaqYIMsUS3RUk+FUMCpSKwJ2NG6ONFYfs6MtMFgrM8= +github.com/bnb-chain/greenfield v1.3.0/go.mod h1:0oHgLtcv1wbmIk6mncR/Fi/Y1ory+2zvxNLvG099Lhw= +github.com/bnb-chain/greenfield-cometbft v1.1.0 h1:jqnkDWIZW6f/rUn5/pE26YZMT9xzpp0qTswNy7FPRBk= +github.com/bnb-chain/greenfield-cometbft v1.1.0/go.mod h1:NZ2/ZJK2HYe3++0CsPiw4LTG6UrC6pH7fQ3VOz6pqJw= github.com/bnb-chain/greenfield-cometbft-db v0.8.1-alpha.1 h1:XcWulGacHVRiSCx90Q8Y//ajOrLNBQWR/KDB89dy3cU= github.com/bnb-chain/greenfield-cometbft-db v0.8.1-alpha.1/go.mod h1:ey1CiK4bYo1RBNJLRiVbYr5CMdSxci9S/AZRINLtppI= github.com/bnb-chain/greenfield-common/go v0.0.0-20230906132736-eb2f0efea228 h1:WywBaew30hZuqDTOQbkRV3uBg6XHjNIE1s3AXVXbG+8= github.com/bnb-chain/greenfield-common/go v0.0.0-20230906132736-eb2f0efea228/go.mod h1:K9jK80fbahciC+FAvrch8Qsbw9ZkvVgjfKsqrzPTAVA= -github.com/bnb-chain/greenfield-cosmos-sdk v1.0.2-0.20231214052136-c20e9a5452b6 h1:XO3cnv1E2vCSPfKw9467y3/8FL4r2XOI/h0C9NrFKTA= -github.com/bnb-chain/greenfield-cosmos-sdk v1.0.2-0.20231214052136-c20e9a5452b6/go.mod h1:Yrvq+J1Lsm7OHFX+M/AZWBTGt1TRHUTC4VYOMlvW3fs= +github.com/bnb-chain/greenfield-cosmos-sdk v1.3.0 h1:jgSxXxHyUNRfVqesuq8Zw6TkRMflY7u+x/bMq8i2ktc= +github.com/bnb-chain/greenfield-cosmos-sdk v1.3.0/go.mod h1:Yrvq+J1Lsm7OHFX+M/AZWBTGt1TRHUTC4VYOMlvW3fs= github.com/bnb-chain/greenfield-cosmos-sdk/api v0.0.0-20231206043955-0855e0965bc8 h1:mUMOeNo3K0SZvAhiOHNKW4mmkrhOphBF8tDUyK6e1tY= github.com/bnb-chain/greenfield-cosmos-sdk/api v0.0.0-20231206043955-0855e0965bc8/go.mod h1:vhsZxXE9tYJeYB5JR4hPhd6Pc/uPf7j1T8IJ7p9FdeM= github.com/bnb-chain/greenfield-cosmos-sdk/math v0.0.0-20231206043955-0855e0965bc8 h1:1Ud7itq03c4Q9h0kBpw1FYlWKN3kco8cgj59vdd50UQ= From e43d11790ce3e9c16a7df2aa8d6b0a4bcaf3513a Mon Sep 17 00:00:00 2001 From: constwz <122766871+constwz@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:31:49 +0800 Subject: [PATCH 26/27] fix:change log confilct (#1321) --- CHANGELOG.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0a9f3d9db..c7633b101 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,12 @@ FEATURES * [#1279](https://github.com/bnb-chain/greenfield-storage-provider/pull/1279) feat: re-implementation of sp exit * [#1312](https://github.com/bnb-chain/greenfield-storage-provider/pull/1312) perf: blocksyncer sql commit +## v1.2.5 +This release contains 1 bugfixes. + +BUGFIXES +* [#1305](https://github.com/bnb-chain/greenfield-storage-provider/pull/1305) fix: secondary SP might need to wait object meta due to latency + ## v1.2.4 This release contains 2 bugfixes. From b7eaa08275817841a826ff9d3f873bfecee1f0db Mon Sep 17 00:00:00 2001 From: constwz <122766871+constwz@users.noreply.github.com> Date: Mon, 22 Jan 2024 21:57:30 +0800 Subject: [PATCH 27/27] fix: confilct (#1323) * fix:change log confilct --------- Co-authored-by: Alexxxxxx <118710506+alexgao001@users.noreply.github.com>