281 lines
9.0 KiB
Go
281 lines
9.0 KiB
Go
package control
|
|
|
|
import (
|
|
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/client"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/common"
|
|
)
|
|
|
|
const serviceName = "control.ControlService"
|
|
|
|
const (
|
|
rpcHealthCheck = "HealthCheck"
|
|
rpcSetNetmapStatus = "SetNetmapStatus"
|
|
rpcDropObjects = "DropObjects"
|
|
rpcListShards = "ListShards"
|
|
rpcSetShardMode = "SetShardMode"
|
|
rpcSynchronizeTree = "SynchronizeTree"
|
|
rpcEvacuateShard = "EvacuateShard"
|
|
rpcStartShardEvacuation = "StartShardEvacuation"
|
|
rpcGetShardEvacuationStatus = "GetShardEvacuationStatus"
|
|
rpcStopShardEvacuation = "StopShardEvacuation"
|
|
rpcFlushCache = "FlushCache"
|
|
rpcDoctor = "Doctor"
|
|
rpcAddChainLocalOverride = "AddChainLocalOverride"
|
|
rpcGetChainLocalOverride = "GetChainLocalOverride"
|
|
rpcListChainLocalOverrides = "ListChainLocalOverrides"
|
|
rpcRemoveChainLocalOverride = "RemoveChainLocalOverride"
|
|
rpcSealWriteCache = "SealWriteCache"
|
|
)
|
|
|
|
// HealthCheck executes ControlService.HealthCheck RPC.
|
|
func HealthCheck(
|
|
cli *client.Client,
|
|
req *HealthCheckRequest,
|
|
opts ...client.CallOption,
|
|
) (*HealthCheckResponse, error) {
|
|
wResp := newResponseWrapper[HealthCheckResponse]()
|
|
wReq := &requestWrapper{
|
|
m: req,
|
|
}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcHealthCheck), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// SetNetmapStatus executes ControlService.SetNetmapStatus RPC.
|
|
func SetNetmapStatus(
|
|
cli *client.Client,
|
|
req *SetNetmapStatusRequest,
|
|
opts ...client.CallOption,
|
|
) (*SetNetmapStatusResponse, error) {
|
|
wResp := newResponseWrapper[SetNetmapStatusResponse]()
|
|
|
|
wReq := &requestWrapper{
|
|
m: req,
|
|
}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcSetNetmapStatus), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// DropObjects executes ControlService.DropObjects RPC.
|
|
func DropObjects(
|
|
cli *client.Client,
|
|
req *DropObjectsRequest,
|
|
opts ...client.CallOption,
|
|
) (*DropObjectsResponse, error) {
|
|
wResp := newResponseWrapper[DropObjectsResponse]()
|
|
|
|
wReq := &requestWrapper{
|
|
m: req,
|
|
}
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcDropObjects), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// ListShards executes ControlService.ListShards RPC.
|
|
func ListShards(
|
|
cli *client.Client,
|
|
req *ListShardsRequest,
|
|
opts ...client.CallOption,
|
|
) (*ListShardsResponse, error) {
|
|
wResp := newResponseWrapper[ListShardsResponse]()
|
|
|
|
wReq := &requestWrapper{
|
|
m: req,
|
|
}
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcListShards), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// SetShardMode executes ControlService.SetShardMode RPC.
|
|
func SetShardMode(
|
|
cli *client.Client,
|
|
req *SetShardModeRequest,
|
|
opts ...client.CallOption,
|
|
) (*SetShardModeResponse, error) {
|
|
wResp := newResponseWrapper[SetShardModeResponse]()
|
|
|
|
wReq := &requestWrapper{
|
|
m: req,
|
|
}
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcSetShardMode), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// SynchronizeTree executes ControlService.SynchronizeTree RPC.
|
|
func SynchronizeTree(cli *client.Client, req *SynchronizeTreeRequest, opts ...client.CallOption) (*SynchronizeTreeResponse, error) {
|
|
wResp := newResponseWrapper[SynchronizeTreeResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcSynchronizeTree), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// EvacuateShard executes ControlService.EvacuateShard RPC.
|
|
func EvacuateShard(cli *client.Client, req *EvacuateShardRequest, opts ...client.CallOption) (*EvacuateShardResponse, error) {
|
|
wResp := newResponseWrapper[EvacuateShardResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcEvacuateShard), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// StartShardEvacuation executes ControlService.StartShardEvacuation RPC.
|
|
func StartShardEvacuation(cli *client.Client, req *StartShardEvacuationRequest, opts ...client.CallOption) (*StartShardEvacuationResponse, error) {
|
|
wResp := newResponseWrapper[StartShardEvacuationResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcStartShardEvacuation), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// GetShardEvacuationStatus executes ControlService.GetShardEvacuationStatus RPC.
|
|
func GetShardEvacuationStatus(cli *client.Client, req *GetShardEvacuationStatusRequest, opts ...client.CallOption) (*GetShardEvacuationStatusResponse, error) {
|
|
wResp := newResponseWrapper[GetShardEvacuationStatusResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcGetShardEvacuationStatus), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// StopShardEvacuation executes ControlService.StopShardEvacuation RPC.
|
|
func StopShardEvacuation(cli *client.Client, req *StopShardEvacuationRequest, opts ...client.CallOption) (*StopShardEvacuationResponse, error) {
|
|
wResp := newResponseWrapper[StopShardEvacuationResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcStopShardEvacuation), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// FlushCache executes ControlService.FlushCache RPC.
|
|
func FlushCache(cli *client.Client, req *FlushCacheRequest, opts ...client.CallOption) (*FlushCacheResponse, error) {
|
|
wResp := newResponseWrapper[FlushCacheResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcFlushCache), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// Doctor executes ControlService.Doctor RPC.
|
|
func Doctor(cli *client.Client, req *DoctorRequest, opts ...client.CallOption) (*DoctorResponse, error) {
|
|
wResp := newResponseWrapper[DoctorResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcDoctor), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// AddChainLocalOverride executes ControlService.AddChainLocalOverride RPC.
|
|
func AddChainLocalOverride(cli *client.Client, req *AddChainLocalOverrideRequest, opts ...client.CallOption) (*AddChainLocalOverrideResponse, error) {
|
|
wResp := newResponseWrapper[AddChainLocalOverrideResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcAddChainLocalOverride), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// ListChainLocalOverrides executes ControlService.ListChainLocalOverrides RPC.
|
|
func ListChainLocalOverrides(cli *client.Client, req *ListChainLocalOverridesRequest, opts ...client.CallOption) (*ListChainLocalOverridesResponse, error) {
|
|
wResp := newResponseWrapper[ListChainLocalOverridesResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcListChainLocalOverrides), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// RemoveChainLocalOverride executes ControlService.RemoveChainLocalOverride RPC.
|
|
func GetChainLocalOverride(cli *client.Client, req *GetChainLocalOverrideRequest, opts ...client.CallOption) (*GetChainLocalOverrideResponse, error) {
|
|
wResp := newResponseWrapper[GetChainLocalOverrideResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcGetChainLocalOverride), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// RemoveChainLocalOverride executes ControlService.RemoveChainLocalOverride RPC.
|
|
func RemoveChainLocalOverride(cli *client.Client, req *RemoveChainLocalOverrideRequest, opts ...client.CallOption) (*RemoveChainLocalOverrideResponse, error) {
|
|
wResp := newResponseWrapper[RemoveChainLocalOverrideResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcRemoveChainLocalOverride), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|
|
|
|
// SealWriteCache executes ControlService.SealWriteCache RPC.
|
|
func SealWriteCache(cli *client.Client, req *SealWriteCacheRequest, opts ...client.CallOption) (*SealWriteCacheResponse, error) {
|
|
wResp := newResponseWrapper[SealWriteCacheResponse]()
|
|
wReq := &requestWrapper{m: req}
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceName, rpcSealWriteCache), wReq, wResp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return wResp.message, nil
|
|
}
|