diff --git a/client/messages_test.go b/client/messages_test.go index 4a7a2102..b0eafc74 100644 --- a/client/messages_test.go +++ b/client/messages_test.go @@ -530,6 +530,17 @@ var ( proto.Clone(validProtoObjectIDs[2]).(*protorefs.ObjectID), }, } + // correct ObjectService.SearchV2 response payload with required fields only. + validMinSearchV2ResponseBody = &protoobject.SearchV2Response_Body{} + // correct ObjectService.SearchV2 response payload with all fields. + validFullSearchV2ResponseBody = &protoobject.SearchV2Response_Body{ + Result: []*protoobject.SearchV2Response_OIDWithMeta{ + {Id: proto.Clone(validProtoObjectIDs[0]).(*protorefs.ObjectID), Attributes: []string{"val_1_1", "val_1_2"}}, + {Id: proto.Clone(validProtoObjectIDs[1]).(*protorefs.ObjectID), Attributes: []string{"val_2_1", "val_2_2"}}, + {Id: proto.Clone(validProtoObjectIDs[2]).(*protorefs.ObjectID), Attributes: []string{"val_3_1", "val_3_2"}}, + }, + Cursor: "any_cursor", + } ) // Reputation service. @@ -1840,7 +1851,7 @@ func checkSplitInfoTransport(s object.SplitInfo, m *protoobject.SplitInfo) error return nil } -func checkObjectSearchFilterTransport(f object.SearchFilter, m *protoobject.SearchRequest_Body_Filter) error { +func checkObjectSearchFilterTransport(f object.SearchFilter, m *protoobject.SearchFilter) error { // 1. matcher var expMatcher protoobject.MatchType switch m := f.Operation(); m { @@ -1877,7 +1888,7 @@ func checkObjectSearchFilterTransport(f object.SearchFilter, m *protoobject.Sear return nil } -func checkObjectSearchFiltersTransport(fs []object.SearchFilter, ms []*protoobject.SearchRequest_Body_Filter) error { +func checkObjectSearchFiltersTransport(fs []object.SearchFilter, ms []*protoobject.SearchFilter) error { if v1, v2 := len(fs), len(ms); v1 != v2 { return fmt.Errorf("number of attributes (client: %d, message: %d)", v1, v2) } diff --git a/client/object_replicate_test.go b/client/object_replicate_test.go index efb38814..4076cd02 100644 --- a/client/object_replicate_test.go +++ b/client/object_replicate_test.go @@ -32,7 +32,7 @@ func BenchmarkPrepareReplicationMessage(b *testing.B) { b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { _, err = prepareReplicateMessage(id, bytes.NewReader(bObj), signer, true) require.NoError(b, err) } diff --git a/client/object_search.go b/client/object_search.go index 80984c18..2d105b51 100644 --- a/client/object_search.go +++ b/client/object_search.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "io" + "slices" "time" "github.com/nspcc-dev/neofs-sdk-go/bearer" @@ -16,11 +17,223 @@ import ( protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object" "github.com/nspcc-dev/neofs-sdk-go/proto/refs" protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session" + "github.com/nspcc-dev/neofs-sdk-go/session" "github.com/nspcc-dev/neofs-sdk-go/stat" "github.com/nspcc-dev/neofs-sdk-go/user" "github.com/nspcc-dev/neofs-sdk-go/version" ) +const ( + defaultSearchObjectsQueryVersion = 1 + + maxSearchObjectsCount = 1000 + maxSearchObjectsFilterCount = 8 + maxSearchObjectsAttrCount = 4 +) + +// SearchResultItem groups data of an object matching particular search query. +type SearchResultItem struct { + ID oid.ID + Attributes []string +} + +// SearchObjectsOptions groups optional parameters of [Client.SearchObjects]. +type SearchObjectsOptions struct { + prmCommonMeta + sessionToken *session.Object + bearerToken *bearer.Token + noForwarding bool + + count uint32 +} + +// DisableForwarding disables request forwarding by the server and limits +// execution to its local storage. Mostly used for system purposes. +func (x *SearchObjectsOptions) DisableForwarding() { x.noForwarding = true } + +// WithSessionToken specifies session token to attach to the request. The token +// must be issued for the request signer and target the requested container and +// operation. +func (x *SearchObjectsOptions) WithSessionToken(st session.Object) { x.sessionToken = &st } + +// WithBearerToken specifies bearer token to attach to the request. The token +// must be issued by the container owner for the request signer. +func (x *SearchObjectsOptions) WithBearerToken(bt bearer.Token) { x.bearerToken = &bt } + +// SetCount limits the search result to a given number. Must be in [1, 1000] +// range. Defaults to 1000. +func (x *SearchObjectsOptions) SetCount(count uint32) { x.count = count } + +// SearchObjects selects objects from given container by applying specified +// filters, collects values of requested attributes and returns the result +// sorted. Elements are compared by attributes' values lexicographically in +// priority from first to last, closing with the default sorting by IDs. System +// attributes can be included using special aliases like +// [object.FilterPayloadSize]. SearchObjects also returns opaque continuation +// cursor: when passed to a repeat call, it specifies where to continue the +// operation from. To start the search anew, pass an empty cursor. +// +// Max number of filters is 8. Max number of attributes is 4. If attributes are +// specified, filters must include the 1st of them. +// +// Note that if requested attribute is missing in the matching object, +// corresponding element in its [SearchResultItem.Attributes] is empty. +func (c *Client) SearchObjects(ctx context.Context, cnr cid.ID, filters object.SearchFilters, attrs []string, cursor string, + signer neofscrypto.Signer, opts SearchObjectsOptions) ([]SearchResultItem, string, error) { + var err error + if c.prm.statisticCallback != nil { + startTime := time.Now() + defer func() { + c.sendStatistic(stat.MethodObjectSearchV2, time.Since(startTime), err) + }() + } + + switch { + case signer == nil: + return nil, "", ErrMissingSigner + case cnr.IsZero(): + err = cid.ErrZero + return nil, "", err + case opts.count > maxSearchObjectsCount: + err = fmt.Errorf("count is out of [1, %d] range", maxSearchObjectsCount) + return nil, "", err + case len(filters) > maxSearchObjectsFilterCount: + err = fmt.Errorf("more than %d filters", maxSearchObjectsFilterCount) + return nil, "", err + case len(attrs) > 0: + if len(attrs) > maxSearchObjectsAttrCount { + err = fmt.Errorf("more than %d attributes", maxSearchObjectsAttrCount) + return nil, "", err + } + for i := range attrs { + if attrs[i] == "" { + err = fmt.Errorf("empty attribute #%d", i) + return nil, "", err + } + for j := i + 1; j < len(attrs); j++ { + if attrs[i] == attrs[j] { + err = fmt.Errorf("duplicated attribute %q", attrs[i]) + return nil, "", err + } + } + } + if !slices.ContainsFunc(filters, func(f object.SearchFilter) bool { return f.Header() == attrs[0] }) { + err = fmt.Errorf("attribute %q is requested but not filtered", attrs[0]) + return nil, "", err + } + } + + if opts.count == 0 { + opts.count = maxSearchObjectsCount + } + + req := &protoobject.SearchV2Request{ + Body: &protoobject.SearchV2Request_Body{ + ContainerId: cnr.ProtoMessage(), + Version: defaultSearchObjectsQueryVersion, + Filters: filters.ProtoMessage(), + Cursor: cursor, + Count: opts.count, + Attributes: attrs, + }, + MetaHeader: &protosession.RequestMetaHeader{ + Version: version.Current().ProtoMessage(), + }, + } + writeXHeadersToMeta(opts.xHeaders, req.MetaHeader) + if opts.noForwarding { + req.MetaHeader.Ttl = localRequestTTL + } else { + req.MetaHeader.Ttl = defaultRequestTTL + } + if opts.sessionToken != nil { + req.MetaHeader.SessionToken = opts.sessionToken.ProtoMessage() + } + if opts.bearerToken != nil { + req.MetaHeader.BearerToken = opts.bearerToken.ProtoMessage() + } + + buf := c.buffers.Get().(*[]byte) + defer func() { c.buffers.Put(buf) }() + + req.VerifyHeader, err = neofscrypto.SignRequestWithBuffer[*protoobject.SearchV2Request_Body](signer, req, *buf) + if err != nil { + err = fmt.Errorf("%w: %w", errSignRequest, err) + return nil, "", err + } + + resp, err := c.object.SearchV2(ctx, req) + if err != nil { + err = rpcErr(err) + return nil, "", err + } + + if c.prm.cbRespInfo != nil { + err = c.prm.cbRespInfo(ResponseMetaInfo{ + key: resp.GetVerifyHeader().GetBodySignature().GetKey(), + epoch: resp.GetMetaHeader().GetEpoch(), + }) + if err != nil { + err = fmt.Errorf("%w: %w", errResponseCallback, err) + return nil, "", err + } + } + + if err = neofscrypto.VerifyResponseWithBuffer[*protoobject.SearchV2Response_Body](resp, *buf); err != nil { + err = fmt.Errorf("%w: %w", errResponseSignatures, err) + return nil, "", err + } + + if err = apistatus.ToError(resp.GetMetaHeader().GetStatus()); err != nil { + return nil, "", err + } + + if resp.Body == nil { + return nil, "", nil + } + + n := uint32(len(resp.Body.Result)) + const cursorField = "cursor" + if n == 0 { + if resp.Body.Cursor != "" { + err = newErrInvalidResponseField(cursorField, errors.New("set while result is empty")) + return nil, "", err + } + return nil, "", nil + } + if cursor != "" && resp.Body.Cursor == cursor { + err = newErrInvalidResponseField(cursorField, errors.New("repeats the initial one")) + return nil, "", err + } + const resultField = "result" + if n > opts.count { + err = newErrInvalidResponseField(resultField, fmt.Errorf("more items than requested: %d", n)) + return nil, "", err + } + + res := make([]SearchResultItem, n) + for i, r := range resp.Body.Result { + switch { + case r == nil: + err = newErrInvalidResponseField(resultField, fmt.Errorf("nil element #%d", i)) + return nil, "", err + case r.Id == nil: + err = newErrInvalidResponseField(resultField, fmt.Errorf("invalid element #%d: missing ID", i)) + return nil, "", err + case len(r.Attributes) != len(attrs): + err = newErrInvalidResponseField(resultField, fmt.Errorf("invalid element #%d: wrong attribute count %d", i, len(r.Attributes))) + return nil, "", err + } + if err = res[i].ID.FromProtoMessage(r.Id); err != nil { + err = newErrInvalidResponseField(resultField, fmt.Errorf("invalid element #%d: invalid ID: %w", i, err)) + return nil, "", err + } + res[i].Attributes = r.Attributes + } + + return res, resp.Body.Cursor, nil +} + // PrmObjectSearch groups optional parameters of ObjectSearch operation. type PrmObjectSearch struct { sessionContainer @@ -216,7 +429,7 @@ func (c *Client) ObjectSearchInit(ctx context.Context, containerID cid.ID, signe req := &protoobject.SearchRequest{ Body: &protoobject.SearchRequest_Body{ ContainerId: containerID.ProtoMessage(), - Version: 1, + Version: defaultSearchObjectsQueryVersion, Filters: prm.filters.ProtoMessage(), }, MetaHeader: &protosession.RequestMetaHeader{ diff --git a/client/object_search_test.go b/client/object_search_test.go index f2130601..01e9365d 100644 --- a/client/object_search_test.go +++ b/client/object_search_test.go @@ -7,17 +7,23 @@ import ( "io" "math" "math/rand" + "slices" + "strconv" "testing" "time" bearertest "github.com/nspcc-dev/neofs-sdk-go/bearer/test" apistatus "github.com/nspcc-dev/neofs-sdk-go/client/status" + cid "github.com/nspcc-dev/neofs-sdk-go/container/id" cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test" + neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto" + neofscryptotest "github.com/nspcc-dev/neofs-sdk-go/crypto/test" "github.com/nspcc-dev/neofs-sdk-go/object" oid "github.com/nspcc-dev/neofs-sdk-go/object/id" oidtest "github.com/nspcc-dev/neofs-sdk-go/object/id/test" protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object" protorefs "github.com/nspcc-dev/neofs-sdk-go/proto/refs" + protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session" protostatus "github.com/nspcc-dev/neofs-sdk-go/proto/status" sessiontest "github.com/nspcc-dev/neofs-sdk-go/session/test" "github.com/nspcc-dev/neofs-sdk-go/stat" @@ -52,20 +58,24 @@ func setChunkInSearchResponse(b *protoobject.SearchResponse_Body, c []oid.ID) *p return b } -type testSearchObjectsServer struct { +type commonSearchObjectsServerSettings struct { protoobject.UnimplementedObjectServiceServer + testObjectSessionServerSettings + testBearerTokenServerSettings + testRequiredContainerIDServerSettings + testLocalRequestServerSettings + reqFilters []object.SearchFilter +} + +type testSearchObjectsServer struct { + commonSearchObjectsServerSettings testCommonServerStreamServerSettings[ *protoobject.SearchRequest_Body, *protoobject.SearchRequest, *protoobject.SearchResponse_Body, *protoobject.SearchResponse, ] - testObjectSessionServerSettings - testBearerTokenServerSettings - testRequiredContainerIDServerSettings - testLocalRequestServerSettings - chunk []oid.ID - reqFilters []object.SearchFilter + chunk []oid.ID } func TestObjectIterate(t *testing.T) { @@ -132,7 +142,9 @@ func newTestSearchObjectsServer() *testSearchObjectsServer { return new(testSear // makes the server to assert that any request carries given filter set. By // default, and if nil, any set is accepted. -func (x *testSearchObjectsServer) checkRequestFilters(fs []object.SearchFilter) { x.reqFilters = fs } +func (x *commonSearchObjectsServerSettings) checkRequestFilters(fs []object.SearchFilter) { + x.reqFilters = fs +} // makes the server to return given chunk of IDs in any response. By default, // and if nil, some non-empty data is returned. @@ -156,35 +168,42 @@ func (x *testSearchObjectsServer) verifyRequest(req *protoobject.SearchRequest) if err := x.testCommonServerStreamServerSettings.verifyRequest(req); err != nil { return err } + return x.commonSearchObjectsServerSettings.verifyRequest(req.MetaHeader, req.Body) +} + +func (x commonSearchObjectsServerSettings) verifyRequest(mh *protosession.RequestMetaHeader, body interface { + GetContainerId() *protorefs.ContainerID + GetVersion() uint32 + GetFilters() []*protoobject.SearchFilter +}) error { // meta header // TTL - if err := x.verifyTTL(req.MetaHeader); err != nil { + if err := x.verifyTTL(mh); err != nil { return err } // session token - if err := x.verifySessionToken(req.MetaHeader.GetSessionToken()); err != nil { + if err := x.verifySessionToken(mh.GetSessionToken()); err != nil { return err } // bearer token - if err := x.verifyBearerToken(req.MetaHeader.GetBearerToken()); err != nil { + if err := x.verifyBearerToken(mh.GetBearerToken()); err != nil { return err } // body - body := req.Body if body == nil { return newInvalidRequestBodyErr(errors.New("missing body")) } // 1. address - if err := x.verifyRequestContainerID(body.ContainerId); err != nil { + if err := x.verifyRequestContainerID(body.GetContainerId()); err != nil { return err } // 2. version - if body.Version != 1 { - return newErrInvalidRequestField("version", fmt.Errorf("wrong value (client: 1, message: %d)", body.Version)) + if v := body.GetVersion(); v != 1 { + return newErrInvalidRequestField("version", fmt.Errorf("wrong value (client: 1, message: %d)", v)) } // 3. filters if x.reqFilters != nil { - if err := checkObjectSearchFiltersTransport(x.reqFilters, body.Filters); err != nil { + if err := checkObjectSearchFiltersTransport(x.reqFilters, body.GetFilters()); err != nil { return newErrInvalidRequestField("filters", err) } } @@ -431,7 +450,7 @@ func TestClient_ObjectSearch(t *testing.T) { require.Equal(t, join(chunks[:n-1]), read) }) t.Run("payloads", func(t *testing.T) { - t.Skip("") + t.Skip("https://github.com/nspcc-dev/neofs-sdk-go/issues/657") type testcase = struct { name, msg string corrupt func(valid *protoobject.SearchResponse_Body) // with 3 valid IDs @@ -634,3 +653,503 @@ func TestClient_ObjectSearch(t *testing.T) { }) }) } + +type testSearchObjectsV2Server struct { + commonSearchObjectsServerSettings + testCommonUnaryServerSettings[ + *protoobject.SearchV2Request_Body, + *protoobject.SearchV2Request, + *protoobject.SearchV2Response_Body, + *protoobject.SearchV2Response, + ] + count *uint32 + reqCursor *string // response also has cursor + attrs []string +} + +// returns [protoobject.ObjectServiceServer] supporting SearchV2 method only. +// Default implementation performs common verification of any request and +// responds with any valid message. Some methods allow to tune the behavior. +func newTestSearchObjectsV2Server() *testSearchObjectsV2Server { return new(testSearchObjectsV2Server) } + +// makes the server to assert that any request carries given count. By default, +// any valid count is accepted. +func (x *testSearchObjectsV2Server) checkRequestCount(count uint32) { x.count = &count } + +// makes the server to assert that any request carries given cursor. By default, +// any cursor is accepted. +func (x *testSearchObjectsV2Server) checkRequestCursor(cursor string) { x.reqCursor = &cursor } + +// makes the server to assert that any request carries given attribute set. By +// default, and if nil, any valid filters are accepted. +func (x *testSearchObjectsV2Server) checkRequestAttributes(as []string) { x.attrs = as } + +func (x *testSearchObjectsV2Server) verifyRequest(req *protoobject.SearchV2Request) error { + if err := x.testCommonUnaryServerSettings.verifyRequest(req); err != nil { + return err + } + if err := x.commonSearchObjectsServerSettings.verifyRequest(req.MetaHeader, req.Body); err != nil { + return err + } + body := req.Body + // 4. count + if body.Count == 0 { + return newErrInvalidRequestField("count", errors.New("zero")) + } + if body.Count > 1000 { + return newErrInvalidRequestField("count", errors.New("limit exceeded")) + } + if x.count != nil { + var expCount uint32 + if *x.count != 0 { + expCount = *x.count + } else { + expCount = 1000 + } + if body.Count != expCount { + return newErrInvalidRequestField("count", fmt.Errorf("wrong value (client: %d, message: %d)", expCount, body.Count)) + } + } + // 5. cursor + if x.reqCursor != nil && body.Cursor != *x.reqCursor { + return newErrInvalidRequestField("cursor", fmt.Errorf("wrong value (client: %q, message: %q)", *x.reqCursor, body.Cursor)) + } + // 6. attributes + if x.attrs != nil && !slices.Equal(body.Attributes, x.attrs) { + return newErrInvalidRequestField("attributes", fmt.Errorf("wrong value (client: %v, message: %v)", x.attrs, body.Attributes)) + } + for i := range body.Attributes { + if body.Attributes[i] == "" { + return newErrInvalidRequestField("attributes", fmt.Errorf("empty element #%d", i)) + } + for j := i + 1; j < len(body.Attributes); j++ { + if body.Attributes[i] == body.Attributes[j] { + return newErrInvalidRequestField("attributes", fmt.Errorf("duplicated attribute %q", body.Attributes[i])) + } + } + } + if len(body.Attributes) > 0 { + if !slices.ContainsFunc(body.Filters, func(f *protoobject.SearchFilter) bool { return f.GetKey() == body.Attributes[0] }) { + return newErrInvalidRequestField("attributes", fmt.Errorf("attribute %q is requested but not filtered", body.Attributes[0])) + } + } + return nil +} + +func (x *testSearchObjectsV2Server) SearchV2(_ context.Context, req *protoobject.SearchV2Request) (*protoobject.SearchV2Response, error) { + time.Sleep(x.handlerSleepDur) + if err := x.verifyRequest(req); err != nil { + return nil, err + } + if x.handlerErr != nil { + return nil, x.handlerErr + } + + resp := &protoobject.SearchV2Response{ + MetaHeader: x.respMeta, + } + if x.respBodyForced { + resp.Body = x.respBody + } else { + count := min(uint32(len(validProtoObjectIDs)), req.Body.Count) + resp.Body = &protoobject.SearchV2Response_Body{ + Result: make([]*protoobject.SearchV2Response_OIDWithMeta, count), + Cursor: req.Body.Cursor + "_next", + } + for i := range resp.Body.Result { + resp.Body.Result[i] = &protoobject.SearchV2Response_OIDWithMeta{ + Id: proto.Clone(validProtoObjectIDs[i]).(*protorefs.ObjectID), + Attributes: make([]string, len(req.Body.Attributes)), + } + for j := range req.Body.Attributes { + resp.Body.Result[i].Attributes[j] = "val_" + strconv.Itoa(i) + "_" + strconv.Itoa(j) + } + } + } + + var err error + resp.VerifyHeader, err = x.signResponse(resp) + if err != nil { + return nil, fmt.Errorf("sign response: %w", err) + } + return resp, nil +} + +func assertSearchV2ResponseTransport(t testing.TB, body *protoobject.SearchV2Response_Body, items []SearchResultItem, cursor string) { + require.Equal(t, body.GetCursor(), cursor) + r := body.GetResult() + require.Len(t, items, len(r)) + for i := range r { + require.NoError(t, checkObjectIDTransport(items[i].ID, r[i].Id), i) + require.Equal(t, r[i].Attributes, items[i].Attributes) + } +} + +func TestClient_SearchObjects(t *testing.T) { + ctx := context.Background() + var anyValidOpts SearchObjectsOptions + anyCID := cidtest.ID() + const anyRequestCursor = "" + var anyValidFilters object.SearchFilters + var anyValidAttrs []string + anyValidSigner := usertest.User() + okConn := newTestObjectClient(t, newTestSearchObjectsV2Server()) + + t.Run("messages", func(t *testing.T) { + /* + This test is dedicated for cases when user input results in sending a certain + request to the server and receiving a specific response to it. For user input + errors, transport, client internals, etc. see/add other tests. + */ + t.Run("requests", func(t *testing.T) { + t.Run("required data", func(t *testing.T) { + srv := newTestSearchObjectsV2Server() + c := newTestObjectClient(t, srv) + const anyRequestCursor = "any_request_cursor" + + reqAttrs := make([]string, 4) + for i := range reqAttrs { + reqAttrs[i] = "attr_" + strconv.Itoa(i) + } + + var fs object.SearchFilters + fs.AddFilter(reqAttrs[0], "any_val", 100) + fs.AddFilter("k1", "v1", object.MatchStringEqual) + fs.AddFilter("k1", "v2", object.MatchStringNotEqual) + fs.AddFilter("k3", "v3", object.MatchNotPresent) + fs.AddFilter("k4", "v4", object.MatchCommonPrefix) + fs.AddFilter("k5", "v5", object.MatchNumGT) + fs.AddFilter("k6", "v6", object.MatchNumGE) + fs.AddFilter("k7", "v7", object.MatchNumLT) + + nItems := min(len(validProtoObjectIDs), 1000) + respBody := &protoobject.SearchV2Response_Body{ + Result: make([]*protoobject.SearchV2Response_OIDWithMeta, nItems), + Cursor: "any_response_cursor", + } + for i := range respBody.Result { + respBody.Result[i] = &protoobject.SearchV2Response_OIDWithMeta{ + Id: validProtoObjectIDs[i], + Attributes: make([]string, len(reqAttrs)), + } + for j := range respBody.Result[i].Attributes { + respBody.Result[i].Attributes[j] = "val_" + strconv.Itoa(i) + "_" + strconv.Itoa(j) + } + } + + srv.respondWithBody(respBody) + + srv.checkRequestContainerID(anyCID) + srv.checkRequestFilters(fs) + srv.checkRequestAttributes(reqAttrs) + srv.checkRequestCursor(anyRequestCursor) + srv.authenticateRequest(anyValidSigner) + items, cursor, err := c.SearchObjects(ctx, anyCID, fs, reqAttrs, anyRequestCursor, anyValidSigner, SearchObjectsOptions{}) + require.NoError(t, err) + assertSearchV2ResponseTransport(t, respBody, items, cursor) + }) + t.Run("options", func(t *testing.T) { + t.Run("X-headers", func(t *testing.T) { + testRequestXHeaders(t, newTestSearchObjectsV2Server, newTestObjectClient, func(c *Client, xhs []string) error { + opts := anyValidOpts + opts.WithXHeaders(xhs...) + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, opts) + return err + }) + }) + t.Run("disable forwarding", func(t *testing.T) { + srv := newTestSearchObjectsV2Server() + c := newTestObjectClient(t, srv) + + opts := anyValidOpts + opts.DisableForwarding() + + srv.checkRequestLocal() + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, opts) + require.NoError(t, err) + }) + t.Run("session token", func(t *testing.T) { + srv := newTestSearchObjectsV2Server() + c := newTestObjectClient(t, srv) + + st := sessiontest.ObjectSigned(usertest.User()) + opts := anyValidOpts + opts.WithSessionToken(st) + + srv.checkRequestSessionToken(st) + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, opts) + require.NoError(t, err) + }) + t.Run("bearer token", func(t *testing.T) { + srv := newTestSearchObjectsV2Server() + c := newTestObjectClient(t, srv) + + bt := bearertest.Token() + require.NoError(t, bt.Sign(usertest.User())) + opts := anyValidOpts + opts.WithBearerToken(bt) + + srv.checkRequestBearerToken(bt) + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, opts) + require.NoError(t, err) + }) + t.Run("count", func(t *testing.T) { + srv := newTestSearchObjectsV2Server() + c := newTestObjectClient(t, srv) + count := rand.Uint32() % 1001 + + opts := anyValidOpts + opts.SetCount(count) + + srv.checkRequestCount(count) + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, opts) + require.NoError(t, err) + }) + }) + }) + t.Run("responses", func(t *testing.T) { + t.Run("valid", func(t *testing.T) { + t.Run("payloads", func(t *testing.T) { + for _, tc := range []struct { + name string + body *protoobject.SearchV2Response_Body + }{ + {name: "nil", body: nil}, + {name: "min", body: validMinSearchV2ResponseBody}, + {name: "full", body: validFullSearchV2ResponseBody}, + } { + t.Run(tc.name, func(t *testing.T) { + srv := newTestSearchObjectsV2Server() + c := newTestObjectClient(t, srv) + + var as []string + var fs object.SearchFilters + if r := tc.body.GetResult(); len(r) > 0 { + if n := len(r[0].GetAttributes()); n > 0 { + as = make([]string, n) + for i := range as { + as[i] = "attr_" + strconv.Itoa(i) + } + + fs.AddFilter(as[0], "any_val", 100) + } + } + + srv.respondWithBody(tc.body) + items, cursor, err := c.SearchObjects(ctx, anyCID, fs, as, anyRequestCursor, anyValidSigner, anyValidOpts) + require.NoError(t, err) + assertSearchV2ResponseTransport(t, tc.body, items, cursor) + }) + } + }) + t.Run("statuses", func(t *testing.T) { + testStatusResponses(t, newTestSearchObjectsV2Server, newTestObjectClient, func(c *Client) error { + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, anyValidOpts) + return err + }) + }) + }) + t.Run("invalid", func(t *testing.T) { + t.Run("format", func(t *testing.T) { + testIncorrectUnaryRPCResponseFormat(t, "object.ObjectService", "SearchV2", func(c *Client) error { + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, anyValidOpts) + return err + }) + }) + t.Run("verification header", func(t *testing.T) { + testInvalidResponseVerificationHeader(t, newTestSearchObjectsV2Server, newTestObjectClient, func(c *Client) error { + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, anyValidOpts) + return err + }) + }) + t.Run("payloads", func(t *testing.T) { + type testcase = struct { + name, msg string + count uint32 + reqCursor string + respCursor string + attrs []string + items []*protoobject.SearchV2Response_OIDWithMeta + } + tcs := []testcase{ + {name: "cursor/without items", msg: "invalid cursor field in the response: set while result is empty", + respCursor: "any_cursor", items: nil, + }, + {name: "cursor/repeated", msg: "invalid cursor field in the response: repeats the initial one", + reqCursor: "req_cursor", respCursor: "req_cursor", items: []*protoobject.SearchV2Response_OIDWithMeta{ + {Id: proto.Clone(validProtoObjectIDs[0]).(*protorefs.ObjectID)}, nil, + }, + }, + {name: "items/limit exceeded", msg: "invalid result field in the response: more items than requested: 3", + count: 2, items: validFullSearchV2ResponseBody.Result, // 3 items + }, + {name: "items/nil element", msg: "invalid result field in the response: invalid element #1: missing ID", + items: []*protoobject.SearchV2Response_OIDWithMeta{ + {Id: proto.Clone(validProtoObjectIDs[0]).(*protorefs.ObjectID)}, nil, + }, + }, + {name: "items/element/missing ID", msg: "invalid result field in the response: invalid element #1: missing ID", + items: []*protoobject.SearchV2Response_OIDWithMeta{ + {Id: proto.Clone(validProtoObjectIDs[0]).(*protorefs.ObjectID)}, {}, + }, + }, + {name: "items/element/lack of attributes", msg: "invalid result field in the response: invalid element #1: wrong attribute count 1", + attrs: []string{"a1", "a2"}, items: []*protoobject.SearchV2Response_OIDWithMeta{ + {Id: proto.Clone(validProtoObjectIDs[0]).(*protorefs.ObjectID), Attributes: []string{"val_1_1", "val_1_2"}}, + {Id: proto.Clone(validProtoObjectIDs[1]).(*protorefs.ObjectID), Attributes: []string{"val_2_1"}}, + }, + }, + {name: "items/element/excess of attributes", msg: "invalid result field in the response: invalid element #1: wrong attribute count 3", + attrs: []string{"a1", "a2"}, items: []*protoobject.SearchV2Response_OIDWithMeta{ + {Id: proto.Clone(validProtoObjectIDs[0]).(*protorefs.ObjectID), Attributes: []string{"val_1_1", "val_1_2"}}, + {Id: proto.Clone(validProtoObjectIDs[1]).(*protorefs.ObjectID), Attributes: []string{"val_2_1", "val_2_2", "val_2_3"}}, + }, + }, + } + for _, tc := range invalidObjectIDProtoTestcases { + id := proto.Clone(validProtoObjectIDs[1]).(*protorefs.ObjectID) + tc.corrupt(id) + tcs = append(tcs, testcase{ + name: "items/element/ID/" + tc.name, + msg: "invalid result field in the response: invalid element #1: invalid ID: " + tc.msg, + items: []*protoobject.SearchV2Response_OIDWithMeta{ + {Id: proto.Clone(validProtoObjectIDs[0]).(*protorefs.ObjectID)}, {Id: id}}, + }) + } + + for _, tc := range tcs { + t.Run(tc.name, func(t *testing.T) { + srv := newTestSearchObjectsV2Server() + c := newTestObjectClient(t, srv) + + if tc.count == 0 { + tc.count = max(uint32(len(tc.items)), 1) + } + + opts := anyValidOpts + opts.SetCount(tc.count) + + var fs object.SearchFilters + if len(tc.attrs) > 0 { + fs.AddFilter(tc.attrs[0], "any_val", 100) + } + + srv.respondWithBody(&protoobject.SearchV2Response_Body{ + Result: tc.items, + Cursor: tc.respCursor, + }) + _, _, err := c.SearchObjects(ctx, anyCID, fs, tc.attrs, tc.reqCursor, anyValidSigner, opts) + require.EqualError(t, err, tc.msg) + }) + } + }) + }) + }) + }) + t.Run("invalid user input", func(t *testing.T) { + t.Run("zero container", func(t *testing.T) { + _, _, err := okConn.SearchObjects(ctx, cid.ID{}, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, anyValidOpts) + require.ErrorIs(t, err, cid.ErrZero) + }) + t.Run("count", func(t *testing.T) { + opts := anyValidOpts + opts.SetCount(1001) + _, _, err := okConn.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, opts) + require.EqualError(t, err, "count is out of [1, 1000] range") + }) + t.Run("missing signer", func(t *testing.T) { + _, _, err := okConn.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, nil, anyValidOpts) + require.ErrorIs(t, err, ErrMissingSigner) + }) + t.Run("filters", func(t *testing.T) { + t.Run("limit exceeded", func(t *testing.T) { + _, _, err := okConn.SearchObjects(ctx, anyCID, make(object.SearchFilters, 9), anyValidAttrs, anyRequestCursor, anyValidSigner, anyValidOpts) + require.EqualError(t, err, "more than 8 filters") + }) + t.Run("missing 1st requested attribute", func(t *testing.T) { + as := []string{"a1", "a2", "a3"} + var fs object.SearchFilters + for i := range as[1:] { + fs.AddFilter(as[i+1], "any_val", 100) + } + + _, _, err := okConn.SearchObjects(ctx, anyCID, fs, as, anyRequestCursor, anyValidSigner, anyValidOpts) + require.EqualError(t, err, `attribute "a1" is requested but not filtered`) + }) + }) + t.Run("attributes", func(t *testing.T) { + for _, tc := range []struct { + name, err string + as []string + }{ + {name: "empty", err: "empty attribute #1", as: []string{"a1", "", "a3"}}, + {name: "duplicated", err: `duplicated attribute "a2"`, as: []string{"a1", "a2", "a3", "a2"}}, + {name: "limit exceeded", err: "more than 4 attributes", as: []string{"a1", "a2", "a3", "a4", "a5"}}, + } { + t.Run(tc.name, func(t *testing.T) { + _, _, err := okConn.SearchObjects(ctx, anyCID, anyValidFilters, tc.as, anyRequestCursor, anyValidSigner, anyValidOpts) + require.EqualError(t, err, tc.err) + }) + } + }) + }) + t.Run("context", func(t *testing.T) { + testContextErrors(t, newTestSearchObjectsV2Server, newTestObjectClient, func(ctx context.Context, c *Client) error { + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, anyValidOpts) + return err + }) + }) + t.Run("sign request failure", func(t *testing.T) { + _, _, err := okConn.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, + neofscryptotest.FailSigner(anyValidSigner), anyValidOpts) + assertSignRequestErr(t, err) + }) + t.Run("transport failure", func(t *testing.T) { + testTransportFailure(t, newTestSearchObjectsV2Server, newTestObjectClient, func(c *Client) error { + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, anyValidOpts) + return err + }) + }) + t.Run("response callback", func(t *testing.T) { + testUnaryResponseCallback(t, newTestSearchObjectsV2Server, newDefaultObjectService, func(c *Client) error { + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, anyValidOpts) + return err + }) + }) + t.Run("exec statistics", func(t *testing.T) { + var statFailures []testedClientOp + for _, in := range []struct { + cnr cid.ID + count uint32 + signer neofscrypto.Signer + filters object.SearchFilters + attrs []string + }{ + {cnr: cid.ID{}, signer: anyValidSigner}, + {cnr: anyCID, count: 1001, signer: anyValidSigner}, + {cnr: anyCID, signer: neofscryptotest.FailSigner(anyValidSigner)}, + {cnr: anyCID, signer: anyValidSigner, filters: make(object.SearchFilters, 9)}, + {cnr: anyCID, signer: anyValidSigner, attrs: []string{"a1", "a2", "a3", "a4", "a5"}}, + {cnr: anyCID, signer: anyValidSigner, attrs: []string{"a1", "", "a3"}}, + {cnr: anyCID, signer: anyValidSigner, attrs: []string{"a1", "a2", "a3", "a2"}}, + {cnr: anyCID, signer: anyValidSigner, filters: nil, attrs: []string{"a1", "a2"}}, + } { + statFailures = append(statFailures, func(c *Client) error { + opts := anyValidOpts + opts.SetCount(in.count) + _, _, err := c.SearchObjects(ctx, in.cnr, in.filters, in.attrs, anyRequestCursor, in.signer, opts) + return err + }) + } + + testStatistic(t, newTestSearchObjectsV2Server, newDefaultObjectService, stat.MethodObjectSearchV2, []testedClientOp{ + func(c *Client) error { + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, nil, anyValidOpts) + return err + }, + }, statFailures, func(c *Client) error { + _, _, err := c.SearchObjects(ctx, anyCID, anyValidFilters, anyValidAttrs, anyRequestCursor, anyValidSigner, anyValidOpts) + return err + }) + }) +} diff --git a/internal/proto/encoding_test.go b/internal/proto/encoding_test.go index 7511248c..6ae98f3b 100644 --- a/internal/proto/encoding_test.go +++ b/internal/proto/encoding_test.go @@ -217,7 +217,7 @@ func benchmarkType[T anySupportedType]( buf := make([]byte, sizeFunc(fieldNum, v)) b.ResetTimer() b.ReportAllocs() - for i := 0; i < b.N; i++ { + for range b.N { marshalFunc(buf, fieldNum, v) } } @@ -233,7 +233,7 @@ func benchmarkRepeatedType[T anySupportedType]( b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { marshalFunc(buf, fieldNum, v) } } @@ -389,7 +389,7 @@ func BenchmarkMarshalEmbedded(b *testing.B) { b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { proto.MarshalToEmbedded(buf, fieldNum, v) } } diff --git a/netmap/json_test.go b/netmap/json_test.go index 13d0cec8..845f8f2f 100644 --- a/netmap/json_test.go +++ b/netmap/json_test.go @@ -135,7 +135,7 @@ func BenchmarkPlacementPolicyInteropability(b *testing.B) { b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { b.StartTimer() v, err := nm.ContainerNodes(tt.Policy, pivot) b.StopTimer() @@ -184,7 +184,7 @@ func BenchmarkManySelects(b *testing.B) { b.ResetTimer() b.ReportAllocs() - for i := 0; i < b.N; i++ { + for range b.N { _, err = nm.ContainerNodes(tt.Policy, pivot) if err != nil { b.FailNow() diff --git a/netmap/selector_test.go b/netmap/selector_test.go index 20781428..36c088b8 100644 --- a/netmap/selector_test.go +++ b/netmap/selector_test.go @@ -41,7 +41,7 @@ func BenchmarkHRWSort(b *testing.B) { b.Run("sort by value, no weight", func(b *testing.B) { realNodes := make([]nodes, netmapSize) b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { b.StopTimer() copy(realNodes, vectors) b.StartTimer() @@ -52,7 +52,7 @@ func BenchmarkHRWSort(b *testing.B) { b.Run("sort by value", func(b *testing.B) { realNodes := make([]nodes, netmapSize) b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { b.StopTimer() copy(realNodes, vectors) b.StartTimer() @@ -99,7 +99,7 @@ func BenchmarkPolicyHRWType(b *testing.B) { nm.SetNodes(nodes) b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { _, err := nm.ContainerNodes(p, cid.ID{1}) if err != nil { b.Fatal() diff --git a/object/search.go b/object/search.go index 55056b8f..46abe426 100644 --- a/object/search.go +++ b/object/search.go @@ -182,8 +182,8 @@ const ( FilterPhysical = reservedFilterPrefix + "PHY" ) -func (f SearchFilter) protoMessage() *protoobject.SearchRequest_Body_Filter { - return &protoobject.SearchRequest_Body_Filter{ +func (f SearchFilter) protoMessage() *protoobject.SearchFilter { + return &protoobject.SearchFilter{ MatchType: protoobject.MatchType(f.Operation()), Key: f.Header(), Value: f.Value(), @@ -267,7 +267,7 @@ func (f *SearchFilters) AddObjectOwnerIDFilter(m SearchMatchType, id user.ID) { // f from it. // // See also [SearchFilters.ProtoMessage]. -func (f *SearchFilters) FromProtoMessage(ms []*protoobject.SearchRequest_Body_Filter) error { +func (f *SearchFilters) FromProtoMessage(ms []*protoobject.SearchFilter) error { fs := make(SearchFilters, len(ms)) for i, m := range ms { if m == nil { @@ -293,8 +293,8 @@ func (f *SearchFilters) FromProtoMessage(ms []*protoobject.SearchRequest_Body_Fi // protocol. // // See also [SearchFilters.FromProtoMessage]. -func (f SearchFilters) ProtoMessage() []*protoobject.SearchRequest_Body_Filter { - m := make([]*protoobject.SearchRequest_Body_Filter, len(f)) +func (f SearchFilters) ProtoMessage() []*protoobject.SearchFilter { + m := make([]*protoobject.SearchFilter, len(f)) for i := range f { m[i] = f[i].protoMessage() } @@ -346,10 +346,10 @@ func (f *SearchFilters) AddTypeFilter(m SearchMatchType, typ Type) { f.addFilter(m, FilterType, typ.EncodeToString()) } -type fj protoobject.SearchRequest_Body_Filter +type fj protoobject.SearchFilter func (x *fj) MarshalJSON() ([]byte, error) { - return neofsproto.MarshalMessageJSON((*protoobject.SearchRequest_Body_Filter)(x)) + return neofsproto.MarshalMessageJSON((*protoobject.SearchFilter)(x)) } // MarshalJSON encodes [SearchFilters] to protobuf JSON format. @@ -364,7 +364,7 @@ func (f SearchFilters) MarshalJSON() ([]byte, error) { } func (x *fj) UnmarshalJSON(b []byte) error { - return neofsproto.UnmarshalMessageJSON(b, (*protoobject.SearchRequest_Body_Filter)(x)) + return neofsproto.UnmarshalMessageJSON(b, (*protoobject.SearchFilter)(x)) } // UnmarshalJSON decodes [SearchFilters] from protobuf JSON format. @@ -377,9 +377,9 @@ func (f *SearchFilters) UnmarshalJSON(data []byte) error { return err } - m := make([]*protoobject.SearchRequest_Body_Filter, len(j)) + m := make([]*protoobject.SearchFilter, len(j)) for i := range j { - m[i] = (*protoobject.SearchRequest_Body_Filter)(j[i]) + m[i] = (*protoobject.SearchFilter)(j[i]) } return f.FromProtoMessage(m) diff --git a/object/search_test.go b/object/search_test.go index bfdaba66..178bf96b 100644 --- a/object/search_test.go +++ b/object/search_test.go @@ -462,7 +462,7 @@ func TestSearchFilters_ProtoMessage(t *testing.T) { } func TestSearchFilters_FromProtoMessage(t *testing.T) { - ms := []*protoobject.SearchRequest_Body_Filter{ + ms := []*protoobject.SearchFilter{ {MatchType: protoobject.MatchType(rand.Int32()), Key: "key_1", Value: "val_1"}, {MatchType: protoobject.MatchType(rand.Int32()), Key: "key_2", Value: "val_2"}, } @@ -482,11 +482,11 @@ func TestSearchFilters_FromProtoMessage(t *testing.T) { t.Run("invalid", func(t *testing.T) { for _, tc := range []struct { name, err string - corrupt func([]*protoobject.SearchRequest_Body_Filter) + corrupt func([]*protoobject.SearchFilter) }{} { cp := slices.Clone(ms) for i := range ms { - cp[i] = proto.Clone(ms[i]).(*protoobject.SearchRequest_Body_Filter) + cp[i] = proto.Clone(ms[i]).(*protoobject.SearchFilter) } tc.corrupt(cp) require.EqualError(t, fs.FromProtoMessage(ms), tc.err) diff --git a/object/slicer/slicer_test.go b/object/slicer/slicer_test.go index d5ac85c3..1a53556d 100644 --- a/object/slicer/slicer_test.go +++ b/object/slicer/slicer_test.go @@ -100,7 +100,7 @@ func benchmarkSliceDataIntoObjects(b *testing.B, size, sizeLimit uint64) { b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { _, err = s.Put(ctx, r, in.attributes) b.StopTimer() require.NoError(b, err) @@ -115,7 +115,7 @@ func benchmarkSliceDataIntoObjects(b *testing.B, size, sizeLimit uint64) { var err error var w *slicer.PayloadWriter - for i := 0; i < b.N; i++ { + for range b.N { w, err = s.InitPut(ctx, in.attributes) b.StopTimer() require.NoError(b, err) @@ -954,7 +954,7 @@ func BenchmarkWritePayloadBuffer(b *testing.B) { b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { w, err := slicer.InitPut(ctx, discardObject{opts: opts}, hdr, in.signer, opts) require.NoError(b, err) @@ -970,7 +970,7 @@ func BenchmarkWritePayloadBuffer(b *testing.B) { b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { w, err := slicer.InitPut(ctx, discardObject{opts: opts}, hdr, in.signer, opts) require.NoError(b, err) @@ -1009,7 +1009,7 @@ func BenchmarkReadPayloadBuffer(b *testing.B) { b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { _, err := slicer.Put(ctx, discardObject{opts: opts}, hdr, in.signer, bytes.NewReader(in.payload), opts) require.NoError(b, err) } @@ -1019,7 +1019,7 @@ func BenchmarkReadPayloadBuffer(b *testing.B) { b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { _, err := slicer.Put(ctx, discardObject{opts: opts}, hdr, in.signer, bytes.NewReader(in.payload), opts) require.NoError(b, err) } @@ -1177,7 +1177,7 @@ func BenchmarkKnownPayloadSize(b *testing.B) { b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { _, err := slicer.Put(ctx, discardObject{opts: opts}, hdr, signer, bytes.NewReader(payload), opts) require.NoError(b, err) } @@ -1198,7 +1198,7 @@ func BenchmarkKnownPayloadSize(b *testing.B) { b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { + for range b.N { w, err := slicer.InitPut(ctx, discardObject{opts: opts}, hdr, signer, opts) require.NoError(b, err) diff --git a/pool/mock_test.go b/pool/mock_test.go index 49506892..d9402efb 100644 --- a/pool/mock_test.go +++ b/pool/mock_test.go @@ -138,6 +138,11 @@ func (m *mockClient) ObjectSearchInit(_ context.Context, _ cid.ID, _ user.Signer panic("implement me") } +func (m *mockClient) SearchObjects(context.Context, cid.ID, object.SearchFilters, []string, string, neofscrypto.Signer, client.SearchObjectsOptions) ([]client.SearchResultItem, string, error) { + // TODO implement me + panic("implement me") +} + func (m *mockClient) SessionCreate(_ context.Context, signer user.Signer, _ client.PrmSessionCreate) (*client.ResSessionCreate, error) { if m.errorOnCreateSession { err := errors.New("create session") diff --git a/pool/object.go b/pool/object.go index 24301598..122e76db 100644 --- a/pool/object.go +++ b/pool/object.go @@ -6,6 +6,7 @@ import ( "github.com/nspcc-dev/neofs-sdk-go/client" cid "github.com/nspcc-dev/neofs-sdk-go/container/id" + neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto" "github.com/nspcc-dev/neofs-sdk-go/object" oid "github.com/nspcc-dev/neofs-sdk-go/object/id" "github.com/nspcc-dev/neofs-sdk-go/session" @@ -150,3 +151,14 @@ func (p *Pool) ObjectSearchInit(ctx context.Context, containerID cid.ID, signer } return c.ObjectSearchInit(ctx, containerID, signer, prm) } + +// SearchObjects selects a suitable connection from the pool and calls +// [client.Client.SearchObjects] on it. +func (p *Pool) SearchObjects(ctx context.Context, containerID cid.ID, filters object.SearchFilters, attrs []string, cursor string, + signer neofscrypto.Signer, opts client.SearchObjectsOptions) ([]client.SearchResultItem, string, error) { + c, err := p.sdkClient() + if err != nil { + return nil, "", err + } + return c.SearchObjects(ctx, containerID, filters, attrs, cursor, signer, opts) +} diff --git a/pool/object_test.go b/pool/object_test.go index 786fbdb9..baec64f4 100644 --- a/pool/object_test.go +++ b/pool/object_test.go @@ -14,6 +14,7 @@ import ( cid "github.com/nspcc-dev/neofs-sdk-go/container/id" cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test" neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto" + neofscryptotest "github.com/nspcc-dev/neofs-sdk-go/crypto/test" "github.com/nspcc-dev/neofs-sdk-go/eacl" "github.com/nspcc-dev/neofs-sdk-go/netmap" "github.com/nspcc-dev/neofs-sdk-go/object" @@ -96,6 +97,10 @@ func (noOtherClientCalls) ObjectSearchInit(context.Context, cid.ID, user.Signer, panic("must not be called") } +func (noOtherClientCalls) SearchObjects(context.Context, cid.ID, object.SearchFilters, []string, string, neofscrypto.Signer, client.SearchObjectsOptions) ([]client.SearchResultItem, string, error) { + panic("must not be called") +} + func (noOtherClientCalls) SessionCreate(context.Context, user.Signer, client.PrmSessionCreate) (*client.ResSessionCreate, error) { panic("must not be called") } @@ -553,3 +558,106 @@ func TestPool_ObjectSearchInit(t *testing.T) { require.Equal(t, err, searchClient.err) require.Equal(t, rdr, searchClient.rdr) } + +type objectSearchV2OnlyClient struct { + noOtherClientCalls + // expected input + cnr cid.ID + filters object.SearchFilters + attrs []string + reqCursor string + signer neofscrypto.Signer + opts client.SearchObjectsOptions + // ret + items []client.SearchResultItem + respCursor string + err error +} + +func (x objectSearchV2OnlyClient) SearchObjects(ctx context.Context, cnr cid.ID, filters object.SearchFilters, attrs []string, cursor string, + signer neofscrypto.Signer, opts client.SearchObjectsOptions) ([]client.SearchResultItem, string, error) { + switch { + case ctx == nil: + return nil, "", errors.New("[test] nil context") + case cnr != x.cnr: + return nil, "", errors.New("[test] wrong container") + case !assert.ObjectsAreEqual(filters, x.filters): + return nil, "", errors.New("[test] wrong filters") + case !assert.ObjectsAreEqual(attrs, x.attrs): + return nil, "", errors.New("[test] wrong attributes") + case cursor != x.reqCursor: + return nil, "", errors.New("[test] wrong cursor") + case !assert.ObjectsAreEqual(signer, x.signer): + return nil, "", errors.New("[test] wrong signer") + case !assert.ObjectsAreEqual(opts, x.opts): + return nil, "", errors.New("[test] wrong options") + } + return x.items, x.respCursor, x.err +} + +type objectSearchV2OnlyClientWrapper struct { + mockedClientWrapper + c objectSearchV2OnlyClient +} + +func (x objectSearchV2OnlyClientWrapper) getClient() (sdkClientInterface, error) { return x.c, nil } + +func TestPool_SearchObjects(t *testing.T) { + ctx := context.Background() + cnrID := cidtest.ID() + const reqCursor = "any_request_cursor" + signer := neofscryptotest.Signer() + attrs := []string{"a1", "a2", "a3"} + var fs object.SearchFilters + fs.AddFilter("k1", "v1", object.MatchStringEqual) + fs.AddFilter("k2", "v2", object.MatchStringNotEqual) + + var opts client.SearchObjectsOptions + opts.WithXHeaders("k1", "v1", "k2", "v2") + opts.DisableForwarding() + opts.WithSessionToken(sessiontest.Object()) + opts.WithBearerToken(bearertest.Token()) + opts.SetCount(1000) + + searchClient := objectSearchV2OnlyClient{ + cnr: cnrID, + filters: fs, + attrs: attrs, + reqCursor: "any_request_cursor", + signer: signer, + opts: opts, + items: []client.SearchResultItem{ + {ID: oidtest.ID(), Attributes: []string{"val_1_1", "val_1_2"}}, + {ID: oidtest.ID(), Attributes: []string{"val_2_1", "val_2_2"}}, + {ID: oidtest.ID(), Attributes: []string{"val_3_1", "val_3_2"}}, + }, + respCursor: "any_response_cursor", + err: errors.New("any error"), + } + endpoints := []string{"localhost:8080", "localhost:8081"} + nodes := make([]NodeParam, len(endpoints)) + cws := make([]objectSearchV2OnlyClientWrapper, len(endpoints)) + for i := range endpoints { + nodes[i].address = endpoints[i] + cws[i].addr = endpoints[i] + cws[i].c = searchClient + } + + var poolOpts InitParameters + poolOpts.setClientBuilder(func(endpoint string) (internalClient, error) { + ind := slices.Index(endpoints, endpoint) + if ind < 0 { + return nil, fmt.Errorf("unexpected endpoint %q", endpoint) + } + return &cws[ind], nil + }) + p, err := New(nodes, usertest.User().RFC6979, poolOpts) + require.NoError(t, err) + require.NoError(t, p.Dial(ctx)) + t.Cleanup(p.Close) + + items, cursor, err := p.SearchObjects(ctx, cnrID, fs, attrs, reqCursor, signer, opts) + require.Equal(t, items, searchClient.items) + require.Equal(t, cursor, searchClient.respCursor) + require.Equal(t, err, searchClient.err) +} diff --git a/pool/pool.go b/pool/pool.go index 514196d5..da5eb002 100644 --- a/pool/pool.go +++ b/pool/pool.go @@ -55,6 +55,7 @@ type sdkClientInterface interface { ObjectDelete(ctx context.Context, containerID cid.ID, objectID oid.ID, signer user.Signer, prm sdkClient.PrmObjectDelete) (oid.ID, error) ObjectHash(ctx context.Context, containerID cid.ID, objectID oid.ID, signer user.Signer, prm sdkClient.PrmObjectHash) ([][]byte, error) ObjectSearchInit(ctx context.Context, containerID cid.ID, signer user.Signer, prm sdkClient.PrmObjectSearch) (*sdkClient.ObjectListReader, error) + SearchObjects(ctx context.Context, containerID cid.ID, filters object.SearchFilters, attrs []string, cursor string, signer neofscrypto.Signer, opts sdkClient.SearchObjectsOptions) ([]sdkClient.SearchResultItem, string, error) SessionCreate(ctx context.Context, signer user.Signer, prm sdkClient.PrmSessionCreate) (*sdkClient.ResSessionCreate, error) diff --git a/proto/accounting/service.pb.go b/proto/accounting/service.pb.go index b0858cc6..f74f7034 100644 --- a/proto/accounting/service.pb.go +++ b/proto/accounting/service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/accounting/service.proto @@ -163,7 +163,7 @@ func (x *BalanceResponse) GetVerifyHeader() *session.ResponseVerificationHeader } // To indicate the account for which the balance is requested, its identifier -// is used. It can be any existing account in NeoFS sidechain `Balance` smart +// is used. It can be any existing account in FS chain `Balance` smart // contract. If omitted, client implementation MUST set it to the request's // signer `OwnerID`. type BalanceRequest_Body struct { @@ -343,7 +343,7 @@ func file_proto_accounting_service_proto_rawDescGZIP() []byte { } var file_proto_accounting_service_proto_msgTypes = make([]protoimpl.MessageInfo, 4) -var file_proto_accounting_service_proto_goTypes = []interface{}{ +var file_proto_accounting_service_proto_goTypes = []any{ (*BalanceRequest)(nil), // 0: neo.fs.v2.accounting.BalanceRequest (*BalanceResponse)(nil), // 1: neo.fs.v2.accounting.BalanceResponse (*BalanceRequest_Body)(nil), // 2: neo.fs.v2.accounting.BalanceRequest.Body @@ -380,7 +380,7 @@ func file_proto_accounting_service_proto_init() { } file_proto_accounting_types_proto_init() if !protoimpl.UnsafeEnabled { - file_proto_accounting_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_accounting_service_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*BalanceRequest); i { case 0: return &v.state @@ -392,7 +392,7 @@ func file_proto_accounting_service_proto_init() { return nil } } - file_proto_accounting_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_accounting_service_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*BalanceResponse); i { case 0: return &v.state @@ -404,7 +404,7 @@ func file_proto_accounting_service_proto_init() { return nil } } - file_proto_accounting_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_accounting_service_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*BalanceRequest_Body); i { case 0: return &v.state @@ -416,7 +416,7 @@ func file_proto_accounting_service_proto_init() { return nil } } - file_proto_accounting_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_accounting_service_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*BalanceResponse_Body); i { case 0: return &v.state diff --git a/proto/accounting/types.pb.go b/proto/accounting/types.pb.go index d8412a75..690be830 100644 --- a/proto/accounting/types.pb.go +++ b/proto/accounting/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/accounting/types.proto @@ -117,7 +117,7 @@ func file_proto_accounting_types_proto_rawDescGZIP() []byte { } var file_proto_accounting_types_proto_msgTypes = make([]protoimpl.MessageInfo, 1) -var file_proto_accounting_types_proto_goTypes = []interface{}{ +var file_proto_accounting_types_proto_goTypes = []any{ (*Decimal)(nil), // 0: neo.fs.v2.accounting.Decimal } var file_proto_accounting_types_proto_depIdxs = []int32{ @@ -134,7 +134,7 @@ func file_proto_accounting_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_accounting_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_accounting_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*Decimal); i { case 0: return &v.state diff --git a/proto/acl/types.pb.go b/proto/acl/types.pb.go index 565e5c5b..7a5e0854 100644 --- a/proto/acl/types.pb.go +++ b/proto/acl/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/acl/types.proto @@ -1000,7 +1000,7 @@ func file_proto_acl_types_proto_rawDescGZIP() []byte { var file_proto_acl_types_proto_enumTypes = make([]protoimpl.EnumInfo, 5) var file_proto_acl_types_proto_msgTypes = make([]protoimpl.MessageInfo, 7) -var file_proto_acl_types_proto_goTypes = []interface{}{ +var file_proto_acl_types_proto_goTypes = []any{ (Role)(0), // 0: neo.fs.v2.acl.Role (MatchType)(0), // 1: neo.fs.v2.acl.MatchType (Operation)(0), // 2: neo.fs.v2.acl.Operation @@ -1048,7 +1048,7 @@ func file_proto_acl_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_acl_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_acl_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*EACLRecord); i { case 0: return &v.state @@ -1060,7 +1060,7 @@ func file_proto_acl_types_proto_init() { return nil } } - file_proto_acl_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_acl_types_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*EACLTable); i { case 0: return &v.state @@ -1072,7 +1072,7 @@ func file_proto_acl_types_proto_init() { return nil } } - file_proto_acl_types_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_acl_types_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*BearerToken); i { case 0: return &v.state @@ -1084,7 +1084,7 @@ func file_proto_acl_types_proto_init() { return nil } } - file_proto_acl_types_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_acl_types_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*EACLRecord_Filter); i { case 0: return &v.state @@ -1096,7 +1096,7 @@ func file_proto_acl_types_proto_init() { return nil } } - file_proto_acl_types_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_acl_types_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*EACLRecord_Target); i { case 0: return &v.state @@ -1108,7 +1108,7 @@ func file_proto_acl_types_proto_init() { return nil } } - file_proto_acl_types_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_proto_acl_types_proto_msgTypes[5].Exporter = func(v any, i int) any { switch v := v.(*BearerToken_Body); i { case 0: return &v.state @@ -1120,7 +1120,7 @@ func file_proto_acl_types_proto_init() { return nil } } - file_proto_acl_types_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_proto_acl_types_proto_msgTypes[6].Exporter = func(v any, i int) any { switch v := v.(*BearerToken_Body_TokenLifetime); i { case 0: return &v.state diff --git a/proto/audit/types.pb.go b/proto/audit/types.pb.go index e7ba9414..b9f0113b 100644 --- a/proto/audit/types.pb.go +++ b/proto/audit/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/audit/types.proto @@ -253,7 +253,7 @@ func file_proto_audit_types_proto_rawDescGZIP() []byte { } var file_proto_audit_types_proto_msgTypes = make([]protoimpl.MessageInfo, 1) -var file_proto_audit_types_proto_goTypes = []interface{}{ +var file_proto_audit_types_proto_goTypes = []any{ (*DataAuditResult)(nil), // 0: neo.fs.v2.audit.DataAuditResult (*refs.Version)(nil), // 1: neo.fs.v2.refs.Version (*refs.ContainerID)(nil), // 2: neo.fs.v2.refs.ContainerID @@ -277,7 +277,7 @@ func file_proto_audit_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_audit_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_audit_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*DataAuditResult); i { case 0: return &v.state diff --git a/proto/container/service.pb.go b/proto/container/service.pb.go index 7e103cc6..63a4d416 100644 --- a/proto/container/service.pb.go +++ b/proto/container/service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/container/service.proto @@ -1005,7 +1005,7 @@ func (x *AnnounceUsedSpaceResponse) GetVerifyHeader() *session.ResponseVerificat } // Container creation request has container structure's signature as a -// separate field. It's not stored in sidechain, just verified on container +// separate field. It's not stored in FS chain, just verified on container // creation by `Container` smart contract. `ContainerID` is a SHA256 hash of // the stable-marshalled container strucutre, hence there is no need for // additional signature checks. @@ -1494,7 +1494,7 @@ func (x *SetExtendedACLRequest_Body) GetSignature() *refs.SignatureRFC6979 { // `SetExtendedACLResponse` has an empty body because the operation is // asynchronous and the update should be reflected in `Container` smart contract's -// storage after next block is issued in sidechain. +// storage after next block is issued in FS chain. type SetExtendedACLResponse_Body struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -2183,7 +2183,7 @@ func file_proto_container_service_proto_rawDescGZIP() []byte { } var file_proto_container_service_proto_msgTypes = make([]protoimpl.MessageInfo, 29) -var file_proto_container_service_proto_goTypes = []interface{}{ +var file_proto_container_service_proto_goTypes = []any{ (*PutRequest)(nil), // 0: neo.fs.v2.container.PutRequest (*PutResponse)(nil), // 1: neo.fs.v2.container.PutResponse (*DeleteRequest)(nil), // 2: neo.fs.v2.container.DeleteRequest @@ -2314,7 +2314,7 @@ func file_proto_container_service_proto_init() { } file_proto_container_types_proto_init() if !protoimpl.UnsafeEnabled { - file_proto_container_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*PutRequest); i { case 0: return &v.state @@ -2326,7 +2326,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*PutResponse); i { case 0: return &v.state @@ -2338,7 +2338,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*DeleteRequest); i { case 0: return &v.state @@ -2350,7 +2350,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*DeleteResponse); i { case 0: return &v.state @@ -2362,7 +2362,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*GetRequest); i { case 0: return &v.state @@ -2374,7 +2374,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[5].Exporter = func(v any, i int) any { switch v := v.(*GetResponse); i { case 0: return &v.state @@ -2386,7 +2386,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[6].Exporter = func(v any, i int) any { switch v := v.(*ListRequest); i { case 0: return &v.state @@ -2398,7 +2398,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[7].Exporter = func(v any, i int) any { switch v := v.(*ListResponse); i { case 0: return &v.state @@ -2410,7 +2410,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[8].Exporter = func(v any, i int) any { switch v := v.(*SetExtendedACLRequest); i { case 0: return &v.state @@ -2422,7 +2422,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[9].Exporter = func(v any, i int) any { switch v := v.(*SetExtendedACLResponse); i { case 0: return &v.state @@ -2434,7 +2434,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[10].Exporter = func(v any, i int) any { switch v := v.(*GetExtendedACLRequest); i { case 0: return &v.state @@ -2446,7 +2446,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[11].Exporter = func(v any, i int) any { switch v := v.(*GetExtendedACLResponse); i { case 0: return &v.state @@ -2458,7 +2458,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[12].Exporter = func(v any, i int) any { switch v := v.(*AnnounceUsedSpaceRequest); i { case 0: return &v.state @@ -2470,7 +2470,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[13].Exporter = func(v any, i int) any { switch v := v.(*AnnounceUsedSpaceResponse); i { case 0: return &v.state @@ -2482,7 +2482,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[14].Exporter = func(v any, i int) any { switch v := v.(*PutRequest_Body); i { case 0: return &v.state @@ -2494,7 +2494,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[15].Exporter = func(v any, i int) any { switch v := v.(*PutResponse_Body); i { case 0: return &v.state @@ -2506,7 +2506,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[16].Exporter = func(v any, i int) any { switch v := v.(*DeleteRequest_Body); i { case 0: return &v.state @@ -2518,7 +2518,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[17].Exporter = func(v any, i int) any { switch v := v.(*DeleteResponse_Body); i { case 0: return &v.state @@ -2530,7 +2530,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[18].Exporter = func(v any, i int) any { switch v := v.(*GetRequest_Body); i { case 0: return &v.state @@ -2542,7 +2542,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[19].Exporter = func(v any, i int) any { switch v := v.(*GetResponse_Body); i { case 0: return &v.state @@ -2554,7 +2554,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[20].Exporter = func(v any, i int) any { switch v := v.(*ListRequest_Body); i { case 0: return &v.state @@ -2566,7 +2566,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[21].Exporter = func(v any, i int) any { switch v := v.(*ListResponse_Body); i { case 0: return &v.state @@ -2578,7 +2578,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[22].Exporter = func(v any, i int) any { switch v := v.(*SetExtendedACLRequest_Body); i { case 0: return &v.state @@ -2590,7 +2590,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[23].Exporter = func(v any, i int) any { switch v := v.(*SetExtendedACLResponse_Body); i { case 0: return &v.state @@ -2602,7 +2602,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[24].Exporter = func(v any, i int) any { switch v := v.(*GetExtendedACLRequest_Body); i { case 0: return &v.state @@ -2614,7 +2614,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[25].Exporter = func(v any, i int) any { switch v := v.(*GetExtendedACLResponse_Body); i { case 0: return &v.state @@ -2626,7 +2626,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[26].Exporter = func(v any, i int) any { switch v := v.(*AnnounceUsedSpaceRequest_Body); i { case 0: return &v.state @@ -2638,7 +2638,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[27].Exporter = func(v any, i int) any { switch v := v.(*AnnounceUsedSpaceRequest_Body_Announcement); i { case 0: return &v.state @@ -2650,7 +2650,7 @@ func file_proto_container_service_proto_init() { return nil } } - file_proto_container_service_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_service_proto_msgTypes[28].Exporter = func(v any, i int) any { switch v := v.(*AnnounceUsedSpaceResponse_Body); i { case 0: return &v.state diff --git a/proto/container/service_grpc.pb.go b/proto/container/service_grpc.pb.go index 890152b4..d173e864 100644 --- a/proto/container/service_grpc.pb.go +++ b/proto/container/service_grpc.pb.go @@ -33,18 +33,18 @@ const ( // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. type ContainerServiceClient interface { // `Put` invokes `Container` smart contract's `Put` method and returns - // response immediately. After a new block is issued in sidechain, request is - // verified by Inner Ring nodes. After one more block in sidechain, the container + // response immediately. After a new block is issued in FS chain, request is + // verified by Inner Ring nodes. After one more block in FS chain, the container // is added into smart contract storage. // // Statuses: // - **OK** (0, SECTION_SUCCESS): \ - // request to save the container has been sent to the sidechain; + // request to save the container has been sent to FS chain; // - Common failures (SECTION_FAILURE_COMMON). Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error) // `Delete` invokes `Container` smart contract's `Delete` method and returns - // response immediately. After a new block is issued in sidechain, request is - // verified by Inner Ring nodes. After one more block in sidechain, the container + // response immediately. After a new block is issued in FS chain, request is + // verified by Inner Ring nodes. After one more block in FS chain, the container // is added into smart contract storage. // NOTE: a container deletion leads to the removal of every object in that // container, regardless of any restrictions on the object removal (e.g. lock/locked @@ -52,7 +52,7 @@ type ContainerServiceClient interface { // // Statuses: // - **OK** (0, SECTION_SUCCESS): \ - // request to remove the container has been sent to the sidechain; + // request to remove the container has been sent to FS chain; // - Common failures (SECTION_FAILURE_COMMON). Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) // Returns container structure from `Container` smart contract storage. @@ -72,12 +72,12 @@ type ContainerServiceClient interface { // - Common failures (SECTION_FAILURE_COMMON). List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) // Invokes 'SetEACL' method of 'Container` smart contract and returns response - // immediately. After one more block in sidechain, changes in an Extended ACL are + // immediately. After one more block in FS chain, changes in an Extended ACL are // added into smart contract storage. // // Statuses: // - **OK** (0, SECTION_SUCCESS): \ - // request to save container eACL has been sent to the sidechain; + // request to save container eACL has been sent to FS chain; // - Common failures (SECTION_FAILURE_COMMON). SetExtendedACL(ctx context.Context, in *SetExtendedACLRequest, opts ...grpc.CallOption) (*SetExtendedACLResponse, error) // Returns Extended ACL table and signature from `Container` smart contract @@ -177,18 +177,18 @@ func (c *containerServiceClient) AnnounceUsedSpace(ctx context.Context, in *Anno // for forward compatibility type ContainerServiceServer interface { // `Put` invokes `Container` smart contract's `Put` method and returns - // response immediately. After a new block is issued in sidechain, request is - // verified by Inner Ring nodes. After one more block in sidechain, the container + // response immediately. After a new block is issued in FS chain, request is + // verified by Inner Ring nodes. After one more block in FS chain, the container // is added into smart contract storage. // // Statuses: // - **OK** (0, SECTION_SUCCESS): \ - // request to save the container has been sent to the sidechain; + // request to save the container has been sent to FS chain; // - Common failures (SECTION_FAILURE_COMMON). Put(context.Context, *PutRequest) (*PutResponse, error) // `Delete` invokes `Container` smart contract's `Delete` method and returns - // response immediately. After a new block is issued in sidechain, request is - // verified by Inner Ring nodes. After one more block in sidechain, the container + // response immediately. After a new block is issued in FS chain, request is + // verified by Inner Ring nodes. After one more block in FS chain, the container // is added into smart contract storage. // NOTE: a container deletion leads to the removal of every object in that // container, regardless of any restrictions on the object removal (e.g. lock/locked @@ -196,7 +196,7 @@ type ContainerServiceServer interface { // // Statuses: // - **OK** (0, SECTION_SUCCESS): \ - // request to remove the container has been sent to the sidechain; + // request to remove the container has been sent to FS chain; // - Common failures (SECTION_FAILURE_COMMON). Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) // Returns container structure from `Container` smart contract storage. @@ -216,12 +216,12 @@ type ContainerServiceServer interface { // - Common failures (SECTION_FAILURE_COMMON). List(context.Context, *ListRequest) (*ListResponse, error) // Invokes 'SetEACL' method of 'Container` smart contract and returns response - // immediately. After one more block in sidechain, changes in an Extended ACL are + // immediately. After one more block in FS chain, changes in an Extended ACL are // added into smart contract storage. // // Statuses: // - **OK** (0, SECTION_SUCCESS): \ - // request to save container eACL has been sent to the sidechain; + // request to save container eACL has been sent to FS chain; // - Common failures (SECTION_FAILURE_COMMON). SetExtendedACL(context.Context, *SetExtendedACLRequest) (*SetExtendedACLResponse, error) // Returns Extended ACL table and signature from `Container` smart contract diff --git a/proto/container/types.pb.go b/proto/container/types.pb.go index 450c53b5..0a330b61 100644 --- a/proto/container/types.pb.go +++ b/proto/container/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/container/types.proto @@ -146,6 +146,22 @@ func (x *Container) GetPlacementPolicy() *netmap.PlacementPolicy { // accepted in a NeoFS network only if the global network hashing configuration // value corresponds with that attribute's value. After container inclusion, network // setting is ignored. +// - __NEOFS__METAINFO_CONSISTENCY \ +// Policy rule that defines the condition under which an object is considered +// processed. Acceptable values and meanings: +// 1. "strict": SN processes objects' meta information, it is validated, +// indexed and signed accordingly by a required minimal number of nodes +// that are included in the container, a corresponding object inclusion +// notification can be caught +// 2. "optimistic": the same as "strict" but a successful PUT operation +// does not mean objects' meta information has been multi signed and +// indexed correctly, however, SNs will try to do it asynchronously; +// in general PUT operations are expected to be faster than in the +// "strict" case +// 3. : SN does not process objects' meta +// information, it is not indexed and object presence/number of copies +// is not proven after a successful object PUT operation; the behavior +// is the same as it was before this attribute introduction // // And some well-known attributes used by applications only: // @@ -264,7 +280,7 @@ func file_proto_container_types_proto_rawDescGZIP() []byte { } var file_proto_container_types_proto_msgTypes = make([]protoimpl.MessageInfo, 2) -var file_proto_container_types_proto_goTypes = []interface{}{ +var file_proto_container_types_proto_goTypes = []any{ (*Container)(nil), // 0: neo.fs.v2.container.Container (*Container_Attribute)(nil), // 1: neo.fs.v2.container.Container.Attribute (*refs.Version)(nil), // 2: neo.fs.v2.refs.Version @@ -289,7 +305,7 @@ func file_proto_container_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_container_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*Container); i { case 0: return &v.state @@ -301,7 +317,7 @@ func file_proto_container_types_proto_init() { return nil } } - file_proto_container_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_container_types_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*Container_Attribute); i { case 0: return &v.state diff --git a/proto/link/types.pb.go b/proto/link/types.pb.go index 5b99a5d3..df2aa4b8 100644 --- a/proto/link/types.pb.go +++ b/proto/link/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/link/types.proto @@ -173,7 +173,7 @@ func file_proto_link_types_proto_rawDescGZIP() []byte { } var file_proto_link_types_proto_msgTypes = make([]protoimpl.MessageInfo, 2) -var file_proto_link_types_proto_goTypes = []interface{}{ +var file_proto_link_types_proto_goTypes = []any{ (*Link)(nil), // 0: neo.fs.v2.link.Link (*Link_MeasuredObject)(nil), // 1: neo.fs.v2.link.Link.MeasuredObject (*refs.ObjectID)(nil), // 2: neo.fs.v2.refs.ObjectID @@ -194,7 +194,7 @@ func file_proto_link_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_link_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_link_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*Link); i { case 0: return &v.state @@ -206,7 +206,7 @@ func file_proto_link_types_proto_init() { return nil } } - file_proto_link_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_link_types_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*Link_MeasuredObject); i { case 0: return &v.state diff --git a/proto/lock/types.pb.go b/proto/lock/types.pb.go index 3fd48397..fcdd5ac6 100644 --- a/proto/lock/types.pb.go +++ b/proto/lock/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/lock/types.proto @@ -108,7 +108,7 @@ func file_proto_lock_types_proto_rawDescGZIP() []byte { } var file_proto_lock_types_proto_msgTypes = make([]protoimpl.MessageInfo, 1) -var file_proto_lock_types_proto_goTypes = []interface{}{ +var file_proto_lock_types_proto_goTypes = []any{ (*Lock)(nil), // 0: neo.fs.v2.lock.Lock (*refs.ObjectID)(nil), // 1: neo.fs.v2.refs.ObjectID } @@ -127,7 +127,7 @@ func file_proto_lock_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_lock_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_lock_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*Lock); i { case 0: return &v.state diff --git a/proto/netmap/service.pb.go b/proto/netmap/service.pb.go index b230d6fe..90cb1093 100644 --- a/proto/netmap/service.pb.go +++ b/proto/netmap/service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/netmap/service.proto @@ -233,7 +233,7 @@ func (x *NetworkInfoRequest) GetVerifyHeader() *session.RequestVerificationHeade } // Response with NetworkInfo structure including current epoch and -// sidechain magic number. +// FS chain magic number. type NetworkInfoResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -876,7 +876,7 @@ func file_proto_netmap_service_proto_rawDescGZIP() []byte { } var file_proto_netmap_service_proto_msgTypes = make([]protoimpl.MessageInfo, 12) -var file_proto_netmap_service_proto_goTypes = []interface{}{ +var file_proto_netmap_service_proto_goTypes = []any{ (*LocalNodeInfoRequest)(nil), // 0: neo.fs.v2.netmap.LocalNodeInfoRequest (*LocalNodeInfoResponse)(nil), // 1: neo.fs.v2.netmap.LocalNodeInfoResponse (*NetworkInfoRequest)(nil), // 2: neo.fs.v2.netmap.NetworkInfoRequest @@ -941,7 +941,7 @@ func file_proto_netmap_service_proto_init() { } file_proto_netmap_types_proto_init() if !protoimpl.UnsafeEnabled { - file_proto_netmap_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*LocalNodeInfoRequest); i { case 0: return &v.state @@ -953,7 +953,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*LocalNodeInfoResponse); i { case 0: return &v.state @@ -965,7 +965,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*NetworkInfoRequest); i { case 0: return &v.state @@ -977,7 +977,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*NetworkInfoResponse); i { case 0: return &v.state @@ -989,7 +989,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*NetmapSnapshotRequest); i { case 0: return &v.state @@ -1001,7 +1001,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[5].Exporter = func(v any, i int) any { switch v := v.(*NetmapSnapshotResponse); i { case 0: return &v.state @@ -1013,7 +1013,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[6].Exporter = func(v any, i int) any { switch v := v.(*LocalNodeInfoRequest_Body); i { case 0: return &v.state @@ -1025,7 +1025,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[7].Exporter = func(v any, i int) any { switch v := v.(*LocalNodeInfoResponse_Body); i { case 0: return &v.state @@ -1037,7 +1037,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[8].Exporter = func(v any, i int) any { switch v := v.(*NetworkInfoRequest_Body); i { case 0: return &v.state @@ -1049,7 +1049,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[9].Exporter = func(v any, i int) any { switch v := v.(*NetworkInfoResponse_Body); i { case 0: return &v.state @@ -1061,7 +1061,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[10].Exporter = func(v any, i int) any { switch v := v.(*NetmapSnapshotRequest_Body); i { case 0: return &v.state @@ -1073,7 +1073,7 @@ func file_proto_netmap_service_proto_init() { return nil } } - file_proto_netmap_service_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_service_proto_msgTypes[11].Exporter = func(v any, i int) any { switch v := v.(*NetmapSnapshotResponse_Body); i { case 0: return &v.state diff --git a/proto/netmap/types.pb.go b/proto/netmap/types.pb.go index 5d681c58..634b8aeb 100644 --- a/proto/netmap/types.pb.go +++ b/proto/netmap/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/netmap/types.proto @@ -733,9 +733,9 @@ type NetworkInfo struct { // Number of the current epoch in the NeoFS network CurrentEpoch uint64 `protobuf:"varint,1,opt,name=current_epoch,json=currentEpoch,proto3" json:"current_epoch,omitempty"` - // Magic number of the sidechain of the NeoFS network + // Magic number of FS chain of the NeoFS network MagicNumber uint64 `protobuf:"varint,2,opt,name=magic_number,json=magicNumber,proto3" json:"magic_number,omitempty"` - // MillisecondsPerBlock network parameter of the sidechain of the NeoFS network + // MillisecondsPerBlock network parameter of FS chain of the NeoFS network MsPerBlock int64 `protobuf:"varint,3,opt,name=ms_per_block,json=msPerBlock,proto3" json:"ms_per_block,omitempty"` // NeoFS network configuration NetworkConfig *NetworkConfig `protobuf:"bytes,4,opt,name=network_config,json=networkConfig,proto3" json:"network_config,omitempty"` @@ -976,7 +976,7 @@ func (x *NodeInfo_Attribute) GetParents() []string { // Number of EigenTrust algorithm iterations to pass in the Reputation system. // Value: little-endian integer. Default: 0. // - **EpochDuration** \ -// NeoFS epoch duration measured in Sidechain blocks. +// NeoFS epoch duration measured in FS chain blocks. // Value: little-endian integer. Default: 0. // - **HomomorphicHashingDisabled** \ // Flag of disabling the homomorphic hashing of objects' payload. @@ -1181,7 +1181,7 @@ func file_proto_netmap_types_proto_rawDescGZIP() []byte { var file_proto_netmap_types_proto_enumTypes = make([]protoimpl.EnumInfo, 3) var file_proto_netmap_types_proto_msgTypes = make([]protoimpl.MessageInfo, 10) -var file_proto_netmap_types_proto_goTypes = []interface{}{ +var file_proto_netmap_types_proto_goTypes = []any{ (Operation)(0), // 0: neo.fs.v2.netmap.Operation (Clause)(0), // 1: neo.fs.v2.netmap.Clause (NodeInfo_State)(0), // 2: neo.fs.v2.netmap.NodeInfo.State @@ -1223,7 +1223,7 @@ func file_proto_netmap_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_netmap_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*Filter); i { case 0: return &v.state @@ -1235,7 +1235,7 @@ func file_proto_netmap_types_proto_init() { return nil } } - file_proto_netmap_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*Selector); i { case 0: return &v.state @@ -1247,7 +1247,7 @@ func file_proto_netmap_types_proto_init() { return nil } } - file_proto_netmap_types_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*Replica); i { case 0: return &v.state @@ -1259,7 +1259,7 @@ func file_proto_netmap_types_proto_init() { return nil } } - file_proto_netmap_types_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*PlacementPolicy); i { case 0: return &v.state @@ -1271,7 +1271,7 @@ func file_proto_netmap_types_proto_init() { return nil } } - file_proto_netmap_types_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*NodeInfo); i { case 0: return &v.state @@ -1283,7 +1283,7 @@ func file_proto_netmap_types_proto_init() { return nil } } - file_proto_netmap_types_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[5].Exporter = func(v any, i int) any { switch v := v.(*Netmap); i { case 0: return &v.state @@ -1295,7 +1295,7 @@ func file_proto_netmap_types_proto_init() { return nil } } - file_proto_netmap_types_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[6].Exporter = func(v any, i int) any { switch v := v.(*NetworkConfig); i { case 0: return &v.state @@ -1307,7 +1307,7 @@ func file_proto_netmap_types_proto_init() { return nil } } - file_proto_netmap_types_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[7].Exporter = func(v any, i int) any { switch v := v.(*NetworkInfo); i { case 0: return &v.state @@ -1319,7 +1319,7 @@ func file_proto_netmap_types_proto_init() { return nil } } - file_proto_netmap_types_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[8].Exporter = func(v any, i int) any { switch v := v.(*NodeInfo_Attribute); i { case 0: return &v.state @@ -1331,7 +1331,7 @@ func file_proto_netmap_types_proto_init() { return nil } } - file_proto_netmap_types_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + file_proto_netmap_types_proto_msgTypes[9].Exporter = func(v any, i int) any { switch v := v.(*NetworkConfig_Parameter); i { case 0: return &v.state diff --git a/proto/object/encoding.go b/proto/object/encoding.go index ca6bc718..9cf8470b 100644 --- a/proto/object/encoding.go +++ b/proto/object/encoding.go @@ -793,9 +793,9 @@ const ( fieldSearchFilterValue ) -// MarshaledSize returns size of the SearchRequest_Body_Filter in Protocol +// MarshaledSize returns size of the SearchFilter in Protocol // Buffers V3 format in bytes. MarshaledSize is NPE-safe. -func (x *SearchRequest_Body_Filter) MarshaledSize() int { +func (x *SearchFilter) MarshaledSize() int { var sz int if x != nil { sz = proto.SizeVarint(fieldSearchFilterMatcher, int32(x.MatchType)) @@ -805,11 +805,11 @@ func (x *SearchRequest_Body_Filter) MarshaledSize() int { return sz } -// MarshalStable writes the SearchRequest_Body_Filter in Protocol Buffers V3 +// MarshalStable writes the SearchFilter in Protocol Buffers V3 // format with ascending order of fields by number into b. MarshalStable uses -// exactly [SearchRequest_Body_Filter.MarshaledSize] first bytes of b. +// exactly [SearchFilter.MarshaledSize] first bytes of b. // MarshalStable is NPE-safe. -func (x *SearchRequest_Body_Filter) MarshalStable(b []byte) { +func (x *SearchFilter) MarshalStable(b []byte) { if x != nil { off := proto.MarshalToVarint(b, fieldSearchFilterMatcher, int32(x.MatchType)) off += proto.MarshalToBytes(b[off:], fieldSearchFilterKey, x.Key) @@ -870,3 +870,96 @@ func (x *SearchResponse_Body) MarshalStable(b []byte) { proto.MarshalToRepeatedMessages(b, fieldSearchRespIDList, x.IdList) } } + +const ( + _ = iota + fieldSearchV2ReqContainer + fieldSearchV2ReqVersion + fieldSearchV2ReqFilters + fieldSearchV2ReqCursor + fieldSearchV2ReqCount + fieldSearchV2ReqAttrs +) + +// MarshaledSize returns size of x in Protocol Buffers V3 format in bytes. +// MarshaledSize is NPE-safe. +func (x *SearchV2Request_Body) MarshaledSize() int { + if x != nil { + return proto.SizeEmbedded(fieldSearchV2ReqContainer, x.ContainerId) + + proto.SizeVarint(fieldSearchV2ReqVersion, x.Version) + + proto.SizeRepeatedMessages(fieldSearchV2ReqFilters, x.Filters) + + proto.SizeBytes(fieldSearchV2ReqCursor, x.Cursor) + + proto.SizeVarint(fieldSearchV2ReqCount, x.Count) + + proto.SizeRepeatedBytes(fieldSearchV2ReqAttrs, x.Attributes) + } + return 0 +} + +// MarshalStable writes x in Protocol Buffers V3 format with ascending order of +// fields by number into b. MarshalStable uses exactly +// [SearchV2Request_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *SearchV2Request_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldSearchV2ReqContainer, x.ContainerId) + off += proto.MarshalToVarint(b[off:], fieldSearchV2ReqVersion, x.Version) + off += proto.MarshalToRepeatedMessages(b[off:], fieldSearchV2ReqFilters, x.Filters) + off += proto.MarshalToBytes(b[off:], fieldSearchV2ReqCursor, x.Cursor) + off += proto.MarshalToVarint(b[off:], fieldSearchV2ReqCount, x.Count) + proto.MarshalToRepeatedBytes(b[off:], fieldSearchV2ReqAttrs, x.Attributes) + } +} + +const ( + _ = iota + fieldSearchV2RespItemID + fieldSearchV2RespItemAttrs +) + +// MarshaledSize returns size of x in Protocol Buffers V3 format in bytes. +// MarshaledSize is NPE-safe. +func (x *SearchV2Response_OIDWithMeta) MarshaledSize() int { + if x != nil { + return proto.SizeEmbedded(fieldSearchV2RespItemID, x.Id) + + proto.SizeRepeatedBytes(fieldSearchV2RespItemAttrs, x.Attributes) + } + return 0 +} + +// MarshalStable writes x in Protocol Buffers V3 format with ascending order of +// fields by number into b. MarshalStable uses exactly +// [SearchV2Response_OIDWithMeta.MarshaledSize] first bytes of b. MarshalStable +// is NPE-safe. +func (x *SearchV2Response_OIDWithMeta) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldSearchV2RespItemID, x.Id) + proto.MarshalToRepeatedBytes(b[off:], fieldSearchV2RespItemAttrs, x.Attributes) + } +} + +const ( + _ = iota + fieldSearchV2RespItems + fieldSearchV2RespCursor +) + +// MarshaledSize returns size of x in Protocol Buffers V3 format in bytes. +// MarshaledSize is NPE-safe. +func (x *SearchV2Response_Body) MarshaledSize() int { + if x != nil { + return proto.SizeRepeatedMessages(fieldSearchV2RespItems, x.Result) + + proto.SizeBytes(fieldSearchV2RespCursor, x.Cursor) + } + return 0 +} + +// MarshalStable writes x in Protocol Buffers V3 format with ascending order of +// fields by number into b. MarshalStable uses exactly +// [SearchV2Response_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *SearchV2Response_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToRepeatedMessages(b, fieldSearchV2RespItems, x.Result) + proto.MarshalToBytes(b[off:], fieldSearchV2RespCursor, x.Cursor) + } +} diff --git a/proto/object/encoding_test.go b/proto/object/encoding_test.go index 2e6eb8c0..07b88ff0 100644 --- a/proto/object/encoding_test.go +++ b/proto/object/encoding_test.go @@ -117,18 +117,18 @@ func randPutRequestInit() *object.PutRequest_Body_Init { } } -// returns random object.SearchRequest_Body_Filter with all non-zero fields. -func randSearchFilter() *object.SearchRequest_Body_Filter { - return &object.SearchRequest_Body_Filter{ +// returns random object.SearchFilter with all non-zero fields. +func randSearchFilter() *object.SearchFilter { + return &object.SearchFilter{ MatchType: prototest.RandInteger[object.MatchType](), Key: prototest.RandString(), Value: prototest.RandString(), } } -// returns non-empty list of object.SearchRequest_Body_Filter up to 10 elements. +// returns non-empty list of object.SearchFilter up to 10 elements. // Each element may be nil and pointer to zero. -func randSearchFilters() []*object.SearchRequest_Body_Filter { +func randSearchFilters() []*object.SearchFilter { return prototest.RandRepeated(randSearchFilter) } @@ -358,10 +358,10 @@ func TestDeleteResponse_Body_MarshalStable(t *testing.T) { }) } -func TestSearchRequest_Body_Filter_MarshalStable(t *testing.T) { +func TestSearchFilter_MarshalStable(t *testing.T) { t.Run("nil in repeated messages", func(t *testing.T) { src := &object.SearchRequest_Body{ - Filters: []*object.SearchRequest_Body_Filter{nil, {}}, + Filters: []*object.SearchFilter{nil, {}}, } var dst object.SearchRequest_Body @@ -369,11 +369,11 @@ func TestSearchRequest_Body_Filter_MarshalStable(t *testing.T) { fs := dst.GetFilters() require.Len(t, fs, 2) - require.Equal(t, fs[0], new(object.SearchRequest_Body_Filter)) - require.Equal(t, fs[1], new(object.SearchRequest_Body_Filter)) + require.Equal(t, fs[0], new(object.SearchFilter)) + require.Equal(t, fs[1], new(object.SearchFilter)) }) - prototest.TestMarshalStable(t, []*object.SearchRequest_Body_Filter{ + prototest.TestMarshalStable(t, []*object.SearchFilter{ randSearchFilter(), }) } @@ -407,3 +407,48 @@ func TestSearchResponse_Body_MarshalStable(t *testing.T) { {IdList: prototest.RandObjectIDs()}, }) } + +func TestSearchV2Request_Body_MarshalStable(t *testing.T) { + prototest.TestMarshalStable(t, []*object.SearchV2Request_Body{ + { + ContainerId: prototest.RandContainerID(), + Version: prototest.RandUint32(), + Filters: randSearchFilters(), + Cursor: prototest.RandString(), + Count: prototest.RandUint32(), + Attributes: prototest.RandStrings(), + }, + }) +} + +func TestSearchV2Response_Body_MarshalStable(t *testing.T) { + t.Run("nil in repeated messages", func(t *testing.T) { + src := &object.SearchV2Response_Body{ + Result: []*object.SearchV2Response_OIDWithMeta{nil, {}}, + } + + var dst object.SearchV2Response_Body + require.NoError(t, neofsproto.UnmarshalMessage(neofsproto.MarshalMessage(src), &dst)) + + ids := dst.GetResult() + require.Len(t, ids, 2) + require.Equal(t, ids[0], new(object.SearchV2Response_OIDWithMeta)) + require.Equal(t, ids[1], new(object.SearchV2Response_OIDWithMeta)) + }) + + prototest.TestMarshalStable(t, []*object.SearchV2Response_Body{ + { + Result: []*object.SearchV2Response_OIDWithMeta{ + { + Id: prototest.RandObjectID(), + Attributes: prototest.RandStrings(), + }, + { + Id: prototest.RandObjectID(), + Attributes: prototest.RandStrings(), + }, + }, + Cursor: prototest.RandString(), + }, + }) +} diff --git a/proto/object/service.pb.go b/proto/object/service.pb.go index cfc0f4a7..7e35b874 100644 --- a/proto/object/service.pb.go +++ b/proto/object/service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/object/service.proto @@ -788,6 +788,146 @@ func (x *SearchResponse) GetVerifyHeader() *session.ResponseVerificationHeader { return nil } +// Object SearchV2 request +type SearchV2Request struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Body of search object request message. + Body *SearchV2Request_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` + // Carries request meta information. Header data is used only to regulate + // message transport and does not affect request execution. + MetaHeader *session.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"` + // Carries request verification information. This header is used to + // authenticate the nodes of the message route and check the correctness of + // transmission. + VerifyHeader *session.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"` +} + +func (x *SearchV2Request) Reset() { + *x = SearchV2Request{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_object_service_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SearchV2Request) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchV2Request) ProtoMessage() {} + +func (x *SearchV2Request) ProtoReflect() protoreflect.Message { + mi := &file_proto_object_service_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchV2Request.ProtoReflect.Descriptor instead. +func (*SearchV2Request) Descriptor() ([]byte, []int) { + return file_proto_object_service_proto_rawDescGZIP(), []int{11} +} + +func (x *SearchV2Request) GetBody() *SearchV2Request_Body { + if x != nil { + return x.Body + } + return nil +} + +func (x *SearchV2Request) GetMetaHeader() *session.RequestMetaHeader { + if x != nil { + return x.MetaHeader + } + return nil +} + +func (x *SearchV2Request) GetVerifyHeader() *session.RequestVerificationHeader { + if x != nil { + return x.VerifyHeader + } + return nil +} + +// SearchV2 response +type SearchV2Response struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Body of search object response message. + Body *SearchV2Response_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` + // Carries response meta information. Header data is used only to regulate + // message transport and does not affect request execution. + MetaHeader *session.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"` + // Carries response verification information. This header is used to + // authenticate the nodes of the message route and check the correctness of + // transmission. + VerifyHeader *session.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"` +} + +func (x *SearchV2Response) Reset() { + *x = SearchV2Response{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_object_service_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SearchV2Response) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchV2Response) ProtoMessage() {} + +func (x *SearchV2Response) ProtoReflect() protoreflect.Message { + mi := &file_proto_object_service_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchV2Response.ProtoReflect.Descriptor instead. +func (*SearchV2Response) Descriptor() ([]byte, []int) { + return file_proto_object_service_proto_rawDescGZIP(), []int{12} +} + +func (x *SearchV2Response) GetBody() *SearchV2Response_Body { + if x != nil { + return x.Body + } + return nil +} + +func (x *SearchV2Response) GetMetaHeader() *session.ResponseMetaHeader { + if x != nil { + return x.MetaHeader + } + return nil +} + +func (x *SearchV2Response) GetVerifyHeader() *session.ResponseVerificationHeader { + if x != nil { + return x.VerifyHeader + } + return nil +} + // Object payload range. Ranges of zero length SHOULD be considered as invalid. type Range struct { state protoimpl.MessageState @@ -803,7 +943,7 @@ type Range struct { func (x *Range) Reset() { *x = Range{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[11] + mi := &file_proto_object_service_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -816,7 +956,7 @@ func (x *Range) String() string { func (*Range) ProtoMessage() {} func (x *Range) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[11] + mi := &file_proto_object_service_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -829,7 +969,7 @@ func (x *Range) ProtoReflect() protoreflect.Message { // Deprecated: Use Range.ProtoReflect.Descriptor instead. func (*Range) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{11} + return file_proto_object_service_proto_rawDescGZIP(), []int{13} } func (x *Range) GetOffset() uint64 { @@ -866,7 +1006,7 @@ type GetRangeRequest struct { func (x *GetRangeRequest) Reset() { *x = GetRangeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[12] + mi := &file_proto_object_service_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -879,7 +1019,7 @@ func (x *GetRangeRequest) String() string { func (*GetRangeRequest) ProtoMessage() {} func (x *GetRangeRequest) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[12] + mi := &file_proto_object_service_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -892,7 +1032,7 @@ func (x *GetRangeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRangeRequest.ProtoReflect.Descriptor instead. func (*GetRangeRequest) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{12} + return file_proto_object_service_proto_rawDescGZIP(), []int{14} } func (x *GetRangeRequest) GetBody() *GetRangeRequest_Body { @@ -936,7 +1076,7 @@ type GetRangeResponse struct { func (x *GetRangeResponse) Reset() { *x = GetRangeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[13] + mi := &file_proto_object_service_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -949,7 +1089,7 @@ func (x *GetRangeResponse) String() string { func (*GetRangeResponse) ProtoMessage() {} func (x *GetRangeResponse) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[13] + mi := &file_proto_object_service_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -962,7 +1102,7 @@ func (x *GetRangeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRangeResponse.ProtoReflect.Descriptor instead. func (*GetRangeResponse) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{13} + return file_proto_object_service_proto_rawDescGZIP(), []int{15} } func (x *GetRangeResponse) GetBody() *GetRangeResponse_Body { @@ -1006,7 +1146,7 @@ type GetRangeHashRequest struct { func (x *GetRangeHashRequest) Reset() { *x = GetRangeHashRequest{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[14] + mi := &file_proto_object_service_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1019,7 +1159,7 @@ func (x *GetRangeHashRequest) String() string { func (*GetRangeHashRequest) ProtoMessage() {} func (x *GetRangeHashRequest) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[14] + mi := &file_proto_object_service_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1032,7 +1172,7 @@ func (x *GetRangeHashRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRangeHashRequest.ProtoReflect.Descriptor instead. func (*GetRangeHashRequest) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{14} + return file_proto_object_service_proto_rawDescGZIP(), []int{16} } func (x *GetRangeHashRequest) GetBody() *GetRangeHashRequest_Body { @@ -1076,7 +1216,7 @@ type GetRangeHashResponse struct { func (x *GetRangeHashResponse) Reset() { *x = GetRangeHashResponse{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[15] + mi := &file_proto_object_service_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1089,7 +1229,7 @@ func (x *GetRangeHashResponse) String() string { func (*GetRangeHashResponse) ProtoMessage() {} func (x *GetRangeHashResponse) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[15] + mi := &file_proto_object_service_proto_msgTypes[17] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1102,7 +1242,7 @@ func (x *GetRangeHashResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRangeHashResponse.ProtoReflect.Descriptor instead. func (*GetRangeHashResponse) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{15} + return file_proto_object_service_proto_rawDescGZIP(), []int{17} } func (x *GetRangeHashResponse) GetBody() *GetRangeHashResponse_Body { @@ -1146,7 +1286,7 @@ type ReplicateRequest struct { func (x *ReplicateRequest) Reset() { *x = ReplicateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[16] + mi := &file_proto_object_service_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1159,7 +1299,7 @@ func (x *ReplicateRequest) String() string { func (*ReplicateRequest) ProtoMessage() {} func (x *ReplicateRequest) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[16] + mi := &file_proto_object_service_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1172,7 +1312,7 @@ func (x *ReplicateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReplicateRequest.ProtoReflect.Descriptor instead. func (*ReplicateRequest) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{16} + return file_proto_object_service_proto_rawDescGZIP(), []int{18} } func (x *ReplicateRequest) GetObject() *Object { @@ -1213,7 +1353,7 @@ type ReplicateResponse struct { func (x *ReplicateResponse) Reset() { *x = ReplicateResponse{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[17] + mi := &file_proto_object_service_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1226,7 +1366,7 @@ func (x *ReplicateResponse) String() string { func (*ReplicateResponse) ProtoMessage() {} func (x *ReplicateResponse) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[17] + mi := &file_proto_object_service_proto_msgTypes[19] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1239,7 +1379,7 @@ func (x *ReplicateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReplicateResponse.ProtoReflect.Descriptor instead. func (*ReplicateResponse) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{17} + return file_proto_object_service_proto_rawDescGZIP(), []int{19} } func (x *ReplicateResponse) GetStatus() *status.Status { @@ -1272,7 +1412,7 @@ type GetRequest_Body struct { func (x *GetRequest_Body) Reset() { *x = GetRequest_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[18] + mi := &file_proto_object_service_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1285,7 +1425,7 @@ func (x *GetRequest_Body) String() string { func (*GetRequest_Body) ProtoMessage() {} func (x *GetRequest_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[18] + mi := &file_proto_object_service_proto_msgTypes[20] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1334,7 +1474,7 @@ type GetResponse_Body struct { func (x *GetResponse_Body) Reset() { *x = GetResponse_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[19] + mi := &file_proto_object_service_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1347,7 +1487,7 @@ func (x *GetResponse_Body) String() string { func (*GetResponse_Body) ProtoMessage() {} func (x *GetResponse_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[19] + mi := &file_proto_object_service_proto_msgTypes[21] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1434,7 +1574,7 @@ type GetResponse_Body_Init struct { func (x *GetResponse_Body_Init) Reset() { *x = GetResponse_Body_Init{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[20] + mi := &file_proto_object_service_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1447,7 +1587,7 @@ func (x *GetResponse_Body_Init) String() string { func (*GetResponse_Body_Init) ProtoMessage() {} func (x *GetResponse_Body_Init) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[20] + mi := &file_proto_object_service_proto_msgTypes[22] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1502,7 +1642,7 @@ type PutRequest_Body struct { func (x *PutRequest_Body) Reset() { *x = PutRequest_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[21] + mi := &file_proto_object_service_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1515,7 +1655,7 @@ func (x *PutRequest_Body) String() string { func (*PutRequest_Body) ProtoMessage() {} func (x *PutRequest_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[21] + mi := &file_proto_object_service_proto_msgTypes[23] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1593,7 +1733,7 @@ type PutRequest_Body_Init struct { func (x *PutRequest_Body_Init) Reset() { *x = PutRequest_Body_Init{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[22] + mi := &file_proto_object_service_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1606,7 +1746,7 @@ func (x *PutRequest_Body_Init) String() string { func (*PutRequest_Body_Init) ProtoMessage() {} func (x *PutRequest_Body_Init) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[22] + mi := &file_proto_object_service_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1663,7 +1803,7 @@ type PutResponse_Body struct { func (x *PutResponse_Body) Reset() { *x = PutResponse_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[23] + mi := &file_proto_object_service_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1676,7 +1816,7 @@ func (x *PutResponse_Body) String() string { func (*PutResponse_Body) ProtoMessage() {} func (x *PutResponse_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[23] + mi := &file_proto_object_service_proto_msgTypes[25] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1712,7 +1852,7 @@ type DeleteRequest_Body struct { func (x *DeleteRequest_Body) Reset() { *x = DeleteRequest_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[24] + mi := &file_proto_object_service_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1725,7 +1865,7 @@ func (x *DeleteRequest_Body) String() string { func (*DeleteRequest_Body) ProtoMessage() {} func (x *DeleteRequest_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[24] + mi := &file_proto_object_service_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1761,7 +1901,7 @@ type DeleteResponse_Body struct { func (x *DeleteResponse_Body) Reset() { *x = DeleteResponse_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[25] + mi := &file_proto_object_service_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1774,7 +1914,7 @@ func (x *DeleteResponse_Body) String() string { func (*DeleteResponse_Body) ProtoMessage() {} func (x *DeleteResponse_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[25] + mi := &file_proto_object_service_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1815,7 +1955,7 @@ type HeadRequest_Body struct { func (x *HeadRequest_Body) Reset() { *x = HeadRequest_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[26] + mi := &file_proto_object_service_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1828,7 +1968,7 @@ func (x *HeadRequest_Body) String() string { func (*HeadRequest_Body) ProtoMessage() {} func (x *HeadRequest_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[26] + mi := &file_proto_object_service_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1885,7 +2025,7 @@ type HeadResponse_Body struct { func (x *HeadResponse_Body) Reset() { *x = HeadResponse_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[27] + mi := &file_proto_object_service_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1898,7 +2038,7 @@ func (x *HeadResponse_Body) String() string { func (*HeadResponse_Body) ProtoMessage() {} func (x *HeadResponse_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[27] + mi := &file_proto_object_service_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1978,13 +2118,13 @@ type SearchRequest_Body struct { // Version of the Query Language used Version uint32 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` // List of search expressions - Filters []*SearchRequest_Body_Filter `protobuf:"bytes,3,rep,name=filters,proto3" json:"filters,omitempty"` + Filters []*SearchFilter `protobuf:"bytes,3,rep,name=filters,proto3" json:"filters,omitempty"` } func (x *SearchRequest_Body) Reset() { *x = SearchRequest_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[28] + mi := &file_proto_object_service_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1997,7 +2137,7 @@ func (x *SearchRequest_Body) String() string { func (*SearchRequest_Body) ProtoMessage() {} func (x *SearchRequest_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[28] + mi := &file_proto_object_service_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2027,102 +2167,105 @@ func (x *SearchRequest_Body) GetVersion() uint32 { return 0 } -func (x *SearchRequest_Body) GetFilters() []*SearchRequest_Body_Filter { +func (x *SearchRequest_Body) GetFilters() []*SearchFilter { if x != nil { return x.Filters } return nil } -// Filter structure checks if the object header field or the attribute content -// matches a value. -// -// If no filters are set, search request will return all objects of the -// container, including Regular object, Tombstones and Storage Group -// objects. Most human users expect to get only object they can directly -// work with. In that case, `$Object:ROOT` filter should be used. -// -// If `match_type` field is numerical, both `value` field and object -// attribute MUST be base-10 integers. -// -// By default `key` field refers to the corresponding object's `Attribute`. -// Some Object's header fields can also be accessed by adding `$Object:` -// prefix to the name. Here is the list of fields available via this prefix: -// -// - $Object:version \ -// version -// - $Object:objectID \ -// object_id -// - $Object:containerID \ -// container_id -// - $Object:ownerID \ -// owner_id -// - $Object:creationEpoch \ -// creation_epoch -// - $Object:payloadLength \ -// payload_length -// - $Object:payloadHash \ -// payload_hash -// - $Object:objectType \ -// object_type -// - $Object:homomorphicHash \ -// homomorphic_hash -// - $Object:split.parent \ -// object_id of parent -// - $Object:split.splitID \ -// 16 byte UUIDv4 used to identify the split object hierarchy parts -// - $Object:split.first \ -// object_id of the first part in split chain; non-acceptable for deprecated V1 split scheme -// -// There are some well-known filter aliases to match objects by certain -// properties: -// -// - $Object:ROOT \ -// Returns only `REGULAR` type objects that are not split or that are the top -// level root objects in a split hierarchy. This includes objects not -// present physically, like large objects split into smaller objects -// without a separate top-level root object. Objects of other types like -// StorageGroups and Tombstones will not be shown. This filter may be -// useful for listing objects like `ls` command of some virtual file -// system. This filter is activated if the `key` exists, disregarding the -// value and matcher type. -// - $Object:PHY \ -// Returns only objects physically stored in the system. This filter is -// activated if the `key` exists, disregarding the value and matcher type. -// -// Note: using filters with a key with prefix `$Object:` and match type -// `NOT_PRESENT `is not recommended since this is not a cross-version approach. -// Behavior when processing this kind of filters is undefined. -type SearchRequest_Body_Filter struct { +// Object Search response body +type SearchResponse_Body struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Match type to use - MatchType MatchType `protobuf:"varint,1,opt,name=match_type,json=matchType,proto3,enum=neo.fs.v2.object.MatchType" json:"match_type,omitempty"` - // Attribute or Header fields to match - Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` - // Value to match - Value string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + // List of `ObjectID`s that match the search query + IdList []*refs.ObjectID `protobuf:"bytes,1,rep,name=id_list,json=idList,proto3" json:"id_list,omitempty"` } -func (x *SearchRequest_Body_Filter) Reset() { - *x = SearchRequest_Body_Filter{} +func (x *SearchResponse_Body) Reset() { + *x = SearchResponse_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[29] + mi := &file_proto_object_service_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *SearchRequest_Body_Filter) String() string { +func (x *SearchResponse_Body) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SearchRequest_Body_Filter) ProtoMessage() {} +func (*SearchResponse_Body) ProtoMessage() {} -func (x *SearchRequest_Body_Filter) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[29] +func (x *SearchResponse_Body) ProtoReflect() protoreflect.Message { + mi := &file_proto_object_service_proto_msgTypes[31] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchResponse_Body.ProtoReflect.Descriptor instead. +func (*SearchResponse_Body) Descriptor() ([]byte, []int) { + return file_proto_object_service_proto_rawDescGZIP(), []int{10, 0} +} + +func (x *SearchResponse_Body) GetIdList() []*refs.ObjectID { + if x != nil { + return x.IdList + } + return nil +} + +// Object Search request body +type SearchV2Request_Body struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Container where the search is being performed. + ContainerId *refs.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` + // Version of the Query Language used. + Version uint32 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` + // List of search expressions. Limited to 8. If additional attributes are + // requested (see attributes below) then the search expression MUST use + // the first requested attribute. + Filters []*SearchFilter `protobuf:"bytes,3,rep,name=filters,proto3" json:"filters,omitempty"` + // Cursor to continue search. Can be omitted or empty for the new search. + Cursor string `protobuf:"bytes,4,opt,name=cursor,proto3" json:"cursor,omitempty"` + // Limits the number of responses to the specified number. Can't be more + // than 1000. + Count uint32 `protobuf:"varint,5,opt,name=count,proto3" json:"count,omitempty"` + // List of attribute names (including special ones as defined by + // SearchFilter key) to include into the reply. Limited to 4, these + // attributes also affect result ordering (result is ordered by attributes + // and then by OID). + Attributes []string `protobuf:"bytes,6,rep,name=attributes,proto3" json:"attributes,omitempty"` +} + +func (x *SearchV2Request_Body) Reset() { + *x = SearchV2Request_Body{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_object_service_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SearchV2Request_Body) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchV2Request_Body) ProtoMessage() {} + +func (x *SearchV2Request_Body) ProtoReflect() protoreflect.Message { + mi := &file_proto_object_service_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2133,59 +2276,83 @@ func (x *SearchRequest_Body_Filter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SearchRequest_Body_Filter.ProtoReflect.Descriptor instead. -func (*SearchRequest_Body_Filter) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{9, 0, 0} +// Deprecated: Use SearchV2Request_Body.ProtoReflect.Descriptor instead. +func (*SearchV2Request_Body) Descriptor() ([]byte, []int) { + return file_proto_object_service_proto_rawDescGZIP(), []int{11, 0} } -func (x *SearchRequest_Body_Filter) GetMatchType() MatchType { +func (x *SearchV2Request_Body) GetContainerId() *refs.ContainerID { if x != nil { - return x.MatchType + return x.ContainerId } - return MatchType_MATCH_TYPE_UNSPECIFIED + return nil } -func (x *SearchRequest_Body_Filter) GetKey() string { +func (x *SearchV2Request_Body) GetVersion() uint32 { if x != nil { - return x.Key + return x.Version } - return "" + return 0 +} + +func (x *SearchV2Request_Body) GetFilters() []*SearchFilter { + if x != nil { + return x.Filters + } + return nil } -func (x *SearchRequest_Body_Filter) GetValue() string { +func (x *SearchV2Request_Body) GetCursor() string { if x != nil { - return x.Value + return x.Cursor } return "" } -// Object Search response body -type SearchResponse_Body struct { +func (x *SearchV2Request_Body) GetCount() uint32 { + if x != nil { + return x.Count + } + return 0 +} + +func (x *SearchV2Request_Body) GetAttributes() []string { + if x != nil { + return x.Attributes + } + return nil +} + +// OID with additional requested metadata. +type SearchV2Response_OIDWithMeta struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // List of `ObjectID`s that match the search query - IdList []*refs.ObjectID `protobuf:"bytes,1,rep,name=id_list,json=idList,proto3" json:"id_list,omitempty"` + // Object ID that matches search criteria. + Id *refs.ObjectID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // List of attribute data from the respective object, fields + // strictly follow requested ones. + Attributes []string `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"` } -func (x *SearchResponse_Body) Reset() { - *x = SearchResponse_Body{} +func (x *SearchV2Response_OIDWithMeta) Reset() { + *x = SearchV2Response_OIDWithMeta{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[30] + mi := &file_proto_object_service_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *SearchResponse_Body) String() string { +func (x *SearchV2Response_OIDWithMeta) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SearchResponse_Body) ProtoMessage() {} +func (*SearchV2Response_OIDWithMeta) ProtoMessage() {} -func (x *SearchResponse_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[30] +func (x *SearchV2Response_OIDWithMeta) ProtoReflect() protoreflect.Message { + mi := &file_proto_object_service_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2196,18 +2363,87 @@ func (x *SearchResponse_Body) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SearchResponse_Body.ProtoReflect.Descriptor instead. -func (*SearchResponse_Body) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{10, 0} +// Deprecated: Use SearchV2Response_OIDWithMeta.ProtoReflect.Descriptor instead. +func (*SearchV2Response_OIDWithMeta) Descriptor() ([]byte, []int) { + return file_proto_object_service_proto_rawDescGZIP(), []int{12, 0} } -func (x *SearchResponse_Body) GetIdList() []*refs.ObjectID { +func (x *SearchV2Response_OIDWithMeta) GetId() *refs.ObjectID { if x != nil { - return x.IdList + return x.Id + } + return nil +} + +func (x *SearchV2Response_OIDWithMeta) GetAttributes() []string { + if x != nil { + return x.Attributes } return nil } +// Main result structure. +type SearchV2Response_Body struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of object IDs with additional requested attributes. + Result []*SearchV2Response_OIDWithMeta `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // Cursor that can be used for subsequent requests. For users it's an + // opaque string that is omitted or empty when there are no more results + // to list. For nodes to interoperate this is defined as the latest OID + // for queries without filters and primary (first) attribute value plus + // OID. Values are encoded in base64. + Cursor string `protobuf:"bytes,2,opt,name=cursor,proto3" json:"cursor,omitempty"` +} + +func (x *SearchV2Response_Body) Reset() { + *x = SearchV2Response_Body{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_object_service_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SearchV2Response_Body) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchV2Response_Body) ProtoMessage() {} + +func (x *SearchV2Response_Body) ProtoReflect() protoreflect.Message { + mi := &file_proto_object_service_proto_msgTypes[34] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchV2Response_Body.ProtoReflect.Descriptor instead. +func (*SearchV2Response_Body) Descriptor() ([]byte, []int) { + return file_proto_object_service_proto_rawDescGZIP(), []int{12, 1} +} + +func (x *SearchV2Response_Body) GetResult() []*SearchV2Response_OIDWithMeta { + if x != nil { + return x.Result + } + return nil +} + +func (x *SearchV2Response_Body) GetCursor() string { + if x != nil { + return x.Cursor + } + return "" +} + // Byte range of object's payload request body type GetRangeRequest_Body struct { state protoimpl.MessageState @@ -2226,7 +2462,7 @@ type GetRangeRequest_Body struct { func (x *GetRangeRequest_Body) Reset() { *x = GetRangeRequest_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[31] + mi := &file_proto_object_service_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2239,7 +2475,7 @@ func (x *GetRangeRequest_Body) String() string { func (*GetRangeRequest_Body) ProtoMessage() {} func (x *GetRangeRequest_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[31] + mi := &file_proto_object_service_proto_msgTypes[35] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2252,7 +2488,7 @@ func (x *GetRangeRequest_Body) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRangeRequest_Body.ProtoReflect.Descriptor instead. func (*GetRangeRequest_Body) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{12, 0} + return file_proto_object_service_proto_rawDescGZIP(), []int{14, 0} } func (x *GetRangeRequest_Body) GetAddress() *refs.Address { @@ -2297,7 +2533,7 @@ type GetRangeResponse_Body struct { func (x *GetRangeResponse_Body) Reset() { *x = GetRangeResponse_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[32] + mi := &file_proto_object_service_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2310,7 +2546,7 @@ func (x *GetRangeResponse_Body) String() string { func (*GetRangeResponse_Body) ProtoMessage() {} func (x *GetRangeResponse_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[32] + mi := &file_proto_object_service_proto_msgTypes[36] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2323,7 +2559,7 @@ func (x *GetRangeResponse_Body) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRangeResponse_Body.ProtoReflect.Descriptor instead. func (*GetRangeResponse_Body) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{13, 0} + return file_proto_object_service_proto_rawDescGZIP(), []int{15, 0} } func (m *GetRangeResponse_Body) GetRangePart() isGetRangeResponse_Body_RangePart { @@ -2384,7 +2620,7 @@ type GetRangeHashRequest_Body struct { func (x *GetRangeHashRequest_Body) Reset() { *x = GetRangeHashRequest_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[33] + mi := &file_proto_object_service_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2397,7 +2633,7 @@ func (x *GetRangeHashRequest_Body) String() string { func (*GetRangeHashRequest_Body) ProtoMessage() {} func (x *GetRangeHashRequest_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[33] + mi := &file_proto_object_service_proto_msgTypes[37] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2410,7 +2646,7 @@ func (x *GetRangeHashRequest_Body) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRangeHashRequest_Body.ProtoReflect.Descriptor instead. func (*GetRangeHashRequest_Body) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{14, 0} + return file_proto_object_service_proto_rawDescGZIP(), []int{16, 0} } func (x *GetRangeHashRequest_Body) GetAddress() *refs.Address { @@ -2456,7 +2692,7 @@ type GetRangeHashResponse_Body struct { func (x *GetRangeHashResponse_Body) Reset() { *x = GetRangeHashResponse_Body{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_service_proto_msgTypes[34] + mi := &file_proto_object_service_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2469,7 +2705,7 @@ func (x *GetRangeHashResponse_Body) String() string { func (*GetRangeHashResponse_Body) ProtoMessage() {} func (x *GetRangeHashResponse_Body) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_service_proto_msgTypes[34] + mi := &file_proto_object_service_proto_msgTypes[38] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2482,7 +2718,7 @@ func (x *GetRangeHashResponse_Body) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRangeHashResponse_Body.ProtoReflect.Descriptor instead. func (*GetRangeHashResponse_Body) Descriptor() ([]byte, []int) { - return file_proto_object_service_proto_rawDescGZIP(), []int{15, 0} + return file_proto_object_service_proto_rawDescGZIP(), []int{17, 0} } func (x *GetRangeHashResponse_Body) GetType() refs.ChecksumType { @@ -2711,7 +2947,7 @@ var file_proto_object_service_proto_rawDesc = []byte{ 0x32, 0x1b, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x09, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x42, 0x06, 0x0a, 0x04, 0x68, 0x65, - 0x61, 0x64, 0x22, 0xfb, 0x03, 0x0a, 0x0d, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, + 0x61, 0x64, 0x22, 0x80, 0x03, 0x0a, 0x0d, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, @@ -2725,73 +2961,170 @@ var file_proto_object_service_proto_rawDesc = []byte{ 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x69, - 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, 0x95, 0x02, 0x0a, 0x04, 0x42, 0x6f, 0x64, + 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, 0x9a, 0x01, 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x3e, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x44, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x07, 0x66, - 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x6e, + 0x28, 0x0d, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x0a, 0x07, 0x66, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, - 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x42, 0x6f, - 0x64, 0x79, 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, - 0x72, 0x73, 0x1a, 0x6c, 0x0a, 0x06, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3a, 0x0a, 0x0a, - 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, - 0x32, 0x1b, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x6d, - 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x22, 0xa2, 0x02, 0x0a, 0x0e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, - 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x2e, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, 0x46, - 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, - 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x07, 0x66, 0x69, + 0x6c, 0x74, 0x65, 0x72, 0x73, 0x22, 0xa2, 0x02, 0x0a, 0x0e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, + 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, + 0x6f, 0x64, 0x79, 0x12, 0x46, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, + 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, + 0x0a, 0x6d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x0d, 0x76, + 0x65, 0x72, 0x69, 0x66, 0x79, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, + 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x56, + 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, + 0x39, 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x31, 0x0a, 0x07, 0x69, 0x64, 0x5f, 0x6c, 0x69, + 0x73, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, + 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x49, 0x44, 0x52, 0x06, 0x69, 0x64, 0x4c, 0x69, 0x73, 0x74, 0x22, 0xd2, 0x03, 0x0a, 0x0f, 0x53, + 0x65, 0x61, 0x72, 0x63, 0x68, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, + 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x6e, + 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, + 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, + 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, 0x45, 0x0a, 0x0b, 0x6d, 0x65, + 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x24, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x48, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0a, 0x6d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x12, 0x51, 0x0a, 0x0d, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x5f, 0x68, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, + 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x1a, 0xe8, 0x01, 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x3e, 0x0a, + 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, + 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x44, + 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x64, 0x12, 0x18, 0x0a, + 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, + 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, 0x72, + 0x63, 0x68, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, + 0x73, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, + 0x1e, 0x0a, 0x0a, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, + 0xac, 0x03, 0x0a, 0x10, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x56, 0x32, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x56, 0x32, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, 0x6f, 0x64, + 0x79, 0x12, 0x46, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, + 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0a, 0x6d, + 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x0d, 0x76, 0x65, 0x72, + 0x69, 0x66, 0x79, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x2d, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x56, 0x65, 0x72, + 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, + 0x0c, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, 0x57, 0x0a, + 0x0b, 0x4f, 0x49, 0x44, 0x57, 0x69, 0x74, 0x68, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x28, 0x0a, 0x02, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, + 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x1a, 0x66, 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x46, + 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, + 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x56, 0x32, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x2e, 0x4f, 0x49, 0x44, 0x57, 0x69, 0x74, 0x68, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x06, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x22, 0x37, + 0x0a, 0x05, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, + 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0xe3, 0x02, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, + 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x04, 0x62, + 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, + 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x42, 0x6f, 0x64, + 0x79, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, 0x45, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6e, + 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x52, 0x0a, 0x6d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x51, + 0x0a, 0x0d, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, + 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x1a, 0x7a, 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x31, 0x0a, 0x07, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, + 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2d, 0x0a, 0x05, + 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, + 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x52, + 0x61, 0x6e, 0x67, 0x65, 0x52, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x72, + 0x61, 0x77, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x03, 0x72, 0x61, 0x77, 0x22, 0xd7, 0x02, + 0x0a, 0x10, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x27, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, + 0x46, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, + 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x4d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0a, 0x6d, 0x65, 0x74, + 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x0d, 0x76, 0x65, 0x72, 0x69, 0x66, + 0x79, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, + 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x56, 0x65, 0x72, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x76, + 0x65, 0x72, 0x69, 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, 0x6a, 0x0a, 0x04, 0x42, + 0x6f, 0x64, 0x79, 0x12, 0x16, 0x0a, 0x05, 0x63, 0x68, 0x75, 0x6e, 0x6b, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0c, 0x48, 0x00, 0x52, 0x05, 0x63, 0x68, 0x75, 0x6e, 0x6b, 0x12, 0x3c, 0x0a, 0x0a, 0x73, + 0x70, 0x6c, 0x69, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x2e, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x09, + 0x73, 0x70, 0x6c, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x42, 0x0c, 0x0a, 0x0a, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x22, 0xa2, 0x03, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x52, + 0x61, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x3e, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, + 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x2e, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, + 0x45, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, + 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0a, 0x6d, 0x65, 0x74, 0x61, - 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x0d, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, - 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x51, 0x0a, 0x0d, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, + 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x76, 0x65, - 0x72, 0x69, 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, 0x39, 0x0a, 0x04, 0x42, 0x6f, - 0x64, 0x79, 0x12, 0x31, 0x0a, 0x07, 0x69, 0x64, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, - 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, 0x06, 0x69, - 0x64, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x37, 0x0a, 0x05, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x16, - 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, - 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0xe3, - 0x02, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x26, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x2e, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, 0x45, - 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, - 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, - 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0a, 0x6d, 0x65, 0x74, 0x61, 0x48, - 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x51, 0x0a, 0x0d, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x5f, - 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x6e, - 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, - 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x69, - 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, 0x7a, 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, - 0x12, 0x31, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, - 0x66, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, - 0x65, 0x73, 0x73, 0x12, 0x2d, 0x0a, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, - 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x05, 0x72, 0x61, 0x6e, - 0x67, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x72, 0x61, 0x77, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x03, 0x72, 0x61, 0x77, 0x22, 0xd7, 0x02, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, - 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x62, 0x6f, 0x64, - 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, - 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, - 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x42, 0x6f, 0x64, 0x79, + 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x76, 0x65, 0x72, + 0x69, 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, 0xb0, 0x01, 0x0a, 0x04, 0x42, 0x6f, + 0x64, 0x79, 0x12, 0x31, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, + 0x72, 0x65, 0x66, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x07, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2f, 0x0a, 0x06, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, + 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x06, + 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x61, 0x6c, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x73, 0x61, 0x6c, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, + 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, + 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0xca, 0x02, 0x0a, + 0x14, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, + 0x61, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, 0x46, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, @@ -2802,124 +3135,81 @@ var file_proto_object_service_proto_rawDesc = []byte{ 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, - 0x65, 0x72, 0x1a, 0x6a, 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x16, 0x0a, 0x05, 0x63, 0x68, - 0x75, 0x6e, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x05, 0x63, 0x68, 0x75, - 0x6e, 0x6b, 0x12, 0x3c, 0x0a, 0x0a, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, - 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x49, - 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x09, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, - 0x42, 0x0c, 0x0a, 0x0a, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x22, 0xa2, - 0x03, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, - 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, - 0x48, 0x61, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x42, 0x6f, 0x64, 0x79, - 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, 0x45, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, - 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6e, 0x65, - 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x52, 0x0a, 0x6d, 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x51, 0x0a, - 0x0d, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, - 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, - 0x65, 0x72, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x1a, 0xb0, 0x01, 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x31, 0x0a, 0x07, 0x61, 0x64, 0x64, - 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, - 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, - 0x65, 0x73, 0x73, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2f, 0x0a, 0x06, - 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, + 0x65, 0x72, 0x1a, 0x55, 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x30, 0x0a, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, + 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, + 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x09, + 0x68, 0x61, 0x73, 0x68, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, + 0x08, 0x68, 0x61, 0x73, 0x68, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x9e, 0x01, 0x0a, 0x10, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, + 0x0a, 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x12, 0x37, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, + 0x72, 0x65, 0x66, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x09, + 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x69, 0x67, + 0x6e, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, + 0x73, 0x69, 0x67, 0x6e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x70, 0x0a, 0x11, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x30, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x73, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x6f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x32, 0xdb, 0x05, 0x0a, + 0x0d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x44, + 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x1c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, + 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x30, 0x01, 0x12, 0x44, 0x0a, 0x03, 0x50, 0x75, 0x74, 0x12, 0x1c, 0x2e, 0x6e, 0x65, + 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, + 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, + 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, 0x75, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x28, 0x01, 0x12, 0x4b, 0x0a, 0x06, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1f, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, + 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, + 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x04, 0x48, 0x65, 0x61, 0x64, 0x12, + 0x1d, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, + 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, + 0x0a, 0x06, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x12, 0x1f, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, + 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, 0x72, + 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, + 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, + 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x51, 0x0a, + 0x08, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x56, 0x32, 0x12, 0x21, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, + 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, + 0x72, 0x63, 0x68, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, - 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x06, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x12, 0x0a, - 0x04, 0x73, 0x61, 0x6c, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x73, 0x61, 0x6c, - 0x74, 0x12, 0x30, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x1c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, - 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, - 0x79, 0x70, 0x65, 0x22, 0xca, 0x02, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, - 0x48, 0x61, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x04, - 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x6e, 0x65, 0x6f, - 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, - 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x2e, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, 0x46, 0x0a, - 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, - 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x4d, - 0x65, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0a, 0x6d, 0x65, 0x74, 0x61, 0x48, - 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x0d, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x5f, - 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x6e, - 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, - 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x76, 0x65, 0x72, - 0x69, 0x66, 0x79, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, 0x55, 0x0a, 0x04, 0x42, 0x6f, 0x64, - 0x79, 0x12, 0x30, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x1c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, - 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, - 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x6c, 0x69, 0x73, 0x74, - 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x08, 0x68, 0x61, 0x73, 0x68, 0x4c, 0x69, 0x73, 0x74, - 0x22, 0x9e, 0x01, 0x0a, 0x10, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, - 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, - 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x37, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, - 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6e, 0x65, 0x6f, - 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, - 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, - 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x69, 0x67, 0x6e, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x4f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x22, 0x70, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, - 0x76, 0x32, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x62, 0x6a, 0x65, - 0x63, 0x74, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x0f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, - 0x75, 0x72, 0x65, 0x32, 0x88, 0x05, 0x0a, 0x0d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x65, - 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x44, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x1c, 0x2e, 0x6e, + 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x56, 0x32, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x53, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x21, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, - 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6e, 0x65, 0x6f, - 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, - 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x44, 0x0a, 0x03, 0x50, - 0x75, 0x74, 0x12, 0x1c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, - 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1d, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x2e, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x28, - 0x01, 0x12, 0x4b, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1f, 0x2e, 0x6e, 0x65, - 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x44, - 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6e, + 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x22, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x5d, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, + 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, + 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, + 0x65, 0x48, 0x61, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, - 0x0a, 0x04, 0x48, 0x65, 0x61, 0x64, 0x12, 0x1d, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, - 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, - 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, 0x0a, 0x06, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x12, - 0x1f, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, - 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x20, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x30, 0x01, 0x12, 0x53, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, - 0x12, 0x21, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, - 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x5d, 0x0a, 0x0c, 0x47, 0x65, 0x74, - 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x25, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, - 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, - 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x26, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x54, 0x0a, 0x09, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x65, 0x12, 0x22, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, + 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x54, 0x0a, 0x09, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x65, 0x12, 0x22, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, + 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, - 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x54, - 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6e, 0x73, 0x70, - 0x63, 0x63, 0x2d, 0x64, 0x65, 0x76, 0x2f, 0x6e, 0x65, 0x6f, 0x66, 0x73, 0x2d, 0x73, 0x64, 0x6b, - 0x2d, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, - 0x3b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0xaa, 0x02, 0x1a, 0x4e, 0x65, 0x6f, 0x2e, 0x46, 0x69, - 0x6c, 0x65, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x41, 0x50, 0x49, 0x2e, 0x4f, 0x62, - 0x6a, 0x65, 0x63, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x54, 0x5a, 0x35, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6e, 0x73, 0x70, 0x63, 0x63, 0x2d, 0x64, + 0x65, 0x76, 0x2f, 0x6e, 0x65, 0x6f, 0x66, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2d, 0x67, 0x6f, 0x2f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x6f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0xaa, 0x02, 0x1a, 0x4e, 0x65, 0x6f, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x53, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x41, 0x50, 0x49, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -2934,8 +3224,8 @@ func file_proto_object_service_proto_rawDescGZIP() []byte { return file_proto_object_service_proto_rawDescData } -var file_proto_object_service_proto_msgTypes = make([]protoimpl.MessageInfo, 35) -var file_proto_object_service_proto_goTypes = []interface{}{ +var file_proto_object_service_proto_msgTypes = make([]protoimpl.MessageInfo, 39) +var file_proto_object_service_proto_goTypes = []any{ (*GetRequest)(nil), // 0: neo.fs.v2.object.GetRequest (*GetResponse)(nil), // 1: neo.fs.v2.object.GetResponse (*PutRequest)(nil), // 2: neo.fs.v2.object.PutRequest @@ -2947,143 +3237,158 @@ var file_proto_object_service_proto_goTypes = []interface{}{ (*HeadResponse)(nil), // 8: neo.fs.v2.object.HeadResponse (*SearchRequest)(nil), // 9: neo.fs.v2.object.SearchRequest (*SearchResponse)(nil), // 10: neo.fs.v2.object.SearchResponse - (*Range)(nil), // 11: neo.fs.v2.object.Range - (*GetRangeRequest)(nil), // 12: neo.fs.v2.object.GetRangeRequest - (*GetRangeResponse)(nil), // 13: neo.fs.v2.object.GetRangeResponse - (*GetRangeHashRequest)(nil), // 14: neo.fs.v2.object.GetRangeHashRequest - (*GetRangeHashResponse)(nil), // 15: neo.fs.v2.object.GetRangeHashResponse - (*ReplicateRequest)(nil), // 16: neo.fs.v2.object.ReplicateRequest - (*ReplicateResponse)(nil), // 17: neo.fs.v2.object.ReplicateResponse - (*GetRequest_Body)(nil), // 18: neo.fs.v2.object.GetRequest.Body - (*GetResponse_Body)(nil), // 19: neo.fs.v2.object.GetResponse.Body - (*GetResponse_Body_Init)(nil), // 20: neo.fs.v2.object.GetResponse.Body.Init - (*PutRequest_Body)(nil), // 21: neo.fs.v2.object.PutRequest.Body - (*PutRequest_Body_Init)(nil), // 22: neo.fs.v2.object.PutRequest.Body.Init - (*PutResponse_Body)(nil), // 23: neo.fs.v2.object.PutResponse.Body - (*DeleteRequest_Body)(nil), // 24: neo.fs.v2.object.DeleteRequest.Body - (*DeleteResponse_Body)(nil), // 25: neo.fs.v2.object.DeleteResponse.Body - (*HeadRequest_Body)(nil), // 26: neo.fs.v2.object.HeadRequest.Body - (*HeadResponse_Body)(nil), // 27: neo.fs.v2.object.HeadResponse.Body - (*SearchRequest_Body)(nil), // 28: neo.fs.v2.object.SearchRequest.Body - (*SearchRequest_Body_Filter)(nil), // 29: neo.fs.v2.object.SearchRequest.Body.Filter - (*SearchResponse_Body)(nil), // 30: neo.fs.v2.object.SearchResponse.Body - (*GetRangeRequest_Body)(nil), // 31: neo.fs.v2.object.GetRangeRequest.Body - (*GetRangeResponse_Body)(nil), // 32: neo.fs.v2.object.GetRangeResponse.Body - (*GetRangeHashRequest_Body)(nil), // 33: neo.fs.v2.object.GetRangeHashRequest.Body - (*GetRangeHashResponse_Body)(nil), // 34: neo.fs.v2.object.GetRangeHashResponse.Body - (*session.RequestMetaHeader)(nil), // 35: neo.fs.v2.session.RequestMetaHeader - (*session.RequestVerificationHeader)(nil), // 36: neo.fs.v2.session.RequestVerificationHeader - (*session.ResponseMetaHeader)(nil), // 37: neo.fs.v2.session.ResponseMetaHeader - (*session.ResponseVerificationHeader)(nil), // 38: neo.fs.v2.session.ResponseVerificationHeader - (*Header)(nil), // 39: neo.fs.v2.object.Header - (*refs.Signature)(nil), // 40: neo.fs.v2.refs.Signature - (*Object)(nil), // 41: neo.fs.v2.object.Object - (*status.Status)(nil), // 42: neo.fs.v2.status.Status - (*refs.Address)(nil), // 43: neo.fs.v2.refs.Address - (*SplitInfo)(nil), // 44: neo.fs.v2.object.SplitInfo - (*refs.ObjectID)(nil), // 45: neo.fs.v2.refs.ObjectID - (*ShortHeader)(nil), // 46: neo.fs.v2.object.ShortHeader - (*refs.ContainerID)(nil), // 47: neo.fs.v2.refs.ContainerID - (MatchType)(0), // 48: neo.fs.v2.object.MatchType - (refs.ChecksumType)(0), // 49: neo.fs.v2.refs.ChecksumType + (*SearchV2Request)(nil), // 11: neo.fs.v2.object.SearchV2Request + (*SearchV2Response)(nil), // 12: neo.fs.v2.object.SearchV2Response + (*Range)(nil), // 13: neo.fs.v2.object.Range + (*GetRangeRequest)(nil), // 14: neo.fs.v2.object.GetRangeRequest + (*GetRangeResponse)(nil), // 15: neo.fs.v2.object.GetRangeResponse + (*GetRangeHashRequest)(nil), // 16: neo.fs.v2.object.GetRangeHashRequest + (*GetRangeHashResponse)(nil), // 17: neo.fs.v2.object.GetRangeHashResponse + (*ReplicateRequest)(nil), // 18: neo.fs.v2.object.ReplicateRequest + (*ReplicateResponse)(nil), // 19: neo.fs.v2.object.ReplicateResponse + (*GetRequest_Body)(nil), // 20: neo.fs.v2.object.GetRequest.Body + (*GetResponse_Body)(nil), // 21: neo.fs.v2.object.GetResponse.Body + (*GetResponse_Body_Init)(nil), // 22: neo.fs.v2.object.GetResponse.Body.Init + (*PutRequest_Body)(nil), // 23: neo.fs.v2.object.PutRequest.Body + (*PutRequest_Body_Init)(nil), // 24: neo.fs.v2.object.PutRequest.Body.Init + (*PutResponse_Body)(nil), // 25: neo.fs.v2.object.PutResponse.Body + (*DeleteRequest_Body)(nil), // 26: neo.fs.v2.object.DeleteRequest.Body + (*DeleteResponse_Body)(nil), // 27: neo.fs.v2.object.DeleteResponse.Body + (*HeadRequest_Body)(nil), // 28: neo.fs.v2.object.HeadRequest.Body + (*HeadResponse_Body)(nil), // 29: neo.fs.v2.object.HeadResponse.Body + (*SearchRequest_Body)(nil), // 30: neo.fs.v2.object.SearchRequest.Body + (*SearchResponse_Body)(nil), // 31: neo.fs.v2.object.SearchResponse.Body + (*SearchV2Request_Body)(nil), // 32: neo.fs.v2.object.SearchV2Request.Body + (*SearchV2Response_OIDWithMeta)(nil), // 33: neo.fs.v2.object.SearchV2Response.OIDWithMeta + (*SearchV2Response_Body)(nil), // 34: neo.fs.v2.object.SearchV2Response.Body + (*GetRangeRequest_Body)(nil), // 35: neo.fs.v2.object.GetRangeRequest.Body + (*GetRangeResponse_Body)(nil), // 36: neo.fs.v2.object.GetRangeResponse.Body + (*GetRangeHashRequest_Body)(nil), // 37: neo.fs.v2.object.GetRangeHashRequest.Body + (*GetRangeHashResponse_Body)(nil), // 38: neo.fs.v2.object.GetRangeHashResponse.Body + (*session.RequestMetaHeader)(nil), // 39: neo.fs.v2.session.RequestMetaHeader + (*session.RequestVerificationHeader)(nil), // 40: neo.fs.v2.session.RequestVerificationHeader + (*session.ResponseMetaHeader)(nil), // 41: neo.fs.v2.session.ResponseMetaHeader + (*session.ResponseVerificationHeader)(nil), // 42: neo.fs.v2.session.ResponseVerificationHeader + (*Header)(nil), // 43: neo.fs.v2.object.Header + (*refs.Signature)(nil), // 44: neo.fs.v2.refs.Signature + (*Object)(nil), // 45: neo.fs.v2.object.Object + (*status.Status)(nil), // 46: neo.fs.v2.status.Status + (*refs.Address)(nil), // 47: neo.fs.v2.refs.Address + (*SplitInfo)(nil), // 48: neo.fs.v2.object.SplitInfo + (*refs.ObjectID)(nil), // 49: neo.fs.v2.refs.ObjectID + (*ShortHeader)(nil), // 50: neo.fs.v2.object.ShortHeader + (*refs.ContainerID)(nil), // 51: neo.fs.v2.refs.ContainerID + (*SearchFilter)(nil), // 52: neo.fs.v2.object.SearchFilter + (refs.ChecksumType)(0), // 53: neo.fs.v2.refs.ChecksumType } var file_proto_object_service_proto_depIdxs = []int32{ - 18, // 0: neo.fs.v2.object.GetRequest.body:type_name -> neo.fs.v2.object.GetRequest.Body - 35, // 1: neo.fs.v2.object.GetRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader - 36, // 2: neo.fs.v2.object.GetRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader - 19, // 3: neo.fs.v2.object.GetResponse.body:type_name -> neo.fs.v2.object.GetResponse.Body - 37, // 4: neo.fs.v2.object.GetResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader - 38, // 5: neo.fs.v2.object.GetResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader - 21, // 6: neo.fs.v2.object.PutRequest.body:type_name -> neo.fs.v2.object.PutRequest.Body - 35, // 7: neo.fs.v2.object.PutRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader - 36, // 8: neo.fs.v2.object.PutRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader - 23, // 9: neo.fs.v2.object.PutResponse.body:type_name -> neo.fs.v2.object.PutResponse.Body - 37, // 10: neo.fs.v2.object.PutResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader - 38, // 11: neo.fs.v2.object.PutResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader - 24, // 12: neo.fs.v2.object.DeleteRequest.body:type_name -> neo.fs.v2.object.DeleteRequest.Body - 35, // 13: neo.fs.v2.object.DeleteRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader - 36, // 14: neo.fs.v2.object.DeleteRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader - 25, // 15: neo.fs.v2.object.DeleteResponse.body:type_name -> neo.fs.v2.object.DeleteResponse.Body - 37, // 16: neo.fs.v2.object.DeleteResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader - 38, // 17: neo.fs.v2.object.DeleteResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader - 26, // 18: neo.fs.v2.object.HeadRequest.body:type_name -> neo.fs.v2.object.HeadRequest.Body - 35, // 19: neo.fs.v2.object.HeadRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader - 36, // 20: neo.fs.v2.object.HeadRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader - 39, // 21: neo.fs.v2.object.HeaderWithSignature.header:type_name -> neo.fs.v2.object.Header - 40, // 22: neo.fs.v2.object.HeaderWithSignature.signature:type_name -> neo.fs.v2.refs.Signature - 27, // 23: neo.fs.v2.object.HeadResponse.body:type_name -> neo.fs.v2.object.HeadResponse.Body - 37, // 24: neo.fs.v2.object.HeadResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader - 38, // 25: neo.fs.v2.object.HeadResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader - 28, // 26: neo.fs.v2.object.SearchRequest.body:type_name -> neo.fs.v2.object.SearchRequest.Body - 35, // 27: neo.fs.v2.object.SearchRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader - 36, // 28: neo.fs.v2.object.SearchRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader - 30, // 29: neo.fs.v2.object.SearchResponse.body:type_name -> neo.fs.v2.object.SearchResponse.Body - 37, // 30: neo.fs.v2.object.SearchResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader - 38, // 31: neo.fs.v2.object.SearchResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader - 31, // 32: neo.fs.v2.object.GetRangeRequest.body:type_name -> neo.fs.v2.object.GetRangeRequest.Body - 35, // 33: neo.fs.v2.object.GetRangeRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader - 36, // 34: neo.fs.v2.object.GetRangeRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader - 32, // 35: neo.fs.v2.object.GetRangeResponse.body:type_name -> neo.fs.v2.object.GetRangeResponse.Body - 37, // 36: neo.fs.v2.object.GetRangeResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader - 38, // 37: neo.fs.v2.object.GetRangeResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader - 33, // 38: neo.fs.v2.object.GetRangeHashRequest.body:type_name -> neo.fs.v2.object.GetRangeHashRequest.Body - 35, // 39: neo.fs.v2.object.GetRangeHashRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader - 36, // 40: neo.fs.v2.object.GetRangeHashRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader - 34, // 41: neo.fs.v2.object.GetRangeHashResponse.body:type_name -> neo.fs.v2.object.GetRangeHashResponse.Body - 37, // 42: neo.fs.v2.object.GetRangeHashResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader - 38, // 43: neo.fs.v2.object.GetRangeHashResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader - 41, // 44: neo.fs.v2.object.ReplicateRequest.object:type_name -> neo.fs.v2.object.Object - 40, // 45: neo.fs.v2.object.ReplicateRequest.signature:type_name -> neo.fs.v2.refs.Signature - 42, // 46: neo.fs.v2.object.ReplicateResponse.status:type_name -> neo.fs.v2.status.Status - 43, // 47: neo.fs.v2.object.GetRequest.Body.address:type_name -> neo.fs.v2.refs.Address - 20, // 48: neo.fs.v2.object.GetResponse.Body.init:type_name -> neo.fs.v2.object.GetResponse.Body.Init - 44, // 49: neo.fs.v2.object.GetResponse.Body.split_info:type_name -> neo.fs.v2.object.SplitInfo - 45, // 50: neo.fs.v2.object.GetResponse.Body.Init.object_id:type_name -> neo.fs.v2.refs.ObjectID - 40, // 51: neo.fs.v2.object.GetResponse.Body.Init.signature:type_name -> neo.fs.v2.refs.Signature - 39, // 52: neo.fs.v2.object.GetResponse.Body.Init.header:type_name -> neo.fs.v2.object.Header - 22, // 53: neo.fs.v2.object.PutRequest.Body.init:type_name -> neo.fs.v2.object.PutRequest.Body.Init - 45, // 54: neo.fs.v2.object.PutRequest.Body.Init.object_id:type_name -> neo.fs.v2.refs.ObjectID - 40, // 55: neo.fs.v2.object.PutRequest.Body.Init.signature:type_name -> neo.fs.v2.refs.Signature - 39, // 56: neo.fs.v2.object.PutRequest.Body.Init.header:type_name -> neo.fs.v2.object.Header - 45, // 57: neo.fs.v2.object.PutResponse.Body.object_id:type_name -> neo.fs.v2.refs.ObjectID - 43, // 58: neo.fs.v2.object.DeleteRequest.Body.address:type_name -> neo.fs.v2.refs.Address - 43, // 59: neo.fs.v2.object.DeleteResponse.Body.tombstone:type_name -> neo.fs.v2.refs.Address - 43, // 60: neo.fs.v2.object.HeadRequest.Body.address:type_name -> neo.fs.v2.refs.Address - 7, // 61: neo.fs.v2.object.HeadResponse.Body.header:type_name -> neo.fs.v2.object.HeaderWithSignature - 46, // 62: neo.fs.v2.object.HeadResponse.Body.short_header:type_name -> neo.fs.v2.object.ShortHeader - 44, // 63: neo.fs.v2.object.HeadResponse.Body.split_info:type_name -> neo.fs.v2.object.SplitInfo - 47, // 64: neo.fs.v2.object.SearchRequest.Body.container_id:type_name -> neo.fs.v2.refs.ContainerID - 29, // 65: neo.fs.v2.object.SearchRequest.Body.filters:type_name -> neo.fs.v2.object.SearchRequest.Body.Filter - 48, // 66: neo.fs.v2.object.SearchRequest.Body.Filter.match_type:type_name -> neo.fs.v2.object.MatchType - 45, // 67: neo.fs.v2.object.SearchResponse.Body.id_list:type_name -> neo.fs.v2.refs.ObjectID - 43, // 68: neo.fs.v2.object.GetRangeRequest.Body.address:type_name -> neo.fs.v2.refs.Address - 11, // 69: neo.fs.v2.object.GetRangeRequest.Body.range:type_name -> neo.fs.v2.object.Range - 44, // 70: neo.fs.v2.object.GetRangeResponse.Body.split_info:type_name -> neo.fs.v2.object.SplitInfo - 43, // 71: neo.fs.v2.object.GetRangeHashRequest.Body.address:type_name -> neo.fs.v2.refs.Address - 11, // 72: neo.fs.v2.object.GetRangeHashRequest.Body.ranges:type_name -> neo.fs.v2.object.Range - 49, // 73: neo.fs.v2.object.GetRangeHashRequest.Body.type:type_name -> neo.fs.v2.refs.ChecksumType - 49, // 74: neo.fs.v2.object.GetRangeHashResponse.Body.type:type_name -> neo.fs.v2.refs.ChecksumType - 0, // 75: neo.fs.v2.object.ObjectService.Get:input_type -> neo.fs.v2.object.GetRequest - 2, // 76: neo.fs.v2.object.ObjectService.Put:input_type -> neo.fs.v2.object.PutRequest - 4, // 77: neo.fs.v2.object.ObjectService.Delete:input_type -> neo.fs.v2.object.DeleteRequest - 6, // 78: neo.fs.v2.object.ObjectService.Head:input_type -> neo.fs.v2.object.HeadRequest - 9, // 79: neo.fs.v2.object.ObjectService.Search:input_type -> neo.fs.v2.object.SearchRequest - 12, // 80: neo.fs.v2.object.ObjectService.GetRange:input_type -> neo.fs.v2.object.GetRangeRequest - 14, // 81: neo.fs.v2.object.ObjectService.GetRangeHash:input_type -> neo.fs.v2.object.GetRangeHashRequest - 16, // 82: neo.fs.v2.object.ObjectService.Replicate:input_type -> neo.fs.v2.object.ReplicateRequest - 1, // 83: neo.fs.v2.object.ObjectService.Get:output_type -> neo.fs.v2.object.GetResponse - 3, // 84: neo.fs.v2.object.ObjectService.Put:output_type -> neo.fs.v2.object.PutResponse - 5, // 85: neo.fs.v2.object.ObjectService.Delete:output_type -> neo.fs.v2.object.DeleteResponse - 8, // 86: neo.fs.v2.object.ObjectService.Head:output_type -> neo.fs.v2.object.HeadResponse - 10, // 87: neo.fs.v2.object.ObjectService.Search:output_type -> neo.fs.v2.object.SearchResponse - 13, // 88: neo.fs.v2.object.ObjectService.GetRange:output_type -> neo.fs.v2.object.GetRangeResponse - 15, // 89: neo.fs.v2.object.ObjectService.GetRangeHash:output_type -> neo.fs.v2.object.GetRangeHashResponse - 17, // 90: neo.fs.v2.object.ObjectService.Replicate:output_type -> neo.fs.v2.object.ReplicateResponse - 83, // [83:91] is the sub-list for method output_type - 75, // [75:83] is the sub-list for method input_type - 75, // [75:75] is the sub-list for extension type_name - 75, // [75:75] is the sub-list for extension extendee - 0, // [0:75] is the sub-list for field type_name + 20, // 0: neo.fs.v2.object.GetRequest.body:type_name -> neo.fs.v2.object.GetRequest.Body + 39, // 1: neo.fs.v2.object.GetRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader + 40, // 2: neo.fs.v2.object.GetRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader + 21, // 3: neo.fs.v2.object.GetResponse.body:type_name -> neo.fs.v2.object.GetResponse.Body + 41, // 4: neo.fs.v2.object.GetResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader + 42, // 5: neo.fs.v2.object.GetResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader + 23, // 6: neo.fs.v2.object.PutRequest.body:type_name -> neo.fs.v2.object.PutRequest.Body + 39, // 7: neo.fs.v2.object.PutRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader + 40, // 8: neo.fs.v2.object.PutRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader + 25, // 9: neo.fs.v2.object.PutResponse.body:type_name -> neo.fs.v2.object.PutResponse.Body + 41, // 10: neo.fs.v2.object.PutResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader + 42, // 11: neo.fs.v2.object.PutResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader + 26, // 12: neo.fs.v2.object.DeleteRequest.body:type_name -> neo.fs.v2.object.DeleteRequest.Body + 39, // 13: neo.fs.v2.object.DeleteRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader + 40, // 14: neo.fs.v2.object.DeleteRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader + 27, // 15: neo.fs.v2.object.DeleteResponse.body:type_name -> neo.fs.v2.object.DeleteResponse.Body + 41, // 16: neo.fs.v2.object.DeleteResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader + 42, // 17: neo.fs.v2.object.DeleteResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader + 28, // 18: neo.fs.v2.object.HeadRequest.body:type_name -> neo.fs.v2.object.HeadRequest.Body + 39, // 19: neo.fs.v2.object.HeadRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader + 40, // 20: neo.fs.v2.object.HeadRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader + 43, // 21: neo.fs.v2.object.HeaderWithSignature.header:type_name -> neo.fs.v2.object.Header + 44, // 22: neo.fs.v2.object.HeaderWithSignature.signature:type_name -> neo.fs.v2.refs.Signature + 29, // 23: neo.fs.v2.object.HeadResponse.body:type_name -> neo.fs.v2.object.HeadResponse.Body + 41, // 24: neo.fs.v2.object.HeadResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader + 42, // 25: neo.fs.v2.object.HeadResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader + 30, // 26: neo.fs.v2.object.SearchRequest.body:type_name -> neo.fs.v2.object.SearchRequest.Body + 39, // 27: neo.fs.v2.object.SearchRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader + 40, // 28: neo.fs.v2.object.SearchRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader + 31, // 29: neo.fs.v2.object.SearchResponse.body:type_name -> neo.fs.v2.object.SearchResponse.Body + 41, // 30: neo.fs.v2.object.SearchResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader + 42, // 31: neo.fs.v2.object.SearchResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader + 32, // 32: neo.fs.v2.object.SearchV2Request.body:type_name -> neo.fs.v2.object.SearchV2Request.Body + 39, // 33: neo.fs.v2.object.SearchV2Request.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader + 40, // 34: neo.fs.v2.object.SearchV2Request.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader + 34, // 35: neo.fs.v2.object.SearchV2Response.body:type_name -> neo.fs.v2.object.SearchV2Response.Body + 41, // 36: neo.fs.v2.object.SearchV2Response.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader + 42, // 37: neo.fs.v2.object.SearchV2Response.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader + 35, // 38: neo.fs.v2.object.GetRangeRequest.body:type_name -> neo.fs.v2.object.GetRangeRequest.Body + 39, // 39: neo.fs.v2.object.GetRangeRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader + 40, // 40: neo.fs.v2.object.GetRangeRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader + 36, // 41: neo.fs.v2.object.GetRangeResponse.body:type_name -> neo.fs.v2.object.GetRangeResponse.Body + 41, // 42: neo.fs.v2.object.GetRangeResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader + 42, // 43: neo.fs.v2.object.GetRangeResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader + 37, // 44: neo.fs.v2.object.GetRangeHashRequest.body:type_name -> neo.fs.v2.object.GetRangeHashRequest.Body + 39, // 45: neo.fs.v2.object.GetRangeHashRequest.meta_header:type_name -> neo.fs.v2.session.RequestMetaHeader + 40, // 46: neo.fs.v2.object.GetRangeHashRequest.verify_header:type_name -> neo.fs.v2.session.RequestVerificationHeader + 38, // 47: neo.fs.v2.object.GetRangeHashResponse.body:type_name -> neo.fs.v2.object.GetRangeHashResponse.Body + 41, // 48: neo.fs.v2.object.GetRangeHashResponse.meta_header:type_name -> neo.fs.v2.session.ResponseMetaHeader + 42, // 49: neo.fs.v2.object.GetRangeHashResponse.verify_header:type_name -> neo.fs.v2.session.ResponseVerificationHeader + 45, // 50: neo.fs.v2.object.ReplicateRequest.object:type_name -> neo.fs.v2.object.Object + 44, // 51: neo.fs.v2.object.ReplicateRequest.signature:type_name -> neo.fs.v2.refs.Signature + 46, // 52: neo.fs.v2.object.ReplicateResponse.status:type_name -> neo.fs.v2.status.Status + 47, // 53: neo.fs.v2.object.GetRequest.Body.address:type_name -> neo.fs.v2.refs.Address + 22, // 54: neo.fs.v2.object.GetResponse.Body.init:type_name -> neo.fs.v2.object.GetResponse.Body.Init + 48, // 55: neo.fs.v2.object.GetResponse.Body.split_info:type_name -> neo.fs.v2.object.SplitInfo + 49, // 56: neo.fs.v2.object.GetResponse.Body.Init.object_id:type_name -> neo.fs.v2.refs.ObjectID + 44, // 57: neo.fs.v2.object.GetResponse.Body.Init.signature:type_name -> neo.fs.v2.refs.Signature + 43, // 58: neo.fs.v2.object.GetResponse.Body.Init.header:type_name -> neo.fs.v2.object.Header + 24, // 59: neo.fs.v2.object.PutRequest.Body.init:type_name -> neo.fs.v2.object.PutRequest.Body.Init + 49, // 60: neo.fs.v2.object.PutRequest.Body.Init.object_id:type_name -> neo.fs.v2.refs.ObjectID + 44, // 61: neo.fs.v2.object.PutRequest.Body.Init.signature:type_name -> neo.fs.v2.refs.Signature + 43, // 62: neo.fs.v2.object.PutRequest.Body.Init.header:type_name -> neo.fs.v2.object.Header + 49, // 63: neo.fs.v2.object.PutResponse.Body.object_id:type_name -> neo.fs.v2.refs.ObjectID + 47, // 64: neo.fs.v2.object.DeleteRequest.Body.address:type_name -> neo.fs.v2.refs.Address + 47, // 65: neo.fs.v2.object.DeleteResponse.Body.tombstone:type_name -> neo.fs.v2.refs.Address + 47, // 66: neo.fs.v2.object.HeadRequest.Body.address:type_name -> neo.fs.v2.refs.Address + 7, // 67: neo.fs.v2.object.HeadResponse.Body.header:type_name -> neo.fs.v2.object.HeaderWithSignature + 50, // 68: neo.fs.v2.object.HeadResponse.Body.short_header:type_name -> neo.fs.v2.object.ShortHeader + 48, // 69: neo.fs.v2.object.HeadResponse.Body.split_info:type_name -> neo.fs.v2.object.SplitInfo + 51, // 70: neo.fs.v2.object.SearchRequest.Body.container_id:type_name -> neo.fs.v2.refs.ContainerID + 52, // 71: neo.fs.v2.object.SearchRequest.Body.filters:type_name -> neo.fs.v2.object.SearchFilter + 49, // 72: neo.fs.v2.object.SearchResponse.Body.id_list:type_name -> neo.fs.v2.refs.ObjectID + 51, // 73: neo.fs.v2.object.SearchV2Request.Body.container_id:type_name -> neo.fs.v2.refs.ContainerID + 52, // 74: neo.fs.v2.object.SearchV2Request.Body.filters:type_name -> neo.fs.v2.object.SearchFilter + 49, // 75: neo.fs.v2.object.SearchV2Response.OIDWithMeta.id:type_name -> neo.fs.v2.refs.ObjectID + 33, // 76: neo.fs.v2.object.SearchV2Response.Body.result:type_name -> neo.fs.v2.object.SearchV2Response.OIDWithMeta + 47, // 77: neo.fs.v2.object.GetRangeRequest.Body.address:type_name -> neo.fs.v2.refs.Address + 13, // 78: neo.fs.v2.object.GetRangeRequest.Body.range:type_name -> neo.fs.v2.object.Range + 48, // 79: neo.fs.v2.object.GetRangeResponse.Body.split_info:type_name -> neo.fs.v2.object.SplitInfo + 47, // 80: neo.fs.v2.object.GetRangeHashRequest.Body.address:type_name -> neo.fs.v2.refs.Address + 13, // 81: neo.fs.v2.object.GetRangeHashRequest.Body.ranges:type_name -> neo.fs.v2.object.Range + 53, // 82: neo.fs.v2.object.GetRangeHashRequest.Body.type:type_name -> neo.fs.v2.refs.ChecksumType + 53, // 83: neo.fs.v2.object.GetRangeHashResponse.Body.type:type_name -> neo.fs.v2.refs.ChecksumType + 0, // 84: neo.fs.v2.object.ObjectService.Get:input_type -> neo.fs.v2.object.GetRequest + 2, // 85: neo.fs.v2.object.ObjectService.Put:input_type -> neo.fs.v2.object.PutRequest + 4, // 86: neo.fs.v2.object.ObjectService.Delete:input_type -> neo.fs.v2.object.DeleteRequest + 6, // 87: neo.fs.v2.object.ObjectService.Head:input_type -> neo.fs.v2.object.HeadRequest + 9, // 88: neo.fs.v2.object.ObjectService.Search:input_type -> neo.fs.v2.object.SearchRequest + 11, // 89: neo.fs.v2.object.ObjectService.SearchV2:input_type -> neo.fs.v2.object.SearchV2Request + 14, // 90: neo.fs.v2.object.ObjectService.GetRange:input_type -> neo.fs.v2.object.GetRangeRequest + 16, // 91: neo.fs.v2.object.ObjectService.GetRangeHash:input_type -> neo.fs.v2.object.GetRangeHashRequest + 18, // 92: neo.fs.v2.object.ObjectService.Replicate:input_type -> neo.fs.v2.object.ReplicateRequest + 1, // 93: neo.fs.v2.object.ObjectService.Get:output_type -> neo.fs.v2.object.GetResponse + 3, // 94: neo.fs.v2.object.ObjectService.Put:output_type -> neo.fs.v2.object.PutResponse + 5, // 95: neo.fs.v2.object.ObjectService.Delete:output_type -> neo.fs.v2.object.DeleteResponse + 8, // 96: neo.fs.v2.object.ObjectService.Head:output_type -> neo.fs.v2.object.HeadResponse + 10, // 97: neo.fs.v2.object.ObjectService.Search:output_type -> neo.fs.v2.object.SearchResponse + 12, // 98: neo.fs.v2.object.ObjectService.SearchV2:output_type -> neo.fs.v2.object.SearchV2Response + 15, // 99: neo.fs.v2.object.ObjectService.GetRange:output_type -> neo.fs.v2.object.GetRangeResponse + 17, // 100: neo.fs.v2.object.ObjectService.GetRangeHash:output_type -> neo.fs.v2.object.GetRangeHashResponse + 19, // 101: neo.fs.v2.object.ObjectService.Replicate:output_type -> neo.fs.v2.object.ReplicateResponse + 93, // [93:102] is the sub-list for method output_type + 84, // [84:93] is the sub-list for method input_type + 84, // [84:84] is the sub-list for extension type_name + 84, // [84:84] is the sub-list for extension extendee + 0, // [0:84] is the sub-list for field type_name } func init() { file_proto_object_service_proto_init() } @@ -3093,7 +3398,7 @@ func file_proto_object_service_proto_init() { } file_proto_object_types_proto_init() if !protoimpl.UnsafeEnabled { - file_proto_object_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*GetRequest); i { case 0: return &v.state @@ -3105,7 +3410,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*GetResponse); i { case 0: return &v.state @@ -3117,7 +3422,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*PutRequest); i { case 0: return &v.state @@ -3129,7 +3434,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*PutResponse); i { case 0: return &v.state @@ -3141,7 +3446,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*DeleteRequest); i { case 0: return &v.state @@ -3153,7 +3458,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[5].Exporter = func(v any, i int) any { switch v := v.(*DeleteResponse); i { case 0: return &v.state @@ -3165,7 +3470,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[6].Exporter = func(v any, i int) any { switch v := v.(*HeadRequest); i { case 0: return &v.state @@ -3177,7 +3482,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[7].Exporter = func(v any, i int) any { switch v := v.(*HeaderWithSignature); i { case 0: return &v.state @@ -3189,7 +3494,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[8].Exporter = func(v any, i int) any { switch v := v.(*HeadResponse); i { case 0: return &v.state @@ -3201,7 +3506,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[9].Exporter = func(v any, i int) any { switch v := v.(*SearchRequest); i { case 0: return &v.state @@ -3213,7 +3518,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[10].Exporter = func(v any, i int) any { switch v := v.(*SearchResponse); i { case 0: return &v.state @@ -3225,7 +3530,31 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[11].Exporter = func(v any, i int) any { + switch v := v.(*SearchV2Request); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_object_service_proto_msgTypes[12].Exporter = func(v any, i int) any { + switch v := v.(*SearchV2Response); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_object_service_proto_msgTypes[13].Exporter = func(v any, i int) any { switch v := v.(*Range); i { case 0: return &v.state @@ -3237,7 +3566,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[14].Exporter = func(v any, i int) any { switch v := v.(*GetRangeRequest); i { case 0: return &v.state @@ -3249,7 +3578,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[15].Exporter = func(v any, i int) any { switch v := v.(*GetRangeResponse); i { case 0: return &v.state @@ -3261,7 +3590,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[16].Exporter = func(v any, i int) any { switch v := v.(*GetRangeHashRequest); i { case 0: return &v.state @@ -3273,7 +3602,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[17].Exporter = func(v any, i int) any { switch v := v.(*GetRangeHashResponse); i { case 0: return &v.state @@ -3285,7 +3614,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[18].Exporter = func(v any, i int) any { switch v := v.(*ReplicateRequest); i { case 0: return &v.state @@ -3297,7 +3626,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[19].Exporter = func(v any, i int) any { switch v := v.(*ReplicateResponse); i { case 0: return &v.state @@ -3309,7 +3638,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[20].Exporter = func(v any, i int) any { switch v := v.(*GetRequest_Body); i { case 0: return &v.state @@ -3321,7 +3650,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[21].Exporter = func(v any, i int) any { switch v := v.(*GetResponse_Body); i { case 0: return &v.state @@ -3333,7 +3662,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[22].Exporter = func(v any, i int) any { switch v := v.(*GetResponse_Body_Init); i { case 0: return &v.state @@ -3345,7 +3674,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[23].Exporter = func(v any, i int) any { switch v := v.(*PutRequest_Body); i { case 0: return &v.state @@ -3357,7 +3686,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[24].Exporter = func(v any, i int) any { switch v := v.(*PutRequest_Body_Init); i { case 0: return &v.state @@ -3369,7 +3698,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[25].Exporter = func(v any, i int) any { switch v := v.(*PutResponse_Body); i { case 0: return &v.state @@ -3381,7 +3710,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[26].Exporter = func(v any, i int) any { switch v := v.(*DeleteRequest_Body); i { case 0: return &v.state @@ -3393,7 +3722,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[27].Exporter = func(v any, i int) any { switch v := v.(*DeleteResponse_Body); i { case 0: return &v.state @@ -3405,7 +3734,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[28].Exporter = func(v any, i int) any { switch v := v.(*HeadRequest_Body); i { case 0: return &v.state @@ -3417,7 +3746,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[29].Exporter = func(v any, i int) any { switch v := v.(*HeadResponse_Body); i { case 0: return &v.state @@ -3429,7 +3758,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[30].Exporter = func(v any, i int) any { switch v := v.(*SearchRequest_Body); i { case 0: return &v.state @@ -3441,8 +3770,8 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchRequest_Body_Filter); i { + file_proto_object_service_proto_msgTypes[31].Exporter = func(v any, i int) any { + switch v := v.(*SearchResponse_Body); i { case 0: return &v.state case 1: @@ -3453,8 +3782,32 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchResponse_Body); i { + file_proto_object_service_proto_msgTypes[32].Exporter = func(v any, i int) any { + switch v := v.(*SearchV2Request_Body); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_object_service_proto_msgTypes[33].Exporter = func(v any, i int) any { + switch v := v.(*SearchV2Response_OIDWithMeta); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_object_service_proto_msgTypes[34].Exporter = func(v any, i int) any { + switch v := v.(*SearchV2Response_Body); i { case 0: return &v.state case 1: @@ -3465,7 +3818,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[35].Exporter = func(v any, i int) any { switch v := v.(*GetRangeRequest_Body); i { case 0: return &v.state @@ -3477,7 +3830,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[36].Exporter = func(v any, i int) any { switch v := v.(*GetRangeResponse_Body); i { case 0: return &v.state @@ -3489,7 +3842,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[37].Exporter = func(v any, i int) any { switch v := v.(*GetRangeHashRequest_Body); i { case 0: return &v.state @@ -3501,7 +3854,7 @@ func file_proto_object_service_proto_init() { return nil } } - file_proto_object_service_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_service_proto_msgTypes[38].Exporter = func(v any, i int) any { switch v := v.(*GetRangeHashResponse_Body); i { case 0: return &v.state @@ -3514,21 +3867,21 @@ func file_proto_object_service_proto_init() { } } } - file_proto_object_service_proto_msgTypes[19].OneofWrappers = []interface{}{ + file_proto_object_service_proto_msgTypes[21].OneofWrappers = []any{ (*GetResponse_Body_Init_)(nil), (*GetResponse_Body_Chunk)(nil), (*GetResponse_Body_SplitInfo)(nil), } - file_proto_object_service_proto_msgTypes[21].OneofWrappers = []interface{}{ + file_proto_object_service_proto_msgTypes[23].OneofWrappers = []any{ (*PutRequest_Body_Init_)(nil), (*PutRequest_Body_Chunk)(nil), } - file_proto_object_service_proto_msgTypes[27].OneofWrappers = []interface{}{ + file_proto_object_service_proto_msgTypes[29].OneofWrappers = []any{ (*HeadResponse_Body_Header)(nil), (*HeadResponse_Body_ShortHeader)(nil), (*HeadResponse_Body_SplitInfo)(nil), } - file_proto_object_service_proto_msgTypes[32].OneofWrappers = []interface{}{ + file_proto_object_service_proto_msgTypes[36].OneofWrappers = []any{ (*GetRangeResponse_Body_Chunk)(nil), (*GetRangeResponse_Body_SplitInfo)(nil), } @@ -3538,7 +3891,7 @@ func file_proto_object_service_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_proto_object_service_proto_rawDesc, NumEnums: 0, - NumMessages: 35, + NumMessages: 39, NumExtensions: 0, NumServices: 1, }, diff --git a/proto/object/service_grpc.pb.go b/proto/object/service_grpc.pb.go index 343a9d54..9f15e6cc 100644 --- a/proto/object/service_grpc.pb.go +++ b/proto/object/service_grpc.pb.go @@ -24,6 +24,7 @@ const ( ObjectService_Delete_FullMethodName = "/neo.fs.v2.object.ObjectService/Delete" ObjectService_Head_FullMethodName = "/neo.fs.v2.object.ObjectService/Head" ObjectService_Search_FullMethodName = "/neo.fs.v2.object.ObjectService/Search" + ObjectService_SearchV2_FullMethodName = "/neo.fs.v2.object.ObjectService/SearchV2" ObjectService_GetRange_FullMethodName = "/neo.fs.v2.object.ObjectService/GetRange" ObjectService_GetRangeHash_FullMethodName = "/neo.fs.v2.object.ObjectService/GetRangeHash" ObjectService_Replicate_FullMethodName = "/neo.fs.v2.object.ObjectService/Replicate" @@ -154,6 +155,8 @@ type ObjectServiceClient interface { // Header's filed values. Please see the corresponding NeoFS Technical // Specification section for more details. // + // DEPRECATED: please use SearchV2. + // // Extended headers can change `Search` behaviour: // - __NEOFS__NETMAP_EPOCH \ // Will use the requsted version of Network Map for object placement @@ -172,6 +175,14 @@ type ObjectServiceClient interface { // - **TOKEN_EXPIRED** (4097, SECTION_SESSION): \ // provided session token has expired. Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (ObjectService_SearchClient, error) + // Search for objects in a container. Similar to Search, but: + // * sorted + // * limited in amount of returned data + // * single message + // * allows for additional header fields to be returned + // + // Result is ordered by requested attributes and object ID. + SearchV2(ctx context.Context, in *SearchV2Request, opts ...grpc.CallOption) (*SearchV2Response, error) // Get byte range of data payload. Range is set as an (offset, length) tuple. // Like in `Get` method, the response uses gRPC stream. Requested range can be // restored by concatenation of all received payload chunks keeping the receiving @@ -376,6 +387,15 @@ func (x *objectServiceSearchClient) Recv() (*SearchResponse, error) { return m, nil } +func (c *objectServiceClient) SearchV2(ctx context.Context, in *SearchV2Request, opts ...grpc.CallOption) (*SearchV2Response, error) { + out := new(SearchV2Response) + err := c.cc.Invoke(ctx, ObjectService_SearchV2_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *objectServiceClient) GetRange(ctx context.Context, in *GetRangeRequest, opts ...grpc.CallOption) (ObjectService_GetRangeClient, error) { stream, err := c.cc.NewStream(ctx, &ObjectService_ServiceDesc.Streams[3], ObjectService_GetRange_FullMethodName, opts...) if err != nil { @@ -551,6 +571,8 @@ type ObjectServiceServer interface { // Header's filed values. Please see the corresponding NeoFS Technical // Specification section for more details. // + // DEPRECATED: please use SearchV2. + // // Extended headers can change `Search` behaviour: // - __NEOFS__NETMAP_EPOCH \ // Will use the requsted version of Network Map for object placement @@ -569,6 +591,14 @@ type ObjectServiceServer interface { // - **TOKEN_EXPIRED** (4097, SECTION_SESSION): \ // provided session token has expired. Search(*SearchRequest, ObjectService_SearchServer) error + // Search for objects in a container. Similar to Search, but: + // * sorted + // * limited in amount of returned data + // * single message + // * allows for additional header fields to be returned + // + // Result is ordered by requested attributes and object ID. + SearchV2(context.Context, *SearchV2Request) (*SearchV2Response, error) // Get byte range of data payload. Range is set as an (offset, length) tuple. // Like in `Get` method, the response uses gRPC stream. Requested range can be // restored by concatenation of all received payload chunks keeping the receiving @@ -668,6 +698,9 @@ func (UnimplementedObjectServiceServer) Head(context.Context, *HeadRequest) (*He func (UnimplementedObjectServiceServer) Search(*SearchRequest, ObjectService_SearchServer) error { return status.Errorf(codes.Unimplemented, "method Search not implemented") } +func (UnimplementedObjectServiceServer) SearchV2(context.Context, *SearchV2Request) (*SearchV2Response, error) { + return nil, status.Errorf(codes.Unimplemented, "method SearchV2 not implemented") +} func (UnimplementedObjectServiceServer) GetRange(*GetRangeRequest, ObjectService_GetRangeServer) error { return status.Errorf(codes.Unimplemented, "method GetRange not implemented") } @@ -793,6 +826,24 @@ func (x *objectServiceSearchServer) Send(m *SearchResponse) error { return x.ServerStream.SendMsg(m) } +func _ObjectService_SearchV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SearchV2Request) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ObjectServiceServer).SearchV2(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ObjectService_SearchV2_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ObjectServiceServer).SearchV2(ctx, req.(*SearchV2Request)) + } + return interceptor(ctx, in, info, handler) +} + func _ObjectService_GetRange_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(GetRangeRequest) if err := stream.RecvMsg(m); err != nil { @@ -865,6 +916,10 @@ var ObjectService_ServiceDesc = grpc.ServiceDesc{ MethodName: "Head", Handler: _ObjectService_Head_Handler, }, + { + MethodName: "SearchV2", + Handler: _ObjectService_SearchV2_Handler, + }, { MethodName: "GetRangeHash", Handler: _ObjectService_GetRangeHash_Handler, diff --git a/proto/object/types.pb.go b/proto/object/types.pb.go index fdd859e9..44705823 100644 --- a/proto/object/types.pb.go +++ b/proto/object/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/object/types.proto @@ -169,6 +169,131 @@ func (MatchType) EnumDescriptor() ([]byte, []int) { return file_proto_object_types_proto_rawDescGZIP(), []int{1} } +// Filter structure checks if the object header field or the attribute content +// matches a value. +// +// If no filters are set, search request will return all objects of the +// container, including Regular object, Tombstones and Storage Group +// objects. Most human users expect to get only object they can directly +// work with. In that case, `$Object:ROOT` filter should be used. +// +// If `match_type` field is numerical, both `value` field and object +// attribute MUST be base-10 integers. +// +// By default `key` field refers to the corresponding object's `Attribute`. +// Some Object's header fields can also be accessed by adding `$Object:` +// prefix to the name. Here is the list of fields available via this prefix: +// +// - $Object:version \ +// version +// - $Object:objectID \ +// object_id +// - $Object:containerID \ +// container_id +// - $Object:ownerID \ +// owner_id +// - $Object:creationEpoch \ +// creation_epoch +// - $Object:payloadLength \ +// payload_length +// - $Object:payloadHash \ +// payload_hash +// - $Object:objectType \ +// object_type +// - $Object:homomorphicHash \ +// homomorphic_hash +// - $Object:split.parent \ +// object_id of parent +// - $Object:split.splitID \ +// 16 byte UUIDv4 used to identify the split object hierarchy parts +// - $Object:split.first \ +// object_id of the first part in split chain; non-acceptable for deprecated V1 split scheme +// +// There are some well-known filter aliases to match objects by certain +// properties: +// +// - $Object:ROOT \ +// Returns only `REGULAR` type objects that are not split or that are the top +// level root objects in a split hierarchy. This includes objects not +// present physically, like large objects split into smaller objects +// without a separate top-level root object. Objects of other types like +// StorageGroups and Tombstones will not be shown. This filter may be +// useful for listing objects like `ls` command of some virtual file +// system. This filter is activated if the `key` exists, disregarding the +// value and matcher type. +// - $Object:PHY \ +// Returns only objects physically stored in the system. This filter is +// activated if the `key` exists, disregarding the value and matcher type. +// +// Note: using filters with a key with prefix `$Object:` and match type +// `NOT_PRESENT `is not recommended since this is not a cross-version approach. +// Behavior when processing this kind of filters is undefined. +type SearchFilter struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Match type to use + MatchType MatchType `protobuf:"varint,1,opt,name=match_type,json=matchType,proto3,enum=neo.fs.v2.object.MatchType" json:"match_type,omitempty"` + // Attribute or Header fields to match + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + // Value to match + Value string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` +} + +func (x *SearchFilter) Reset() { + *x = SearchFilter{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_object_types_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SearchFilter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchFilter) ProtoMessage() {} + +func (x *SearchFilter) ProtoReflect() protoreflect.Message { + mi := &file_proto_object_types_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchFilter.ProtoReflect.Descriptor instead. +func (*SearchFilter) Descriptor() ([]byte, []int) { + return file_proto_object_types_proto_rawDescGZIP(), []int{0} +} + +func (x *SearchFilter) GetMatchType() MatchType { + if x != nil { + return x.MatchType + } + return MatchType_MATCH_TYPE_UNSPECIFIED +} + +func (x *SearchFilter) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *SearchFilter) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + // Short header fields type ShortHeader struct { state protoimpl.MessageState @@ -196,7 +321,7 @@ type ShortHeader struct { func (x *ShortHeader) Reset() { *x = ShortHeader{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_types_proto_msgTypes[0] + mi := &file_proto_object_types_proto_msgTypes[1] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -209,7 +334,7 @@ func (x *ShortHeader) String() string { func (*ShortHeader) ProtoMessage() {} func (x *ShortHeader) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_types_proto_msgTypes[0] + mi := &file_proto_object_types_proto_msgTypes[1] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -222,7 +347,7 @@ func (x *ShortHeader) ProtoReflect() protoreflect.Message { // Deprecated: Use ShortHeader.ProtoReflect.Descriptor instead. func (*ShortHeader) Descriptor() ([]byte, []int) { - return file_proto_object_types_proto_rawDescGZIP(), []int{0} + return file_proto_object_types_proto_rawDescGZIP(), []int{1} } func (x *ShortHeader) GetVersion() *refs.Version { @@ -311,7 +436,7 @@ type Header struct { func (x *Header) Reset() { *x = Header{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_types_proto_msgTypes[1] + mi := &file_proto_object_types_proto_msgTypes[2] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -324,7 +449,7 @@ func (x *Header) String() string { func (*Header) ProtoMessage() {} func (x *Header) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_types_proto_msgTypes[1] + mi := &file_proto_object_types_proto_msgTypes[2] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -337,7 +462,7 @@ func (x *Header) ProtoReflect() protoreflect.Message { // Deprecated: Use Header.ProtoReflect.Descriptor instead. func (*Header) Descriptor() ([]byte, []int) { - return file_proto_object_types_proto_rawDescGZIP(), []int{1} + return file_proto_object_types_proto_rawDescGZIP(), []int{2} } func (x *Header) GetVersion() *refs.Version { @@ -441,7 +566,7 @@ type Object struct { func (x *Object) Reset() { *x = Object{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_types_proto_msgTypes[2] + mi := &file_proto_object_types_proto_msgTypes[3] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -454,7 +579,7 @@ func (x *Object) String() string { func (*Object) ProtoMessage() {} func (x *Object) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_types_proto_msgTypes[2] + mi := &file_proto_object_types_proto_msgTypes[3] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -467,7 +592,7 @@ func (x *Object) ProtoReflect() protoreflect.Message { // Deprecated: Use Object.ProtoReflect.Descriptor instead. func (*Object) Descriptor() ([]byte, []int) { - return file_proto_object_types_proto_rawDescGZIP(), []int{2} + return file_proto_object_types_proto_rawDescGZIP(), []int{3} } func (x *Object) GetObjectId() *refs.ObjectID { @@ -526,7 +651,7 @@ type SplitInfo struct { func (x *SplitInfo) Reset() { *x = SplitInfo{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_types_proto_msgTypes[3] + mi := &file_proto_object_types_proto_msgTypes[4] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -539,7 +664,7 @@ func (x *SplitInfo) String() string { func (*SplitInfo) ProtoMessage() {} func (x *SplitInfo) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_types_proto_msgTypes[3] + mi := &file_proto_object_types_proto_msgTypes[4] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -552,7 +677,7 @@ func (x *SplitInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use SplitInfo.ProtoReflect.Descriptor instead. func (*SplitInfo) Descriptor() ([]byte, []int) { - return file_proto_object_types_proto_rawDescGZIP(), []int{3} + return file_proto_object_types_proto_rawDescGZIP(), []int{4} } func (x *SplitInfo) GetSplitId() []byte { @@ -639,7 +764,7 @@ type Header_Attribute struct { func (x *Header_Attribute) Reset() { *x = Header_Attribute{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_types_proto_msgTypes[4] + mi := &file_proto_object_types_proto_msgTypes[5] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -652,7 +777,7 @@ func (x *Header_Attribute) String() string { func (*Header_Attribute) ProtoMessage() {} func (x *Header_Attribute) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_types_proto_msgTypes[4] + mi := &file_proto_object_types_proto_msgTypes[5] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -665,7 +790,7 @@ func (x *Header_Attribute) ProtoReflect() protoreflect.Message { // Deprecated: Use Header_Attribute.ProtoReflect.Descriptor instead. func (*Header_Attribute) Descriptor() ([]byte, []int) { - return file_proto_object_types_proto_rawDescGZIP(), []int{1, 0} + return file_proto_object_types_proto_rawDescGZIP(), []int{2, 0} } func (x *Header_Attribute) GetKey() string { @@ -717,7 +842,7 @@ type Header_Split struct { func (x *Header_Split) Reset() { *x = Header_Split{} if protoimpl.UnsafeEnabled { - mi := &file_proto_object_types_proto_msgTypes[5] + mi := &file_proto_object_types_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -730,7 +855,7 @@ func (x *Header_Split) String() string { func (*Header_Split) ProtoMessage() {} func (x *Header_Split) ProtoReflect() protoreflect.Message { - mi := &file_proto_object_types_proto_msgTypes[5] + mi := &file_proto_object_types_proto_msgTypes[6] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -743,7 +868,7 @@ func (x *Header_Split) ProtoReflect() protoreflect.Message { // Deprecated: Use Header_Split.ProtoReflect.Descriptor instead. func (*Header_Split) Descriptor() ([]byte, []int) { - return file_proto_object_types_proto_rawDescGZIP(), []int{1, 1} + return file_proto_object_types_proto_rawDescGZIP(), []int{2, 1} } func (x *Header_Split) GetParent() *refs.ObjectID { @@ -804,144 +929,151 @@ var file_proto_object_types_proto_rawDesc = []byte{ 0x6f, 0x74, 0x6f, 0x2f, 0x72, 0x65, 0x66, 0x73, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, - 0x83, 0x03, 0x0a, 0x0b, 0x53, 0x68, 0x6f, 0x72, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, - 0x31, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, - 0x73, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, - 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x63, 0x72, 0x65, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x32, 0x0a, 0x08, 0x6f, 0x77, 0x6e, - 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, - 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x77, 0x6e, - 0x65, 0x72, 0x49, 0x44, 0x52, 0x07, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x49, 0x44, 0x12, 0x3d, 0x0a, - 0x0b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, - 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, - 0x52, 0x0a, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, - 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x65, 0x6e, - 0x67, 0x74, 0x68, 0x12, 0x3b, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x68, - 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, - 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, - 0x73, 0x75, 0x6d, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x48, 0x61, 0x73, 0x68, - 0x12, 0x43, 0x0a, 0x10, 0x68, 0x6f, 0x6d, 0x6f, 0x6d, 0x6f, 0x72, 0x70, 0x68, 0x69, 0x63, 0x5f, - 0x68, 0x61, 0x73, 0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, - 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, - 0x6b, 0x73, 0x75, 0x6d, 0x52, 0x0f, 0x68, 0x6f, 0x6d, 0x6f, 0x6d, 0x6f, 0x72, 0x70, 0x68, 0x69, - 0x63, 0x48, 0x61, 0x73, 0x68, 0x22, 0xab, 0x08, 0x0a, 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x12, 0x31, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, - 0x66, 0x73, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, - 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, - 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, - 0x69, 0x6e, 0x65, 0x72, 0x49, 0x44, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x49, 0x44, 0x12, 0x32, 0x0a, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, - 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x49, 0x44, 0x52, 0x07, - 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x49, 0x44, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x72, 0x65, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, - 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x25, - 0x0a, 0x0e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x4c, - 0x65, 0x6e, 0x67, 0x74, 0x68, 0x12, 0x3b, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, - 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, - 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, 0x68, 0x65, - 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x48, 0x61, - 0x73, 0x68, 0x12, 0x3d, 0x0a, 0x0b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, - 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x43, 0x0a, 0x10, 0x68, 0x6f, 0x6d, 0x6f, 0x6d, 0x6f, 0x72, 0x70, 0x68, 0x69, 0x63, - 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, - 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, 0x68, 0x65, - 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x52, 0x0f, 0x68, 0x6f, 0x6d, 0x6f, 0x6d, 0x6f, 0x72, 0x70, 0x68, - 0x69, 0x63, 0x48, 0x61, 0x73, 0x68, 0x12, 0x44, 0x0a, 0x0d, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, - 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x2e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x0c, - 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x42, 0x0a, 0x0a, - 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x22, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x41, 0x74, 0x74, 0x72, 0x69, - 0x62, 0x75, 0x74, 0x65, 0x52, 0x0a, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, - 0x12, 0x34, 0x0a, 0x05, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1e, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, - 0x63, 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x52, - 0x05, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x1a, 0x33, 0x0a, 0x09, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, - 0x75, 0x74, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x1a, 0xf5, 0x02, 0x0a, 0x05, - 0x53, 0x70, 0x6c, 0x69, 0x74, 0x12, 0x30, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, - 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, - 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x08, 0x70, 0x72, 0x65, 0x76, 0x69, - 0x6f, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, + 0x72, 0x0a, 0x0c, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, + 0x3a, 0x0a, 0x0a, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x09, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x22, 0x83, 0x03, 0x0a, 0x0b, 0x53, 0x68, 0x6f, 0x72, 0x74, 0x48, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, + 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x32, 0x0a, + 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, + 0x2e, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x49, 0x44, 0x52, 0x07, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x49, + 0x44, 0x12, 0x3d, 0x0a, 0x0b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, + 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6c, 0x65, 0x6e, 0x67, + 0x74, 0x68, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, + 0x64, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x12, 0x3b, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6c, 0x6f, + 0x61, 0x64, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, + 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, + 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, + 0x48, 0x61, 0x73, 0x68, 0x12, 0x43, 0x0a, 0x10, 0x68, 0x6f, 0x6d, 0x6f, 0x6d, 0x6f, 0x72, 0x70, + 0x68, 0x69, 0x63, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, + 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x52, 0x0f, 0x68, 0x6f, 0x6d, 0x6f, 0x6d, 0x6f, + 0x72, 0x70, 0x68, 0x69, 0x63, 0x48, 0x61, 0x73, 0x68, 0x22, 0xab, 0x08, 0x0a, 0x06, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, + 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, + 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x43, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x44, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x44, 0x12, 0x32, 0x0a, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, + 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, + 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x77, 0x6e, 0x65, 0x72, + 0x49, 0x44, 0x52, 0x07, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x49, 0x44, 0x12, 0x25, 0x0a, 0x0e, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x70, 0x6f, + 0x63, 0x68, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6c, 0x65, + 0x6e, 0x67, 0x74, 0x68, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x70, 0x61, 0x79, 0x6c, + 0x6f, 0x61, 0x64, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x12, 0x3b, 0x0a, 0x0c, 0x70, 0x61, 0x79, + 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, + 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6c, 0x6f, + 0x61, 0x64, 0x48, 0x61, 0x73, 0x68, 0x12, 0x3d, 0x0a, 0x0b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6e, 0x65, + 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x6f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x43, 0x0a, 0x10, 0x68, 0x6f, 0x6d, 0x6f, 0x6d, 0x6f, 0x72, + 0x70, 0x68, 0x69, 0x63, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, + 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x52, 0x0f, 0x68, 0x6f, 0x6d, 0x6f, 0x6d, + 0x6f, 0x72, 0x70, 0x68, 0x69, 0x63, 0x48, 0x61, 0x73, 0x68, 0x12, 0x44, 0x0a, 0x0d, 0x73, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1f, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x52, 0x0c, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x12, 0x42, 0x0a, 0x0a, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x18, 0x0a, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, + 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x41, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x0a, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x05, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x18, 0x0b, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x53, 0x70, + 0x6c, 0x69, 0x74, 0x52, 0x05, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x1a, 0x33, 0x0a, 0x09, 0x41, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x1a, + 0xf5, 0x02, 0x0a, 0x05, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x12, 0x30, 0x0a, 0x06, 0x70, 0x61, 0x72, + 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x49, 0x44, 0x52, 0x08, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x12, 0x44, 0x0a, - 0x10, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, - 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, - 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, - 0x72, 0x65, 0x52, 0x0f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, - 0x75, 0x72, 0x65, 0x12, 0x3d, 0x0a, 0x0d, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x65, - 0x61, 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, - 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x48, 0x65, - 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, - 0x65, 0x72, 0x12, 0x34, 0x0a, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x18, 0x05, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, - 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, 0x08, - 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x70, 0x6c, 0x69, - 0x74, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x73, 0x70, 0x6c, 0x69, - 0x74, 0x49, 0x44, 0x12, 0x2e, 0x0a, 0x05, 0x66, 0x69, 0x72, 0x73, 0x74, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, - 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, 0x05, 0x66, 0x69, - 0x72, 0x73, 0x74, 0x22, 0xc4, 0x01, 0x0a, 0x06, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x35, - 0x0a, 0x09, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, - 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, 0x08, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x49, 0x44, 0x12, 0x37, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, - 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, - 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, - 0x75, 0x72, 0x65, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x30, - 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x74, 0x49, 0x44, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x08, 0x70, + 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, + 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, 0x08, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, + 0x73, 0x12, 0x44, 0x0a, 0x10, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6e, 0x65, + 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x53, 0x69, 0x67, + 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x0f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x69, + 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x3d, 0x0a, 0x0d, 0x70, 0x61, 0x72, 0x65, 0x6e, + 0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0xc4, 0x01, 0x0a, 0x09, 0x53, - 0x70, 0x6c, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x70, 0x6c, 0x69, - 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x73, 0x70, 0x6c, 0x69, - 0x74, 0x49, 0x64, 0x12, 0x35, 0x0a, 0x09, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, - 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, - 0x52, 0x08, 0x6c, 0x61, 0x73, 0x74, 0x50, 0x61, 0x72, 0x74, 0x12, 0x2c, 0x0a, 0x04, 0x6c, 0x69, - 0x6e, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, + 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0c, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x34, 0x0a, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, + 0x65, 0x6e, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, - 0x49, 0x44, 0x52, 0x04, 0x6c, 0x69, 0x6e, 0x6b, 0x12, 0x37, 0x0a, 0x0a, 0x66, 0x69, 0x72, 0x73, - 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, + 0x49, 0x44, 0x52, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x19, 0x0a, 0x08, + 0x73, 0x70, 0x6c, 0x69, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, + 0x73, 0x70, 0x6c, 0x69, 0x74, 0x49, 0x44, 0x12, 0x2e, 0x0a, 0x05, 0x66, 0x69, 0x72, 0x73, 0x74, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, + 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, + 0x52, 0x05, 0x66, 0x69, 0x72, 0x73, 0x74, 0x22, 0xc4, 0x01, 0x0a, 0x06, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x12, 0x35, 0x0a, 0x09, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, + 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, + 0x08, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x12, 0x37, 0x0a, 0x09, 0x73, 0x69, 0x67, + 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6e, + 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x53, 0x69, + 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x12, 0x30, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x6f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x06, 0x68, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0xc4, + 0x01, 0x0a, 0x09, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x19, 0x0a, 0x08, + 0x73, 0x70, 0x6c, 0x69, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, + 0x73, 0x70, 0x6c, 0x69, 0x74, 0x49, 0x64, 0x12, 0x35, 0x0a, 0x09, 0x6c, 0x61, 0x73, 0x74, 0x5f, + 0x70, 0x61, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, + 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x49, 0x44, 0x52, 0x08, 0x6c, 0x61, 0x73, 0x74, 0x50, 0x61, 0x72, 0x74, 0x12, 0x2c, + 0x0a, 0x04, 0x6c, 0x69, 0x6e, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, 0x73, 0x2e, 0x4f, 0x62, - 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, 0x09, 0x66, 0x69, 0x72, 0x73, 0x74, 0x50, 0x61, 0x72, - 0x74, 0x2a, 0x4f, 0x0a, 0x0a, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x0b, 0x0a, 0x07, 0x52, 0x45, 0x47, 0x55, 0x4c, 0x41, 0x52, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, - 0x54, 0x4f, 0x4d, 0x42, 0x53, 0x54, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x53, - 0x54, 0x4f, 0x52, 0x41, 0x47, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x10, 0x02, 0x12, 0x08, - 0x0a, 0x04, 0x4c, 0x4f, 0x43, 0x4b, 0x10, 0x03, 0x12, 0x08, 0x0a, 0x04, 0x4c, 0x49, 0x4e, 0x4b, - 0x10, 0x04, 0x2a, 0xa3, 0x01, 0x0a, 0x09, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x1a, 0x0a, 0x16, 0x4d, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, - 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, - 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x14, - 0x0a, 0x10, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x45, 0x51, 0x55, - 0x41, 0x4c, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x4e, 0x4f, 0x54, 0x5f, 0x50, 0x52, 0x45, 0x53, - 0x45, 0x4e, 0x54, 0x10, 0x03, 0x12, 0x11, 0x0a, 0x0d, 0x43, 0x4f, 0x4d, 0x4d, 0x4f, 0x4e, 0x5f, - 0x50, 0x52, 0x45, 0x46, 0x49, 0x58, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x55, 0x4d, 0x5f, - 0x47, 0x54, 0x10, 0x05, 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x55, 0x4d, 0x5f, 0x47, 0x45, 0x10, 0x06, - 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x55, 0x4d, 0x5f, 0x4c, 0x54, 0x10, 0x07, 0x12, 0x0a, 0x0a, 0x06, - 0x4e, 0x55, 0x4d, 0x5f, 0x4c, 0x45, 0x10, 0x08, 0x42, 0x54, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, - 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6e, 0x73, 0x70, 0x63, 0x63, 0x2d, 0x64, 0x65, 0x76, - 0x2f, 0x6e, 0x65, 0x6f, 0x66, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2d, 0x67, 0x6f, 0x2f, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x6f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0xaa, 0x02, 0x1a, 0x4e, 0x65, 0x6f, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x6f, 0x72, - 0x61, 0x67, 0x65, 0x2e, 0x41, 0x50, 0x49, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x62, 0x06, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, 0x04, 0x6c, 0x69, 0x6e, 0x6b, 0x12, 0x37, 0x0a, 0x0a, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x18, 0x2e, 0x6e, 0x65, 0x6f, 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x65, 0x66, + 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x44, 0x52, 0x09, 0x66, 0x69, 0x72, 0x73, + 0x74, 0x50, 0x61, 0x72, 0x74, 0x2a, 0x4f, 0x0a, 0x0a, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x52, 0x45, 0x47, 0x55, 0x4c, 0x41, 0x52, 0x10, 0x00, + 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x4f, 0x4d, 0x42, 0x53, 0x54, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x12, + 0x11, 0x0a, 0x0d, 0x53, 0x54, 0x4f, 0x52, 0x41, 0x47, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, + 0x10, 0x02, 0x12, 0x08, 0x0a, 0x04, 0x4c, 0x4f, 0x43, 0x4b, 0x10, 0x03, 0x12, 0x08, 0x0a, 0x04, + 0x4c, 0x49, 0x4e, 0x4b, 0x10, 0x04, 0x2a, 0xa3, 0x01, 0x0a, 0x09, 0x4d, 0x61, 0x74, 0x63, 0x68, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x4d, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, + 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x45, 0x51, 0x55, 0x41, 0x4c, + 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x4e, 0x4f, 0x54, + 0x5f, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x4e, 0x4f, 0x54, 0x5f, + 0x50, 0x52, 0x45, 0x53, 0x45, 0x4e, 0x54, 0x10, 0x03, 0x12, 0x11, 0x0a, 0x0d, 0x43, 0x4f, 0x4d, + 0x4d, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x45, 0x46, 0x49, 0x58, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, + 0x4e, 0x55, 0x4d, 0x5f, 0x47, 0x54, 0x10, 0x05, 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x55, 0x4d, 0x5f, + 0x47, 0x45, 0x10, 0x06, 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x55, 0x4d, 0x5f, 0x4c, 0x54, 0x10, 0x07, + 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x55, 0x4d, 0x5f, 0x4c, 0x45, 0x10, 0x08, 0x42, 0x54, 0x5a, 0x35, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6e, 0x73, 0x70, 0x63, 0x63, + 0x2d, 0x64, 0x65, 0x76, 0x2f, 0x6e, 0x65, 0x6f, 0x66, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2d, 0x67, + 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x6f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0xaa, 0x02, 0x1a, 0x4e, 0x65, 0x6f, 0x2e, 0x46, 0x69, 0x6c, 0x65, + 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x41, 0x50, 0x49, 0x2e, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -957,56 +1089,58 @@ func file_proto_object_types_proto_rawDescGZIP() []byte { } var file_proto_object_types_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_proto_object_types_proto_msgTypes = make([]protoimpl.MessageInfo, 6) -var file_proto_object_types_proto_goTypes = []interface{}{ +var file_proto_object_types_proto_msgTypes = make([]protoimpl.MessageInfo, 7) +var file_proto_object_types_proto_goTypes = []any{ (ObjectType)(0), // 0: neo.fs.v2.object.ObjectType (MatchType)(0), // 1: neo.fs.v2.object.MatchType - (*ShortHeader)(nil), // 2: neo.fs.v2.object.ShortHeader - (*Header)(nil), // 3: neo.fs.v2.object.Header - (*Object)(nil), // 4: neo.fs.v2.object.Object - (*SplitInfo)(nil), // 5: neo.fs.v2.object.SplitInfo - (*Header_Attribute)(nil), // 6: neo.fs.v2.object.Header.Attribute - (*Header_Split)(nil), // 7: neo.fs.v2.object.Header.Split - (*refs.Version)(nil), // 8: neo.fs.v2.refs.Version - (*refs.OwnerID)(nil), // 9: neo.fs.v2.refs.OwnerID - (*refs.Checksum)(nil), // 10: neo.fs.v2.refs.Checksum - (*refs.ContainerID)(nil), // 11: neo.fs.v2.refs.ContainerID - (*session.SessionToken)(nil), // 12: neo.fs.v2.session.SessionToken - (*refs.ObjectID)(nil), // 13: neo.fs.v2.refs.ObjectID - (*refs.Signature)(nil), // 14: neo.fs.v2.refs.Signature + (*SearchFilter)(nil), // 2: neo.fs.v2.object.SearchFilter + (*ShortHeader)(nil), // 3: neo.fs.v2.object.ShortHeader + (*Header)(nil), // 4: neo.fs.v2.object.Header + (*Object)(nil), // 5: neo.fs.v2.object.Object + (*SplitInfo)(nil), // 6: neo.fs.v2.object.SplitInfo + (*Header_Attribute)(nil), // 7: neo.fs.v2.object.Header.Attribute + (*Header_Split)(nil), // 8: neo.fs.v2.object.Header.Split + (*refs.Version)(nil), // 9: neo.fs.v2.refs.Version + (*refs.OwnerID)(nil), // 10: neo.fs.v2.refs.OwnerID + (*refs.Checksum)(nil), // 11: neo.fs.v2.refs.Checksum + (*refs.ContainerID)(nil), // 12: neo.fs.v2.refs.ContainerID + (*session.SessionToken)(nil), // 13: neo.fs.v2.session.SessionToken + (*refs.ObjectID)(nil), // 14: neo.fs.v2.refs.ObjectID + (*refs.Signature)(nil), // 15: neo.fs.v2.refs.Signature } var file_proto_object_types_proto_depIdxs = []int32{ - 8, // 0: neo.fs.v2.object.ShortHeader.version:type_name -> neo.fs.v2.refs.Version - 9, // 1: neo.fs.v2.object.ShortHeader.owner_id:type_name -> neo.fs.v2.refs.OwnerID - 0, // 2: neo.fs.v2.object.ShortHeader.object_type:type_name -> neo.fs.v2.object.ObjectType - 10, // 3: neo.fs.v2.object.ShortHeader.payload_hash:type_name -> neo.fs.v2.refs.Checksum - 10, // 4: neo.fs.v2.object.ShortHeader.homomorphic_hash:type_name -> neo.fs.v2.refs.Checksum - 8, // 5: neo.fs.v2.object.Header.version:type_name -> neo.fs.v2.refs.Version - 11, // 6: neo.fs.v2.object.Header.container_id:type_name -> neo.fs.v2.refs.ContainerID - 9, // 7: neo.fs.v2.object.Header.owner_id:type_name -> neo.fs.v2.refs.OwnerID - 10, // 8: neo.fs.v2.object.Header.payload_hash:type_name -> neo.fs.v2.refs.Checksum - 0, // 9: neo.fs.v2.object.Header.object_type:type_name -> neo.fs.v2.object.ObjectType - 10, // 10: neo.fs.v2.object.Header.homomorphic_hash:type_name -> neo.fs.v2.refs.Checksum - 12, // 11: neo.fs.v2.object.Header.session_token:type_name -> neo.fs.v2.session.SessionToken - 6, // 12: neo.fs.v2.object.Header.attributes:type_name -> neo.fs.v2.object.Header.Attribute - 7, // 13: neo.fs.v2.object.Header.split:type_name -> neo.fs.v2.object.Header.Split - 13, // 14: neo.fs.v2.object.Object.object_id:type_name -> neo.fs.v2.refs.ObjectID - 14, // 15: neo.fs.v2.object.Object.signature:type_name -> neo.fs.v2.refs.Signature - 3, // 16: neo.fs.v2.object.Object.header:type_name -> neo.fs.v2.object.Header - 13, // 17: neo.fs.v2.object.SplitInfo.last_part:type_name -> neo.fs.v2.refs.ObjectID - 13, // 18: neo.fs.v2.object.SplitInfo.link:type_name -> neo.fs.v2.refs.ObjectID - 13, // 19: neo.fs.v2.object.SplitInfo.first_part:type_name -> neo.fs.v2.refs.ObjectID - 13, // 20: neo.fs.v2.object.Header.Split.parent:type_name -> neo.fs.v2.refs.ObjectID - 13, // 21: neo.fs.v2.object.Header.Split.previous:type_name -> neo.fs.v2.refs.ObjectID - 14, // 22: neo.fs.v2.object.Header.Split.parent_signature:type_name -> neo.fs.v2.refs.Signature - 3, // 23: neo.fs.v2.object.Header.Split.parent_header:type_name -> neo.fs.v2.object.Header - 13, // 24: neo.fs.v2.object.Header.Split.children:type_name -> neo.fs.v2.refs.ObjectID - 13, // 25: neo.fs.v2.object.Header.Split.first:type_name -> neo.fs.v2.refs.ObjectID - 26, // [26:26] is the sub-list for method output_type - 26, // [26:26] is the sub-list for method input_type - 26, // [26:26] is the sub-list for extension type_name - 26, // [26:26] is the sub-list for extension extendee - 0, // [0:26] is the sub-list for field type_name + 1, // 0: neo.fs.v2.object.SearchFilter.match_type:type_name -> neo.fs.v2.object.MatchType + 9, // 1: neo.fs.v2.object.ShortHeader.version:type_name -> neo.fs.v2.refs.Version + 10, // 2: neo.fs.v2.object.ShortHeader.owner_id:type_name -> neo.fs.v2.refs.OwnerID + 0, // 3: neo.fs.v2.object.ShortHeader.object_type:type_name -> neo.fs.v2.object.ObjectType + 11, // 4: neo.fs.v2.object.ShortHeader.payload_hash:type_name -> neo.fs.v2.refs.Checksum + 11, // 5: neo.fs.v2.object.ShortHeader.homomorphic_hash:type_name -> neo.fs.v2.refs.Checksum + 9, // 6: neo.fs.v2.object.Header.version:type_name -> neo.fs.v2.refs.Version + 12, // 7: neo.fs.v2.object.Header.container_id:type_name -> neo.fs.v2.refs.ContainerID + 10, // 8: neo.fs.v2.object.Header.owner_id:type_name -> neo.fs.v2.refs.OwnerID + 11, // 9: neo.fs.v2.object.Header.payload_hash:type_name -> neo.fs.v2.refs.Checksum + 0, // 10: neo.fs.v2.object.Header.object_type:type_name -> neo.fs.v2.object.ObjectType + 11, // 11: neo.fs.v2.object.Header.homomorphic_hash:type_name -> neo.fs.v2.refs.Checksum + 13, // 12: neo.fs.v2.object.Header.session_token:type_name -> neo.fs.v2.session.SessionToken + 7, // 13: neo.fs.v2.object.Header.attributes:type_name -> neo.fs.v2.object.Header.Attribute + 8, // 14: neo.fs.v2.object.Header.split:type_name -> neo.fs.v2.object.Header.Split + 14, // 15: neo.fs.v2.object.Object.object_id:type_name -> neo.fs.v2.refs.ObjectID + 15, // 16: neo.fs.v2.object.Object.signature:type_name -> neo.fs.v2.refs.Signature + 4, // 17: neo.fs.v2.object.Object.header:type_name -> neo.fs.v2.object.Header + 14, // 18: neo.fs.v2.object.SplitInfo.last_part:type_name -> neo.fs.v2.refs.ObjectID + 14, // 19: neo.fs.v2.object.SplitInfo.link:type_name -> neo.fs.v2.refs.ObjectID + 14, // 20: neo.fs.v2.object.SplitInfo.first_part:type_name -> neo.fs.v2.refs.ObjectID + 14, // 21: neo.fs.v2.object.Header.Split.parent:type_name -> neo.fs.v2.refs.ObjectID + 14, // 22: neo.fs.v2.object.Header.Split.previous:type_name -> neo.fs.v2.refs.ObjectID + 15, // 23: neo.fs.v2.object.Header.Split.parent_signature:type_name -> neo.fs.v2.refs.Signature + 4, // 24: neo.fs.v2.object.Header.Split.parent_header:type_name -> neo.fs.v2.object.Header + 14, // 25: neo.fs.v2.object.Header.Split.children:type_name -> neo.fs.v2.refs.ObjectID + 14, // 26: neo.fs.v2.object.Header.Split.first:type_name -> neo.fs.v2.refs.ObjectID + 27, // [27:27] is the sub-list for method output_type + 27, // [27:27] is the sub-list for method input_type + 27, // [27:27] is the sub-list for extension type_name + 27, // [27:27] is the sub-list for extension extendee + 0, // [0:27] is the sub-list for field type_name } func init() { file_proto_object_types_proto_init() } @@ -1015,7 +1149,19 @@ func file_proto_object_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_object_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_types_proto_msgTypes[0].Exporter = func(v any, i int) any { + switch v := v.(*SearchFilter); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_object_types_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*ShortHeader); i { case 0: return &v.state @@ -1027,7 +1173,7 @@ func file_proto_object_types_proto_init() { return nil } } - file_proto_object_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_types_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*Header); i { case 0: return &v.state @@ -1039,7 +1185,7 @@ func file_proto_object_types_proto_init() { return nil } } - file_proto_object_types_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_types_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*Object); i { case 0: return &v.state @@ -1051,7 +1197,7 @@ func file_proto_object_types_proto_init() { return nil } } - file_proto_object_types_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_types_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*SplitInfo); i { case 0: return &v.state @@ -1063,7 +1209,7 @@ func file_proto_object_types_proto_init() { return nil } } - file_proto_object_types_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_types_proto_msgTypes[5].Exporter = func(v any, i int) any { switch v := v.(*Header_Attribute); i { case 0: return &v.state @@ -1075,7 +1221,7 @@ func file_proto_object_types_proto_init() { return nil } } - file_proto_object_types_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_proto_object_types_proto_msgTypes[6].Exporter = func(v any, i int) any { switch v := v.(*Header_Split); i { case 0: return &v.state @@ -1094,7 +1240,7 @@ func file_proto_object_types_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_proto_object_types_proto_rawDesc, NumEnums: 2, - NumMessages: 6, + NumMessages: 7, NumExtensions: 0, NumServices: 0, }, diff --git a/proto/refs/types.pb.go b/proto/refs/types.pb.go index c8c626ec..90a9d049 100644 --- a/proto/refs/types.pb.go +++ b/proto/refs/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/refs/types.proto @@ -759,7 +759,7 @@ func file_proto_refs_types_proto_rawDescGZIP() []byte { var file_proto_refs_types_proto_enumTypes = make([]protoimpl.EnumInfo, 2) var file_proto_refs_types_proto_msgTypes = make([]protoimpl.MessageInfo, 9) -var file_proto_refs_types_proto_goTypes = []interface{}{ +var file_proto_refs_types_proto_goTypes = []any{ (SignatureScheme)(0), // 0: neo.fs.v2.refs.SignatureScheme (ChecksumType)(0), // 1: neo.fs.v2.refs.ChecksumType (*Address)(nil), // 2: neo.fs.v2.refs.Address @@ -790,7 +790,7 @@ func file_proto_refs_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_refs_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_refs_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*Address); i { case 0: return &v.state @@ -802,7 +802,7 @@ func file_proto_refs_types_proto_init() { return nil } } - file_proto_refs_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_refs_types_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*ObjectID); i { case 0: return &v.state @@ -814,7 +814,7 @@ func file_proto_refs_types_proto_init() { return nil } } - file_proto_refs_types_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_refs_types_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*ContainerID); i { case 0: return &v.state @@ -826,7 +826,7 @@ func file_proto_refs_types_proto_init() { return nil } } - file_proto_refs_types_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_refs_types_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*OwnerID); i { case 0: return &v.state @@ -838,7 +838,7 @@ func file_proto_refs_types_proto_init() { return nil } } - file_proto_refs_types_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_refs_types_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*SubnetID); i { case 0: return &v.state @@ -850,7 +850,7 @@ func file_proto_refs_types_proto_init() { return nil } } - file_proto_refs_types_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_proto_refs_types_proto_msgTypes[5].Exporter = func(v any, i int) any { switch v := v.(*Version); i { case 0: return &v.state @@ -862,7 +862,7 @@ func file_proto_refs_types_proto_init() { return nil } } - file_proto_refs_types_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_proto_refs_types_proto_msgTypes[6].Exporter = func(v any, i int) any { switch v := v.(*Signature); i { case 0: return &v.state @@ -874,7 +874,7 @@ func file_proto_refs_types_proto_init() { return nil } } - file_proto_refs_types_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + file_proto_refs_types_proto_msgTypes[7].Exporter = func(v any, i int) any { switch v := v.(*SignatureRFC6979); i { case 0: return &v.state @@ -886,7 +886,7 @@ func file_proto_refs_types_proto_init() { return nil } } - file_proto_refs_types_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + file_proto_refs_types_proto_msgTypes[8].Exporter = func(v any, i int) any { switch v := v.(*Checksum); i { case 0: return &v.state diff --git a/proto/reputation/service.pb.go b/proto/reputation/service.pb.go index c0134926..9b71d816 100644 --- a/proto/reputation/service.pb.go +++ b/proto/reputation/service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/reputation/service.proto @@ -641,7 +641,7 @@ func file_proto_reputation_service_proto_rawDescGZIP() []byte { } var file_proto_reputation_service_proto_msgTypes = make([]protoimpl.MessageInfo, 8) -var file_proto_reputation_service_proto_goTypes = []interface{}{ +var file_proto_reputation_service_proto_goTypes = []any{ (*AnnounceLocalTrustRequest)(nil), // 0: neo.fs.v2.reputation.AnnounceLocalTrustRequest (*AnnounceLocalTrustResponse)(nil), // 1: neo.fs.v2.reputation.AnnounceLocalTrustResponse (*AnnounceIntermediateResultRequest)(nil), // 2: neo.fs.v2.reputation.AnnounceIntermediateResultRequest @@ -690,7 +690,7 @@ func file_proto_reputation_service_proto_init() { } file_proto_reputation_types_proto_init() if !protoimpl.UnsafeEnabled { - file_proto_reputation_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_service_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*AnnounceLocalTrustRequest); i { case 0: return &v.state @@ -702,7 +702,7 @@ func file_proto_reputation_service_proto_init() { return nil } } - file_proto_reputation_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_service_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*AnnounceLocalTrustResponse); i { case 0: return &v.state @@ -714,7 +714,7 @@ func file_proto_reputation_service_proto_init() { return nil } } - file_proto_reputation_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_service_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*AnnounceIntermediateResultRequest); i { case 0: return &v.state @@ -726,7 +726,7 @@ func file_proto_reputation_service_proto_init() { return nil } } - file_proto_reputation_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_service_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*AnnounceIntermediateResultResponse); i { case 0: return &v.state @@ -738,7 +738,7 @@ func file_proto_reputation_service_proto_init() { return nil } } - file_proto_reputation_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_service_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*AnnounceLocalTrustRequest_Body); i { case 0: return &v.state @@ -750,7 +750,7 @@ func file_proto_reputation_service_proto_init() { return nil } } - file_proto_reputation_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_service_proto_msgTypes[5].Exporter = func(v any, i int) any { switch v := v.(*AnnounceLocalTrustResponse_Body); i { case 0: return &v.state @@ -762,7 +762,7 @@ func file_proto_reputation_service_proto_init() { return nil } } - file_proto_reputation_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_service_proto_msgTypes[6].Exporter = func(v any, i int) any { switch v := v.(*AnnounceIntermediateResultRequest_Body); i { case 0: return &v.state @@ -774,7 +774,7 @@ func file_proto_reputation_service_proto_init() { return nil } } - file_proto_reputation_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_service_proto_msgTypes[7].Exporter = func(v any, i int) any { switch v := v.(*AnnounceIntermediateResultResponse_Body); i { case 0: return &v.state diff --git a/proto/reputation/types.pb.go b/proto/reputation/types.pb.go index b77c4aeb..dd270c37 100644 --- a/proto/reputation/types.pb.go +++ b/proto/reputation/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/reputation/types.proto @@ -387,7 +387,7 @@ func file_proto_reputation_types_proto_rawDescGZIP() []byte { } var file_proto_reputation_types_proto_msgTypes = make([]protoimpl.MessageInfo, 5) -var file_proto_reputation_types_proto_goTypes = []interface{}{ +var file_proto_reputation_types_proto_goTypes = []any{ (*PeerID)(nil), // 0: neo.fs.v2.reputation.PeerID (*Trust)(nil), // 1: neo.fs.v2.reputation.Trust (*PeerToPeerTrust)(nil), // 2: neo.fs.v2.reputation.PeerToPeerTrust @@ -418,7 +418,7 @@ func file_proto_reputation_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_reputation_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*PeerID); i { case 0: return &v.state @@ -430,7 +430,7 @@ func file_proto_reputation_types_proto_init() { return nil } } - file_proto_reputation_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_types_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*Trust); i { case 0: return &v.state @@ -442,7 +442,7 @@ func file_proto_reputation_types_proto_init() { return nil } } - file_proto_reputation_types_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_types_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*PeerToPeerTrust); i { case 0: return &v.state @@ -454,7 +454,7 @@ func file_proto_reputation_types_proto_init() { return nil } } - file_proto_reputation_types_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_types_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*GlobalTrust); i { case 0: return &v.state @@ -466,7 +466,7 @@ func file_proto_reputation_types_proto_init() { return nil } } - file_proto_reputation_types_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_reputation_types_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*GlobalTrust_Body); i { case 0: return &v.state diff --git a/proto/session/service.pb.go b/proto/session/service.pb.go index 1d1c8dcf..a2ab56f0 100644 --- a/proto/session/service.pb.go +++ b/proto/session/service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/session/service.proto @@ -352,7 +352,7 @@ func file_proto_session_service_proto_rawDescGZIP() []byte { } var file_proto_session_service_proto_msgTypes = make([]protoimpl.MessageInfo, 4) -var file_proto_session_service_proto_goTypes = []interface{}{ +var file_proto_session_service_proto_goTypes = []any{ (*CreateRequest)(nil), // 0: neo.fs.v2.session.CreateRequest (*CreateResponse)(nil), // 1: neo.fs.v2.session.CreateResponse (*CreateRequest_Body)(nil), // 2: neo.fs.v2.session.CreateRequest.Body @@ -387,7 +387,7 @@ func file_proto_session_service_proto_init() { } file_proto_session_types_proto_init() if !protoimpl.UnsafeEnabled { - file_proto_session_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_service_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*CreateRequest); i { case 0: return &v.state @@ -399,7 +399,7 @@ func file_proto_session_service_proto_init() { return nil } } - file_proto_session_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_service_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*CreateResponse); i { case 0: return &v.state @@ -411,7 +411,7 @@ func file_proto_session_service_proto_init() { return nil } } - file_proto_session_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_service_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*CreateRequest_Body); i { case 0: return &v.state @@ -423,7 +423,7 @@ func file_proto_session_service_proto_init() { return nil } } - file_proto_session_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_service_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*CreateResponse_Body); i { case 0: return &v.state diff --git a/proto/session/types.pb.go b/proto/session/types.pb.go index 09d72423..dc45c64b 100644 --- a/proto/session/types.pb.go +++ b/proto/session/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/session/types.proto @@ -1033,10 +1033,10 @@ var File_proto_session_types_proto protoreflect.FileDescriptor var file_proto_session_types_proto_rawDesc = []byte{ 0x0a, 0x19, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x6e, 0x65, 0x6f, - 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x16, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x72, 0x65, 0x66, 0x73, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x15, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x61, 0x63, - 0x6c, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x70, + 0x2e, 0x66, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x15, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x61, 0x63, 0x6c, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x16, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x72, 0x65, 0x66, + 0x73, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x85, 0x03, 0x0a, 0x14, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, @@ -1219,7 +1219,7 @@ func file_proto_session_types_proto_rawDescGZIP() []byte { var file_proto_session_types_proto_enumTypes = make([]protoimpl.EnumInfo, 2) var file_proto_session_types_proto_msgTypes = make([]protoimpl.MessageInfo, 11) -var file_proto_session_types_proto_goTypes = []interface{}{ +var file_proto_session_types_proto_goTypes = []any{ (ObjectSessionContext_Verb)(0), // 0: neo.fs.v2.session.ObjectSessionContext.Verb (ContainerSessionContext_Verb)(0), // 1: neo.fs.v2.session.ContainerSessionContext.Verb (*ObjectSessionContext)(nil), // 2: neo.fs.v2.session.ObjectSessionContext @@ -1284,7 +1284,7 @@ func file_proto_session_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_session_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*ObjectSessionContext); i { case 0: return &v.state @@ -1296,7 +1296,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*ContainerSessionContext); i { case 0: return &v.state @@ -1308,7 +1308,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[2].Exporter = func(v any, i int) any { switch v := v.(*SessionToken); i { case 0: return &v.state @@ -1320,7 +1320,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[3].Exporter = func(v any, i int) any { switch v := v.(*XHeader); i { case 0: return &v.state @@ -1332,7 +1332,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[4].Exporter = func(v any, i int) any { switch v := v.(*RequestMetaHeader); i { case 0: return &v.state @@ -1344,7 +1344,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[5].Exporter = func(v any, i int) any { switch v := v.(*ResponseMetaHeader); i { case 0: return &v.state @@ -1356,7 +1356,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[6].Exporter = func(v any, i int) any { switch v := v.(*RequestVerificationHeader); i { case 0: return &v.state @@ -1368,7 +1368,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[7].Exporter = func(v any, i int) any { switch v := v.(*ResponseVerificationHeader); i { case 0: return &v.state @@ -1380,7 +1380,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[8].Exporter = func(v any, i int) any { switch v := v.(*ObjectSessionContext_Target); i { case 0: return &v.state @@ -1392,7 +1392,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[9].Exporter = func(v any, i int) any { switch v := v.(*SessionToken_Body); i { case 0: return &v.state @@ -1404,7 +1404,7 @@ func file_proto_session_types_proto_init() { return nil } } - file_proto_session_types_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + file_proto_session_types_proto_msgTypes[10].Exporter = func(v any, i int) any { switch v := v.(*SessionToken_Body_TokenLifetime); i { case 0: return &v.state @@ -1417,7 +1417,7 @@ func file_proto_session_types_proto_init() { } } } - file_proto_session_types_proto_msgTypes[9].OneofWrappers = []interface{}{ + file_proto_session_types_proto_msgTypes[9].OneofWrappers = []any{ (*SessionToken_Body_Object)(nil), (*SessionToken_Body_Container)(nil), } diff --git a/proto/status/types.pb.go b/proto/status/types.pb.go index 45bb84ee..67aa5d14 100644 --- a/proto/status/types.pb.go +++ b/proto/status/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/status/types.proto @@ -581,7 +581,7 @@ func file_proto_status_types_proto_rawDescGZIP() []byte { var file_proto_status_types_proto_enumTypes = make([]protoimpl.EnumInfo, 6) var file_proto_status_types_proto_msgTypes = make([]protoimpl.MessageInfo, 2) -var file_proto_status_types_proto_goTypes = []interface{}{ +var file_proto_status_types_proto_goTypes = []any{ (Section)(0), // 0: neo.fs.v2.status.Section (Success)(0), // 1: neo.fs.v2.status.Success (CommonFail)(0), // 2: neo.fs.v2.status.CommonFail @@ -606,7 +606,7 @@ func file_proto_status_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_status_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_status_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*Status); i { case 0: return &v.state @@ -618,7 +618,7 @@ func file_proto_status_types_proto_init() { return nil } } - file_proto_status_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_proto_status_types_proto_msgTypes[1].Exporter = func(v any, i int) any { switch v := v.(*Status_Detail); i { case 0: return &v.state diff --git a/proto/storagegroup/types.pb.go b/proto/storagegroup/types.pb.go index 8f4e3cfb..2307da06 100644 --- a/proto/storagegroup/types.pb.go +++ b/proto/storagegroup/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/storagegroup/types.proto @@ -155,7 +155,7 @@ func file_proto_storagegroup_types_proto_rawDescGZIP() []byte { } var file_proto_storagegroup_types_proto_msgTypes = make([]protoimpl.MessageInfo, 1) -var file_proto_storagegroup_types_proto_goTypes = []interface{}{ +var file_proto_storagegroup_types_proto_goTypes = []any{ (*StorageGroup)(nil), // 0: neo.fs.v2.storagegroup.StorageGroup (*refs.Checksum)(nil), // 1: neo.fs.v2.refs.Checksum (*refs.ObjectID)(nil), // 2: neo.fs.v2.refs.ObjectID @@ -176,7 +176,7 @@ func file_proto_storagegroup_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_storagegroup_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_storagegroup_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*StorageGroup); i { case 0: return &v.state diff --git a/proto/subnet/types.pb.go b/proto/subnet/types.pb.go index 8e3a1825..a7596a1c 100644 --- a/proto/subnet/types.pb.go +++ b/proto/subnet/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/subnet/types.proto @@ -117,7 +117,7 @@ func file_proto_subnet_types_proto_rawDescGZIP() []byte { } var file_proto_subnet_types_proto_msgTypes = make([]protoimpl.MessageInfo, 1) -var file_proto_subnet_types_proto_goTypes = []interface{}{ +var file_proto_subnet_types_proto_goTypes = []any{ (*SubnetInfo)(nil), // 0: neo.fs.v2.subnet.SubnetInfo (*refs.SubnetID)(nil), // 1: neo.fs.v2.refs.SubnetID (*refs.OwnerID)(nil), // 2: neo.fs.v2.refs.OwnerID @@ -138,7 +138,7 @@ func file_proto_subnet_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_subnet_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_subnet_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*SubnetInfo); i { case 0: return &v.state diff --git a/proto/tombstone/types.pb.go b/proto/tombstone/types.pb.go index 72bc3a47..83856c95 100644 --- a/proto/tombstone/types.pb.go +++ b/proto/tombstone/types.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.33.0 +// protoc-gen-go v1.34.2 // protoc v4.25.1 // source: proto/tombstone/types.proto @@ -139,7 +139,7 @@ func file_proto_tombstone_types_proto_rawDescGZIP() []byte { } var file_proto_tombstone_types_proto_msgTypes = make([]protoimpl.MessageInfo, 1) -var file_proto_tombstone_types_proto_goTypes = []interface{}{ +var file_proto_tombstone_types_proto_goTypes = []any{ (*Tombstone)(nil), // 0: neo.fs.v2.tombstone.Tombstone (*refs.ObjectID)(nil), // 1: neo.fs.v2.refs.ObjectID } @@ -158,7 +158,7 @@ func file_proto_tombstone_types_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_proto_tombstone_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_proto_tombstone_types_proto_msgTypes[0].Exporter = func(v any, i int) any { switch v := v.(*Tombstone); i { case 0: return &v.state diff --git a/stat/stat.go b/stat/stat.go index aa9df980..238fb66c 100644 --- a/stat/stat.go +++ b/stat/stat.go @@ -38,6 +38,7 @@ const ( MethodObjectRangeStream MethodObjectSearchStream MethodObjectPutStream + MethodObjectSearchV2 // MethodLast is no a valid method name, it's a system anchor for tests, etc. MethodLast ) @@ -95,6 +96,8 @@ func (m Method) String() string { return "objectSearchStream" case MethodObjectPutStream: return "objectPutStream" + case MethodObjectSearchV2: + return "objectSearchV2" case MethodLast: return "it's a system name rather than a method" default: