move a collection of peer APIs to websockets (#18936)

cmd/peer-rest-client.go

@@ -408,133 +408,162 @@ func (client *peerRESTClient) GetAllBucketStats() (BucketStatsMap, error) {
 
 // LoadBucketMetadata - load bucket metadata
 func (client *peerRESTClient) LoadBucketMetadata(bucket string) error {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTBucket, bucket)
+	if conn == nil {
-	respBody, err := client.call(peerRESTMethodLoadBucketMetadata, values, nil, -1)
+		return nil
+	}
+	_, err := loadBucketMetadataHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
+		peerRESTBucket: bucket,
+	}))
 	if err != nil {
 		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 // DeleteBucketMetadata - Delete bucket metadata
 func (client *peerRESTClient) DeleteBucketMetadata(bucket string) error {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTBucket, bucket)
+	if conn == nil {
-	respBody, err := client.call(peerRESTMethodDeleteBucketMetadata, values, nil, -1)
+		return nil
+	}
+	_, err := deleteBucketMetadataHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
+		peerRESTBucket: bucket,
+	}))
 	if err != nil {
 		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 // DeletePolicy - delete a specific canned policy.
 func (client *peerRESTClient) DeletePolicy(policyName string) (err error) {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTPolicy, policyName)
+	if conn == nil {
-
+		return nil
-	respBody, err := client.call(peerRESTMethodDeletePolicy, values, nil, -1)
+	}
-	if err != nil {
+
-		return
+	_, err = deletePolicyHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
+		peerRESTPolicy: policyName,
+	}))
+	if err != nil {
+		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 // LoadPolicy - reload a specific canned policy.
 func (client *peerRESTClient) LoadPolicy(policyName string) (err error) {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTPolicy, policyName)
+	if conn == nil {
-
+		return nil
-	respBody, err := client.call(peerRESTMethodLoadPolicy, values, nil, -1)
+	}
-	if err != nil {
+
-		return
+	_, err = loadPolicyHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
+		peerRESTPolicy: policyName,
+	}))
+	if err != nil {
+		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 // LoadPolicyMapping - reload a specific policy mapping
 func (client *peerRESTClient) LoadPolicyMapping(userOrGroup string, userType IAMUserType, isGroup bool) error {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTUserOrGroup, userOrGroup)
+	if conn == nil {
-	values.Set(peerRESTUserType, strconv.Itoa(int(userType)))
+		return nil
-	if isGroup {
-		values.Set(peerRESTIsGroup, "")
 	}
 
-	respBody, err := client.call(peerRESTMethodLoadPolicyMapping, values, nil, -1)
+	_, err := loadPolicyMappingHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
+		peerRESTUserOrGroup: userOrGroup,
+		peerRESTUserType:    strconv.Itoa(int(userType)),
+		peerRESTIsGroup:     strconv.FormatBool(isGroup),
+	}))
 	if err != nil {
 		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 // DeleteUser - delete a specific user.
 func (client *peerRESTClient) DeleteUser(accessKey string) (err error) {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTUser, accessKey)
+	if conn == nil {
-
+		return nil
-	respBody, err := client.call(peerRESTMethodDeleteUser, values, nil, -1)
+	}
-	if err != nil {
+
-		return
+	_, err = deleteUserHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
+		peerRESTUser: accessKey,
+	}))
+	if err != nil {
+		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 // DeleteServiceAccount - delete a specific service account.
 func (client *peerRESTClient) DeleteServiceAccount(accessKey string) (err error) {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTUser, accessKey)
+	if conn == nil {
-
+		return nil
-	respBody, err := client.call(peerRESTMethodDeleteServiceAccount, values, nil, -1)
+	}
-	if err != nil {
+
-		return
+	_, err = deleteSvcActHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
+		peerRESTUser: accessKey,
+	}))
+	if err != nil {
+		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 // LoadUser - reload a specific user.
 func (client *peerRESTClient) LoadUser(accessKey string, temp bool) (err error) {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTUser, accessKey)
+	if conn == nil {
-	values.Set(peerRESTUserTemp, strconv.FormatBool(temp))
+		return nil
-
+	}
-	respBody, err := client.call(peerRESTMethodLoadUser, values, nil, -1)
+
-	if err != nil {
+	_, err = loadUserHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
-		return
+		peerRESTUser:     accessKey,
+		peerRESTUserTemp: strconv.FormatBool(temp),
+	}))
+	if err != nil {
+		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 // LoadServiceAccount - reload a specific service account.
 func (client *peerRESTClient) LoadServiceAccount(accessKey string) (err error) {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTUser, accessKey)
+	if conn == nil {
-
+		return nil
-	respBody, err := client.call(peerRESTMethodLoadServiceAccount, values, nil, -1)
+	}
-	if err != nil {
+
-		return
+	_, err = loadSvcActHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
+		peerRESTUser: accessKey,
+	}))
+	if err != nil {
+		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 // LoadGroup - send load group command to peers.
 func (client *peerRESTClient) LoadGroup(group string) error {
-	values := make(url.Values)
+	conn := client.gridConn()
-	values.Set(peerRESTGroup, group)
+	if conn == nil {
-	respBody, err := client.call(peerRESTMethodLoadGroup, values, nil, -1)
+		return nil
+	}
+
+	_, err := loadGroupHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{
+		peerRESTGroup: group,
+	}))
 	if err != nil {
 		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
@@ -591,15 +620,17 @@ func (client *peerRESTClient) BackgroundHealStatus() (madmin.BgHealState, error)
 
 // GetLocalDiskIDs - get a peer's local disks' IDs.
 func (client *peerRESTClient) GetLocalDiskIDs(ctx context.Context) (diskIDs []string) {
-	respBody, err := client.callWithContext(ctx, peerRESTMethodGetLocalDiskIDs, nil, nil, -1)
+	conn := client.gridConn()
+	if conn == nil {
+		return
+	}
+
+	resp, err := getLocalDiskIDsHandler.Call(ctx, conn, grid.NewMSS())
 	if err != nil {
-		return nil
+		return
 	}
-	defer xhttp.DrainBody(respBody)
+
-	if err = gob.NewDecoder(respBody).Decode(&diskIDs); err != nil {
+	return resp.IDs
-		return nil
-	}
-	return diskIDs
 }
 
 // GetMetacacheListing - get a new or existing metacache.
@@ -642,40 +673,52 @@ func (client *peerRESTClient) UpdateMetacacheListing(ctx context.Context, m meta
 }
 
 func (client *peerRESTClient) ReloadPoolMeta(ctx context.Context) error {
-	respBody, err := client.callWithContext(ctx, peerRESTMethodReloadPoolMeta, nil, nil, 0)
+	conn := client.gridConn()
+	if conn == nil {
+		return nil
+	}
+	_, err := reloadPoolMetaHandler.Call(ctx, conn, grid.NewMSSWith(map[string]string{}))
 	if err != nil {
 		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 func (client *peerRESTClient) StopRebalance(ctx context.Context) error {
-	respBody, err := client.callWithContext(ctx, peerRESTMethodStopRebalance, nil, nil, 0)
+	conn := client.gridConn()
+	if conn == nil {
+		return nil
+	}
+	_, err := stopRebalanceHandler.Call(ctx, conn, grid.NewMSSWith(map[string]string{}))
 	if err != nil {
 		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 func (client *peerRESTClient) LoadRebalanceMeta(ctx context.Context, startRebalance bool) error {
-	values := url.Values{}
+	conn := client.gridConn()
-	values.Set(peerRESTStartRebalance, strconv.FormatBool(startRebalance))
+	if conn == nil {
-	respBody, err := client.callWithContext(ctx, peerRESTMethodLoadRebalanceMeta, values, nil, 0)
+		return nil
+	}
+	_, err := loadRebalanceMetaHandler.Call(ctx, conn, grid.NewMSSWith(map[string]string{
+		peerRESTStartRebalance: strconv.FormatBool(startRebalance),
+	}))
 	if err != nil {
 		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 
 func (client *peerRESTClient) LoadTransitionTierConfig(ctx context.Context) error {
-	respBody, err := client.callWithContext(ctx, peerRESTMethodLoadTransitionTierConfig, nil, nil, 0)
+	conn := client.gridConn()
+	if conn == nil {
+		return nil
+	}
+	_, err := loadTransitionTierConfigHandler.Call(ctx, conn, grid.NewMSSWith(map[string]string{}))
 	if err != nil {
 		return err
 	}
-	defer xhttp.DrainBody(respBody)
 	return nil
 }
 

cmd/peer-rest-server.go

@@ -61,192 +61,151 @@ func (s *peerRESTServer) GetLocksHandler(w http.ResponseWriter, r *http.Request)
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(globalLockServer.DupLockMap()))
 }
 
-// DeletePolicyHandler - deletes a policy on the server.
+var (
-func (s *peerRESTServer) DeletePolicyHandler(w http.ResponseWriter, r *http.Request) {
+	deletePolicyHandler      = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerDeletePolicy, grid.NewMSS, grid.NewNoPayload)
-	if !s.IsValid(w, r) {
+	loadPolicyHandler        = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadPolicy, grid.NewMSS, grid.NewNoPayload)
-		s.writeErrorResponse(w, errors.New("Invalid request"))
+	loadPolicyMappingHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadPolicyMapping, grid.NewMSS, grid.NewNoPayload)
-		return
+	deleteSvcActHandler      = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerDeleteServiceAccount, grid.NewMSS, grid.NewNoPayload)
-	}
+	loadSvcActHandler        = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadServiceAccount, grid.NewMSS, grid.NewNoPayload)
+	deleteUserHandler        = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerDeleteUser, grid.NewMSS, grid.NewNoPayload)
+	loadUserHandler          = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadUser, grid.NewMSS, grid.NewNoPayload)
+	loadGroupHandler         = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadGroup, grid.NewMSS, grid.NewNoPayload)
+)
 
