package apemanager import ( "fmt" apemanager "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/apemanager/grpc" "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/grpc" "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message" ) func TargetTypeToGRPCField(typ TargetType) apemanager.TargetType { switch typ { case TargetTypeNamespace: return apemanager.TargetType_NAMESPACE case TargetTypeContainer: return apemanager.TargetType_CONTAINER case TargetTypeUser: return apemanager.TargetType_USER case TargetTypeGroup: return apemanager.TargetType_GROUP default: return apemanager.TargetType_UNDEFINED } } func TargetTypeFromGRPCField(typ apemanager.TargetType) TargetType { switch typ { case apemanager.TargetType_NAMESPACE: return TargetTypeNamespace case apemanager.TargetType_CONTAINER: return TargetTypeContainer case apemanager.TargetType_USER: return TargetTypeUser case apemanager.TargetType_GROUP: return TargetTypeGroup default: return TargetTypeUndefined } } func TargetTypeToGRPC(typ TargetType) apemanager.TargetType { return apemanager.TargetType(typ) } func TargetTypeFromGRPC(typ apemanager.TargetType) TargetType { return TargetType(typ) } func (v2 *ChainTarget) ToGRPCMessage() grpc.Message { var mgrpc *apemanager.ChainTarget if v2 != nil { mgrpc = new(apemanager.ChainTarget) mgrpc.SetType(TargetTypeToGRPC(v2.GetTargetType())) mgrpc.SetName(v2.GetName()) } return mgrpc } func (v2 *ChainTarget) FromGRPCMessage(m grpc.Message) error { mgrpc, ok := m.(*apemanager.ChainTarget) if !ok { return message.NewUnexpectedMessageType(m, mgrpc) } v2.SetTargetType(TargetTypeFromGRPC(mgrpc.GetType())) v2.SetName(mgrpc.GetName()) return nil } func (v2 *ChainRaw) ToGRPCMessage() grpc.Message { var mgrpc *apemanager.Chain_Raw if v2 != nil { mgrpc = new(apemanager.Chain_Raw) mgrpc.SetRaw(v2.GetRaw()) } return mgrpc } func (v2 *ChainRaw) FromGRPCMessage(m grpc.Message) error { mgrpc, ok := m.(*apemanager.Chain_Raw) if !ok { return message.NewUnexpectedMessageType(m, mgrpc) } v2.SetRaw(mgrpc.GetRaw()) return nil } func (v2 *Chain) ToGRPCMessage() grpc.Message { var mgrpc *apemanager.Chain if v2 != nil { mgrpc = new(apemanager.Chain) switch chainKind := v2.GetKind().(type) { default: panic(fmt.Sprintf("unsupported chain kind: %T", chainKind)) case *ChainRaw: mgrpc.SetKind(chainKind.ToGRPCMessage().(*apemanager.Chain_Raw)) } } return mgrpc } func (v2 *Chain) FromGRPCMessage(m grpc.Message) error { mgrpc, ok := m.(*apemanager.Chain) if !ok { return message.NewUnexpectedMessageType(m, mgrpc) } switch chainKind := mgrpc.GetKind().(type) { default: return fmt.Errorf("unsupported chain kind: %T", chainKind) case *apemanager.Chain_Raw: chainRaw := new(ChainRaw) if err := chainRaw.FromGRPCMessage(chainKind); err != nil { return err } v2.SetKind(chainRaw) } return nil } func (reqBody *AddChainRequestBody) ToGRPCMessage() grpc.Message { var reqBodygrpc *apemanager.AddChainRequest_Body if reqBody != nil { reqBodygrpc = new(apemanager.AddChainRequest_Body) reqBodygrpc.SetTarget(reqBody.GetTarget().ToGRPCMessage().(*apemanager.ChainTarget)) reqBodygrpc.SetChain(reqBody.GetChain().ToGRPCMessage().(*apemanager.Chain)) } return reqBodygrpc } func (reqBody *AddChainRequestBody) FromGRPCMessage(m grpc.Message) error { reqBodygrpc, ok := m.(*apemanager.AddChainRequest_Body) if !ok { return message.NewUnexpectedMessageType(m, reqBodygrpc) } if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil { reqBody.target = new(ChainTarget) if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil { return err } } if chaingrpc := reqBodygrpc.GetChain(); chaingrpc != nil { reqBody.chain = new(Chain) if err := reqBody.GetChain().FromGRPCMessage(chaingrpc); err != nil { return err } } return nil } func (req *AddChainRequest) ToGRPCMessage() grpc.Message { var reqgrpc *apemanager.AddChainRequest if req != nil { reqgrpc = new(apemanager.AddChainRequest) reqgrpc.SetBody(req.GetBody().ToGRPCMessage().(*apemanager.AddChainRequest_Body)) req.RequestHeaders.ToMessage(reqgrpc) } return reqgrpc } func (req *AddChainRequest) FromGRPCMessage(m grpc.Message) error { reqgrpc, ok := m.(*apemanager.AddChainRequest) if !ok { return message.NewUnexpectedMessageType(m, reqgrpc) } if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil { req.body = new(AddChainRequestBody) if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil { return err } } return req.RequestHeaders.FromMessage(reqgrpc) } func (respBody *AddChainResponseBody) ToGRPCMessage() grpc.Message { var respBodygrpc *apemanager.AddChainResponse_Body if respBody != nil { respBodygrpc = new(apemanager.AddChainResponse_Body) respBodygrpc.SetChainID(respBody.GetChainID()) } return respBodygrpc } func (respBody *AddChainResponseBody) FromGRPCMessage(m grpc.Message) error { respBodygrpc, ok := m.(*apemanager.AddChainResponse_Body) if !ok { return message.NewUnexpectedMessageType(m, respBodygrpc) } respBody.SetChainID(respBodygrpc.GetChainId()) return nil } func (resp *AddChainResponse) ToGRPCMessage() grpc.Message { var respgrpc *apemanager.AddChainResponse if resp != nil { respgrpc = new(apemanager.AddChainResponse) respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.AddChainResponse_Body)) resp.ResponseHeaders.ToMessage(respgrpc) } return respgrpc } func (resp *AddChainResponse) FromGRPCMessage(m grpc.Message) error { respgrpc, ok := m.(*apemanager.AddChainResponse) if !ok { return message.NewUnexpectedMessageType(m, respgrpc) } if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil { resp.body = new(AddChainResponseBody) if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil { return err } } return resp.ResponseHeaders.FromMessage(respgrpc) } func (reqBody *RemoveChainRequestBody) ToGRPCMessage() grpc.Message { var reqBodygrpc *apemanager.RemoveChainRequest_Body if reqBody != nil { reqBodygrpc = new(apemanager.RemoveChainRequest_Body) reqBodygrpc.SetTarget(reqBody.target.ToGRPCMessage().(*apemanager.ChainTarget)) reqBodygrpc.SetChainID(reqBody.GetChainID()) } return reqBodygrpc } func (reqBody *RemoveChainRequestBody) FromGRPCMessage(m grpc.Message) error { reqBodygrpc, ok := m.(*apemanager.RemoveChainRequest_Body) if !ok { return message.NewUnexpectedMessageType(m, reqBodygrpc) } if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil { reqBody.target = new(ChainTarget) if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil { return err } } reqBody.SetChainID(reqBodygrpc.GetChainId()) return nil } func (req *RemoveChainRequest) ToGRPCMessage() grpc.Message { var reqgrpc *apemanager.RemoveChainRequest if req != nil { reqgrpc = new(apemanager.RemoveChainRequest) reqgrpc.SetBody(req.body.ToGRPCMessage().(*apemanager.RemoveChainRequest_Body)) req.RequestHeaders.ToMessage(reqgrpc) } return reqgrpc } func (req *RemoveChainRequest) FromGRPCMessage(m grpc.Message) error { reqgrpc, ok := m.(*apemanager.RemoveChainRequest) if !ok { return message.NewUnexpectedMessageType(m, reqgrpc) } if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil { req.body = new(RemoveChainRequestBody) if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil { return err } } return req.RequestHeaders.FromMessage(reqgrpc) } func (respBody *RemoveChainResponseBody) ToGRPCMessage() grpc.Message { var respBodygrpc *apemanager.RemoveChainResponse_Body if respBody != nil { respBodygrpc = new(apemanager.RemoveChainResponse_Body) } return respBodygrpc } func (respBody *RemoveChainResponseBody) FromGRPCMessage(m grpc.Message) error { respBodygrpc, ok := m.(*apemanager.RemoveChainResponse_Body) if !ok { return message.NewUnexpectedMessageType(m, respBodygrpc) } return nil } func (resp *RemoveChainResponse) ToGRPCMessage() grpc.Message { var respgrpc *apemanager.RemoveChainResponse if resp != nil { respgrpc = new(apemanager.RemoveChainResponse) respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.RemoveChainResponse_Body)) resp.ResponseHeaders.ToMessage(respgrpc) } return respgrpc } func (resp *RemoveChainResponse) FromGRPCMessage(m grpc.Message) error { respgrpc, ok := m.(*apemanager.RemoveChainResponse) if !ok { return message.NewUnexpectedMessageType(m, respgrpc) } if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil { resp.body = new(RemoveChainResponseBody) if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil { return err } } return resp.ResponseHeaders.FromMessage(respgrpc) } func (reqBody *ListChainsRequestBody) ToGRPCMessage() grpc.Message { var reqBodygrpc *apemanager.ListChainsRequest_Body if reqBody != nil { reqBodygrpc = new(apemanager.ListChainsRequest_Body) reqBodygrpc.SetTarget(reqBody.target.ToGRPCMessage().(*apemanager.ChainTarget)) } return reqBodygrpc } func (reqBody *ListChainsRequestBody) FromGRPCMessage(m grpc.Message) error { reqBodygrpc, ok := m.(*apemanager.ListChainsRequest_Body) if !ok { return message.NewUnexpectedMessageType(m, reqBodygrpc) } if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil { reqBody.target = new(ChainTarget) if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil { return err } } return nil } func (req *ListChainsRequest) ToGRPCMessage() grpc.Message { var reqgrpc *apemanager.ListChainsRequest if req != nil { reqgrpc = new(apemanager.ListChainsRequest) reqgrpc.SetBody(req.body.ToGRPCMessage().(*apemanager.ListChainsRequest_Body)) req.RequestHeaders.ToMessage(reqgrpc) } return reqgrpc } func (req *ListChainsRequest) FromGRPCMessage(m grpc.Message) error { reqgrpc, ok := m.(*apemanager.ListChainsRequest) if !ok { return message.NewUnexpectedMessageType(m, reqgrpc) } if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil { req.body = new(ListChainsRequestBody) if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil { return err } } return req.RequestHeaders.FromMessage(reqgrpc) } func (respBody *ListChainsResponseBody) ToGRPCMessage() grpc.Message { var respBodygrpc *apemanager.ListChainsResponse_Body if respBody != nil { respBodygrpc = new(apemanager.ListChainsResponse_Body) chainsgrpc := make([]*apemanager.Chain, 0, len(respBody.GetChains())) for _, chain := range respBody.GetChains() { chainsgrpc = append(chainsgrpc, chain.ToGRPCMessage().(*apemanager.Chain)) } respBodygrpc.SetChains(chainsgrpc) } return respBodygrpc } func (respBody *ListChainsResponseBody) FromGRPCMessage(m grpc.Message) error { respBodygrpc, ok := m.(*apemanager.ListChainsResponse_Body) if !ok { return message.NewUnexpectedMessageType(m, respBodygrpc) } chains := make([]*Chain, 0, len(respBodygrpc.GetChains())) for _, chaingrpc := range respBodygrpc.GetChains() { chain := new(Chain) if err := chain.FromGRPCMessage(chaingrpc); err != nil { return err } chains = append(chains, chain) } respBody.SetChains(chains) return nil } func (resp *ListChainsResponse) ToGRPCMessage() grpc.Message { var respgrpc *apemanager.ListChainsResponse if resp != nil { respgrpc = new(apemanager.ListChainsResponse) respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.ListChainsResponse_Body)) resp.ResponseHeaders.ToMessage(respgrpc) } return respgrpc } func (resp *ListChainsResponse) FromGRPCMessage(m grpc.Message) error { respgrpc, ok := m.(*apemanager.ListChainsResponse) if !ok { return message.NewUnexpectedMessageType(m, respgrpc) } if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil { resp.body = new(ListChainsResponseBody) if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil { return err } } return resp.ResponseHeaders.FromMessage(respgrpc) }