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 }