679 lines
13 KiB
Go
679 lines
13 KiB
Go
package session
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/nspcc-dev/neofs-api-go/v2/acl"
|
|
"github.com/nspcc-dev/neofs-api-go/v2/refs"
|
|
session "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
|
|
)
|
|
|
|
func CreateRequestBodyToGRPCMessage(c *CreateRequestBody) *session.CreateRequest_Body {
|
|
if c == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.CreateRequest_Body)
|
|
|
|
m.SetOwnerId(
|
|
refs.OwnerIDToGRPCMessage(c.GetOwnerID()),
|
|
)
|
|
|
|
m.SetExpiration(c.GetExpiration())
|
|
|
|
return m
|
|
}
|
|
|
|
func CreateRequestBodyFromGRPCMessage(m *session.CreateRequest_Body) *CreateRequestBody {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
c := new(CreateRequestBody)
|
|
|
|
c.SetOwnerID(
|
|
refs.OwnerIDFromGRPCMessage(m.GetOwnerId()),
|
|
)
|
|
|
|
c.SetExpiration(m.GetExpiration())
|
|
|
|
return c
|
|
}
|
|
|
|
func CreateRequestToGRPCMessage(c *CreateRequest) *session.CreateRequest {
|
|
if c == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.CreateRequest)
|
|
|
|
m.SetBody(
|
|
CreateRequestBodyToGRPCMessage(c.GetBody()),
|
|
)
|
|
|
|
RequestHeadersToGRPC(c, m)
|
|
|
|
return m
|
|
}
|
|
|
|
func CreateRequestFromGRPCMessage(m *session.CreateRequest) *CreateRequest {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
c := new(CreateRequest)
|
|
|
|
c.SetBody(
|
|
CreateRequestBodyFromGRPCMessage(m.GetBody()),
|
|
)
|
|
|
|
RequestHeadersFromGRPC(m, c)
|
|
|
|
return c
|
|
}
|
|
|
|
func CreateResponseBodyToGRPCMessage(c *CreateResponseBody) *session.CreateResponse_Body {
|
|
if c == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.CreateResponse_Body)
|
|
|
|
m.SetId(c.GetID())
|
|
m.SetSessionKey(c.GetSessionKey())
|
|
|
|
return m
|
|
}
|
|
|
|
func CreateResponseBodyFromGRPCMessage(m *session.CreateResponse_Body) *CreateResponseBody {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
c := new(CreateResponseBody)
|
|
|
|
c.SetID(m.GetId())
|
|
c.SetSessionKey(m.GetSessionKey())
|
|
|
|
return c
|
|
}
|
|
|
|
func CreateResponseToGRPCMessage(c *CreateResponse) *session.CreateResponse {
|
|
if c == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.CreateResponse)
|
|
|
|
m.SetBody(
|
|
CreateResponseBodyToGRPCMessage(c.GetBody()),
|
|
)
|
|
|
|
ResponseHeadersToGRPC(c, m)
|
|
|
|
return m
|
|
}
|
|
|
|
func CreateResponseFromGRPCMessage(m *session.CreateResponse) *CreateResponse {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
c := new(CreateResponse)
|
|
|
|
c.SetBody(
|
|
CreateResponseBodyFromGRPCMessage(m.GetBody()),
|
|
)
|
|
|
|
ResponseHeadersFromGRPC(m, c)
|
|
|
|
return c
|
|
}
|
|
|
|
func TokenLifetimeToGRPCMessage(tl *TokenLifetime) *session.SessionToken_Body_TokenLifetime {
|
|
if tl == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.SessionToken_Body_TokenLifetime)
|
|
|
|
m.SetExp(tl.GetExp())
|
|
m.SetNbf(tl.GetNbf())
|
|
m.SetIat(tl.GetIat())
|
|
|
|
return m
|
|
}
|
|
|
|
func TokenLifetimeFromGRPCMessage(m *session.SessionToken_Body_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 XHeaderToGRPCMessage(x *XHeader) *session.XHeader {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.XHeader)
|
|
|
|
m.SetKey(x.GetKey())
|
|
m.SetValue(x.GetValue())
|
|
|
|
return m
|
|
}
|
|
|
|
func XHeaderFromGRPCMessage(m *session.XHeader) *XHeader {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
x := new(XHeader)
|
|
|
|
x.SetKey(m.GetKey())
|
|
x.SetValue(m.GetValue())
|
|
|
|
return x
|
|
}
|
|
|
|
func SessionTokenToGRPCMessage(t *SessionToken) *session.SessionToken {
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.SessionToken)
|
|
|
|
m.SetBody(
|
|
SessionTokenBodyToGRPCMessage(t.GetBody()),
|
|
)
|
|
|
|
m.SetSignature(
|
|
refs.SignatureToGRPCMessage(t.GetSignature()),
|
|
)
|
|
|
|
return m
|
|
}
|
|
|
|
func SessionTokenFromGRPCMessage(m *session.SessionToken) *SessionToken {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
t := new(SessionToken)
|
|
|
|
t.SetBody(
|
|
SessionTokenBodyFromGRPCMessage(m.GetBody()),
|
|
)
|
|
|
|
t.SetSignature(
|
|
refs.SignatureFromGRPCMessage(m.GetSignature()),
|
|
)
|
|
|
|
return t
|
|
}
|
|
|
|
func RequestVerificationHeaderToGRPCMessage(r *RequestVerificationHeader) *session.RequestVerificationHeader {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.RequestVerificationHeader)
|
|
|
|
m.SetBodySignature(
|
|
refs.SignatureToGRPCMessage(r.GetBodySignature()),
|
|
)
|
|
|
|
m.SetMetaSignature(
|
|
refs.SignatureToGRPCMessage(r.GetMetaSignature()),
|
|
)
|
|
|
|
m.SetOriginSignature(
|
|
refs.SignatureToGRPCMessage(r.GetOriginSignature()),
|
|
)
|
|
|
|
m.SetOrigin(
|
|
RequestVerificationHeaderToGRPCMessage(r.GetOrigin()),
|
|
)
|
|
|
|
return m
|
|
}
|
|
|
|
func RequestVerificationHeaderFromGRPCMessage(m *session.RequestVerificationHeader) *RequestVerificationHeader {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
r := new(RequestVerificationHeader)
|
|
|
|
r.SetBodySignature(
|
|
refs.SignatureFromGRPCMessage(m.GetBodySignature()),
|
|
)
|
|
|
|
r.SetMetaSignature(
|
|
refs.SignatureFromGRPCMessage(m.GetMetaSignature()),
|
|
)
|
|
|
|
r.SetOriginSignature(
|
|
refs.SignatureFromGRPCMessage(m.GetOriginSignature()),
|
|
)
|
|
|
|
r.SetOrigin(
|
|
RequestVerificationHeaderFromGRPCMessage(m.GetOrigin()),
|
|
)
|
|
|
|
return r
|
|
}
|
|
|
|
func RequestMetaHeaderToGRPCMessage(r *RequestMetaHeader) *session.RequestMetaHeader {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.RequestMetaHeader)
|
|
|
|
m.SetTtl(r.GetTTL())
|
|
m.SetEpoch(r.GetEpoch())
|
|
|
|
m.SetVersion(
|
|
refs.VersionToGRPCMessage(r.GetVersion()),
|
|
)
|
|
|
|
m.SetSessionToken(
|
|
SessionTokenToGRPCMessage(r.GetSessionToken()),
|
|
)
|
|
|
|
m.SetBearerToken(
|
|
acl.BearerTokenToGRPCMessage(r.GetBearerToken()),
|
|
)
|
|
|
|
m.SetOrigin(
|
|
RequestMetaHeaderToGRPCMessage(r.GetOrigin()),
|
|
)
|
|
|
|
xHeaders := r.GetXHeaders()
|
|
xHdrMsg := make([]*session.XHeader, 0, len(xHeaders))
|
|
|
|
for i := range xHeaders {
|
|
xHdrMsg = append(xHdrMsg, XHeaderToGRPCMessage(xHeaders[i]))
|
|
}
|
|
|
|
m.SetXHeaders(xHdrMsg)
|
|
|
|
return m
|
|
}
|
|
|
|
func RequestMetaHeaderFromGRPCMessage(m *session.RequestMetaHeader) *RequestMetaHeader {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
r := new(RequestMetaHeader)
|
|
|
|
r.SetTTL(m.GetTtl())
|
|
r.SetEpoch(m.GetEpoch())
|
|
|
|
r.SetVersion(
|
|
refs.VersionFromGRPCMessage(m.GetVersion()),
|
|
)
|
|
|
|
r.SetSessionToken(
|
|
SessionTokenFromGRPCMessage(m.GetSessionToken()),
|
|
)
|
|
|
|
r.SetBearerToken(
|
|
acl.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 RequestHeadersToGRPC(
|
|
src interface {
|
|
GetMetaHeader() *RequestMetaHeader
|
|
GetVerificationHeader() *RequestVerificationHeader
|
|
},
|
|
dst interface {
|
|
SetMetaHeader(*session.RequestMetaHeader)
|
|
SetVerifyHeader(*session.RequestVerificationHeader)
|
|
},
|
|
) {
|
|
dst.SetMetaHeader(
|
|
RequestMetaHeaderToGRPCMessage(src.GetMetaHeader()),
|
|
)
|
|
|
|
dst.SetVerifyHeader(
|
|
RequestVerificationHeaderToGRPCMessage(src.GetVerificationHeader()),
|
|
)
|
|
}
|
|
|
|
func RequestHeadersFromGRPC(
|
|
src interface {
|
|
GetMetaHeader() *session.RequestMetaHeader
|
|
GetVerifyHeader() *session.RequestVerificationHeader
|
|
},
|
|
dst interface {
|
|
SetMetaHeader(*RequestMetaHeader)
|
|
SetVerificationHeader(*RequestVerificationHeader)
|
|
},
|
|
) {
|
|
dst.SetMetaHeader(
|
|
RequestMetaHeaderFromGRPCMessage(src.GetMetaHeader()),
|
|
)
|
|
|
|
dst.SetVerificationHeader(
|
|
RequestVerificationHeaderFromGRPCMessage(src.GetVerifyHeader()),
|
|
)
|
|
}
|
|
|
|
func ResponseVerificationHeaderToGRPCMessage(r *ResponseVerificationHeader) *session.ResponseVerificationHeader {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.ResponseVerificationHeader)
|
|
|
|
m.SetBodySignature(
|
|
refs.SignatureToGRPCMessage(r.GetBodySignature()),
|
|
)
|
|
|
|
m.SetMetaSignature(
|
|
refs.SignatureToGRPCMessage(r.GetMetaSignature()),
|
|
)
|
|
|
|
m.SetOriginSignature(
|
|
refs.SignatureToGRPCMessage(r.GetOriginSignature()),
|
|
)
|
|
|
|
m.SetOrigin(
|
|
ResponseVerificationHeaderToGRPCMessage(r.GetOrigin()),
|
|
)
|
|
|
|
return m
|
|
}
|
|
|
|
func ResponseVerificationHeaderFromGRPCMessage(m *session.ResponseVerificationHeader) *ResponseVerificationHeader {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
r := new(ResponseVerificationHeader)
|
|
|
|
r.SetBodySignature(
|
|
refs.SignatureFromGRPCMessage(m.GetBodySignature()),
|
|
)
|
|
|
|
r.SetMetaSignature(
|
|
refs.SignatureFromGRPCMessage(m.GetMetaSignature()),
|
|
)
|
|
|
|
r.SetOriginSignature(
|
|
refs.SignatureFromGRPCMessage(m.GetOriginSignature()),
|
|
)
|
|
|
|
r.SetOrigin(
|
|
ResponseVerificationHeaderFromGRPCMessage(m.GetOrigin()),
|
|
)
|
|
|
|
return r
|
|
}
|
|
|
|
func ResponseMetaHeaderToGRPCMessage(r *ResponseMetaHeader) *session.ResponseMetaHeader {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.ResponseMetaHeader)
|
|
|
|
m.SetTtl(r.GetTTL())
|
|
m.SetEpoch(r.GetEpoch())
|
|
|
|
m.SetVersion(
|
|
refs.VersionToGRPCMessage(r.GetVersion()),
|
|
)
|
|
|
|
m.SetOrigin(
|
|
ResponseMetaHeaderToGRPCMessage(r.GetOrigin()),
|
|
)
|
|
|
|
xHeaders := r.GetXHeaders()
|
|
xHdrMsg := make([]*session.XHeader, 0, len(xHeaders))
|
|
|
|
for i := range xHeaders {
|
|
xHdrMsg = append(xHdrMsg, XHeaderToGRPCMessage(xHeaders[i]))
|
|
}
|
|
|
|
m.SetXHeaders(xHdrMsg)
|
|
|
|
return m
|
|
}
|
|
|
|
func ResponseMetaHeaderFromGRPCMessage(m *session.ResponseMetaHeader) *ResponseMetaHeader {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
r := new(ResponseMetaHeader)
|
|
|
|
r.SetTTL(m.GetTtl())
|
|
r.SetEpoch(m.GetEpoch())
|
|
|
|
r.SetVersion(
|
|
refs.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(*session.ResponseMetaHeader)
|
|
SetVerifyHeader(*session.ResponseVerificationHeader)
|
|
},
|
|
) {
|
|
dst.SetMetaHeader(
|
|
ResponseMetaHeaderToGRPCMessage(src.GetMetaHeader()),
|
|
)
|
|
|
|
dst.SetVerifyHeader(
|
|
ResponseVerificationHeaderToGRPCMessage(src.GetVerificationHeader()),
|
|
)
|
|
}
|
|
|
|
func ResponseHeadersFromGRPC(
|
|
src interface {
|
|
GetMetaHeader() *session.ResponseMetaHeader
|
|
GetVerifyHeader() *session.ResponseVerificationHeader
|
|
},
|
|
dst interface {
|
|
SetMetaHeader(*ResponseMetaHeader)
|
|
SetVerificationHeader(*ResponseVerificationHeader)
|
|
},
|
|
) {
|
|
dst.SetMetaHeader(
|
|
ResponseMetaHeaderFromGRPCMessage(src.GetMetaHeader()),
|
|
)
|
|
|
|
dst.SetVerificationHeader(
|
|
ResponseVerificationHeaderFromGRPCMessage(src.GetVerifyHeader()),
|
|
)
|
|
}
|
|
|
|
func ObjectSessionVerbToGRPCField(v ObjectSessionVerb) session.ObjectSessionContext_Verb {
|
|
switch v {
|
|
case ObjectVerbPut:
|
|
return session.ObjectSessionContext_PUT
|
|
case ObjectVerbGet:
|
|
return session.ObjectSessionContext_GET
|
|
case ObjectVerbHead:
|
|
return session.ObjectSessionContext_HEAD
|
|
case ObjectVerbSearch:
|
|
return session.ObjectSessionContext_SEARCH
|
|
case ObjectVerbDelete:
|
|
return session.ObjectSessionContext_DELETE
|
|
case ObjectVerbRange:
|
|
return session.ObjectSessionContext_RANGE
|
|
case ObjectVerbRangeHash:
|
|
return session.ObjectSessionContext_RANGEHASH
|
|
default:
|
|
return session.ObjectSessionContext_VERB_UNSPECIFIED
|
|
}
|
|
}
|
|
|
|
func ObjectSessionVerbFromGRPCField(v session.ObjectSessionContext_Verb) ObjectSessionVerb {
|
|
switch v {
|
|
case session.ObjectSessionContext_PUT:
|
|
return ObjectVerbPut
|
|
case session.ObjectSessionContext_GET:
|
|
return ObjectVerbGet
|
|
case session.ObjectSessionContext_HEAD:
|
|
return ObjectVerbHead
|
|
case session.ObjectSessionContext_SEARCH:
|
|
return ObjectVerbSearch
|
|
case session.ObjectSessionContext_DELETE:
|
|
return ObjectVerbDelete
|
|
case session.ObjectSessionContext_RANGE:
|
|
return ObjectVerbRange
|
|
case session.ObjectSessionContext_RANGEHASH:
|
|
return ObjectVerbRangeHash
|
|
default:
|
|
return ObjectVerbUnknown
|
|
}
|
|
}
|
|
|
|
func ObjectSessionContextToGRPCMessage(c *ObjectSessionContext) *session.ObjectSessionContext {
|
|
if c == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.ObjectSessionContext)
|
|
|
|
m.SetVerb(
|
|
ObjectSessionVerbToGRPCField(c.GetVerb()),
|
|
)
|
|
|
|
m.SetAddress(
|
|
refs.AddressToGRPCMessage(c.GetAddress()),
|
|
)
|
|
|
|
return m
|
|
}
|
|
|
|
func ObjectSessionContextFromGRPCMessage(m *session.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) *session.SessionToken_Body {
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
m := new(session.SessionToken_Body)
|
|
|
|
switch v := t.GetContext(); t := v.(type) {
|
|
case nil:
|
|
case *ObjectSessionContext:
|
|
m.SetObjectSessionContext(
|
|
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 *session.SessionToken_Body) *SessionTokenBody {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
t := new(SessionTokenBody)
|
|
|
|
switch v := m.GetContext().(type) {
|
|
case nil:
|
|
case *session.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
|
|
}
|