diff --git a/cmd/peer-rest-client.go b/cmd/peer-rest-client.go index 98d94a1dc..31f1c1e4c 100644 --- a/cmd/peer-rest-client.go +++ b/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) - values.Set(peerRESTBucket, bucket) - respBody, err := client.call(peerRESTMethodLoadBucketMetadata, values, nil, -1) + conn := client.gridConn() + if conn == nil { + 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) - values.Set(peerRESTBucket, bucket) - respBody, err := client.call(peerRESTMethodDeleteBucketMetadata, values, nil, -1) + conn := client.gridConn() + if conn == nil { + 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) - values.Set(peerRESTPolicy, policyName) - - respBody, err := client.call(peerRESTMethodDeletePolicy, values, nil, -1) - if err != nil { - return + conn := client.gridConn() + if conn == nil { + return nil + } + + _, 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) - values.Set(peerRESTPolicy, policyName) - - respBody, err := client.call(peerRESTMethodLoadPolicy, values, nil, -1) - if err != nil { - return + conn := client.gridConn() + if conn == nil { + return nil + } + + _, 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) - values.Set(peerRESTUserOrGroup, userOrGroup) - values.Set(peerRESTUserType, strconv.Itoa(int(userType))) - if isGroup { - values.Set(peerRESTIsGroup, "") + conn := client.gridConn() + if conn == nil { + return nil } - 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) - values.Set(peerRESTUser, accessKey) - - respBody, err := client.call(peerRESTMethodDeleteUser, values, nil, -1) - if err != nil { - return + conn := client.gridConn() + if conn == nil { + return nil + } + + _, 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) - values.Set(peerRESTUser, accessKey) - - respBody, err := client.call(peerRESTMethodDeleteServiceAccount, values, nil, -1) - if err != nil { - return + conn := client.gridConn() + if conn == nil { + return nil + } + + _, 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) - values.Set(peerRESTUser, accessKey) - values.Set(peerRESTUserTemp, strconv.FormatBool(temp)) - - respBody, err := client.call(peerRESTMethodLoadUser, values, nil, -1) - if err != nil { - return + conn := client.gridConn() + if conn == nil { + return nil + } + + _, err = loadUserHandler.Call(context.Background(), conn, grid.NewMSSWith(map[string]string{ + 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) - values.Set(peerRESTUser, accessKey) - - respBody, err := client.call(peerRESTMethodLoadServiceAccount, values, nil, -1) - if err != nil { - return + conn := client.gridConn() + if conn == nil { + return nil + } + + _, 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) - values.Set(peerRESTGroup, group) - respBody, err := client.call(peerRESTMethodLoadGroup, values, nil, -1) + conn := client.gridConn() + if conn == nil { + 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 nil - } - return diskIDs + + return resp.IDs } // 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{} - values.Set(peerRESTStartRebalance, strconv.FormatBool(startRebalance)) - respBody, err := client.callWithContext(ctx, peerRESTMethodLoadRebalanceMeta, values, nil, 0) + conn := client.gridConn() + if conn == nil { + 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 } diff --git a/cmd/peer-rest-server.go b/cmd/peer-rest-server.go index 93dda9c6d..7be90b4e6 100644 --- a/cmd/peer-rest-server.go +++ b/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. -func (s *peerRESTServer) DeletePolicyHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } +var ( + deletePolicyHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerDeletePolicy, grid.NewMSS, grid.NewNoPayload) + loadPolicyHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadPolicy, grid.NewMSS, grid.NewNoPayload) + loadPolicyMappingHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadPolicyMapping, grid.NewMSS, grid.NewNoPayload) + 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 + return np, grid.NewRemoteErr(errServerNotInitialized) } - vars := mux.Vars(r) - policyName := vars[peerRESTPolicy] + policyName := mss.Get(peerRESTPolicy) if policyName == "" { - s.writeErrorResponse(w, errors.New("policyName is missing")) - return + return np, grid.NewRemoteErr(errors.New("policyName is missing")) } - if err := globalIAMSys.DeletePolicy(r.Context(), policyName, false); err != nil { - s.writeErrorResponse(w, err) - return + if err := globalIAMSys.DeletePolicy(context.Background(), policyName, false); err != nil { + return np, grid.NewRemoteErr(err) } + + return } // LoadPolicyHandler - reloads a policy on the server. -func (s *peerRESTServer) LoadPolicyHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } - +func (s *peerRESTServer) LoadPolicyHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } - vars := mux.Vars(r) - policyName := vars[peerRESTPolicy] + policyName := mss.Get(peerRESTPolicy) if policyName == "" { - s.writeErrorResponse(w, errors.New("policyName is missing")) - return + return np, grid.NewRemoteErr(errors.New("policyName is missing")) } - if err := globalIAMSys.LoadPolicy(r.Context(), objAPI, policyName); err != nil { - s.writeErrorResponse(w, err) - return + if err := globalIAMSys.LoadPolicy(context.Background(), objAPI, policyName); err != nil { + return np, grid.NewRemoteErr(err) } + + return } // LoadPolicyMappingHandler - reloads a policy mapping on the server. -func (s *peerRESTServer) LoadPolicyMappingHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } - +func (s *peerRESTServer) LoadPolicyMappingHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } - - userOrGroup := r.Form.Get(peerRESTUserOrGroup) + userOrGroup := mss.Get(peerRESTUserOrGroup) if userOrGroup == "" { - s.writeErrorResponse(w, errors.New("user-or-group is missing")) - return + return np, grid.NewRemoteErr(errors.New("user-or-group is missing")) } - 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 + return np, grid.NewRemoteErr(fmt.Errorf("user-type `%s` is invalid: %w", mss.Get(peerRESTUserType), err)) } - _, isGroup := r.Form[peerRESTIsGroup] - if err := globalIAMSys.LoadPolicyMapping(r.Context(), objAPI, userOrGroup, IAMUserType(userType), isGroup); err != nil { - s.writeErrorResponse(w, err) - return + isGroup := mss.Get(peerRESTIsGroup) == "true" + if err := globalIAMSys.LoadPolicyMapping(context.Background(), objAPI, userOrGroup, IAMUserType(userType), isGroup); err != nil { + return np, grid.NewRemoteErr(err) } + + return } // DeleteServiceAccountHandler - deletes a service account on the server. -func (s *peerRESTServer) DeleteServiceAccountHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } - +func (s *peerRESTServer) DeleteServiceAccountHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } - vars := mux.Vars(r) - accessKey := vars[peerRESTUser] + accessKey := mss.Get(peerRESTUser) if accessKey == "" { - s.writeErrorResponse(w, errors.New("service account name is missing")) - return + return np, grid.NewRemoteErr(errors.New("service account name is missing")) } - if err := globalIAMSys.DeleteServiceAccount(r.Context(), accessKey, false); err != nil { - s.writeErrorResponse(w, err) - return + if err := globalIAMSys.DeleteServiceAccount(context.Background(), accessKey, false); err != nil { + return np, grid.NewRemoteErr(err) } + + return } // LoadServiceAccountHandler - reloads a service account on the server. -func (s *peerRESTServer) LoadServiceAccountHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } - +func (s *peerRESTServer) LoadServiceAccountHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } - vars := mux.Vars(r) - accessKey := vars[peerRESTUser] + accessKey := mss.Get(peerRESTUser) if accessKey == "" { - s.writeErrorResponse(w, errors.New("service account parameter is missing")) - return + return np, grid.NewRemoteErr(errors.New("service account name is missing")) } - if err := globalIAMSys.LoadServiceAccount(r.Context(), accessKey); err != nil { - s.writeErrorResponse(w, err) - return + if err := globalIAMSys.LoadServiceAccount(context.Background(), accessKey); err != nil { + return np, grid.NewRemoteErr(err) } + + return } // DeleteUserHandler - deletes a user on the server. -func (s *peerRESTServer) DeleteUserHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } - +func (s *peerRESTServer) DeleteUserHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } - vars := mux.Vars(r) - accessKey := vars[peerRESTUser] + accessKey := mss.Get(peerRESTUser) if accessKey == "" { - s.writeErrorResponse(w, errors.New("username is missing")) - return + return np, grid.NewRemoteErr(errors.New("username is missing")) } - if err := globalIAMSys.DeleteUser(r.Context(), accessKey, false); err != nil { - s.writeErrorResponse(w, err) - return + if err := globalIAMSys.DeleteUser(context.Background(), accessKey, false); err != nil { + return np, grid.NewRemoteErr(err) } + + return } // LoadUserHandler - reloads a user on the server. -func (s *peerRESTServer) LoadUserHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } - +func (s *peerRESTServer) LoadUserHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } - vars := mux.Vars(r) - accessKey := vars[peerRESTUser] + accessKey := mss.Get(peerRESTUser) if accessKey == "" { - s.writeErrorResponse(w, errors.New("username is missing")) - return + return np, grid.NewRemoteErr(errors.New("username is missing")) } - temp, err := strconv.ParseBool(vars[peerRESTUserTemp]) + temp, err := strconv.ParseBool(mss.Get(peerRESTUserTemp)) if err != nil { - s.writeErrorResponse(w, err) - return + return np, grid.NewRemoteErr(err) } 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 { - s.writeErrorResponse(w, err) - return + if err = globalIAMSys.LoadUser(context.Background(), objAPI, accessKey, userType); err != nil { + return np, grid.NewRemoteErr(err) } + + return } // LoadGroupHandler - reloads group along with members list. -func (s *peerRESTServer) LoadGroupHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } - +func (s *peerRESTServer) LoadGroupHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } - vars := mux.Vars(r) - group := vars[peerRESTGroup] - err := globalIAMSys.LoadGroup(r.Context(), objAPI, group) + group := mss.Get(peerRESTGroup) + err := globalIAMSys.LoadGroup(context.Background(), objAPI, group) if err != nil { - s.writeErrorResponse(w, err) - return + return np, grid.NewRemoteErr(err) } + + 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 -func (s *peerRESTServer) DeleteBucketMetadataHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } +var deleteBucketMetadataHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerDeleteBucketMetadata, grid.NewMSS, grid.NewNoPayload) - vars := mux.Vars(r) - bucketName := vars[peerRESTBucket] +// DeleteBucketMetadataHandler - Delete in memory bucket metadata +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 + return np, grid.NewRemoteErr(errors.New("Bucket name is missing")) } globalReplicationStats.Delete(bucketName) @@ -589,24 +538,7 @@ func (s *peerRESTServer) DeleteBucketMetadataHandler(w http.ResponseWriter, r *h if localMetacacheMgr != nil { localMetacacheMgr.deleteBucketCache(bucketName) } -} - -// 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)) + return } // 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 -func (s *peerRESTServer) LoadBucketMetadataHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } +var loadBucketMetadataHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadBucketMetadata, grid.NewMSS, grid.NewNoPayload) - vars := mux.Vars(r) - bucketName := vars[peerRESTBucket] +// LoadBucketMetadataHandler - reloads in memory bucket metadata +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 + return np, grid.NewRemoteErr(errors.New("Bucket name is missing")) } objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } - meta, err := loadBucketMetadata(r.Context(), objAPI, bucketName) + meta, err := loadBucketMetadata(context.Background(), objAPI, bucketName) if err != nil { - s.writeErrorResponse(w, err) - return + return np, grid.NewRemoteErr(err) } 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) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("Invalid request")) - return - } - - ctx := newContext(r, w, "GetLocalDiskIDs") - +func (s *peerRESTServer) GetLocalDiskIDs(mss *grid.MSS) (*LocalDiskIDs, *grid.RemoteErr) { objLayer := newObjectLayerFn() - // Service not initialized yet if objLayer == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return nil, grid.NewRemoteErr(errServerNotInitialized) } z, ok := objLayer.(*erasureServerPools) if !ok { - s.writeErrorResponse(w, errServerNotInitialized) - return + return nil, grid.NewRemoteErr(errServerNotInitialized) } - ids := getLocalDiskIDs(z) - logger.LogIf(ctx, gob.NewEncoder(w).Encode(ids)) + return &LocalDiskIDs{IDs: getLocalDiskIDs(z)}, nil } // 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) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("invalid request")) - return - } +var reloadSiteReplicationConfigHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerReloadSiteReplicationConfig, grid.NewMSS, grid.NewNoPayload) + +// ReloadSiteReplicationConfigHandler - reloads site replication configuration from the disks +func (s *peerRESTServer) ReloadSiteReplicationConfigHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } - pools, ok := objAPI.(*erasureServerPools) - if !ok { - return - } - if err := pools.ReloadPoolMeta(r.Context()); err != nil { - s.writeErrorResponse(w, err) - return - } + logger.LogIf(context.Background(), globalSiteReplicationSys.Init(context.Background(), objAPI)) + return } -func (s *peerRESTServer) StopRebalanceHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("invalid request")) +var reloadPoolMetaHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerReloadPoolMeta, grid.NewMSS, grid.NewNoPayload) + +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 + return np, grid.NewRemoteErr(errServerNotInitialized) } + pools, ok := objAPI.(*erasureServerPools) if !ok { - s.writeErrorResponse(w, errors.New("not a multiple pools setup")) - return + return np, grid.NewRemoteErr(errors.New("not a pooled setup")) } pools.StopRebalance() + return } -func (s *peerRESTServer) LoadRebalanceMetaHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("invalid request")) - return - } +var loadRebalanceMetaHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadRebalanceMeta, grid.NewMSS, grid.NewNoPayload) +func (s *peerRESTServer) LoadRebalanceMetaHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { objAPI := newObjectLayerFn() if objAPI == nil { - s.writeErrorResponse(w, errServerNotInitialized) - return + return np, grid.NewRemoteErr(errServerNotInitialized) } pools, ok := objAPI.(*erasureServerPools) if !ok { - s.writeErrorResponse(w, errors.New("not a multiple pools setup")) - return + return np, grid.NewRemoteErr(errors.New("not a pooled setup")) } - startRebalanceStr := r.Form.Get(peerRESTStartRebalance) - startRebalance, err := strconv.ParseBool(startRebalanceStr) + startRebalance, err := strconv.ParseBool(mss.Get(peerRESTStartRebalance)) if err != nil { - s.writeErrorResponse(w, err) - return + return np, grid.NewRemoteErr(err) } - if err := pools.loadRebalanceMeta(r.Context()); err != nil { - s.writeErrorResponse(w, err) - return + if err := pools.loadRebalanceMeta(context.Background()); err != nil { + return np, grid.NewRemoteErr(err) } + if startRebalance { go pools.StartRebalance() } + + return } -func (s *peerRESTServer) LoadTransitionTierConfigHandler(w http.ResponseWriter, r *http.Request) { - if !s.IsValid(w, r) { - s.writeErrorResponse(w, errors.New("invalid request")) - return +var loadTransitionTierConfigHandler = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerLoadTransitionTierConfig, grid.NewMSS, grid.NewNoPayload) + +func (s *peerRESTServer) LoadTransitionTierConfigHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) { + 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, diff --git a/cmd/storage-datatypes.go b/cmd/storage-datatypes.go index 2bf5bc835..5fcaaff30 100644 --- a/cmd/storage-datatypes.go +++ b/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 +} diff --git a/cmd/storage-datatypes_gen.go b/cmd/storage-datatypes_gen.go index 0f36091ee..4978dd4db 100644 --- a/cmd/storage-datatypes_gen.go +++ b/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 diff --git a/cmd/storage-datatypes_gen_test.go b/cmd/storage-datatypes_gen_test.go index 10ac587dd..68a6716ca 100644 --- a/cmd/storage-datatypes_gen_test.go +++ b/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) diff --git a/internal/grid/handlers.go b/internal/grid/handlers.go index 36ff172d5..cc026b651 100644 --- a/internal/grid/handlers.go +++ b/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, - HandlerLockRLock: lockPrefix, - HandlerLockUnlock: lockPrefix, - HandlerLockRUnlock: lockPrefix, - HandlerLockRefresh: lockPrefix, - HandlerLockForceUnlock: lockPrefix, - HandlerWalkDir: storagePrefix, - HandlerStatVol: storagePrefix, - HandlerDiskInfo: storagePrefix, - HandlerNSScanner: storagePrefix, - HandlerReadXL: storagePrefix, - HandlerReadVersion: storagePrefix, - HandlerDeleteFile: storagePrefix, - HandlerDeleteVersion: storagePrefix, - HandlerUpdateMetadata: storagePrefix, - HandlerWriteMetadata: storagePrefix, - HandlerCheckParts: storagePrefix, - HandlerRenameData: storagePrefix, - HandlerRenameFile: storagePrefix, - HandlerReadAll: storagePrefix, - HandlerServerVerify: bootstrapPrefix, + HandlerLockLock: lockPrefix, + HandlerLockRLock: lockPrefix, + HandlerLockUnlock: lockPrefix, + HandlerLockRUnlock: lockPrefix, + HandlerLockRefresh: lockPrefix, + HandlerLockForceUnlock: lockPrefix, + HandlerWalkDir: storagePrefix, + HandlerStatVol: storagePrefix, + HandlerDiskInfo: storagePrefix, + HandlerNSScanner: storagePrefix, + HandlerReadXL: storagePrefix, + HandlerReadVersion: storagePrefix, + HandlerDeleteFile: storagePrefix, + HandlerDeleteVersion: storagePrefix, + HandlerUpdateMetadata: storagePrefix, + HandlerWriteMetadata: storagePrefix, + HandlerCheckParts: storagePrefix, + HandlerRenameData: storagePrefix, + HandlerRenameFile: storagePrefix, + HandlerReadAll: storagePrefix, + 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() { diff --git a/internal/grid/handlers_string.go b/internal/grid/handlers_string.go index b260ea72d..e32776881 100644 --- a/internal/grid/handlers_string.go +++ b/internal/grid/handlers_string.go @@ -32,14 +32,30 @@ func _() { _ = x[HandlerServerVerify-21] _ = x[HandlerTrace-22] _ = x[HandlerListen-23] - _ = x[handlerTest-24] - _ = x[handlerTest2-25] - _ = x[handlerLast-26] + _ = x[HandlerGetLocalDiskIDs-24] + _ = x[HandlerDeleteBucketMetadata-25] + _ = 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) {