+// DeletePolicyHandler - deletes a policy on the server.
+func (s *peerRESTServer) DeletePolicyHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	vars := mux.Vars(r)
+	policyName := mss.Get(peerRESTPolicy)
-	policyName := vars[peerRESTPolicy]
 	if policyName == "" {
-		s.writeErrorResponse(w, errors.New("policyName is missing"))
+		return np, grid.NewRemoteErr(errors.New("policyName is missing"))
-		return
 	}
 
-	if err := globalIAMSys.DeletePolicy(r.Context(), policyName, false); err != nil {
+	if err := globalIAMSys.DeletePolicy(context.Background(), policyName, false); err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
+
+	return
 }
 
 // LoadPolicyHandler - reloads a policy on the server.
-func (s *peerRESTServer) LoadPolicyHandler(w http.ResponseWriter, r *http.Request) {
+func (s *peerRESTServer) LoadPolicyHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
-
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	vars := mux.Vars(r)
+	policyName := mss.Get(peerRESTPolicy)
-	policyName := vars[peerRESTPolicy]
 	if policyName == "" {
-		s.writeErrorResponse(w, errors.New("policyName is missing"))
+		return np, grid.NewRemoteErr(errors.New("policyName is missing"))
-		return
 	}
 
-	if err := globalIAMSys.LoadPolicy(r.Context(), objAPI, policyName); err != nil {
+	if err := globalIAMSys.LoadPolicy(context.Background(), objAPI, policyName); err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
+
+	return
 }
 
 // LoadPolicyMappingHandler - reloads a policy mapping on the server.
-func (s *peerRESTServer) LoadPolicyMappingHandler(w http.ResponseWriter, r *http.Request) {
+func (s *peerRESTServer) LoadPolicyMappingHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
-
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
-
+	userOrGroup := mss.Get(peerRESTUserOrGroup)
-	userOrGroup := r.Form.Get(peerRESTUserOrGroup)
 	if userOrGroup == "" {
-		s.writeErrorResponse(w, errors.New("user-or-group is missing"))
+		return np, grid.NewRemoteErr(errors.New("user-or-group is missing"))
-		return
 	}
 
-	userType, err := strconv.Atoi(r.Form.Get(peerRESTUserType))
+	userType, err := strconv.Atoi(mss.Get(peerRESTUserType))
 	if err != nil {
-		s.writeErrorResponse(w, fmt.Errorf("user-type `%s` is invalid: %w", r.Form.Get(peerRESTUserType), err))
+		return np, grid.NewRemoteErr(fmt.Errorf("user-type `%s` is invalid: %w", mss.Get(peerRESTUserType), err))
-		return
 	}
 
-	_, isGroup := r.Form[peerRESTIsGroup]
+	isGroup := mss.Get(peerRESTIsGroup) == "true"
-	if err := globalIAMSys.LoadPolicyMapping(r.Context(), objAPI, userOrGroup, IAMUserType(userType), isGroup); err != nil {
+	if err := globalIAMSys.LoadPolicyMapping(context.Background(), objAPI, userOrGroup, IAMUserType(userType), isGroup); err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
+
+	return
 }
 
 // DeleteServiceAccountHandler - deletes a service account on the server.
-func (s *peerRESTServer) DeleteServiceAccountHandler(w http.ResponseWriter, r *http.Request) {
+func (s *peerRESTServer) DeleteServiceAccountHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
-
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	vars := mux.Vars(r)
+	accessKey := mss.Get(peerRESTUser)
-	accessKey := vars[peerRESTUser]
 	if accessKey == "" {
-		s.writeErrorResponse(w, errors.New("service account name is missing"))
+		return np, grid.NewRemoteErr(errors.New("service account name is missing"))
-		return
 	}
 
-	if err := globalIAMSys.DeleteServiceAccount(r.Context(), accessKey, false); err != nil {
+	if err := globalIAMSys.DeleteServiceAccount(context.Background(), accessKey, false); err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
+
+	return
 }
 
 // LoadServiceAccountHandler - reloads a service account on the server.
-func (s *peerRESTServer) LoadServiceAccountHandler(w http.ResponseWriter, r *http.Request) {
+func (s *peerRESTServer) LoadServiceAccountHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
-
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	vars := mux.Vars(r)
+	accessKey := mss.Get(peerRESTUser)
-	accessKey := vars[peerRESTUser]
 	if accessKey == "" {
-		s.writeErrorResponse(w, errors.New("service account parameter is missing"))
+		return np, grid.NewRemoteErr(errors.New("service account name is missing"))
-		return
 	}
 
-	if err := globalIAMSys.LoadServiceAccount(r.Context(), accessKey); err != nil {
+	if err := globalIAMSys.LoadServiceAccount(context.Background(), accessKey); err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
+
+	return
 }
 
 // DeleteUserHandler - deletes a user on the server.
-func (s *peerRESTServer) DeleteUserHandler(w http.ResponseWriter, r *http.Request) {
+func (s *peerRESTServer) DeleteUserHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
-
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	vars := mux.Vars(r)
+	accessKey := mss.Get(peerRESTUser)
-	accessKey := vars[peerRESTUser]
 	if accessKey == "" {
-		s.writeErrorResponse(w, errors.New("username is missing"))
+		return np, grid.NewRemoteErr(errors.New("username is missing"))
-		return
 	}
 
-	if err := globalIAMSys.DeleteUser(r.Context(), accessKey, false); err != nil {
+	if err := globalIAMSys.DeleteUser(context.Background(), accessKey, false); err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
+
+	return
 }
 
 // LoadUserHandler - reloads a user on the server.
-func (s *peerRESTServer) LoadUserHandler(w http.ResponseWriter, r *http.Request) {
+func (s *peerRESTServer) LoadUserHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
-
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	vars := mux.Vars(r)
+	accessKey := mss.Get(peerRESTUser)
-	accessKey := vars[peerRESTUser]
 	if accessKey == "" {
-		s.writeErrorResponse(w, errors.New("username is missing"))
+		return np, grid.NewRemoteErr(errors.New("username is missing"))
-		return
 	}
 
-	temp, err := strconv.ParseBool(vars[peerRESTUserTemp])
+	temp, err := strconv.ParseBool(mss.Get(peerRESTUserTemp))
 	if err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
 
 	userType := regUser
@@ -254,32 +213,27 @@ func (s *peerRESTServer) LoadUserHandler(w http.ResponseWriter, r *http.Request)
 		userType = stsUser
 	}
 
-	if err = globalIAMSys.LoadUser(r.Context(), objAPI, accessKey, userType); err != nil {
+	if err = globalIAMSys.LoadUser(context.Background(), objAPI, accessKey, userType); err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
+
+	return
 }
 
 // LoadGroupHandler - reloads group along with members list.
-func (s *peerRESTServer) LoadGroupHandler(w http.ResponseWriter, r *http.Request) {
+func (s *peerRESTServer) LoadGroupHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
-
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	vars := mux.Vars(r)
+	group := mss.Get(peerRESTGroup)
-	group := vars[peerRESTGroup]
+	err := globalIAMSys.LoadGroup(context.Background(), objAPI, group)
-	err := globalIAMSys.LoadGroup(r.Context(), objAPI, group)
 	if err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
+
+	return
 }
 
 // StartProfilingHandler - Issues the start profiling command.
@@ -566,18 +520,13 @@ func (s *peerRESTServer) GetSysErrorsHandler(w http.ResponseWriter, r *http.Requ
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(info))
 }
 
-// DeleteBucketMetadataHandler - Delete in memory bucket metadata
+var deleteBucketMetadataHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerDeleteBucketMetadata, grid.NewMSS, grid.NewNoPayload)
-func (s *peerRESTServer) DeleteBucketMetadataHandler(w http.ResponseWriter, r *http.Request) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
 
-	vars := mux.Vars(r)
+// DeleteBucketMetadataHandler - Delete in memory bucket metadata
-	bucketName := vars[peerRESTBucket]
+func (s *peerRESTServer) DeleteBucketMetadataHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
+	bucketName := mss.Get(peerRESTBucket)
 	if bucketName == "" {
-		s.writeErrorResponse(w, errors.New("Bucket name is missing"))
+		return np, grid.NewRemoteErr(errors.New("Bucket name is missing"))
-		return
 	}
 
 	globalReplicationStats.Delete(bucketName)
@@ -589,24 +538,7 @@ func (s *peerRESTServer) DeleteBucketMetadataHandler(w http.ResponseWriter, r *h
 	if localMetacacheMgr != nil {
 		localMetacacheMgr.deleteBucketCache(bucketName)
 	}
-}
+	return
-
-// ReloadSiteReplicationConfigHandler - reloads site replication configuration from the disks
-func (s *peerRESTServer) ReloadSiteReplicationConfigHandler(w http.ResponseWriter, r *http.Request) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
-
-	ctx := newContext(r, w, "LoadSiteReplication")
-
-	objAPI := newObjectLayerFn()
-	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
-		return
-	}
-
-	logger.LogIf(r.Context(), globalSiteReplicationSys.Init(ctx, objAPI))
 }
 
 // GetAllBucketStatsHandler - fetches bucket replication stats for all buckets from this peer.
@@ -664,30 +596,23 @@ func (s *peerRESTServer) GetSRMetricsHandler(w http.ResponseWriter, r *http.Requ
 	logger.LogIf(r.Context(), msgp.Encode(w, &sm))
 }
 
-// LoadBucketMetadataHandler - reloads in memory bucket metadata
+var loadBucketMetadataHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadBucketMetadata, grid.NewMSS, grid.NewNoPayload)
-func (s *peerRESTServer) LoadBucketMetadataHandler(w http.ResponseWriter, r *http.Request) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
 
