frostfs-api-go/v2/convert.go

352 lines
6.1 KiB
Go
Raw Normal View History

package v2
import (
"github.com/nspcc-dev/neofs-api-go/v2/accounting"
"github.com/nspcc-dev/neofs-api-go/v2/refs"
"github.com/nspcc-dev/neofs-api-go/v2/service"
)
func SignatureToGRPCMessage(s *Signature) *service.Signature {
if s == nil {
return nil
}
m := new(service.Signature)
m.SetKey(s.GetKey())
m.SetSign(s.GetSign())
return m
}
func SignatureFromGRPCMessage(m *service.Signature) *Signature {
if m == nil {
return nil
}
s := new(Signature)
s.SetKey(m.GetKey())
s.SetSign(m.GetSign())
return s
}
func VersionToGRPCMessage(v *Version) *service.Version {
if v == nil {
return nil
}
msg := new(service.Version)
msg.SetMajor(v.GetMajor())
msg.SetMinor(v.GetMinor())
return msg
}
func VersionFromGRPCMessage(m *service.Version) *Version {
if m == nil {
return nil
}
v := new(Version)
v.SetMajor(m.GetMajor())
v.SetMinor(m.GetMinor())
return v
}
func XHeaderToGRPCMessage(x *XHeader) *service.XHeader {
if x == nil {
return nil
}
m := new(service.XHeader)
m.SetKey(x.GetKey())
m.SetValue(x.GetValue())
return m
}
func XHeaderFromGRPCMessage(m *service.XHeader) *XHeader {
if m == nil {
return nil
}
x := new(XHeader)
x.SetKey(m.GetKey())
x.SetValue(m.GetValue())
return x
}
func SessionTokenToGRPCMessage(t *SessionToken) *service.SessionToken {
// TODO: fill me
return nil
}
func SessionTokenFromGRPCMessage(m *service.SessionToken) *SessionToken {
// TODO: fill me
return nil
}
func BearerTokenToGRPCMessage(t *BearerToken) *service.BearerToken {
// TODO: fill me
return nil
}
func BearerTokenFromGRPCMessage(m *service.BearerToken) *BearerToken {
// TODO: fill me
return nil
}
func RequestVerificationHeaderToGRPCMessage(r *RequestVerificationHeader) *service.RequestVerificationHeader {
if r == nil {
return nil
}
m := new(service.RequestVerificationHeader)
m.SetBodySignature(
SignatureToGRPCMessage(r.GetBodySignature()),
)
m.SetMetaSignature(
SignatureToGRPCMessage(r.GetMetaSignature()),
)
m.SetOriginSignature(
SignatureToGRPCMessage(r.GetOriginSignature()),
)
m.SetOrigin(
RequestVerificationHeaderToGRPCMessage(r.GetOrigin()),
)
return m
}
func RequestVerificationHeaderFromGRPCMessage(m *service.RequestVerificationHeader) *RequestVerificationHeader {
if m == nil {
return nil
}
r := new(RequestVerificationHeader)
r.SetBodySignature(
SignatureFromGRPCMessage(m.GetBodySignature()),
)
r.SetMetaSignature(
SignatureFromGRPCMessage(m.GetMetaSignature()),
)
r.SetOriginSignature(
SignatureFromGRPCMessage(m.GetOriginSignature()),
)
r.SetOrigin(
RequestVerificationHeaderFromGRPCMessage(m.GetOrigin()),
)
return r
}
func RequestMetaHeaderToGRPCMessage(r *RequestMetaHeader) *service.RequestMetaHeader {
if r == nil {
return nil
}
m := new(service.RequestMetaHeader)
m.SetTtl(r.GetTTL())
m.SetEpoch(r.GetEpoch())
m.SetVersion(
VersionToGRPCMessage(r.GetVersion()),
)
m.SetSessionToken(
SessionTokenToGRPCMessage(r.GetSessionToken()),
)
m.SetBearerToken(
BearerTokenToGRPCMessage(r.GetBearerToken()),
)
m.SetOrigin(
RequestMetaHeaderToGRPCMessage(r.GetOrigin()),
)
xHeaders := r.GetXHeaders()
xHdrMsg := make([]*service.XHeader, 0, len(xHeaders))
for i := range xHeaders {
xHdrMsg = append(xHdrMsg, XHeaderToGRPCMessage(xHeaders[i]))
}
return m
}
func RequestMetaHeaderFromGRPCMessage(m *service.RequestMetaHeader) *RequestMetaHeader {
if m == nil {
return nil
}
r := new(RequestMetaHeader)
r.SetTTL(m.GetTtl())
r.SetEpoch(m.GetEpoch())
r.SetVersion(
VersionFromGRPCMessage(m.GetVersion()),
)
r.SetSessionToken(
SessionTokenFromGRPCMessage(m.GetSessionToken()),
)
r.SetBearerToken(
BearerTokenFromGRPCMessage(m.GetBearerToken()),
)
r.SetOrigin(
RequestMetaHeaderFromGRPCMessage(m.GetOrigin()),
)
xHdrMsg := m.GetXHeaders()
xHeaders := make([]*XHeader, 0, len(xHdrMsg))
for i := range xHdrMsg {
xHeaders = append(xHeaders, XHeaderFromGRPCMessage(xHdrMsg[i]))
}
return r
}
func OwnerIDToGRPCMessage(o *OwnerID) *refs.OwnerID {
if o == nil {
return nil
}
m := new(refs.OwnerID)
m.SetValue(o.GetValue())
return m
}
func OwnerIDFromGRPCMessage(m *refs.OwnerID) *OwnerID {
if m == nil {
return nil
}
o := new(OwnerID)
o.SetValue(m.GetValue())
return o
}
func BalanceRequestBodyToGRPCMessage(b *BalanceRequestBody) *accounting.BalanceRequest_Body {
if b == nil {
return nil
}
m := new(accounting.BalanceRequest_Body)
m.SetOwnerId(
OwnerIDToGRPCMessage(b.GetOwnerID()),
)
return m
}
func BalanceRequestBodyFromGRPCMessage(m *accounting.BalanceRequest_Body) *BalanceRequestBody {
if m == nil {
return nil
}
b := new(BalanceRequestBody)
b.SetOwnerID(
OwnerIDFromGRPCMessage(m.GetOwnerId()),
)
return b
}
func headersToGRPC(
src interface {
GetRequestMetaHeader() *RequestMetaHeader
GetRequestVerificationHeader() *RequestVerificationHeader
},
dst interface {
SetMetaHeader(*service.RequestMetaHeader)
SetVerifyHeader(*service.RequestVerificationHeader)
},
) {
dst.SetMetaHeader(
RequestMetaHeaderToGRPCMessage(src.GetRequestMetaHeader()),
)
dst.SetVerifyHeader(
RequestVerificationHeaderToGRPCMessage(src.GetRequestVerificationHeader()),
)
}
func headersFromGRPC(
src interface {
GetMetaHeader() *service.RequestMetaHeader
GetVerifyHeader() *service.RequestVerificationHeader
},
dst interface {
SetRequestMetaHeader(*RequestMetaHeader)
SetRequestVerificationHeader(*RequestVerificationHeader)
},
) {
dst.SetRequestMetaHeader(
RequestMetaHeaderFromGRPCMessage(src.GetMetaHeader()),
)
dst.SetRequestVerificationHeader(
RequestVerificationHeaderFromGRPCMessage(src.GetVerifyHeader()),
)
}
func BalanceRequestToGRPCMessage(b *BalanceRequest) *accounting.BalanceRequest {
if b == nil {
return nil
}
m := new(accounting.BalanceRequest)
m.SetBody(
BalanceRequestBodyToGRPCMessage(b.GetBody()),
)
headersToGRPC(b, m)
return m
}
func BalanceRequestFromGRPCMessage(m *accounting.BalanceRequest) *BalanceRequest {
if m == nil {
return nil
}
b := new(BalanceRequest)
b.SetBody(
BalanceRequestBodyFromGRPCMessage(m.GetBody()),
)
headersFromGRPC(m, b)
return b
}