forked from TrueCloudLab/frostfs-sdk-go
243 lines
5.8 KiB
Go
243 lines
5.8 KiB
Go
package rpc
|
|
|
|
import (
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/object"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/client"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/common"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
|
|
)
|
|
|
|
const serviceObject = serviceNamePrefix + "object.ObjectService"
|
|
|
|
const (
|
|
rpcObjectPut = "Put"
|
|
rpcObjectGet = "Get"
|
|
rpcObjectSearch = "Search"
|
|
rpcObjectRange = "GetRange"
|
|
rpcObjectHash = "GetRangeHash"
|
|
rpcObjectHead = "Head"
|
|
rpcObjectDelete = "Delete"
|
|
rpcObjectPutSingle = "PutSingle"
|
|
rpcObjectPatch = "Patch"
|
|
)
|
|
|
|
// PutRequestWriter is an object.PutRequest
|
|
// message streaming component.
|
|
type PutRequestWriter struct {
|
|
wc client.MessageWriterCloser
|
|
|
|
resp message.Message
|
|
}
|
|
|
|
// Write writes req to the stream.
|
|
func (w *PutRequestWriter) Write(req *object.PutRequest) error {
|
|
return w.wc.WriteMessage(req)
|
|
}
|
|
|
|
// Close closes the stream.
|
|
func (w *PutRequestWriter) Close() error {
|
|
return w.wc.Close()
|
|
}
|
|
|
|
// PutObject executes ObjectService.Put RPC.
|
|
func PutObject(
|
|
cli *client.Client,
|
|
resp *object.PutResponse,
|
|
opts ...client.CallOption,
|
|
) (*PutRequestWriter, error) {
|
|
wc, err := client.OpenClientStream(cli, common.CallMethodInfoClientStream(serviceObject, rpcObjectPut), resp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &PutRequestWriter{
|
|
wc: wc,
|
|
resp: resp,
|
|
}, nil
|
|
}
|
|
|
|
// GetResponseReader is an object.GetResponse
|
|
// stream reader.
|
|
type GetResponseReader struct {
|
|
r client.MessageReader
|
|
}
|
|
|
|
// Read reads response from the stream.
|
|
//
|
|
// Returns io.EOF of streaming is finished.
|
|
func (r *GetResponseReader) Read(resp *object.GetResponse) error {
|
|
return r.r.ReadMessage(resp)
|
|
}
|
|
|
|
// GetObject executes ObjectService.Get RPC.
|
|
func GetObject(
|
|
cli *client.Client,
|
|
req *object.GetRequest,
|
|
opts ...client.CallOption,
|
|
) (*GetResponseReader, error) {
|
|
wc, err := client.OpenServerStream(cli, common.CallMethodInfoServerStream(serviceObject, rpcObjectGet), req, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &GetResponseReader{
|
|
r: wc,
|
|
}, nil
|
|
}
|
|
|
|
// GetResponseReader is an object.SearchResponse
|
|
// stream reader.
|
|
type SearchResponseReader struct {
|
|
r client.MessageReader
|
|
}
|
|
|
|
// Read reads response from the stream.
|
|
//
|
|
// Returns io.EOF of streaming is finished.
|
|
func (r *SearchResponseReader) Read(resp *object.SearchResponse) error {
|
|
return r.r.ReadMessage(resp)
|
|
}
|
|
|
|
// SearchObjects executes ObjectService.Search RPC.
|
|
func SearchObjects(
|
|
cli *client.Client,
|
|
req *object.SearchRequest,
|
|
opts ...client.CallOption,
|
|
) (*SearchResponseReader, error) {
|
|
wc, err := client.OpenServerStream(cli, common.CallMethodInfoServerStream(serviceObject, rpcObjectSearch), req, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &SearchResponseReader{
|
|
r: wc,
|
|
}, nil
|
|
}
|
|
|
|
// GetResponseReader is an object.GetRangeResponse
|
|
// stream reader.
|
|
type ObjectRangeResponseReader struct {
|
|
r client.MessageReader
|
|
}
|
|
|
|
// Read reads response from the stream.
|
|
//
|
|
// Returns io.EOF of streaming is finished.
|
|
func (r *ObjectRangeResponseReader) Read(resp *object.GetRangeResponse) error {
|
|
return r.r.ReadMessage(resp)
|
|
}
|
|
|
|
// GetObjectRange executes ObjectService.GetRange RPC.
|
|
func GetObjectRange(
|
|
cli *client.Client,
|
|
req *object.GetRangeRequest,
|
|
opts ...client.CallOption,
|
|
) (*ObjectRangeResponseReader, error) {
|
|
wc, err := client.OpenServerStream(cli, common.CallMethodInfoServerStream(serviceObject, rpcObjectRange), req, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &ObjectRangeResponseReader{
|
|
r: wc,
|
|
}, nil
|
|
}
|
|
|
|
// HeadObject executes ObjectService.Head RPC.
|
|
func HeadObject(
|
|
cli *client.Client,
|
|
req *object.HeadRequest,
|
|
opts ...client.CallOption,
|
|
) (*object.HeadResponse, error) {
|
|
resp := new(object.HeadResponse)
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceObject, rpcObjectHead), req, resp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
// DeleteObject executes ObjectService.Delete RPC.
|
|
func DeleteObject(
|
|
cli *client.Client,
|
|
req *object.DeleteRequest,
|
|
opts ...client.CallOption,
|
|
) (*object.DeleteResponse, error) {
|
|
resp := new(object.DeleteResponse)
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceObject, rpcObjectDelete), req, resp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
// HashObjectRange executes ObjectService.GetRangeHash RPC.
|
|
func HashObjectRange(
|
|
cli *client.Client,
|
|
req *object.GetRangeHashRequest,
|
|
opts ...client.CallOption,
|
|
) (*object.GetRangeHashResponse, error) {
|
|
resp := new(object.GetRangeHashResponse)
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceObject, rpcObjectHash), req, resp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
// PutSingleObject executes ObjectService.PutSingle RPC.
|
|
func PutSingleObject(
|
|
cli *client.Client,
|
|
req *object.PutSingleRequest,
|
|
opts ...client.CallOption,
|
|
) (*object.PutSingleResponse, error) {
|
|
resp := new(object.PutSingleResponse)
|
|
|
|
err := client.SendUnary(cli, common.CallMethodInfoUnary(serviceObject, rpcObjectPutSingle), req, resp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
// PatchRequestWriter is an object.PatchRequest
|
|
// message streaming component.
|
|
type PatchRequestWriter struct {
|
|
wc client.MessageWriterCloser
|
|
|
|
resp message.Message
|
|
}
|
|
|
|
// Write writes req to the stream.
|
|
func (w *PatchRequestWriter) Write(req *object.PatchRequest) error {
|
|
return w.wc.WriteMessage(req)
|
|
}
|
|
|
|
// Close closes the stream.
|
|
func (w *PatchRequestWriter) Close() error {
|
|
return w.wc.Close()
|
|
}
|
|
|
|
// Patch executes ObjectService.Patch RPC.
|
|
func Patch(
|
|
cli *client.Client,
|
|
resp *object.PatchResponse,
|
|
opts ...client.CallOption,
|
|
) (*PatchRequestWriter, error) {
|
|
wc, err := client.OpenClientStream(cli, common.CallMethodInfoClientStream(serviceObject, rpcObjectPatch), resp, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &PatchRequestWriter{
|
|
wc: wc,
|
|
resp: resp,
|
|
}, nil
|
|
}
|