-	vars := mux.Vars(r)
+// LoadBucketMetadataHandler - reloads in memory bucket metadata
-	bucketName := vars[peerRESTBucket]
+func (s *peerRESTServer) LoadBucketMetadataHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
+	bucketName := mss.Get(peerRESTBucket)
 	if bucketName == "" {
-		s.writeErrorResponse(w, errors.New("Bucket name is missing"))
+		return np, grid.NewRemoteErr(errors.New("Bucket name is missing"))
-		return
 	}
 
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	meta, err := loadBucketMetadata(r.Context(), objAPI, bucketName)
+	meta, err := loadBucketMetadata(context.Background(), objAPI, bucketName)
 	if err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
 
 	globalBucketMetadataSys.Set(bucketName, meta)
@@ -699,6 +624,8 @@ func (s *peerRESTServer) LoadBucketMetadataHandler(w http.ResponseWriter, r *htt
 	if meta.bucketTargetConfig != nil {
 		globalBucketTargetSys.UpdateAllTargets(bucketName, meta.bucketTargetConfig)
 	}
+
+	return
 }
 
 func (s *peerRESTServer) GetMetacacheListingHandler(w http.ResponseWriter, r *http.Request) {
@@ -802,31 +729,24 @@ func (s *peerRESTServer) HealthHandler(w http.ResponseWriter, r *http.Request) {
 	s.IsValid(w, r)
 }
 
+var getLocalDiskIDsHandler = grid.NewSingleHandler[*grid.MSS, *LocalDiskIDs](grid.HandlerGetLocalDiskIDs, grid.NewMSS, func() *LocalDiskIDs {
+	return &LocalDiskIDs{}
+})
+
 // GetLocalDiskIDs - Return disk IDs of all the local disks.
-func (s *peerRESTServer) GetLocalDiskIDs(w http.ResponseWriter, r *http.Request) {
+func (s *peerRESTServer) GetLocalDiskIDs(mss *grid.MSS) (*LocalDiskIDs, *grid.RemoteErr) {
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("Invalid request"))
-		return
-	}
-
-	ctx := newContext(r, w, "GetLocalDiskIDs")
-
 	objLayer := newObjectLayerFn()
-
 	// Service not initialized yet
 	if objLayer == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return nil, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
 	z, ok := objLayer.(*erasureServerPools)
 	if !ok {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return nil, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	ids := getLocalDiskIDs(z)
+	return &LocalDiskIDs{IDs: getLocalDiskIDs(z)}, nil
-	logger.LogIf(ctx, gob.NewEncoder(w).Encode(ids))
 }
 
 // VerifyBinary - verifies the downloaded binary is in-tact
@@ -1108,92 +1028,101 @@ func (s *peerRESTServer) BackgroundHealStatusHandler(w http.ResponseWriter, r *h
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(state))
 }
 
