From d2ee6b469a3e5ac047eaa244db6f9efefb3716ae Mon Sep 17 00:00:00 2001 From: Alex Vanin Date: Thu, 21 Jan 2021 17:57:04 +0300 Subject: [PATCH] [#245] v2/container: Add AnnounceUsedSpace method Signed-off-by: Alex Vanin --- v2/container/client.go | 34 +++++++ v2/container/convert.go | 160 +++++++++++++++++++++++++++++++ v2/container/grpc/client.go | 4 + v2/container/grpc/service.go | 63 ++++++++++++ v2/container/grpc/service.pb.go | Bin 103802 -> 123969 bytes v2/container/marshal.go | 91 ++++++++++++++++++ v2/container/marshal_test.go | 59 ++++++++++++ v2/container/service.go | 17 ++++ v2/container/test/client_test.go | 156 ++++++++++++++++++++++++++++-- v2/container/types.go | 138 ++++++++++++++++++++++++++ v2/signature/sign.go | 4 + 11 files changed, 718 insertions(+), 8 deletions(-) diff --git a/v2/container/client.go b/v2/container/client.go index bffe3b8..c0921b6 100644 --- a/v2/container/client.go +++ b/v2/container/client.go @@ -23,6 +23,8 @@ type Client struct { cSetEACL *setEACLClient cGetEACL *getEACLClient + + cAnnounce *announceUsedSpaceClient } // Option represents Client option. @@ -94,6 +96,14 @@ type getEACLClient struct { responseConverter func(interface{}) *GetExtendedACLResponse } +type announceUsedSpaceClient struct { + requestConverter func(request *AnnounceUsedSpaceRequest) interface{} + + caller func(context.Context, interface{}) (interface{}, error) + + responseConverter func(interface{}) *AnnounceUsedSpaceResponse +} + // Put sends PutRequest over the network and returns PutResponse. // // It returns any error encountered during the call. @@ -166,6 +176,19 @@ func (c *Client) GetExtendedACL(ctx context.Context, req *GetExtendedACLRequest) return c.cGetEACL.responseConverter(resp), nil } +// AnnounceUsedSpace sends AnnounceUsedSpaceRequest over the network and returns +// AnnounceUsedSpaceResponse. +// +// It returns any error encountered during the call. +func (c *Client) AnnounceUsedSpace(ctx context.Context, req *AnnounceUsedSpaceRequest) (*AnnounceUsedSpaceResponse, error) { + resp, err := c.cAnnounce.caller(ctx, c.cAnnounce.requestConverter(req)) + if err != nil { + return nil, errors.Wrap(err, "could not send announce used space request") + } + + return c.cAnnounce.responseConverter(resp), nil +} + func defaultCfg() *cfg { return &cfg{ proto: client.ProtoGRPC, @@ -255,6 +278,17 @@ func NewClient(opts ...Option) (*Client, error) { return GetExtendedACLResponseFromGRPCMessage(resp.(*container.GetExtendedACLResponse)) }, }, + cAnnounce: &announceUsedSpaceClient{ + requestConverter: func(req *AnnounceUsedSpaceRequest) interface{} { + return AnnounceUsedSpaceRequestToGRPCMessage(req) + }, + caller: func(ctx context.Context, req interface{}) (interface{}, error) { + return c.AnnounceUsedSpace(ctx, req.(*container.AnnounceUsedSpaceRequest)) + }, + responseConverter: func(resp interface{}) *AnnounceUsedSpaceResponse { + return AnnounceUsedSpaceResponseFromGRPCMessage(resp.(*container.AnnounceUsedSpaceResponse)) + }, + }, }, nil default: err = client.ErrProtoUnsupported diff --git a/v2/container/convert.go b/v2/container/convert.go index b60d9a3..d40813f 100644 --- a/v2/container/convert.go +++ b/v2/container/convert.go @@ -849,3 +849,163 @@ func GetExtendedACLResponseFromGRPCMessage(m *container.GetExtendedACLResponse) return r } + +func UsedSpaceAnnouncementToGRPCMessage(a *UsedSpaceAnnouncement) *container.AnnounceUsedSpaceRequest_Body_Announcement { + if a == nil { + return nil + } + + m := new(container.AnnounceUsedSpaceRequest_Body_Announcement) + + m.SetContainerId( + refs.ContainerIDToGRPCMessage(a.GetContainerID()), + ) + + m.SetUsedSpace(a.GetUsedSpace()) + + return m +} + +func UsedSpaceAnnouncementFromGRPCMessage(m *container.AnnounceUsedSpaceRequest_Body_Announcement) *UsedSpaceAnnouncement { + if m == nil { + return nil + } + + a := new(UsedSpaceAnnouncement) + + a.SetContainerID( + refs.ContainerIDFromGRPCMessage(m.GetContainerId()), + ) + + a.SetUsedSpace(m.GetUsedSpace()) + + return a +} + +func AnnounceUsedSpaceRequestBodyToGRPCMessage(r *AnnounceUsedSpaceRequestBody) *container.AnnounceUsedSpaceRequest_Body { + if r == nil { + return nil + } + + m := new(container.AnnounceUsedSpaceRequest_Body) + + announcements := r.GetAnnouncements() + msgAnnouncements := make([]*container.AnnounceUsedSpaceRequest_Body_Announcement, 0, len(announcements)) + + for i := range announcements { + msgAnnouncements = append( + msgAnnouncements, + UsedSpaceAnnouncementToGRPCMessage(announcements[i]), + ) + } + + m.SetAnnouncements(msgAnnouncements) + + return m +} + +func AnnounceUsedSpaceRequestBodyFromGRPCMessage(m *container.AnnounceUsedSpaceRequest_Body) *AnnounceUsedSpaceRequestBody { + if m == nil { + return nil + } + + r := new(AnnounceUsedSpaceRequestBody) + + msgAnnouncements := m.GetAnnouncements() + announcements := make([]*UsedSpaceAnnouncement, 0, len(msgAnnouncements)) + + for i := range msgAnnouncements { + announcements = append( + announcements, + UsedSpaceAnnouncementFromGRPCMessage(msgAnnouncements[i]), + ) + } + + r.SetAnnouncements(announcements) + + return r +} + +func AnnounceUsedSpaceRequestToGRPCMessage(r *AnnounceUsedSpaceRequest) *container.AnnounceUsedSpaceRequest { + if r == nil { + return nil + } + + m := new(container.AnnounceUsedSpaceRequest) + + m.SetBody( + AnnounceUsedSpaceRequestBodyToGRPCMessage(r.GetBody()), + ) + + session.RequestHeadersToGRPC(r, m) + + return m +} + +func AnnounceUsedSpaceRequestFromGRPCMessage(m *container.AnnounceUsedSpaceRequest) *AnnounceUsedSpaceRequest { + if m == nil { + return nil + } + + r := new(AnnounceUsedSpaceRequest) + + r.SetBody( + AnnounceUsedSpaceRequestBodyFromGRPCMessage(m.GetBody()), + ) + + session.RequestHeadersFromGRPC(m, r) + + return r +} + +func AnnounceUsedSpaceResponseBodyToGRPCMessage(r *AnnounceUsedSpaceResponseBody) *container.AnnounceUsedSpaceResponse_Body { + if r == nil { + return nil + } + + m := new(container.AnnounceUsedSpaceResponse_Body) + + return m +} + +func AnnounceUsedSpaceResponseBodyFromGRPCMessage(m *container.AnnounceUsedSpaceResponse_Body) *AnnounceUsedSpaceResponseBody { + if m == nil { + return nil + } + + r := new(AnnounceUsedSpaceResponseBody) + + return r +} + +func AnnounceUsedSpaceResponseToGRPCMessage(r *AnnounceUsedSpaceResponse) *container.AnnounceUsedSpaceResponse { + if r == nil { + return nil + } + + m := new(container.AnnounceUsedSpaceResponse) + + m.SetBody( + AnnounceUsedSpaceResponseBodyToGRPCMessage(r.GetBody()), + ) + + session.ResponseHeadersToGRPC(r, m) + + return m +} + +func AnnounceUsedSpaceResponseFromGRPCMessage(m *container.AnnounceUsedSpaceResponse) *AnnounceUsedSpaceResponse { + if m == nil { + return nil + } + + r := new(AnnounceUsedSpaceResponse) + + r.SetBody( + AnnounceUsedSpaceResponseBodyFromGRPCMessage(m.GetBody()), + ) + + session.ResponseHeadersFromGRPC(m, r) + + return r +} diff --git a/v2/container/grpc/client.go b/v2/container/grpc/client.go index 8e3cdf9..7e126d2 100644 --- a/v2/container/grpc/client.go +++ b/v2/container/grpc/client.go @@ -73,6 +73,10 @@ func (c *Client) GetExtendedACL(ctx context.Context, req *GetExtendedACLRequest) return c.client.GetExtendedACL(ctx, req, c.callOpts...) } +func (c *Client) AnnounceUsedSpace(ctx context.Context, req *AnnounceUsedSpaceRequest) (*AnnounceUsedSpaceResponse, error) { + return c.client.AnnounceUsedSpace(ctx, req, c.callOpts...) +} + // WithCallOptions returns Option that configures // Client to attach call options to each rpc call. func WithCallOptions(opts []grpc.CallOption) Option { diff --git a/v2/container/grpc/service.go b/v2/container/grpc/service.go index 61648b5..98c5cc6 100644 --- a/v2/container/grpc/service.go +++ b/v2/container/grpc/service.go @@ -353,3 +353,66 @@ func (m *GetExtendedACLResponse) SetVerifyHeader(v *session.ResponseVerification m.VerifyHeader = v } } + +// SetContainerId sets identifier of the container. +func (m *AnnounceUsedSpaceRequest_Body_Announcement) SetContainerId(v *refs.ContainerID) { + if m != nil { + m.ContainerId = v + } +} + +// SetUsedSpace sets used space value of the container. +func (m *AnnounceUsedSpaceRequest_Body_Announcement) SetUsedSpace(v uint64) { + if m != nil { + m.UsedSpace = v + } +} + +// SetAnnouncements sets list of announcement for shared containers between nodes. +func (m *AnnounceUsedSpaceRequest_Body) SetAnnouncements(v []*AnnounceUsedSpaceRequest_Body_Announcement) { + if m != nil { + m.Announcements = v + } +} + +// SetBody sets body of the request. +func (m *AnnounceUsedSpaceRequest) SetBody(v *AnnounceUsedSpaceRequest_Body) { + if m != nil { + m.Body = v + } +} + +// SetMetaHeader sets meta header of the request. +func (m *AnnounceUsedSpaceRequest) SetMetaHeader(v *session.RequestMetaHeader) { + if m != nil { + m.MetaHeader = v + } +} + +// SetVerifyHeader sets verification header of the request. +func (m *AnnounceUsedSpaceRequest) SetVerifyHeader(v *session.RequestVerificationHeader) { + if m != nil { + m.VerifyHeader = v + } +} + +// SetBody sets body of the response. +func (m *AnnounceUsedSpaceResponse) SetBody(v *AnnounceUsedSpaceResponse_Body) { + if m != nil { + m.Body = v + } +} + +// SetMetaHeader sets meta header of the response. +func (m *AnnounceUsedSpaceResponse) SetMetaHeader(v *session.ResponseMetaHeader) { + if m != nil { + m.MetaHeader = v + } +} + +// SetVerifyHeader sets verification header of the response. +func (m *AnnounceUsedSpaceResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) { + if m != nil { + m.VerifyHeader = v + } +} diff --git a/v2/container/grpc/service.pb.go b/v2/container/grpc/service.pb.go index 809418fc92496b8d0ad0ce21f3b748eaa44ccbd5..2951a95b95a5c4e5e531dcfc69610ae7e3da896b 100644 GIT binary patch delta 9298 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 RpEt{}1{u@5KNB delta 2926 zcmZ8jdr*|u6`!;0i{-UGKm#gkbc`ej%d)$$YJr4|3bKliVk56bT@(;l5CIjIC7{G9 zRq!CkC%zK3)u_$dP=gwXeK=-H+eu^EOjI1jPUE8{O`DEWrRRR%uC)Gh=ic8r=XcNZ ze&4`V&6A(0&%IQF{a19}?>FxWz^rm7_HR|;S*;57ZVjGoPsasK`?0TL7%Ox-RPT-Z zpgC8GmRh0rEuN?w_EOs+CGK=P@mW*|j6Q5gaIz@(t7)Lj0?crtwKqQ zm#3?{i$IN)C*H&#?>dGbY!k{_Z&cSw1zOvk*zl?jPqt@b1MNrr$uK@nRC!^qJpczg zo#?g%;pGE=#W)m#Ak=&qhnq}6-oc(x{t4^V9Hf|7HyS#jtl|;4-Lci>eLtuyf2bFMP2f-;ijEH5lt{ ztHo+GOKXu>6O6ICKx4g`roIjqs+b3_D0G3eC=(*-+&l=Qx=a|0Ke{~~4fiHdM;6RQ z&sTx0vbzex=?_|%OksA=(60F~gDSG1Kx>f+lc*CQnTG5TNQDa^icN6mKO$-O0tjP1 ztGHz#6Jls61FRTw-$HsjsHrYP<|$N~*)JN&fEYB~S5m*7ReR=vxSAYn_aet6bUlfr z8Y{f~+@WOBzYccB$K%txag?3OeooASSV6IKJ}m3b0VSnrK#RA&dAWNbOHXUr<>Cw& zLlJg}#O&|N1T>utV?ay0r!aSQHjJhB!eN#m>5pb-|B?+;G40P2@%Q(a(pQT(W$vZ0 zOr$21VrGC|cIW;QFwwa;IcLkG;S*JYNkr$$=AbI4Lz+y&*Riu>D0GpOE<0Y_IfM&_s!U|Nrf>V3?>q))WS3rpZ z%#^kgD(J#WSWJ!r&g+C+$fAl|SW2Jfaynx2SkRIO*>qDZwtQGZyYpcsJ;{e$YA%N; z>Zs-HbQHjA^qT^1#lb>&MW(9Cg$a~a3PCi(0r4`nuTaKR1?@s`xSCrrz7_a}$9mqS6hn+k5LhT}Emx936*ZN@ zc+#xp0lSf-qmPT3<)bySnVyEKAy^1wXr@!f>~ze@uHWDZy}A}&QwuuVY)bI33(@N! zMgWP%*;LrXQ(nseeOb(wed{2J=B(viXbCLhw$3ksLT-RdCEyG&Sz@U?mkGFD%Qf66 zf`i7aW)~Tes->YzrI4&OaWApZ{Gu?r3{n-QByyBNwZa@rH}aV6?`4po<_>2As&a8o z83?7jC6J=!8wH$9osB%HzgrI(8X2((WD2>;Igbmfc~Vo0AY5UxQd2pUi5ni2L#;;k zB0;VLH%Yoyz9zxvwbVBcDj-D)ZKRM3B|*z8A%pYKQwc?a6I`%PaF)5)>x5*w<$_gy zCYv1MXj7F|i4ZMxstT$U2{xKi4Xge6@O1<$X9>PX)lfq>U7%K&q)f$9X)VkU?WWQN znm9f7HNv9}oZpZdND-{|8fc)&)f}~yDX9gY)j)cnFXN_U`eO~uqJ{O48fZ$AvS+f% zSbsfaYWPbbRqf|hoM`UF2ytgRSNKdV`^z^>t%C-BntJM>&QF@?tE0bl=LzTA>%mQp zo7t1wc}yjZaC8IA(VA?&D0cg*^@m`VLgRYaS@5tC3{>HP#eRci*%^OQqn0?Lhf=XU9 zm_$Uva|?+=@R;i9^SAj;Zf)|Nl3E~*A4(CIBt6suvuT+JCQ2u0g}HRae=2KZ^M|ec z1>;@`r_-(cCADxoE&R0HY~_UVlit}3lO)s6wsLBime|OU_YVHT_w5MkeY6ikK^#NH-y~)Cz^|yelQjwsvDLQ+dDn25cjFGh zLfU_XcL|4i_t8