forked from TrueCloudLab/frostfs-api-go
893 lines
18 KiB
Go
893 lines
18 KiB
Go
|
package session
|
||
|
|
||
|
import (
|
||
|
"fmt"
|
||
|
|
||
|
"github.com/nspcc-dev/neofs-api-go/v2/acl"
|
||
|
aclGRPC "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
|
||
|
"github.com/nspcc-dev/neofs-api-go/v2/refs"
|
||
|
refsGRPC "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
|
||
|
"github.com/nspcc-dev/neofs-api-go/v2/rpc/grpc"
|
||
|
"github.com/nspcc-dev/neofs-api-go/v2/rpc/message"
|
||
|
session "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
|
||
|
"github.com/nspcc-dev/neofs-api-go/v2/status"
|
||
|
statusGRPC "github.com/nspcc-dev/neofs-api-go/v2/status/grpc"
|
||
|
)
|
||
|
|
||
|
func (c *CreateRequestBody) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.CreateRequest_Body
|
||
|
|
||
|
if c != nil {
|
||
|
m = new(session.CreateRequest_Body)
|
||
|
|
||
|
m.SetOwnerId(c.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
|
||
|
m.SetExpiration(c.expiration)
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (c *CreateRequestBody) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.CreateRequest_Body)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
ownerID := v.GetOwnerId()
|
||
|
if ownerID == nil {
|
||
|
c.ownerID = nil
|
||
|
} else {
|
||
|
if c.ownerID == nil {
|
||
|
c.ownerID = new(refs.OwnerID)
|
||
|
}
|
||
|
|
||
|
err = c.ownerID.FromGRPCMessage(ownerID)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
c.expiration = v.GetExpiration()
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (c *CreateRequest) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.CreateRequest
|
||
|
|
||
|
if c != nil {
|
||
|
m = new(session.CreateRequest)
|
||
|
|
||
|
m.SetBody(c.body.ToGRPCMessage().(*session.CreateRequest_Body))
|
||
|
c.RequestHeaders.ToMessage(m)
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (c *CreateRequest) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.CreateRequest)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
body := v.GetBody()
|
||
|
if body == nil {
|
||
|
c.body = nil
|
||
|
} else {
|
||
|
if c.body == nil {
|
||
|
c.body = new(CreateRequestBody)
|
||
|
}
|
||
|
|
||
|
err = c.body.FromGRPCMessage(body)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return c.RequestHeaders.FromMessage(v)
|
||
|
}
|
||
|
|
||
|
func (c *CreateResponseBody) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.CreateResponse_Body
|
||
|
|
||
|
if c != nil {
|
||
|
m = new(session.CreateResponse_Body)
|
||
|
|
||
|
m.SetSessionKey(c.sessionKey)
|
||
|
m.SetId(c.id)
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (c *CreateResponseBody) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.CreateResponse_Body)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
c.sessionKey = v.GetSessionKey()
|
||
|
c.id = v.GetId()
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (c *CreateResponse) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.CreateResponse
|
||
|
|
||
|
if c != nil {
|
||
|
m = new(session.CreateResponse)
|
||
|
|
||
|
m.SetBody(c.body.ToGRPCMessage().(*session.CreateResponse_Body))
|
||
|
c.ResponseHeaders.ToMessage(m)
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (c *CreateResponse) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.CreateResponse)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
body := v.GetBody()
|
||
|
if body == nil {
|
||
|
c.body = nil
|
||
|
} else {
|
||
|
if c.body == nil {
|
||
|
c.body = new(CreateResponseBody)
|
||
|
}
|
||
|
|
||
|
err = c.body.FromGRPCMessage(body)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return c.ResponseHeaders.FromMessage(v)
|
||
|
}
|
||
|
|
||
|
func (l *TokenLifetime) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.SessionToken_Body_TokenLifetime
|
||
|
|
||
|
if l != nil {
|
||
|
m = new(session.SessionToken_Body_TokenLifetime)
|
||
|
|
||
|
m.SetExp(l.exp)
|
||
|
m.SetIat(l.iat)
|
||
|
m.SetNbf(l.nbf)
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (l *TokenLifetime) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.SessionToken_Body_TokenLifetime)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
l.exp = v.GetExp()
|
||
|
l.iat = v.GetIat()
|
||
|
l.nbf = v.GetNbf()
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (x *XHeader) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.XHeader
|
||
|
|
||
|
if x != nil {
|
||
|
m = new(session.XHeader)
|
||
|
|
||
|
m.SetKey(x.key)
|
||
|
m.SetValue(x.val)
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (x *XHeader) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.XHeader)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
x.key = v.GetKey()
|
||
|
x.val = v.GetValue()
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func XHeadersToGRPC(xs []*XHeader) (res []*session.XHeader) {
|
||
|
if xs != nil {
|
||
|
res = make([]*session.XHeader, 0, len(xs))
|
||
|
|
||
|
for i := range xs {
|
||
|
res = append(res, xs[i].ToGRPCMessage().(*session.XHeader))
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return
|
||
|
}
|
||
|
|
||
|
func XHeadersFromGRPC(xs []*session.XHeader) (res []*XHeader, err error) {
|
||
|
if xs != nil {
|
||
|
res = make([]*XHeader, 0, len(xs))
|
||
|
|
||
|
for i := range xs {
|
||
|
var x *XHeader
|
||
|
|
||
|
if xs[i] != nil {
|
||
|
x = new(XHeader)
|
||
|
|
||
|
err = x.FromGRPCMessage(xs[i])
|
||
|
if err != nil {
|
||
|
return
|
||
|
}
|
||
|
}
|
||
|
|
||
|
res = append(res, x)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return
|
||
|
}
|
||
|
|
||
|
func (t *SessionToken) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.SessionToken
|
||
|
|
||
|
if t != nil {
|
||
|
m = new(session.SessionToken)
|
||
|
|
||
|
m.SetBody(t.body.ToGRPCMessage().(*session.SessionToken_Body))
|
||
|
m.SetSignature(t.sig.ToGRPCMessage().(*refsGRPC.Signature))
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (t *SessionToken) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.SessionToken)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
body := v.GetBody()
|
||
|
if body == nil {
|
||
|
t.body = nil
|
||
|
} else {
|
||
|
if t.body == nil {
|
||
|
t.body = new(SessionTokenBody)
|
||
|
}
|
||
|
|
||
|
err = t.body.FromGRPCMessage(body)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
sig := v.GetSignature()
|
||
|
if sig == nil {
|
||
|
t.sig = nil
|
||
|
} else {
|
||
|
if t.sig == nil {
|
||
|
t.sig = new(refs.Signature)
|
||
|
}
|
||
|
|
||
|
err = t.sig.FromGRPCMessage(sig)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (r *RequestVerificationHeader) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.RequestVerificationHeader
|
||
|
|
||
|
if r != nil {
|
||
|
m = new(session.RequestVerificationHeader)
|
||
|
|
||
|
m.SetBodySignature(r.bodySig.ToGRPCMessage().(*refsGRPC.Signature))
|
||
|
m.SetMetaSignature(r.metaSig.ToGRPCMessage().(*refsGRPC.Signature))
|
||
|
m.SetOriginSignature(r.originSig.ToGRPCMessage().(*refsGRPC.Signature))
|
||
|
m.SetOrigin(r.origin.ToGRPCMessage().(*session.RequestVerificationHeader))
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (r *RequestVerificationHeader) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.RequestVerificationHeader)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
originSig := v.GetOriginSignature()
|
||
|
if originSig == nil {
|
||
|
r.originSig = nil
|
||
|
} else {
|
||
|
if r.originSig == nil {
|
||
|
r.originSig = new(refs.Signature)
|
||
|
}
|
||
|
|
||
|
err = r.originSig.FromGRPCMessage(originSig)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
metaSig := v.GetMetaSignature()
|
||
|
if metaSig == nil {
|
||
|
r.metaSig = nil
|
||
|
} else {
|
||
|
if r.metaSig == nil {
|
||
|
r.metaSig = new(refs.Signature)
|
||
|
}
|
||
|
|
||
|
err = r.metaSig.FromGRPCMessage(metaSig)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bodySig := v.GetBodySignature()
|
||
|
if bodySig == nil {
|
||
|
r.bodySig = nil
|
||
|
} else {
|
||
|
if r.bodySig == nil {
|
||
|
r.bodySig = new(refs.Signature)
|
||
|
}
|
||
|
|
||
|
err = r.bodySig.FromGRPCMessage(bodySig)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
origin := v.GetOrigin()
|
||
|
if origin == nil {
|
||
|
r.origin = nil
|
||
|
} else {
|
||
|
if r.origin == nil {
|
||
|
r.origin = new(RequestVerificationHeader)
|
||
|
}
|
||
|
|
||
|
err = r.origin.FromGRPCMessage(origin)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (r *RequestMetaHeader) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.RequestMetaHeader
|
||
|
|
||
|
if r != nil {
|
||
|
m = new(session.RequestMetaHeader)
|
||
|
|
||
|
m.SetVersion(r.version.ToGRPCMessage().(*refsGRPC.Version))
|
||
|
m.SetSessionToken(r.sessionToken.ToGRPCMessage().(*session.SessionToken))
|
||
|
m.SetBearerToken(r.bearerToken.ToGRPCMessage().(*aclGRPC.BearerToken))
|
||
|
m.SetXHeaders(XHeadersToGRPC(r.xHeaders))
|
||
|
m.SetEpoch(r.epoch)
|
||
|
m.SetTtl(r.ttl)
|
||
|
m.SetOrigin(r.origin.ToGRPCMessage().(*session.RequestMetaHeader))
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (r *RequestMetaHeader) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.RequestMetaHeader)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
version := v.GetVersion()
|
||
|
if version == nil {
|
||
|
r.version = nil
|
||
|
} else {
|
||
|
if r.version == nil {
|
||
|
r.version = new(refs.Version)
|
||
|
}
|
||
|
|
||
|
err = r.version.FromGRPCMessage(version)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
sessionToken := v.GetSessionToken()
|
||
|
if sessionToken == nil {
|
||
|
r.sessionToken = nil
|
||
|
} else {
|
||
|
if r.sessionToken == nil {
|
||
|
r.sessionToken = new(SessionToken)
|
||
|
}
|
||
|
|
||
|
err = r.sessionToken.FromGRPCMessage(sessionToken)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bearerToken := v.GetBearerToken()
|
||
|
if bearerToken == nil {
|
||
|
r.bearerToken = nil
|
||
|
} else {
|
||
|
if r.bearerToken == nil {
|
||
|
r.bearerToken = new(acl.BearerToken)
|
||
|
}
|
||
|
|
||
|
err = r.bearerToken.FromGRPCMessage(bearerToken)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
origin := v.GetOrigin()
|
||
|
if origin == nil {
|
||
|
r.origin = nil
|
||
|
} else {
|
||
|
if r.origin == nil {
|
||
|
r.origin = new(RequestMetaHeader)
|
||
|
}
|
||
|
|
||
|
err = r.origin.FromGRPCMessage(origin)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
r.xHeaders, err = XHeadersFromGRPC(v.GetXHeaders())
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
|
||
|
r.epoch = v.GetEpoch()
|
||
|
r.ttl = v.GetTtl()
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (r *ResponseVerificationHeader) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.ResponseVerificationHeader
|
||
|
|
||
|
if r != nil {
|
||
|
m = new(session.ResponseVerificationHeader)
|
||
|
|
||
|
m.SetBodySignature(r.bodySig.ToGRPCMessage().(*refsGRPC.Signature))
|
||
|
m.SetMetaSignature(r.metaSig.ToGRPCMessage().(*refsGRPC.Signature))
|
||
|
m.SetOriginSignature(r.originSig.ToGRPCMessage().(*refsGRPC.Signature))
|
||
|
m.SetOrigin(r.origin.ToGRPCMessage().(*session.ResponseVerificationHeader))
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (r *ResponseVerificationHeader) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.ResponseVerificationHeader)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
originSig := v.GetOriginSignature()
|
||
|
if originSig == nil {
|
||
|
r.originSig = nil
|
||
|
} else {
|
||
|
if r.originSig == nil {
|
||
|
r.originSig = new(refs.Signature)
|
||
|
}
|
||
|
|
||
|
err = r.originSig.FromGRPCMessage(originSig)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
metaSig := v.GetMetaSignature()
|
||
|
if metaSig == nil {
|
||
|
r.metaSig = nil
|
||
|
} else {
|
||
|
if r.metaSig == nil {
|
||
|
r.metaSig = new(refs.Signature)
|
||
|
}
|
||
|
|
||
|
err = r.metaSig.FromGRPCMessage(metaSig)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bodySig := v.GetBodySignature()
|
||
|
if bodySig == nil {
|
||
|
r.bodySig = nil
|
||
|
} else {
|
||
|
if r.bodySig == nil {
|
||
|
r.bodySig = new(refs.Signature)
|
||
|
}
|
||
|
|
||
|
err = r.bodySig.FromGRPCMessage(bodySig)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
origin := v.GetOrigin()
|
||
|
if origin == nil {
|
||
|
r.origin = nil
|
||
|
} else {
|
||
|
if r.origin == nil {
|
||
|
r.origin = new(ResponseVerificationHeader)
|
||
|
}
|
||
|
|
||
|
err = r.origin.FromGRPCMessage(origin)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (r *ResponseMetaHeader) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.ResponseMetaHeader
|
||
|
|
||
|
if r != nil {
|
||
|
m = new(session.ResponseMetaHeader)
|
||
|
|
||
|
m.SetVersion(r.version.ToGRPCMessage().(*refsGRPC.Version))
|
||
|
m.SetXHeaders(XHeadersToGRPC(r.xHeaders))
|
||
|
m.SetEpoch(r.epoch)
|
||
|
m.SetTtl(r.ttl)
|
||
|
m.SetOrigin(r.origin.ToGRPCMessage().(*session.ResponseMetaHeader))
|
||
|
m.SetStatus(r.status.ToGRPCMessage().(*statusGRPC.Status))
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (r *ResponseMetaHeader) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.ResponseMetaHeader)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
version := v.GetVersion()
|
||
|
if version == nil {
|
||
|
r.version = nil
|
||
|
} else {
|
||
|
if r.version == nil {
|
||
|
r.version = new(refs.Version)
|
||
|
}
|
||
|
|
||
|
err = r.version.FromGRPCMessage(version)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
origin := v.GetOrigin()
|
||
|
if origin == nil {
|
||
|
r.origin = nil
|
||
|
} else {
|
||
|
if r.origin == nil {
|
||
|
r.origin = new(ResponseMetaHeader)
|
||
|
}
|
||
|
|
||
|
err = r.origin.FromGRPCMessage(origin)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
st := v.GetStatus()
|
||
|
if st == nil {
|
||
|
r.status = nil
|
||
|
} else {
|
||
|
if r.status == nil {
|
||
|
r.status = new(status.Status)
|
||
|
}
|
||
|
|
||
|
err = r.status.FromGRPCMessage(st)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
r.xHeaders, err = XHeadersFromGRPC(v.GetXHeaders())
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
|
||
|
r.epoch = v.GetEpoch()
|
||
|
r.ttl = v.GetTtl()
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
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 (c *ObjectSessionContext) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.ObjectSessionContext
|
||
|
|
||
|
if c != nil {
|
||
|
m = new(session.ObjectSessionContext)
|
||
|
|
||
|
m.SetVerb(ObjectSessionVerbToGRPCField(c.verb))
|
||
|
m.SetAddress(c.addr.ToGRPCMessage().(*refsGRPC.Address))
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (c *ObjectSessionContext) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.ObjectSessionContext)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
addr := v.GetAddress()
|
||
|
if addr == nil {
|
||
|
c.addr = nil
|
||
|
} else {
|
||
|
if c.addr == nil {
|
||
|
c.addr = new(refs.Address)
|
||
|
}
|
||
|
|
||
|
err = c.addr.FromGRPCMessage(addr)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
c.verb = ObjectSessionVerbFromGRPCField(v.GetVerb())
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (t *SessionTokenBody) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.SessionToken_Body
|
||
|
|
||
|
if t != nil {
|
||
|
m = new(session.SessionToken_Body)
|
||
|
|
||
|
switch typ := t.ctx.(type) {
|
||
|
default:
|
||
|
panic(fmt.Sprintf("unknown session context %T", typ))
|
||
|
case nil:
|
||
|
m.Context = nil
|
||
|
case *ObjectSessionContext:
|
||
|
m.SetObjectSessionContext(typ.ToGRPCMessage().(*session.ObjectSessionContext))
|
||
|
case *ContainerSessionContext:
|
||
|
m.SetContainerSessionContext(typ.ToGRPCMessage().(*session.ContainerSessionContext))
|
||
|
}
|
||
|
|
||
|
m.SetOwnerId(t.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
|
||
|
m.SetId(t.id)
|
||
|
m.SetSessionKey(t.sessionKey)
|
||
|
m.SetLifetime(t.lifetime.ToGRPCMessage().(*session.SessionToken_Body_TokenLifetime))
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
func (t *SessionTokenBody) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.SessionToken_Body)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
t.ctx = nil
|
||
|
|
||
|
switch val := v.GetContext().(type) {
|
||
|
default:
|
||
|
err = fmt.Errorf("unknown session context %T", val)
|
||
|
case nil:
|
||
|
case *session.SessionToken_Body_Object:
|
||
|
ctx, ok := t.ctx.(*ObjectSessionContext)
|
||
|
if !ok {
|
||
|
ctx = new(ObjectSessionContext)
|
||
|
t.ctx = ctx
|
||
|
}
|
||
|
|
||
|
err = ctx.FromGRPCMessage(val.Object)
|
||
|
case *session.SessionToken_Body_Container:
|
||
|
ctx, ok := t.ctx.(*ContainerSessionContext)
|
||
|
if !ok {
|
||
|
ctx = new(ContainerSessionContext)
|
||
|
t.ctx = ctx
|
||
|
}
|
||
|
|
||
|
err = ctx.FromGRPCMessage(val.Container)
|
||
|
}
|
||
|
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
|
||
|
ownerID := v.GetOwnerId()
|
||
|
if ownerID == nil {
|
||
|
t.ownerID = nil
|
||
|
} else {
|
||
|
if t.ownerID == nil {
|
||
|
t.ownerID = new(refs.OwnerID)
|
||
|
}
|
||
|
|
||
|
err = t.ownerID.FromGRPCMessage(ownerID)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
lifetime := v.GetLifetime()
|
||
|
if lifetime == nil {
|
||
|
t.lifetime = nil
|
||
|
} else {
|
||
|
if t.lifetime == nil {
|
||
|
t.lifetime = new(TokenLifetime)
|
||
|
}
|
||
|
|
||
|
err = t.lifetime.FromGRPCMessage(lifetime)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
t.id = v.GetId()
|
||
|
t.sessionKey = v.GetSessionKey()
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// ContainerSessionVerbToGRPCField converts ContainerSessionVerb
|
||
|
// to gRPC-generated session.ContainerSessionContext_Verb.
|
||
|
//
|
||
|
// If v is outside of the ContainerSessionVerb enum,
|
||
|
// session.ContainerSessionContext_VERB_UNSPECIFIED is returned.
|
||
|
func ContainerSessionVerbToGRPCField(v ContainerSessionVerb) session.ContainerSessionContext_Verb {
|
||
|
switch v {
|
||
|
default:
|
||
|
return session.ContainerSessionContext_VERB_UNSPECIFIED
|
||
|
case ContainerVerbPut:
|
||
|
return session.ContainerSessionContext_PUT
|
||
|
case ContainerVerbDelete:
|
||
|
return session.ContainerSessionContext_DELETE
|
||
|
case ContainerVerbSetEACL:
|
||
|
return session.ContainerSessionContext_SETEACL
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// ContainerSessionVerbFromGRPCField converts gRPC-generated
|
||
|
// session.ContainerSessionContext_Verb to ContainerSessionVerb.
|
||
|
//
|
||
|
// If v is outside of the session.ContainerSessionContext_Verb enum,
|
||
|
// ContainerVerbUnknown is returned.
|
||
|
func ContainerSessionVerbFromGRPCField(v session.ContainerSessionContext_Verb) ContainerSessionVerb {
|
||
|
switch v {
|
||
|
default:
|
||
|
return ContainerVerbUnknown
|
||
|
case session.ContainerSessionContext_PUT:
|
||
|
return ContainerVerbPut
|
||
|
case session.ContainerSessionContext_DELETE:
|
||
|
return ContainerVerbDelete
|
||
|
case session.ContainerSessionContext_SETEACL:
|
||
|
return ContainerVerbSetEACL
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// ToGRPCMessage converts ContainerSessionContext to gRPC-generated
|
||
|
// session.ContainerSessionContext message.
|
||
|
func (x *ContainerSessionContext) ToGRPCMessage() grpc.Message {
|
||
|
var m *session.ContainerSessionContext
|
||
|
|
||
|
if x != nil {
|
||
|
m = new(session.ContainerSessionContext)
|
||
|
|
||
|
m.SetVerb(ContainerSessionVerbToGRPCField(x.verb))
|
||
|
m.SetWildcard(x.wildcard)
|
||
|
m.SetContainerId(x.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
// FromGRPCMessage tries to restore ContainerSessionContext from grpc.Message.
|
||
|
//
|
||
|
// Returns message.ErrUnexpectedMessageType if m is not
|
||
|
// a gRPC-generated session.ContainerSessionContext message.
|
||
|
func (x *ContainerSessionContext) FromGRPCMessage(m grpc.Message) error {
|
||
|
v, ok := m.(*session.ContainerSessionContext)
|
||
|
if !ok {
|
||
|
return message.NewUnexpectedMessageType(m, v)
|
||
|
}
|
||
|
|
||
|
var err error
|
||
|
|
||
|
cid := v.GetContainerId()
|
||
|
if cid == nil {
|
||
|
x.cid = nil
|
||
|
} else {
|
||
|
if x.cid == nil {
|
||
|
x.cid = new(refs.ContainerID)
|
||
|
}
|
||
|
|
||
|
err = x.cid.FromGRPCMessage(cid)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
}
|
||
|
|
||
|
x.verb = ContainerSessionVerbFromGRPCField(v.GetVerb())
|
||
|
x.wildcard = v.GetWildcard()
|
||
|
|
||
|
return nil
|
||
|
}
|