-func (s *peerRESTServer) ReloadPoolMetaHandler(w http.ResponseWriter, r *http.Request) {
+var reloadSiteReplicationConfigHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerReloadSiteReplicationConfig, grid.NewMSS, grid.NewNoPayload)
-	if !s.IsValid(w, r) {
+
-		s.writeErrorResponse(w, errors.New("invalid request"))
+// ReloadSiteReplicationConfigHandler - reloads site replication configuration from the disks
-		return
+func (s *peerRESTServer) ReloadSiteReplicationConfigHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
-	}
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
-	pools, ok := objAPI.(*erasureServerPools)
+	logger.LogIf(context.Background(), globalSiteReplicationSys.Init(context.Background(), objAPI))
-	if !ok {
+	return
-		return
-	}
-	if err := pools.ReloadPoolMeta(r.Context()); err != nil {
-		s.writeErrorResponse(w, err)
-		return
-	}
 }
 
-func (s *peerRESTServer) StopRebalanceHandler(w http.ResponseWriter, r *http.Request) {
+var reloadPoolMetaHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerReloadPoolMeta, grid.NewMSS, grid.NewNoPayload)
-	if !s.IsValid(w, r) {
+
-		s.writeErrorResponse(w, errors.New("invalid request"))
+func (s *peerRESTServer) ReloadPoolMetaHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
+	objAPI := newObjectLayerFn()
+	if objAPI == nil {
+		return np, grid.NewRemoteErr(errServerNotInitialized)
+	}
+
+	pools, ok := objAPI.(*erasureServerPools)
+	if !ok {
 		return
 	}
 
+	if err := pools.ReloadPoolMeta(context.Background()); err != nil {
+		return np, grid.NewRemoteErr(err)
+	}
+
+	return
+}
+
+var stopRebalanceHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerStopRebalance, grid.NewMSS, grid.NewNoPayload)
+
+func (s *peerRESTServer) StopRebalanceHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
+
 	pools, ok := objAPI.(*erasureServerPools)
 	if !ok {
-		s.writeErrorResponse(w, errors.New("not a multiple pools setup"))
+		return np, grid.NewRemoteErr(errors.New("not a pooled setup"))
-		return
 	}
 
 	pools.StopRebalance()
+	return
 }
 
-func (s *peerRESTServer) LoadRebalanceMetaHandler(w http.ResponseWriter, r *http.Request) {
+var loadRebalanceMetaHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadRebalanceMeta, grid.NewMSS, grid.NewNoPayload)
-	if !s.IsValid(w, r) {
-		s.writeErrorResponse(w, errors.New("invalid request"))
-		return
-	}
 
+func (s *peerRESTServer) LoadRebalanceMetaHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		s.writeErrorResponse(w, errServerNotInitialized)
+		return np, grid.NewRemoteErr(errServerNotInitialized)
-		return
 	}
 
 	pools, ok := objAPI.(*erasureServerPools)
 	if !ok {
-		s.writeErrorResponse(w, errors.New("not a multiple pools setup"))
+		return np, grid.NewRemoteErr(errors.New("not a pooled setup"))
-		return
 	}
 
-	startRebalanceStr := r.Form.Get(peerRESTStartRebalance)
+	startRebalance, err := strconv.ParseBool(mss.Get(peerRESTStartRebalance))
-	startRebalance, err := strconv.ParseBool(startRebalanceStr)
 	if err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
 
-	if err := pools.loadRebalanceMeta(r.Context()); err != nil {
+	if err := pools.loadRebalanceMeta(context.Background()); err != nil {
-		s.writeErrorResponse(w, err)
+		return np, grid.NewRemoteErr(err)
-		return
 	}
+
 	if startRebalance {
 		go pools.StartRebalance()
 	}
+
+	return
 }
 
-func (s *peerRESTServer) LoadTransitionTierConfigHandler(w http.ResponseWriter, r *http.Request) {
+var loadTransitionTierConfigHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadTransitionTierConfig, grid.NewMSS, grid.NewNoPayload)
-	if !s.IsValid(w, r) {
+
-		s.writeErrorResponse(w, errors.New("invalid request"))
+func (s *peerRESTServer) LoadTransitionTierConfigHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
-		return
+	objAPI := newObjectLayerFn()
+	if objAPI == nil {
+		return np, grid.NewRemoteErr(errServerNotInitialized)
 	}
+
 	go func() {
 		err := globalTierConfigMgr.Reload(context.Background(), newObjectLayerFn())
 		if err != nil {
 			logger.LogIf(context.Background(), fmt.Errorf("Failed to reload remote tier config %s", err))
 		}
 	}()
+
+	return
 }
 
 // ConsoleLogHandler sends console logs of this node back to peer rest client
@@ -1512,20 +1441,10 @@ func registerPeerRESTHandlers(router *mux.Router, gm *grid.Manager) {
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodNetHwInfo).HandlerFunc(h(server.GetNetInfoHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodCPUInfo).HandlerFunc(h(server.GetCPUsHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetAllBucketStats).HandlerFunc(h(server.GetAllBucketStatsHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDeleteBucketMetadata).HandlerFunc(h(server.DeleteBucketMetadataHandler)).Queries(restQueries(peerRESTBucket)...)
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodLoadBucketMetadata).HandlerFunc(h(server.LoadBucketMetadataHandler)).Queries(restQueries(peerRESTBucket)...)
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetBucketStats).HandlerFunc(h(server.GetBucketStatsHandler)).Queries(restQueries(peerRESTBucket)...)
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodSignalService).HandlerFunc(h(server.SignalServiceHandler)).Queries(restQueries(peerRESTSignal)...)
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodVerifyBinary).HandlerFunc(h(server.VerifyBinaryHandler)).Queries(restQueries(peerRESTURL, peerRESTSha256Sum, peerRESTReleaseInfo)...)
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodCommitBinary).HandlerFunc(h(server.CommitBinaryHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDeletePolicy).HandlerFunc(h(server.DeletePolicyHandler)).Queries(restQueries(peerRESTPolicy)...)
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodLoadPolicy).HandlerFunc(h(server.LoadPolicyHandler)).Queries(restQueries(peerRESTPolicy)...)
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodLoadPolicyMapping).HandlerFunc(h(server.LoadPolicyMappingHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDeleteUser).HandlerFunc(h(server.DeleteUserHandler)).Queries(restQueries(peerRESTUser)...)
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDeleteServiceAccount).HandlerFunc(h(server.DeleteServiceAccountHandler)).Queries(restQueries(peerRESTUser)...)
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodLoadUser).HandlerFunc(h(server.LoadUserHandler)).Queries(restQueries(peerRESTUser, peerRESTUserTemp)...)
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodLoadServiceAccount).HandlerFunc(h(server.LoadServiceAccountHandler)).Queries(restQueries(peerRESTUser)...)
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodLoadGroup).HandlerFunc(h(server.LoadGroupHandler)).Queries(restQueries(peerRESTGroup)...)
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetReplicationMRF).HandlerFunc(httpTraceHdrs(server.GetReplicationMRFHandler)).Queries(restQueries(peerRESTBucket)...)
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetSRMetrics).HandlerFunc(h(server.GetSRMetricsHandler))
 
