forked from TrueCloudLab/frostfs-api-go
689 lines
12 KiB
Go
689 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/nspcc-dev/neofs-api-go/v2/acl"
|
|
"github.com/nspcc-dev/neofs-api-go/v2/refs"
|
|
service "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
|
|
)
|
|
|
|
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 {
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(service.SessionToken)
|
|
|
|
m.SetBody(
|
|
SessionTokenBodyToGRPCMessage(t.GetBody()),
|
|
)
|
|
|
|
m.SetSignature(
|
|
SignatureToGRPCMessage(t.GetSignature()),
|
|
)
|
|
|
|
return m
|
|
}
|
|
|
|
func SessionTokenFromGRPCMessage(m *service.SessionToken) *SessionToken {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
t := new(SessionToken)
|
|
|
|
t.SetBody(
|
|
SessionTokenBodyFromGRPCMessage(m.GetBody()),
|
|
)
|
|
|
|
t.SetSignature(
|
|
SignatureFromGRPCMessage(m.GetSignature()),
|
|
)
|
|
|
|
return t
|
|
}
|
|
|
|
func BearerTokenToGRPCMessage(t *BearerToken) *service.BearerToken {
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(service.BearerToken)
|
|
|
|
m.SetBody(
|
|
BearerTokenBodyToGRPCMessage(t.GetBody()),
|
|
)
|
|
|
|
m.SetSignature(
|
|
SignatureToGRPCMessage(t.GetSignature()),
|
|
)
|
|
|
|
return m
|
|
}
|
|
|
|
func BearerTokenFromGRPCMessage(m *service.BearerToken) *BearerToken {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
bt := new(BearerToken)
|
|
|
|
bt.SetBody(
|
|
BearerTokenBodyFromGRPCMessage(m.GetBody()),
|
|
)
|
|
|
|
bt.SetSignature(
|
|
SignatureFromGRPCMessage(m.GetSignature()),
|
|
)
|
|
|
|
return bt
|
|
}
|
|
|
|
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]))
|
|
}
|
|
|
|
m.SetXHeaders(xHdrMsg)
|
|
|
|
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]))
|
|
}
|
|
|
|
r.SetXHeaders(xHeaders)
|
|
|
|
return r
|
|
}
|
|
|
|
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 TokenLifetimeToGRPCMessage(tl *TokenLifetime) *service.TokenLifetime {
|
|
if tl == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(service.TokenLifetime)
|
|
|
|
m.SetExp(tl.GetExp())
|
|
m.SetNbf(tl.GetNbf())
|
|
m.SetIat(tl.GetIat())
|
|
|
|
return m
|
|
}
|
|
|
|
func TokenLifetimeFromGRPCMessage(m *service.TokenLifetime) *TokenLifetime {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
tl := new(TokenLifetime)
|
|
|
|
tl.SetExp(m.GetExp())
|
|
tl.SetNbf(m.GetNbf())
|
|
tl.SetIat(m.GetIat())
|
|
|
|
return tl
|
|
}
|
|
|
|
func BearerTokenBodyToGRPCMessage(v *BearerTokenBody) *service.BearerToken_Body {
|
|
if v == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(service.BearerToken_Body)
|
|
|
|
m.SetEaclTable(
|
|
acl.TableToGRPCMessage(v.GetEACL()),
|
|
)
|
|
|
|
m.SetOwnerId(
|
|
refs.OwnerIDToGRPCMessage(v.GetOwnerID()),
|
|
)
|
|
|
|
m.SetLifetime(
|
|
TokenLifetimeToGRPCMessage(v.GetLifetime()),
|
|
)
|
|
|
|
return m
|
|
}
|
|
|
|
func BearerTokenBodyFromGRPCMessage(m *service.BearerToken_Body) *BearerTokenBody {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
bt := new(BearerTokenBody)
|
|
|
|
bt.SetEACL(
|
|
acl.TableFromGRPCMessage(m.GetEaclTable()),
|
|
)
|
|
|
|
bt.SetOwnerID(
|
|
refs.OwnerIDFromGRPCMessage(m.GetOwnerId()),
|
|
)
|
|
|
|
bt.SetLifetime(
|
|
TokenLifetimeFromGRPCMessage(m.GetLifetime()),
|
|
)
|
|
|
|
return bt
|
|
}
|
|
|
|
func RequestHeadersToGRPC(
|
|
src interface {
|
|
GetMetaHeader() *RequestMetaHeader
|
|
GetVerificationHeader() *RequestVerificationHeader
|
|
},
|
|
dst interface {
|
|
SetMetaHeader(*service.RequestMetaHeader)
|
|
SetVerifyHeader(*service.RequestVerificationHeader)
|
|
},
|
|
) {
|
|
dst.SetMetaHeader(
|
|
RequestMetaHeaderToGRPCMessage(src.GetMetaHeader()),
|
|
)
|
|
|
|
dst.SetVerifyHeader(
|
|
RequestVerificationHeaderToGRPCMessage(src.GetVerificationHeader()),
|
|
)
|
|
}
|
|
|
|
func RequestHeadersFromGRPC(
|
|
src interface {
|
|
GetMetaHeader() *service.RequestMetaHeader
|
|
GetVerifyHeader() *service.RequestVerificationHeader
|
|
},
|
|
dst interface {
|
|
SetMetaHeader(*RequestMetaHeader)
|
|
SetVerificationHeader(*RequestVerificationHeader)
|
|
},
|
|
) {
|
|
dst.SetMetaHeader(
|
|
RequestMetaHeaderFromGRPCMessage(src.GetMetaHeader()),
|
|
)
|
|
|
|
dst.SetVerificationHeader(
|
|
RequestVerificationHeaderFromGRPCMessage(src.GetVerifyHeader()),
|
|
)
|
|
}
|
|
|
|
func ResponseVerificationHeaderToGRPCMessage(r *ResponseVerificationHeader) *service.ResponseVerificationHeader {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(service.ResponseVerificationHeader)
|
|
|
|
m.SetBodySignature(
|
|
SignatureToGRPCMessage(r.GetBodySignature()),
|
|
)
|
|
|
|
m.SetMetaSignature(
|
|
SignatureToGRPCMessage(r.GetMetaSignature()),
|
|
)
|
|
|
|
m.SetOriginSignature(
|
|
SignatureToGRPCMessage(r.GetOriginSignature()),
|
|
)
|
|
|
|
m.SetOrigin(
|
|
ResponseVerificationHeaderToGRPCMessage(r.GetOrigin()),
|
|
)
|
|
|
|
return m
|
|
}
|
|
|
|
func ResponseVerificationHeaderFromGRPCMessage(m *service.ResponseVerificationHeader) *ResponseVerificationHeader {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
r := new(ResponseVerificationHeader)
|
|
|
|
r.SetBodySignature(
|
|
SignatureFromGRPCMessage(m.GetBodySignature()),
|
|
)
|
|
|
|
r.SetMetaSignature(
|
|
SignatureFromGRPCMessage(m.GetMetaSignature()),
|
|
)
|
|
|
|
r.SetOriginSignature(
|
|
SignatureFromGRPCMessage(m.GetOriginSignature()),
|
|
)
|
|
|
|
r.SetOrigin(
|
|
ResponseVerificationHeaderFromGRPCMessage(m.GetOrigin()),
|
|
)
|
|
|
|
return r
|
|
}
|
|
|
|
func ResponseMetaHeaderToGRPCMessage(r *ResponseMetaHeader) *service.ResponseMetaHeader {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(service.ResponseMetaHeader)
|
|
|
|
m.SetTtl(r.GetTTL())
|
|
m.SetEpoch(r.GetEpoch())
|
|
|
|
m.SetVersion(
|
|
VersionToGRPCMessage(r.GetVersion()),
|
|
)
|
|
|
|
m.SetOrigin(
|
|
ResponseMetaHeaderToGRPCMessage(r.GetOrigin()),
|
|
)
|
|
|
|
xHeaders := r.GetXHeaders()
|
|
xHdrMsg := make([]*service.XHeader, 0, len(xHeaders))
|
|
|
|
for i := range xHeaders {
|
|
xHdrMsg = append(xHdrMsg, XHeaderToGRPCMessage(xHeaders[i]))
|
|
}
|
|
|
|
m.SetXHeaders(xHdrMsg)
|
|
|
|
return m
|
|
}
|
|
|
|
func ResponseMetaHeaderFromGRPCMessage(m *service.ResponseMetaHeader) *ResponseMetaHeader {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
r := new(ResponseMetaHeader)
|
|
|
|
r.SetTTL(m.GetTtl())
|
|
r.SetEpoch(m.GetEpoch())
|
|
|
|
r.SetVersion(
|
|
VersionFromGRPCMessage(m.GetVersion()),
|
|
)
|
|
|
|
r.SetOrigin(
|
|
ResponseMetaHeaderFromGRPCMessage(m.GetOrigin()),
|
|
)
|
|
|
|
xHdrMsg := m.GetXHeaders()
|
|
xHeaders := make([]*XHeader, 0, len(xHdrMsg))
|
|
|
|
for i := range xHdrMsg {
|
|
xHeaders = append(xHeaders, XHeaderFromGRPCMessage(xHdrMsg[i]))
|
|
}
|
|
|
|
r.SetXHeaders(xHeaders)
|
|
|
|
return r
|
|
}
|
|
|
|
func ResponseHeadersToGRPC(
|
|
src interface {
|
|
GetMetaHeader() *ResponseMetaHeader
|
|
GetVerificationHeader() *ResponseVerificationHeader
|
|
},
|
|
dst interface {
|
|
SetMetaHeader(*service.ResponseMetaHeader)
|
|
SetVerifyHeader(*service.ResponseVerificationHeader)
|
|
},
|
|
) {
|
|
dst.SetMetaHeader(
|
|
ResponseMetaHeaderToGRPCMessage(src.GetMetaHeader()),
|
|
)
|
|
|
|
dst.SetVerifyHeader(
|
|
ResponseVerificationHeaderToGRPCMessage(src.GetVerificationHeader()),
|
|
)
|
|
}
|
|
|
|
func ResponseHeadersFromGRPC(
|
|
src interface {
|
|
GetMetaHeader() *service.ResponseMetaHeader
|
|
GetVerifyHeader() *service.ResponseVerificationHeader
|
|
},
|
|
dst interface {
|
|
SetMetaHeader(*ResponseMetaHeader)
|
|
SetVerificationHeader(*ResponseVerificationHeader)
|
|
},
|
|
) {
|
|
dst.SetMetaHeader(
|
|
ResponseMetaHeaderFromGRPCMessage(src.GetMetaHeader()),
|
|
)
|
|
|
|
dst.SetVerificationHeader(
|
|
ResponseVerificationHeaderFromGRPCMessage(src.GetVerifyHeader()),
|
|
)
|
|
}
|
|
|
|
func ObjectSessionVerbToGRPCField(v ObjectSessionVerb) service.ObjectSessionContext_Verb {
|
|
switch v {
|
|
case ObjectVerbPut:
|
|
return service.ObjectSessionContext_PUT
|
|
case ObjectVerbGet:
|
|
return service.ObjectSessionContext_GET
|
|
case ObjectVerbHead:
|
|
return service.ObjectSessionContext_HEAD
|
|
case ObjectVerbSearch:
|
|
return service.ObjectSessionContext_SEARCH
|
|
case ObjectVerbDelete:
|
|
return service.ObjectSessionContext_DELETE
|
|
case ObjectVerbRange:
|
|
return service.ObjectSessionContext_RANGE
|
|
case ObjectVerbRangeHash:
|
|
return service.ObjectSessionContext_RANGEHASH
|
|
default:
|
|
return service.ObjectSessionContext_VERB_UNSPECIFIED
|
|
}
|
|
}
|
|
|
|
func ObjectSessionVerbFromGRPCField(v service.ObjectSessionContext_Verb) ObjectSessionVerb {
|
|
switch v {
|
|
case service.ObjectSessionContext_PUT:
|
|
return ObjectVerbPut
|
|
case service.ObjectSessionContext_GET:
|
|
return ObjectVerbGet
|
|
case service.ObjectSessionContext_HEAD:
|
|
return ObjectVerbHead
|
|
case service.ObjectSessionContext_SEARCH:
|
|
return ObjectVerbSearch
|
|
case service.ObjectSessionContext_DELETE:
|
|
return ObjectVerbDelete
|
|
case service.ObjectSessionContext_RANGE:
|
|
return ObjectVerbRange
|
|
case service.ObjectSessionContext_RANGEHASH:
|
|
return ObjectVerbRangeHash
|
|
default:
|
|
return ObjectVerbUnknown
|
|
}
|
|
}
|
|
|
|
func ObjectSessionContextToGRPCMessage(c *ObjectSessionContext) *service.ObjectSessionContext {
|
|
if c == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(service.ObjectSessionContext)
|
|
|
|
m.SetVerb(
|
|
ObjectSessionVerbToGRPCField(c.GetVerb()),
|
|
)
|
|
|
|
m.SetAddress(
|
|
refs.AddressToGRPCMessage(c.GetAddress()),
|
|
)
|
|
|
|
return m
|
|
}
|
|
|
|
func ObjectSessionContextFromGRPCMessage(m *service.ObjectSessionContext) *ObjectSessionContext {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
c := new(ObjectSessionContext)
|
|
|
|
c.SetVerb(
|
|
ObjectSessionVerbFromGRPCField(m.GetVerb()),
|
|
)
|
|
|
|
c.SetAddress(
|
|
refs.AddressFromGRPCMessage(m.GetAddress()),
|
|
)
|
|
|
|
return c
|
|
}
|
|
|
|
func SessionTokenBodyToGRPCMessage(t *SessionTokenBody) *service.SessionToken_Body {
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(service.SessionToken_Body)
|
|
|
|
switch v := t.GetContext(); t := v.(type) {
|
|
case nil:
|
|
case *ObjectSessionContext:
|
|
m.SetObjectServiceContext(
|
|
ObjectSessionContextToGRPCMessage(t),
|
|
)
|
|
default:
|
|
panic(fmt.Sprintf("unknown session context %T", t))
|
|
}
|
|
|
|
m.SetId(t.GetID())
|
|
|
|
m.SetOwnerId(
|
|
refs.OwnerIDToGRPCMessage(t.GetOwnerID()),
|
|
)
|
|
|
|
m.SetLifetime(
|
|
TokenLifetimeToGRPCMessage(t.GetLifetime()),
|
|
)
|
|
|
|
m.SetSessionKey(t.GetSessionKey())
|
|
|
|
return m
|
|
}
|
|
|
|
func SessionTokenBodyFromGRPCMessage(m *service.SessionToken_Body) *SessionTokenBody {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
t := new(SessionTokenBody)
|
|
|
|
switch v := m.GetContext().(type) {
|
|
case nil:
|
|
case *service.SessionToken_Body_Object:
|
|
t.SetContext(
|
|
ObjectSessionContextFromGRPCMessage(v.Object),
|
|
)
|
|
default:
|
|
panic(fmt.Sprintf("unknown session context %T", v))
|
|
}
|
|
|
|
t.SetID(m.GetId())
|
|
|
|
t.SetOwnerID(
|
|
refs.OwnerIDFromGRPCMessage(m.GetOwnerId()),
|
|
)
|
|
|
|
t.SetLifetime(
|
|
TokenLifetimeFromGRPCMessage(m.GetLifetime()),
|
|
)
|
|
|
|
t.SetSessionKey(m.GetSessionKey())
|
|
|
|
return t
|
|
}
|