package session import ( "context" "crypto/ecdsa" "github.com/nspcc-dev/neofs-api-go/internal" "github.com/nspcc-dev/neofs-api-go/service" crypto "github.com/nspcc-dev/neofs-crypto" "google.golang.org/grpc" ) type gRPCCreator struct { conn *grpc.ClientConn key *ecdsa.PrivateKey clientFunc func(*grpc.ClientConn) SessionClient } const ErrNilCreateParamsSource = internal.Error("create params source is nil") const ErrNilGPRCClientConn = internal.Error("gRPC client connection is nil") // NewGRPCCreator unites virtual gRPC client with private ket and returns Creator interface. // // If passed ClientConn is nil, ErrNilGPRCClientConn returns. // If passed private key is nil, crypto.ErrEmptyPrivateKey returns. func NewGRPCCreator(conn *grpc.ClientConn, key *ecdsa.PrivateKey) (Creator, error) { if conn == nil { return nil, ErrNilGPRCClientConn } else if key == nil { return nil, crypto.ErrEmptyPrivateKey } return &gRPCCreator{ conn: conn, key: key, clientFunc: NewSessionClient, }, nil } // Create constructs message, signs it with private key and sends it to a gRPC client. // // If passed CreateParamsSource is nil, ErrNilCreateParamsSource returns. // If message could not be signed, an error returns. func (s gRPCCreator) Create(ctx context.Context, p CreateParamsSource) (CreateResult, error) { if p == nil { return nil, ErrNilCreateParamsSource } // create and fill a message req := new(CreateRequest) req.SetOwnerID(p.GetOwnerID()) req.SetCreationEpoch(p.CreationEpoch()) req.SetExpirationEpoch(p.ExpirationEpoch()) // sign with private key if err := service.SignDataWithSessionToken(s.key, req); err != nil { return nil, err } // make gRPC call return s.clientFunc(s.conn).Create(ctx, req) }