@@ -1533,22 +1452,34 @@ func registerPeerRESTHandlers(router *mux.Router, gm *grid.Manager) {
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDownloadProfilingData).HandlerFunc(h(server.DownloadProfilingDataHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodBackgroundHealStatus).HandlerFunc(server.BackgroundHealStatusHandler)
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodLog).HandlerFunc(server.ConsoleLogHandler)
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetLocalDiskIDs).HandlerFunc(h(server.GetLocalDiskIDs))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetBandwidth).HandlerFunc(h(server.GetBandwidth))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetMetacacheListing).HandlerFunc(h(server.GetMetacacheListingHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodUpdateMetacacheListing).HandlerFunc(h(server.UpdateMetacacheListingHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetPeerMetrics).HandlerFunc(h(server.GetPeerMetrics))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetPeerBucketMetrics).HandlerFunc(h(server.GetPeerBucketMetrics))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodLoadTransitionTierConfig).HandlerFunc(h(server.LoadTransitionTierConfigHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodSpeedTest).HandlerFunc(h(server.SpeedTestHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDriveSpeedTest).HandlerFunc(h(server.DriveSpeedTestHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodNetperf).HandlerFunc(h(server.NetSpeedTestHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDevNull).HandlerFunc(h(server.DevNull))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodReloadSiteReplicationConfig).HandlerFunc(h(server.ReloadSiteReplicationConfigHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodReloadPoolMeta).HandlerFunc(h(server.ReloadPoolMetaHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodLoadRebalanceMeta).HandlerFunc(h(server.LoadRebalanceMetaHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodStopRebalance).HandlerFunc(h(server.StopRebalanceHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetLastDayTierStats).HandlerFunc(h(server.GetLastDayTierStatsHandler))
+
+	logger.FatalIf(deletePolicyHandler.Register(gm, server.DeletePolicyHandler), "unable to register handler")
+	logger.FatalIf(loadPolicyHandler.Register(gm, server.LoadPolicyHandler), "unable to register handler")
+	logger.FatalIf(loadPolicyMappingHandler.Register(gm, server.LoadPolicyMappingHandler), "unable to register handler")
+	logger.FatalIf(deleteUserHandler.Register(gm, server.DeleteUserHandler), "unable to register handler")
+	logger.FatalIf(deleteSvcActHandler.Register(gm, server.DeleteServiceAccountHandler), "unable to register handler")
+	logger.FatalIf(loadUserHandler.Register(gm, server.LoadUserHandler), "unable to register handler")
+	logger.FatalIf(loadSvcActHandler.Register(gm, server.LoadServiceAccountHandler), "unable to register handler")
+	logger.FatalIf(loadGroupHandler.Register(gm, server.LoadGroupHandler), "unable to register handler")
+
+	logger.FatalIf(loadTransitionTierConfigHandler.Register(gm, server.LoadTransitionTierConfigHandler), "unable to register handler")
+	logger.FatalIf(reloadPoolMetaHandler.Register(gm, server.ReloadPoolMetaHandler), "unable to register handler")
+	logger.FatalIf(loadRebalanceMetaHandler.Register(gm, server.LoadRebalanceMetaHandler), "unable to register handler")
+	logger.FatalIf(stopRebalanceHandler.Register(gm, server.StopRebalanceHandler), "unable to register handler")
+	logger.FatalIf(reloadSiteReplicationConfigHandler.Register(gm, server.ReloadSiteReplicationConfigHandler), "unable to register handler")
+	logger.FatalIf(loadBucketMetadataHandler.Register(gm, server.LoadBucketMetadataHandler), "unable to register handler")
+	logger.FatalIf(deleteBucketMetadataHandler.Register(gm, server.DeleteBucketMetadataHandler), "unable to register handler")
+	logger.FatalIf(getLocalDiskIDsHandler.Register(gm, server.GetLocalDiskIDs), "unable to register handler")
 	logger.FatalIf(listenHandler.RegisterNoInput(gm, server.ListenHandler), "unable to register handler")
 	logger.FatalIf(gm.RegisterStreamingHandler(grid.HandlerTrace, grid.StreamHandler{
 		Handle:      server.TraceHandler,

cmd/storage-datatypes.go

@@ -451,3 +451,8 @@ type ReadAllHandlerParams struct {
 type RenameDataResp struct {
 	Signature uint64 `msg:"sig"`
 }
+
+// LocalDiskIDs - GetLocalIDs response.
+type LocalDiskIDs struct {
+	IDs []string
+}

cmd/storage-datatypes_gen.go

@@ -2912,6 +2912,148 @@ func (z *FilesInfo) Msgsize() (s int) {
 	return
 }
 
+// DecodeMsg implements msgp.Decodable
+func (z *LocalDiskIDs) DecodeMsg(dc *msgp.Reader) (err error) {
+	var field []byte
+	_ = field
+	var zb0001 uint32
+	zb0001, err = dc.ReadMapHeader()
+	if err != nil {
+		err = msgp.WrapError(err)
+		return
+	}
+	for zb0001 > 0 {
+		zb0001--
+		field, err = dc.ReadMapKeyPtr()
+		if err != nil {
+			err = msgp.WrapError(err)
+			return
+		}
+		switch msgp.UnsafeString(field) {
+		case "IDs":
+			var zb0002 uint32
+			zb0002, err = dc.ReadArrayHeader()
+			if err != nil {
+				err = msgp.WrapError(err, "IDs")
+				return
+			}
+			if cap(z.IDs) >= int(zb0002) {
+				z.IDs = (z.IDs)[:zb0002]
+			} else {
+				z.IDs = make([]string, zb0002)
+			}
+			for za0001 := range z.IDs {
+				z.IDs[za0001], err = dc.ReadString()
+				if err != nil {
+					err = msgp.WrapError(err, "IDs", za0001)
+					return
+				}
+			}
+		default:
+			err = dc.Skip()
+			if err != nil {
+				err = msgp.WrapError(err)
+				return
+			}
+		}
+	}
+	return
+}
+
+// EncodeMsg implements msgp.Encodable
+func (z *LocalDiskIDs) EncodeMsg(en *msgp.Writer) (err error) {
+	// map header, size 1
+	// write "IDs"
+	err = en.Append(0x81, 0xa3, 0x49, 0x44, 0x73)
+	if err != nil {
+		return
+	}
+	err = en.WriteArrayHeader(uint32(len(z.IDs)))
+	if err != nil {
+		err = msgp.WrapError(err, "IDs")
+		return
+	}
+	for za0001 := range z.IDs {
+		err = en.WriteString(z.IDs[za0001])
+		if err != nil {
+			err = msgp.WrapError(err, "IDs", za0001)
+			return
+		}
+	}
+	return
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *LocalDiskIDs) MarshalMsg(b []byte) (o []byte, err error) {
+	o = msgp.Require(b, z.Msgsize())
+	// map header, size 1
+	// string "IDs"
+	o = append(o, 0x81, 0xa3, 0x49, 0x44, 0x73)
+	o = msgp.AppendArrayHeader(o, uint32(len(z.IDs)))
+	for za0001 := range z.IDs {
+		o = msgp.AppendString(o, z.IDs[za0001])
+	}
+	return
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *LocalDiskIDs) UnmarshalMsg(bts []byte) (o []byte, err error) {
+	var field []byte
+	_ = field
+	var zb0001 uint32
+	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
+	if err != nil {
+		err = msgp.WrapError(err)
+		return
+	}
+	for zb0001 > 0 {
+		zb0001--
+		field, bts, err = msgp.ReadMapKeyZC(bts)
+		if err != nil {
+			err = msgp.WrapError(err)
+			return
+		}
+		switch msgp.UnsafeString(field) {
+		case "IDs":
+			var zb0002 uint32
+			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
+			if err != nil {
+				err = msgp.WrapError(err, "IDs")
+				return
+			}
+			if cap(z.IDs) >= int(zb0002) {
+				z.IDs = (z.IDs)[:zb0002]
+			} else {
+				z.IDs = make([]string, zb0002)
+			}
+			for za0001 := range z.IDs {
+				z.IDs[za0001], bts, err = msgp.ReadStringBytes(bts)
+				if err != nil {
+					err = msgp.WrapError(err, "IDs", za0001)
+					return
+				}
+			}
+		default:
+			bts, err = msgp.Skip(bts)
+			if err != nil {
+				err = msgp.WrapError(err)
+				return
+			}
+		}
+	}
+	o = bts
+	return
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *LocalDiskIDs) Msgsize() (s int) {
+	s = 1 + 4 + msgp.ArrayHeaderSize
+	for za0001 := range z.IDs {
+		s += msgp.StringPrefixSize + len(z.IDs[za0001])
+	}
+	return
+}
+
 // DecodeMsg implements msgp.Decodable
 func (z *MetadataHandlerParams) DecodeMsg(dc *msgp.Reader) (err error) {
 	var field []byte

cmd/storage-datatypes_gen_test.go

@@ -1252,6 +1252,119 @@ func BenchmarkDecodeFilesInfo(b *testing.B) {
 	}
 }
 
+func TestMarshalUnmarshalLocalDiskIDs(t *testing.T) {
+	v := LocalDiskIDs{}
+	bts, err := v.MarshalMsg(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	left, err := v.UnmarshalMsg(bts)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(left) > 0 {
+		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+	}
+
+	left, err = msgp.Skip(bts)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(left) > 0 {
+		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+	}
+}
+
+func BenchmarkMarshalMsgLocalDiskIDs(b *testing.B) {
+	v := LocalDiskIDs{}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		v.MarshalMsg(nil)
+	}
+}
+
+func BenchmarkAppendMsgLocalDiskIDs(b *testing.B) {
+	v := LocalDiskIDs{}
+	bts := make([]byte, 0, v.Msgsize())
+	bts, _ = v.MarshalMsg(bts[0:0])
+	b.SetBytes(int64(len(bts)))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		bts, _ = v.MarshalMsg(bts[0:0])
+	}
+}
+
+func BenchmarkUnmarshalLocalDiskIDs(b *testing.B) {
+	v := LocalDiskIDs{}
+	bts, _ := v.MarshalMsg(nil)
+	b.ReportAllocs()
+	b.SetBytes(int64(len(bts)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := v.UnmarshalMsg(bts)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func TestEncodeDecodeLocalDiskIDs(t *testing.T) {
+	v := LocalDiskIDs{}
+	var buf bytes.Buffer
+	msgp.Encode(&buf, &v)
+
+	m := v.Msgsize()
+	if buf.Len() > m {
+		t.Log("WARNING: TestEncodeDecodeLocalDiskIDs Msgsize() is inaccurate")
+	}
+
+	vn := LocalDiskIDs{}
+	err := msgp.Decode(&buf, &vn)
+	if err != nil {
+		t.Error(err)
+	}
+
+	buf.Reset()
+	msgp.Encode(&buf, &v)
+	err = msgp.NewReader(&buf).Skip()
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func BenchmarkEncodeLocalDiskIDs(b *testing.B) {
+	v := LocalDiskIDs{}
+	var buf bytes.Buffer
+	msgp.Encode(&buf, &v)
+	b.SetBytes(int64(buf.Len()))
+	en := msgp.NewWriter(msgp.Nowhere)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		v.EncodeMsg(en)
+	}
+	en.Flush()
+}
+
+func BenchmarkDecodeLocalDiskIDs(b *testing.B) {
+	v := LocalDiskIDs{}
+	var buf bytes.Buffer
+	msgp.Encode(&buf, &v)
+	b.SetBytes(int64(buf.Len()))
+	rd := msgp.NewEndlessReader(buf.Bytes(), b)
+	dc := msgp.NewReader(rd)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		err := v.DecodeMsg(dc)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
 func TestMarshalUnmarshalMetadataHandlerParams(t *testing.T) {
 	v := MetadataHandlerParams{}
 	bts, err := v.MarshalMsg(nil)

internal/grid/handlers.go

@@ -62,6 +62,23 @@ const (
 	HandlerServerVerify
 	HandlerTrace
 	HandlerListen
+	HandlerGetLocalDiskIDs
+	HandlerDeleteBucketMetadata
+	HandlerLoadBucketMetadata
+	HandlerReloadSiteReplicationConfig
+	HandlerReloadPoolMeta
+	HandlerStopRebalance
+	HandlerLoadRebalanceMeta
+	HandlerLoadTransitionTierConfig
+
+	HandlerDeletePolicy
+	HandlerLoadPolicy
+	HandlerLoadPolicyMapping
+	HandlerDeleteServiceAccount
+	HandlerLoadServiceAccount
+	HandlerDeleteUser
+	HandlerLoadUser
+	HandlerLoadGroup
 
 	// Add more above here ^^^
 	// If all handlers are used, the type of Handler can be changed.
@@ -74,33 +91,52 @@ const (
 // handlerPrefixes are prefixes for handler IDs used for tracing.
 // If a handler is not listed here, it will be traced with "grid" prefix.
 var handlerPrefixes = [handlerLast]string{
-	HandlerLockLock:        lockPrefix,
+	HandlerLockLock:                    lockPrefix,
-	HandlerLockRLock:       lockPrefix,
+	HandlerLockRLock:                   lockPrefix,
-	HandlerLockUnlock:      lockPrefix,
+	HandlerLockUnlock:                  lockPrefix,
-	HandlerLockRUnlock:     lockPrefix,
+	HandlerLockRUnlock:                 lockPrefix,
-	HandlerLockRefresh:     lockPrefix,
+	HandlerLockRefresh:                 lockPrefix,
-	HandlerLockForceUnlock: lockPrefix,
+	HandlerLockForceUnlock:             lockPrefix,
-	HandlerWalkDir:         storagePrefix,
+	HandlerWalkDir:                     storagePrefix,
-	HandlerStatVol:         storagePrefix,
+	HandlerStatVol:                     storagePrefix,
-	HandlerDiskInfo:        storagePrefix,
+	HandlerDiskInfo:                    storagePrefix,
-	HandlerNSScanner:       storagePrefix,
+	HandlerNSScanner:                   storagePrefix,
-	HandlerReadXL:          storagePrefix,
+	HandlerReadXL:                      storagePrefix,
-	HandlerReadVersion:     storagePrefix,
+	HandlerReadVersion:                 storagePrefix,
-	HandlerDeleteFile:      storagePrefix,
+	HandlerDeleteFile:                  storagePrefix,
-	HandlerDeleteVersion:   storagePrefix,
+	HandlerDeleteVersion:               storagePrefix,
-	HandlerUpdateMetadata:  storagePrefix,
+	HandlerUpdateMetadata:              storagePrefix,
-	HandlerWriteMetadata:   storagePrefix,
+	HandlerWriteMetadata:               storagePrefix,
-	HandlerCheckParts:      storagePrefix,
+	HandlerCheckParts:                  storagePrefix,
-	HandlerRenameData:      storagePrefix,
+	HandlerRenameData:                  storagePrefix,
-	HandlerRenameFile:      storagePrefix,
+	HandlerRenameFile:                  storagePrefix,
-	HandlerReadAll:         storagePrefix,
+	HandlerReadAll:                     storagePrefix,
-	HandlerServerVerify:    bootstrapPrefix,
+	HandlerServerVerify:                bootstrapPrefix,
+	HandlerTrace:                       peerPrefix,
+	HandlerListen:                      peerPrefix,
+	HandlerGetLocalDiskIDs:             peerPrefix,
+	HandlerDeleteBucketMetadata:        peerPrefix,
+	HandlerLoadBucketMetadata:          peerPrefix,
+	HandlerReloadSiteReplicationConfig: peerPrefix,
+	HandlerReloadPoolMeta:              peerPrefix,
+	HandlerStopRebalance:               peerPrefix,
+	HandlerLoadRebalanceMeta:           peerPrefix,
+	HandlerLoadTransitionTierConfig:    peerPrefix,
+	HandlerDeletePolicy:                peerPrefix,
+	HandlerLoadPolicy:                  peerPrefix,
+	HandlerLoadPolicyMapping:           peerPrefix,
+	HandlerDeleteServiceAccount:        peerPrefix,
+	HandlerLoadServiceAccount:          peerPrefix,
+	HandlerDeleteUser:                  peerPrefix,
+	HandlerLoadUser:                    peerPrefix,
+	HandlerLoadGroup:                   peerPrefix,
 }
 
 const (
 	lockPrefix      = "lockR"
 	storagePrefix   = "storageR"
 	bootstrapPrefix = "bootstrap"
+	peerPrefix      = "peer"
 )
 
 func init() {

internal/grid/handlers_string.go

@@ -32,14 +32,30 @@ func _() {
 	_ = x[HandlerServerVerify-21]
 	_ = x[HandlerTrace-22]
 	_ = x[HandlerListen-23]
-	_ = x[handlerTest-24]
+	_ = x[HandlerGetLocalDiskIDs-24]
-	_ = x[handlerTest2-25]
+	_ = x[HandlerDeleteBucketMetadata-25]
-	_ = x[handlerLast-26]
+	_ = x[HandlerLoadBucketMetadata-26]
+	_ = x[HandlerReloadSiteReplicationConfig-27]
+	_ = x[HandlerReloadPoolMeta-28]
+	_ = x[HandlerStopRebalance-29]
+	_ = x[HandlerLoadRebalanceMeta-30]
+	_ = x[HandlerLoadTransitionTierConfig-31]
+	_ = x[HandlerDeletePolicy-32]
+	_ = x[HandlerLoadPolicy-33]
+	_ = x[HandlerLoadPolicyMapping-34]
+	_ = x[HandlerDeleteServiceAccount-35]
+	_ = x[HandlerLoadServiceAccount-36]
+	_ = x[HandlerDeleteUser-37]
+	_ = x[HandlerLoadUser-38]
+	_ = x[HandlerLoadGroup-39]
+	_ = x[handlerTest-40]
+	_ = x[handlerTest2-41]
+	_ = x[handlerLast-42]
 }
 
-const _HandlerID_name = "handlerInvalidLockLockLockRLockLockUnlockLockRUnlockLockRefreshLockForceUnlockWalkDirStatVolDiskInfoNSScannerReadXLReadVersionDeleteFileDeleteVersionUpdateMetadataWriteMetadataCheckPartsRenameDataRenameFileReadAllServerVerifyTraceListenhandlerTesthandlerTest2handlerLast"
+const _HandlerID_name = "handlerInvalidLockLockLockRLockLockUnlockLockRUnlockLockRefreshLockForceUnlockWalkDirStatVolDiskInfoNSScannerReadXLReadVersionDeleteFileDeleteVersionUpdateMetadataWriteMetadataCheckPartsRenameDataRenameFileReadAllServerVerifyTraceListenGetLocalDiskIDsDeleteBucketMetadataLoadBucketMetadataReloadSiteReplicationConfigReloadPoolMetaStopRebalanceLoadRebalanceMetaLoadTransitionTierConfigDeletePolicyLoadPolicyLoadPolicyMappingDeleteServiceAccountLoadServiceAccountDeleteUserLoadUserLoadGrouphandlerTesthandlerTest2handlerLast"
 
-var _HandlerID_index = [...]uint16{0, 14, 22, 31, 41, 52, 63, 78, 85, 92, 100, 109, 115, 126, 136, 149, 163, 176, 186, 196, 206, 213, 225, 230, 236, 247, 259, 270}
+var _HandlerID_index = [...]uint16{0, 14, 22, 31, 41, 52, 63, 78, 85, 92, 100, 109, 115, 126, 136, 149, 163, 176, 186, 196, 206, 213, 225, 230, 236, 251, 271, 289, 316, 330, 343, 360, 384, 396, 406, 423, 443, 461, 471, 479, 488, 499, 511, 522}
 
 func (i HandlerID) String() string {
 	if i >= HandlerID(len(_HandlerID_index)-1) {