Add SaveBinlogPaths grpc in dataservice (#5277)

* Add SaveBinlogPaths grpc in dataservice

* fix merged compile error

Signed-off-by: Congqi Xia <congqi.xia@zilliz.com>

configs/milvus.yaml

@@ -21,6 +21,8 @@ etcd:
   kvSubPath: kv # kvRootPath = rootPath + '/' + kvSubPath
   segFlushMetaSubPath: datanode/segment # Full Path = rootPath/metaSubPath/segFlushMetaSubPath
   ddlFlushMetaSubPath: datanode/ddl     # Full Path = rootPath/metaSubPath/ddlFlushMetaSubPath
+  segmentBinlogSubPath: dataservice/binlog/segment  # Full Path = rootPath/metaSubPath/segmentBinlogSubPath
+  collectionBinlogSubPath: dataservice/binlog/collection # Full Path = rootPath/metaSubPath/collectionBinglogSubPath
   flushStreamPosSubPath: dataservice/flushstream # Full path = rootPath/metaSubPath/flushStreamPosSubPath
   statsStreamPosSubPath: dataservice/statsstream # Full path = rootPath/metaSubPath/statsStreamPosSubPath
 

internal/dataservice/binlog_helper.go

@@ -0,0 +1,188 @@
+package dataservice
+
+import (
+	"errors"
+	"path"
+	"strconv"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/milvus-io/milvus/internal/proto/datapb"
+)
+
+// binlog helper functions persisting binlog paths into kv storage.
+// migrated from datanode[Author XuanYang-cn]
+// ddl binlog etcd meta key:
+//   ${prefix}/${collectionID}/${idx}
+// segment binlog etcd meta key:
+//   ${prefix}/${segmentID}/${fieldID}/${idx}
+
+// genKey gives a valid key string for lists of UniqueIDs:
+//  if alloc is true, the returned keys will have a generated-unique ID at the end.
+//  if alloc is false, the returned keys will only consist of provided ids.
+func (s *Server) genKey(alloc bool, ids ...UniqueID) (key string, err error) {
+	if alloc {
+		idx, err := s.allocator.allocID()
+		if err != nil {
+			return "", err
+		}
+		ids = append(ids, idx)
+	}
+
+	idStr := make([]string, len(ids))
+	for _, id := range ids {
+		idStr = append(idStr, strconv.FormatInt(id, 10))
+	}
+
+	key = path.Join(idStr...)
+	return key, nil
+}
+
+var (
+	errNilKvClient = errors.New("kv client not initialized")
+)
+
+//SaveBinLogMetaTxn saves segment-field2Path, collection-tsPath/ddlPath into kv store in transcation
+func (s *Server) SaveBinLogMetaTxn(meta map[string]string) error {
+	if s.kvClient == nil {
+		return errNilKvClient
+	}
+	return s.kvClient.MultiSave(meta)
+}
+
+var (
+	errNilID2Paths             = errors.New("nil ID2PathList")
+	errCollectionTsDdlNotMatch = errors.New("collection ts/ddl path not matched")
+)
+
+// prepareField2PathMeta parses fields2Paths ID2PathList
+//		into key-value for kv store
+func (s *Server) prepareField2PathMeta(segID UniqueID, field2Paths *datapb.ID2PathList) (result map[string]string, err error) {
+	if field2Paths == nil {
+		return nil, errNilID2Paths
+	}
+	result = make(map[string]string, len(field2Paths.GetPaths()))
+	fieldID := field2Paths.GetID()
+	var key string
+	for _, p := range field2Paths.GetPaths() {
+		key, err = s.genKey(true, segID, fieldID)
+		if err != nil {
+			return nil, err
+		}
+		binlogPath := proto.MarshalTextString(&datapb.SegmentFieldBinlogMeta{
+			FieldID:    fieldID,
+			BinlogPath: p,
+		})
+
+		result[path.Join(Params.SegmentBinlogSubPath, key)] = binlogPath
+	}
+	return result, err
+}
+
+// prepareDDLBinlogMeta parses Coll2DdlBinlogPaths & Coll2TsBinlogPaths
+//		into key-value for kv store
+func (s *Server) prepareDDLBinlogMeta(collID UniqueID, tsPaths, ddlPaths *datapb.ID2PathList) (result map[string]string, err error) {
+	if tsPaths == nil || ddlPaths == nil {
+		return nil, errNilID2Paths
+	}
+
+	// tsPaths.ID & ddlPaths.ID ignored for now, datanode will change flowgraph filter in the future
+	// stores all provided paths now
+	// if tsPaths.ID != collID || ddlPaths.ID != collID {
+	// 	return nil, collectionIDNotMatchErr
+	// }
+
+	if len(tsPaths.GetPaths()) != len(ddlPaths.GetPaths()) {
+		return nil, errCollectionTsDdlNotMatch
+	}
+
+	result = make(map[string]string, len(tsPaths.GetPaths()))
+
+	for idx, tsPath := range tsPaths.GetPaths() {
+		// in range checked
+		ddlPath := ddlPaths.GetPaths()[idx]
+
+		uniqueKey, err := s.genKey(true, collID)
+		if err != nil {
+			return nil, err
+		}
+		binlogPathPair := proto.MarshalTextString(&datapb.DDLBinlogMeta{
+			DdlBinlogPath: ddlPath,
+			TsBinlogPath:  tsPath,
+		})
+
+		result[path.Join(Params.CollectionBinlogSubPath, uniqueKey)] = binlogPathPair
+	}
+	return result, nil
+}
+
+// getFieldBinlogMeta querys field binlog meta from kv store
+func (s *Server) getFieldBinlogMeta(segmentID UniqueID,
+	fieldID UniqueID) (metas []*datapb.SegmentFieldBinlogMeta, err error) {
+
+	prefix, err := s.genKey(false, segmentID, fieldID)
+	if err != nil {
+		return nil, err
+	}
+
+	_, vs, err := s.kvClient.LoadWithPrefix(path.Join(Params.SegmentBinlogSubPath, prefix))
+	if err != nil {
+		return nil, err
+	}
+
+	for _, blob := range vs {
+		m := &datapb.SegmentFieldBinlogMeta{}
+		if err = proto.UnmarshalText(blob, m); err != nil {
+			return nil, err
+		}
+
+		metas = append(metas, m)
+	}
+
+	return
+}
+
+// getSegmentBinlogMeta querys segment bin log meta from kv store
+func (s *Server) getSegmentBinlogMeta(segmentID UniqueID) (metas []*datapb.SegmentFieldBinlogMeta, err error) {
+
+	prefix, err := s.genKey(false, segmentID)
+	if err != nil {
+		return nil, err
+	}
+
+	_, vs, err := s.kvClient.LoadWithPrefix(path.Join(Params.SegmentBinlogSubPath, prefix))
+	if err != nil {
+		return nil, err
+	}
+
+	for _, blob := range vs {
+		m := &datapb.SegmentFieldBinlogMeta{}
+		if err = proto.UnmarshalText(blob, m); err != nil {
+			return nil, err
+		}
+
+		metas = append(metas, m)
+	}
+	return
+}
+
+func (s *Server) getDDLBinlogMeta(collID UniqueID) (metas []*datapb.DDLBinlogMeta, err error) {
+	prefix, err := s.genKey(false, collID)
+	if err != nil {
+		return nil, err
+	}
+
+	_, vs, err := s.kvClient.LoadWithPrefix(path.Join(Params.CollectionBinlogSubPath, prefix))
+	if err != nil {
+		return nil, err
+	}
+
+	for _, blob := range vs {
+		m := &datapb.DDLBinlogMeta{}
+		if err = proto.UnmarshalText(blob, m); err != nil {
+			return nil, err
+		}
+
+		metas = append(metas, m)
+	}
+	return
+}

internal/dataservice/param.go

@@ -25,9 +25,14 @@ type ParamTable struct {
 
 	NodeID int64
 
-	EtcdAddress   string
-	MetaRootPath  string
-	KvRootPath    string
+	// --- ETCD ---
+	EtcdAddress             string
+	MetaRootPath            string
+	KvRootPath              string
+	SegmentBinlogSubPath    string
+	CollectionBinlogSubPath string
+
+	// --- Pulsar ---
 	PulsarAddress string
 
 	FlushStreamPosSubPath string
@@ -70,6 +75,9 @@ func (p *ParamTable) Init() {
 		p.initEtcdAddress()
 		p.initMetaRootPath()
 		p.initKvRootPath()
+		p.initSegmentBinlogSubPath()
+		p.initCollectionBinlogSubPath()
+
 		p.initPulsarAddress()
 
 		p.initSegmentSize()
@@ -135,6 +143,23 @@ func (p *ParamTable) initKvRootPath() {
 	}
 	p.KvRootPath = rootPath + "/" + subPath
 }
+
+func (p *ParamTable) initSegmentBinlogSubPath() {
+	subPath, err := p.Load("etcd.segmentBinlogSubPath")
+	if err != nil {
+		panic(err)
+	}
+	p.SegmentBinlogSubPath = subPath
+}
+
+func (p *ParamTable) initCollectionBinlogSubPath() {
+	subPath, err := p.Load("etcd.collectionBinlogSubPath")
+	if err != nil {
+		panic(err)
+	}
+	p.CollectionBinlogSubPath = subPath
+}
+
 func (p *ParamTable) initSegmentSize() {
 	p.SegmentSize = p.ParseFloat("dataservice.segment.size")
 }

internal/dataservice/server.go

@@ -8,6 +8,7 @@
 // Unless required by applicable law or agreed to in writing, software distributed under the License
 // is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 // or implied. See the License for the specific language governing permissions and limitations under the License.
+
 package dataservice
 
 import (
@@ -883,3 +884,57 @@ func (s *Server) GetSegmentInfo(ctx context.Context, req *datapb.GetSegmentInfoR
 	resp.Infos = infos
 	return resp, nil
 }
+
+// SaveBinlogPaths implement DataServiceServer
+func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error) {
+	resp := &commonpb.Status{
+		ErrorCode: commonpb.ErrorCode_UnexpectedError,
+	}
+	if !s.checkStateIsHealthy() {
+		resp.Reason = "server is initializing"
+		return resp, nil
+	}
+
+	// check segment id & collection id matched
+	_, err := s.meta.GetCollection(req.GetCollectionID())
+	if err != nil {
+		log.Error("Failed to get collection info", zap.Int64("collectionID", req.GetCollectionID()), zap.Error(err))
+		resp.Reason = err.Error()
+		return resp, err
+	}
+
+	segInfo, err := s.meta.GetSegment(req.GetSegmentID())
+	if err != nil {
+		log.Error("Failed to get segment info", zap.Int64("segmentID", req.GetSegmentID()), zap.Error(err))
+		resp.Reason = err.Error()
+		return resp, err
+	}
+	log.Debug("segment", zap.Int64("segment", segInfo.CollectionID))
+
+	meta := make(map[string]string)
+	fieldMeta, err := s.prepareField2PathMeta(req.SegmentID, req.Field2BinlogPaths)
+	if err != nil {
+		resp.Reason = err.Error()
+		return resp, err
+	}
+	for k, v := range fieldMeta {
+		meta[k] = v
+	}
+	ddlMeta, err := s.prepareDDLBinlogMeta(req.CollectionID,
+		req.GetColl2TsBinlogPaths(), req.GetColl2DdlBinlogPaths())
+	if err != nil {
+		resp.Reason = err.Error()
+		return resp, err
+	}
+	for k, v := range ddlMeta {
+		meta[k] = v
+	}
+	err = s.SaveBinLogMetaTxn(meta)
+	if err != nil {
+		resp.Reason = err.Error()
+		return resp, err
+	}
+
+	resp.ErrorCode = commonpb.ErrorCode_Success
+	return resp, nil
+}

internal/dataservice/server_test.go

@@ -487,6 +487,117 @@ func TestChannel(t *testing.T) {
 	})
 }
 
+func TestSaveBinlogPaths(t *testing.T) {
+	svr := newTestServer(t)
+	defer closeTestServer(t, svr)
+
+	collections := []struct {
+		ID         UniqueID
+		Partitions []int64
+	}{
+		{0, []int64{0, 1}},
+		{1, []int64{0, 1}},
+	}
+
+	for _, collection := range collections {
+		err := svr.meta.AddCollection(&datapb.CollectionInfo{
+			ID:         collection.ID,
+			Schema:     nil,
+			Partitions: collection.Partitions,
+		})
+		assert.Nil(t, err)
+	}
+
+	segments := []struct {
+		id           UniqueID
+		collectionID UniqueID
+		partitionID  UniqueID
+	}{
+		{0, 0, 0},
+		{1, 0, 0},
+		{2, 0, 1},
+		{3, 1, 1},
+	}
+	for _, segment := range segments {
+		err := svr.meta.AddSegment(&datapb.SegmentInfo{
+			ID:           segment.id,
+			CollectionID: segment.collectionID,
+			PartitionID:  segment.partitionID,
+		})
+		assert.Nil(t, err)
+	}
+	t.Run("Normal SaveRequest", func(t *testing.T) {
+		ctx := context.Background()
+		resp, err := svr.SaveBinlogPaths(ctx, &datapb.SaveBinlogPathsRequest{
+			SegmentID:    2,
+			CollectionID: 0,
+			Field2BinlogPaths: &datapb.ID2PathList{
+				ID:    1,
+				Paths: []string{"/by-dev/test/0/1/2/1/Allo1", "/by-dev/test/0/1/2/1/Allo2"},
+			},
+			Coll2TsBinlogPaths: &datapb.ID2PathList{
+				ID:    0,
+				Paths: []string{"/by-dev/test/0/ts/Allo5", "/by-dev/test/0/ts/Allo8"},
+			},
+			Coll2DdlBinlogPaths: &datapb.ID2PathList{
+				ID:    0,
+				Paths: []string{"/by-dev/test/0/ddl/Allo7", "/by-dev/test/0/ddl/Allo9"},
+			},
+		})
+		assert.Nil(t, err)
+		assert.EqualValues(t, resp.ErrorCode, commonpb.ErrorCode_Success)
+
+		metas, err := svr.getFieldBinlogMeta(2, 1)
+		assert.Nil(t, err)
+		if assert.EqualValues(t, 2, len(metas)) {
+			assert.EqualValues(t, 1, metas[0].FieldID)
+			assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo1", metas[0].BinlogPath)
+			assert.EqualValues(t, 1, metas[1].FieldID)
+			assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo2", metas[1].BinlogPath)
+		}
+
+		metas, err = svr.getSegmentBinlogMeta(2)
+		assert.Nil(t, err)
+		if assert.EqualValues(t, 2, len(metas)) {
+			assert.EqualValues(t, 1, metas[0].FieldID)
+			assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo1", metas[0].BinlogPath)
+			assert.EqualValues(t, 1, metas[1].FieldID)
+			assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo2", metas[1].BinlogPath)
+		}
+
+		collMetas, err := svr.getDDLBinlogMeta(0)
+		assert.Nil(t, err)
+		if assert.EqualValues(t, 2, len(collMetas)) {
+			assert.EqualValues(t, "/by-dev/test/0/ts/Allo5", collMetas[0].TsBinlogPath)
+			assert.EqualValues(t, "/by-dev/test/0/ddl/Allo7", collMetas[0].DdlBinlogPath)
+			assert.EqualValues(t, "/by-dev/test/0/ts/Allo8", collMetas[1].TsBinlogPath)
+			assert.EqualValues(t, "/by-dev/test/0/ddl/Allo9", collMetas[1].DdlBinlogPath)
+		}
+
+	})
+	t.Run("Abnormal SaveRequest", func(t *testing.T) {
+		ctx := context.Background()
+		resp, err := svr.SaveBinlogPaths(ctx, &datapb.SaveBinlogPathsRequest{
+			SegmentID:    10,
+			CollectionID: 5,
+			Field2BinlogPaths: &datapb.ID2PathList{
+				ID:    1,
+				Paths: []string{"/by-dev/test/0/1/2/1/Allo1", "/by-dev/test/0/1/2/1/Allo2"},
+			},
+			Coll2TsBinlogPaths: &datapb.ID2PathList{
+				ID:    0,
+				Paths: []string{"/by-dev/test/0/ts/Allo5", "/by-dev/test/0/ts/Allo8"},
+			},
+			Coll2DdlBinlogPaths: &datapb.ID2PathList{
+				ID:    0,
+				Paths: []string{"/by-dev/test/0/ddl/Allo7", "/by-dev/test/0/ddl/Allo9"},
+			},
+		})
+		assert.NotNil(t, err)
+		assert.EqualValues(t, resp.ErrorCode, commonpb.ErrorCode_UnexpectedError)
+	})
+}
+
 func TestResumeChannel(t *testing.T) {
 	Params.Init()
 
@@ -655,7 +766,6 @@ func TestResumeChannel(t *testing.T) {
 			assert.Nil(t, err)
 		}
 	})
-
 }
 
 func newTestServer(t *testing.T) *Server {

internal/distributed/dataservice/service.go

@@ -262,3 +262,8 @@ func (s *Server) GetPartitionStatistics(ctx context.Context, req *datapb.GetPart
 func (s *Server) GetSegmentInfoChannel(ctx context.Context, req *datapb.GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error) {
 	return s.dataService.GetSegmentInfoChannel(ctx)
 }
+
+//SaveBinlogPaths implement DataServiceServer, saves segment, collection binlog according to datanode request
+func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error) {
+	return s.dataService.SaveBinlogPaths(ctx, req)
+}

internal/proto/data_service.proto

@@ -29,6 +29,8 @@ service DataService {
   rpc GetPartitionStatistics(GetPartitionStatisticsRequest) returns (GetPartitionStatisticsResponse) {}
 
   rpc GetSegmentInfoChannel(GetSegmentInfoChannelRequest) returns (milvus.StringResponse){}
+
+  rpc SaveBinlogPaths(SaveBinlogPathsRequest) returns (common.Status){}
 }
 
 service DataNode {
@@ -233,3 +235,19 @@ message SegmentInfo {
   internal.MsgPosition start_position = 11;
   internal.MsgPosition end_position = 12;
 }
+
+message ID2PathList {                                                                                            
+  int64 ID = 1;                                                                                                
+  repeated string Paths = 2;                                                                                   
+}                                                                                                                
+
+message SaveBinlogPathsRequest {                                                                                 
+  common.MsgBase base = 1; 
+  int64 segmentID = 2;
+  int64 collectionID = 3;
+  ID2PathList field2BinlogPaths = 4;
+  ID2PathList coll2TsBinlogPaths = 5; 
+  ID2PathList coll2DdlBinlogPaths = 6;  
+  repeated internal.MsgPosition start_positions = 7;  
+  repeated internal.MsgPosition end_positions = 8; 
+}

internal/proto/datapb/data_service.pb.go

@@ -1806,6 +1806,148 @@ func (m *SegmentInfo) GetEndPosition() *internalpb.MsgPosition {
 	return nil
 }
 
+type ID2PathList struct {
+	ID                   int64    `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	Paths                []string `protobuf:"bytes,2,rep,name=Paths,proto3" json:"Paths,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ID2PathList) Reset()         { *m = ID2PathList{} }
+func (m *ID2PathList) String() string { return proto.CompactTextString(m) }
+func (*ID2PathList) ProtoMessage()    {}
+func (*ID2PathList) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3385cd32ad6cfe64, []int{32}
+}
+
+func (m *ID2PathList) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ID2PathList.Unmarshal(m, b)
+}
+func (m *ID2PathList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ID2PathList.Marshal(b, m, deterministic)
+}
+func (m *ID2PathList) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ID2PathList.Merge(m, src)
+}
+func (m *ID2PathList) XXX_Size() int {
+	return xxx_messageInfo_ID2PathList.Size(m)
+}
+func (m *ID2PathList) XXX_DiscardUnknown() {
+	xxx_messageInfo_ID2PathList.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ID2PathList proto.InternalMessageInfo
+
+func (m *ID2PathList) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+func (m *ID2PathList) GetPaths() []string {
+	if m != nil {
+		return m.Paths
+	}
+	return nil
+}
+
+type SaveBinlogPathsRequest struct {
+	Base                 *commonpb.MsgBase         `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	SegmentID            int64                     `protobuf:"varint,2,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
+	CollectionID         int64                     `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
+	Field2BinlogPaths    *ID2PathList              `protobuf:"bytes,4,opt,name=field2BinlogPaths,proto3" json:"field2BinlogPaths,omitempty"`
+	Coll2TsBinlogPaths   *ID2PathList              `protobuf:"bytes,5,opt,name=coll2TsBinlogPaths,proto3" json:"coll2TsBinlogPaths,omitempty"`
+	Coll2DdlBinlogPaths  *ID2PathList              `protobuf:"bytes,6,opt,name=coll2DdlBinlogPaths,proto3" json:"coll2DdlBinlogPaths,omitempty"`
+	StartPositions       []*internalpb.MsgPosition `protobuf:"bytes,7,rep,name=start_positions,json=startPositions,proto3" json:"start_positions,omitempty"`
+	EndPositions         []*internalpb.MsgPosition `protobuf:"bytes,8,rep,name=end_positions,json=endPositions,proto3" json:"end_positions,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
+	XXX_unrecognized     []byte                    `json:"-"`
+	XXX_sizecache        int32                     `json:"-"`
+}
+
+func (m *SaveBinlogPathsRequest) Reset()         { *m = SaveBinlogPathsRequest{} }
+func (m *SaveBinlogPathsRequest) String() string { return proto.CompactTextString(m) }
+func (*SaveBinlogPathsRequest) ProtoMessage()    {}
+func (*SaveBinlogPathsRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3385cd32ad6cfe64, []int{33}
+}
+
+func (m *SaveBinlogPathsRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SaveBinlogPathsRequest.Unmarshal(m, b)
+}
+func (m *SaveBinlogPathsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SaveBinlogPathsRequest.Marshal(b, m, deterministic)
+}
+func (m *SaveBinlogPathsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SaveBinlogPathsRequest.Merge(m, src)
+}
+func (m *SaveBinlogPathsRequest) XXX_Size() int {
+	return xxx_messageInfo_SaveBinlogPathsRequest.Size(m)
+}
+func (m *SaveBinlogPathsRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_SaveBinlogPathsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SaveBinlogPathsRequest proto.InternalMessageInfo
+
+func (m *SaveBinlogPathsRequest) GetBase() *commonpb.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *SaveBinlogPathsRequest) GetSegmentID() int64 {
+	if m != nil {
+		return m.SegmentID
+	}
+	return 0
+}
+
+func (m *SaveBinlogPathsRequest) GetCollectionID() int64 {
+	if m != nil {
+		return m.CollectionID
+	}
+	return 0
+}
+
+func (m *SaveBinlogPathsRequest) GetField2BinlogPaths() *ID2PathList {
+	if m != nil {
+		return m.Field2BinlogPaths
+	}
+	return nil
+}
+
+func (m *SaveBinlogPathsRequest) GetColl2TsBinlogPaths() *ID2PathList {
+	if m != nil {
+		return m.Coll2TsBinlogPaths
+	}
+	return nil
+}
+
+func (m *SaveBinlogPathsRequest) GetColl2DdlBinlogPaths() *ID2PathList {
+	if m != nil {
+		return m.Coll2DdlBinlogPaths
+	}
+	return nil
+}
+
+func (m *SaveBinlogPathsRequest) GetStartPositions() []*internalpb.MsgPosition {
+	if m != nil {
+		return m.StartPositions
+	}
+	return nil
+}
+
+func (m *SaveBinlogPathsRequest) GetEndPositions() []*internalpb.MsgPosition {
+	if m != nil {
+		return m.EndPositions
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*RegisterNodeRequest)(nil), "milvus.proto.data.RegisterNodeRequest")
 	proto.RegisterType((*RegisterNodeResponse)(nil), "milvus.proto.data.RegisterNodeResponse")
@@ -1839,117 +1981,127 @@ func init() {
 	proto.RegisterType((*DDLFlushMeta)(nil), "milvus.proto.data.DDLFlushMeta")
 	proto.RegisterType((*CollectionInfo)(nil), "milvus.proto.data.CollectionInfo")
 	proto.RegisterType((*SegmentInfo)(nil), "milvus.proto.data.SegmentInfo")
+	proto.RegisterType((*ID2PathList)(nil), "milvus.proto.data.ID2PathList")
+	proto.RegisterType((*SaveBinlogPathsRequest)(nil), "milvus.proto.data.SaveBinlogPathsRequest")
 }
 
 func init() { proto.RegisterFile("data_service.proto", fileDescriptor_3385cd32ad6cfe64) }
 
 var fileDescriptor_3385cd32ad6cfe64 = []byte{
-	// 1667 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x5b, 0x6f, 0x1c, 0xc5,
-	0x12, 0xf6, 0x78, 0x7c, 0xad, 0x1d, 0x6f, 0x92, 0x8e, 0x8f, 0xb3, 0x67, 0x93, 0xf8, 0x32, 0x39,
-	0x49, 0x9c, 0x44, 0xc7, 0x4e, 0x9c, 0xa3, 0x03, 0x08, 0xf1, 0x10, 0x67, 0x89, 0xb5, 0x22, 0x8e,
-	0x4c, 0x3b, 0x10, 0x09, 0x84, 0x56, 0xe3, 0xdd, 0xf6, 0x6e, 0x93, 0x9d, 0x99, 0xcd, 0x74, 0x6f,
-	0x6e, 0x2f, 0x41, 0xc0, 0x13, 0x02, 0x22, 0x1e, 0x78, 0x07, 0x24, 0x24, 0x24, 0xfe, 0x1a, 0x3f,
-	0x02, 0xf5, 0x65, 0x2e, 0x3b, 0x33, 0x7b, 0xf1, 0x3a, 0xc1, 0x6f, 0xd3, 0x3d, 0x5f, 0x57, 0x55,
-	0x57, 0x57, 0x7d, 0x5d, 0xd5, 0x80, 0x1a, 0x0e, 0x77, 0x6a, 0x8c, 0x04, 0x4f, 0x69, 0x9d, 0x6c,
-	0x74, 0x02, 0x9f, 0xfb, 0xe8, 0x8c, 0x4b, 0xdb, 0x4f, 0xbb, 0x4c, 0x8d, 0x36, 0x04, 0xa0, 0x6c,
-	0xd5, 0x7d, 0xd7, 0xf5, 0x3d, 0x35, 0x55, 0x2e, 0x52, 0x8f, 0x93, 0xc0, 0x73, 0xda, 0x7a, 0x6c,
-	0x25, 0x17, 0x94, 0x2d, 0x56, 0x6f, 0x11, 0xd7, 0x51, 0x23, 0xfb, 0x15, 0x9c, 0xc5, 0xa4, 0x49,
-	0x19, 0x27, 0xc1, 0x03, 0xbf, 0x41, 0x30, 0x79, 0xd2, 0x25, 0x8c, 0xa3, 0x9b, 0x30, 0x75, 0xe0,
-	0x30, 0x52, 0x32, 0x56, 0x8d, 0xf5, 0xc2, 0xd6, 0x85, 0x8d, 0x1e, 0x95, 0x5a, 0xd9, 0x2e, 0x6b,
-	0x6e, 0x3b, 0x8c, 0x60, 0x89, 0x44, 0xff, 0x87, 0x59, 0xa7, 0xd1, 0x08, 0x08, 0x63, 0xa5, 0xc9,
-	0x01, 0x8b, 0xee, 0x28, 0x0c, 0x0e, 0xc1, 0xf6, 0x6b, 0x03, 0x16, 0x7b, 0x2d, 0x60, 0x1d, 0xdf,
-	0x63, 0x04, 0x6d, 0x43, 0x81, 0x7a, 0x94, 0xd7, 0x3a, 0x4e, 0xe0, 0xb8, 0x4c, 0x5b, 0xb2, 0xd6,
-	0x2b, 0x34, 0xda, 0x68, 0xd5, 0xa3, 0x7c, 0x4f, 0x02, 0x31, 0xd0, 0xe8, 0x1b, 0xdd, 0x86, 0x19,
-	0xc6, 0x1d, 0xde, 0x0d, 0x6d, 0x3a, 0x9f, 0x6b, 0xd3, 0xbe, 0x84, 0x60, 0x0d, 0xb5, 0x9f, 0x83,
-	0x75, 0xaf, 0xdd, 0x65, 0xad, 0xf1, 0x7d, 0x81, 0x60, 0xaa, 0x71, 0x50, 0xad, 0x48, 0xa5, 0x26,
-	0x96, 0xdf, 0xc8, 0x06, 0xab, 0xee, 0xb7, 0xdb, 0xa4, 0xce, 0xa9, 0xef, 0x55, 0x2b, 0xa5, 0x29,
-	0xf9, 0xaf, 0x67, 0xce, 0xfe, 0xc9, 0x80, 0xd3, 0xfb, 0xa4, 0xe9, 0x12, 0x8f, 0x57, 0x2b, 0xa1,
-	0xfa, 0x45, 0x98, 0xae, 0xfb, 0x5d, 0x8f, 0x4b, 0xfd, 0x0b, 0x58, 0x0d, 0xd0, 0x1a, 0x58, 0xf5,
-	0x96, 0xe3, 0x79, 0xa4, 0x5d, 0xf3, 0x1c, 0x97, 0x48, 0x55, 0xf3, 0xb8, 0xa0, 0xe7, 0x1e, 0x38,
-	0x2e, 0xc9, 0x68, 0x34, 0xb3, 0x1a, 0xd1, 0x2a, 0x14, 0x3a, 0x4e, 0xc0, 0x69, 0x8f, 0x51, 0xc9,
-	0x29, 0xfb, 0x17, 0x03, 0x96, 0xee, 0x30, 0x46, 0x9b, 0x5e, 0xc6, 0xb2, 0x25, 0x98, 0xf1, 0xfc,
-	0x06, 0xa9, 0x56, 0xa4, 0x69, 0x26, 0xd6, 0x23, 0x74, 0x1e, 0xe6, 0x3b, 0x84, 0x04, 0xb5, 0xc0,
-	0x6f, 0x87, 0x86, 0xcd, 0x89, 0x09, 0xec, 0xb7, 0x09, 0xfa, 0x18, 0xce, 0xb0, 0x94, 0x20, 0x56,
-	0x32, 0x57, 0xcd, 0xf5, 0xc2, 0xd6, 0xa5, 0x8d, 0x4c, 0x64, 0x6f, 0xa4, 0x95, 0xe2, 0xec, 0x6a,
-	0xfb, 0xab, 0x49, 0x38, 0x1b, 0xe1, 0x94, 0xad, 0xe2, 0x5b, 0x78, 0x8e, 0x91, 0x66, 0x64, 0x9e,
-	0x1a, 0x8c, 0xe2, 0xb9, 0xc8, 0xe5, 0x66, 0xd2, 0xe5, 0x23, 0x9c, 0x60, 0xda, 0x9f, 0xd3, 0x19,
-	0x7f, 0xa2, 0x15, 0x28, 0x90, 0xe7, 0x1d, 0x1a, 0x90, 0x1a, 0xa7, 0x2e, 0x29, 0xcd, 0xac, 0x1a,
-	0xeb, 0x53, 0x18, 0xd4, 0xd4, 0x43, 0xea, 0x92, 0x44, 0xcc, 0xce, 0x8e, 0x1e, 0xb3, 0xbf, 0x19,
-	0x70, 0x2e, 0x73, 0x4a, 0x3a, 0x91, 0x30, 0x9c, 0x96, 0x3b, 0x8f, 0x3d, 0x23, 0xb2, 0x49, 0x38,
-	0xfc, 0xca, 0x20, 0x87, 0xc7, 0x70, 0x9c, 0x59, 0x3f, 0x5e, 0x62, 0xfd, 0x6a, 0xc0, 0xd9, 0xfd,
-	0x96, 0xff, 0x4c, 0xab, 0x60, 0xe3, 0x27, 0x58, 0xfa, 0x28, 0x26, 0x87, 0x1f, 0x85, 0x99, 0x3d,
-	0x8a, 0x30, 0x4d, 0xa7, 0xe2, 0x34, 0xb5, 0x1f, 0xc3, 0x62, 0xaf, 0x89, 0xda, 0x89, 0xcb, 0x00,
-	0x51, 0xe0, 0x29, 0xf7, 0x99, 0x38, 0x31, 0x33, 0x9e, 0x43, 0x1e, 0xc3, 0xb9, 0x1d, 0xc2, 0xb5,
-	0x2e, 0xf1, 0x8f, 0x1c, 0xc3, 0x27, 0xbd, 0x16, 0x4e, 0xa6, 0x2d, 0xb4, 0x7f, 0x36, 0x23, 0x72,
-	0x91, 0xaa, 0xaa, 0xde, 0xa1, 0x8f, 0x2e, 0xc0, 0x7c, 0x04, 0xd1, 0x69, 0x12, 0x4f, 0xa0, 0x77,
-	0x60, 0x5a, 0x58, 0xaa, 0x72, 0xa4, 0x98, 0x26, 0xdf, 0x70, 0x4f, 0x09, 0x99, 0x58, 0xe1, 0x45,
-	0x90, 0xd7, 0x03, 0xe2, 0x70, 0x1d, 0xe4, 0xa6, 0x0a, 0x72, 0x35, 0x25, 0x83, 0x7c, 0x05, 0x0a,
-	0x8c, 0x38, 0x6d, 0xd2, 0x50, 0x80, 0x29, 0x05, 0x50, 0x53, 0x12, 0xb0, 0x06, 0xd6, 0xa1, 0x20,
-	0xe1, 0x10, 0x31, 0x2d, 0x11, 0x05, 0x3d, 0x27, 0x21, 0x55, 0x28, 0x32, 0xee, 0x04, 0xbc, 0xd6,
-	0xf1, 0x99, 0x3c, 0x52, 0x99, 0x4c, 0x85, 0x2d, 0xbb, 0xcf, 0x1d, 0xb1, 0xcb, 0x9a, 0x7b, 0x1a,
-	0x89, 0x17, 0xe4, 0xca, 0x70, 0x88, 0x3e, 0x04, 0x8b, 0x78, 0x8d, 0x58, 0xd0, 0xec, 0xc8, 0x82,
-	0x0a, 0xc4, 0x6b, 0x44, 0x62, 0xe2, 0x20, 0x98, 0x1b, 0x3d, 0x08, 0xbe, 0x37, 0xa0, 0x94, 0x8d,
-	0x02, 0x1d, 0x76, 0xb1, 0x44, 0x63, 0x64, 0x89, 0xe8, 0x7d, 0xb5, 0x88, 0xa8, 0x28, 0x18, 0xc8,
-	0xab, 0x51, 0x24, 0x60, 0xbd, 0xc4, 0xa6, 0xf0, 0xaf, 0xd8, 0x1a, 0xf9, 0xe7, 0xad, 0x45, 0xe4,
-	0x37, 0x06, 0x2c, 0xa5, 0x75, 0x1d, 0x67, 0xdf, 0xff, 0x83, 0x69, 0xea, 0x1d, 0xfa, 0xe1, 0xb6,
-	0x97, 0x07, 0xb0, 0x9b, 0xd0, 0xa5, 0xc0, 0xb6, 0x0b, 0xe7, 0x77, 0x08, 0xaf, 0x7a, 0x8c, 0x04,
-	0x7c, 0x9b, 0x7a, 0x6d, 0xbf, 0xb9, 0xe7, 0xf0, 0xd6, 0x31, 0x12, 0xb1, 0x27, 0xa7, 0x26, 0x53,
-	0x39, 0x65, 0xff, 0x61, 0xc0, 0x85, 0x7c, 0x7d, 0x7a, 0xeb, 0x65, 0x98, 0x3b, 0xa4, 0xa4, 0xdd,
-	0x88, 0x79, 0x26, 0x1a, 0x8b, 0x84, 0xec, 0x08, 0xb0, 0xde, 0x61, 0xbf, 0x6a, 0x68, 0x9f, 0x07,
-	0xd4, 0x6b, 0xde, 0xa7, 0x8c, 0x63, 0x85, 0x4f, 0xf8, 0xd3, 0x1c, 0x3d, 0x32, 0xbf, 0x55, 0x91,
-	0xa9, 0x4c, 0xbd, 0xab, 0xee, 0x47, 0xf6, 0x76, 0xab, 0xa2, 0x9c, 0x1a, 0xc5, 0xfe, 0xce, 0x80,
-	0xe5, 0x1d, 0xc2, 0xef, 0x46, 0x73, 0xc2, 0x4c, 0xca, 0x38, 0xad, 0x9f, 0x80, 0x31, 0xaf, 0x0d,
-	0x58, 0xe9, 0x6b, 0x8c, 0x3e, 0x41, 0x4d, 0x9b, 0xe1, 0x2d, 0x9b, 0x4f, 0x9b, 0x1f, 0x91, 0x17,
-	0x9f, 0x3a, 0xed, 0x2e, 0xd9, 0x73, 0x68, 0xa0, 0x68, 0x73, 0xcc, 0x4b, 0xe4, 0x4f, 0x03, 0x2e,
-	0xee, 0x10, 0x51, 0xf1, 0xaa, 0x8b, 0xed, 0x04, 0xbd, 0x33, 0x42, 0x39, 0xf9, 0xa3, 0x3a, 0xcc,
-	0x5c, 0x6b, 0x4f, 0xc4, 0x7d, 0xcb, 0x32, 0x1d, 0x13, 0xbc, 0xa0, 0x03, 0x5d, 0x3b, 0xcf, 0xf6,
-	0x61, 0xe9, 0x91, 0xc3, 0xeb, 0xad, 0x8a, 0x7b, 0xfc, 0x0c, 0xb8, 0x04, 0x0b, 0xc9, 0xd2, 0x53,
-	0xa5, 0xf1, 0x3c, 0xb6, 0x12, 0xb5, 0x27, 0x13, 0x05, 0xf7, 0xa2, 0xec, 0x3f, 0x8e, 0x5f, 0x26,
-	0x8d, 0x7b, 0x8c, 0xbd, 0xc4, 0x3d, 0x95, 0x21, 0xee, 0xe7, 0x00, 0xda, 0xb8, 0x5d, 0xd6, 0x1c,
-	0xc3, 0xae, 0x77, 0x61, 0x56, 0x4b, 0xd3, 0x27, 0x35, 0x8c, 0xaa, 0x43, 0xb8, 0xbd, 0x0f, 0x4b,
-	0x7a, 0xfe, 0x9e, 0xe0, 0x44, 0xc5, 0x9f, 0xbb, 0x84, 0x3b, 0xa8, 0x04, 0xb3, 0x9a, 0x26, 0x75,
-	0x1d, 0x13, 0x0e, 0x45, 0xad, 0x71, 0x20, 0x71, 0x35, 0xc1, 0x85, 0xba, 0xde, 0x87, 0x83, 0x88,
-	0x7a, 0xed, 0x2f, 0x60, 0xa1, 0x52, 0xb9, 0x9f, 0x90, 0x75, 0x05, 0x4e, 0x35, 0x1a, 0xed, 0x5a,
-	0x72, 0x95, 0x21, 0x57, 0x2d, 0x34, 0x1a, 0xed, 0x98, 0xb3, 0xd1, 0x7f, 0xa0, 0xc8, 0x59, 0x2d,
-	0x2b, 0xdc, 0xe2, 0x2c, 0x46, 0xd9, 0xbb, 0x50, 0x94, 0xc6, 0xca, 0x43, 0x1d, 0x62, 0xeb, 0x1a,
-	0x58, 0x09, 0x71, 0x61, 0x80, 0x14, 0x62, 0x63, 0x99, 0xa0, 0xc3, 0xb0, 0x8e, 0x8b, 0x25, 0x0e,
-	0xae, 0xe3, 0x2e, 0x02, 0x50, 0x56, 0xd3, 0xb5, 0x93, 0xb4, 0x71, 0x0e, 0xcf, 0x53, 0x76, 0x4f,
-	0x4d, 0xa0, 0xf7, 0x60, 0x46, 0xea, 0x67, 0xa5, 0xe9, 0xbc, 0x8c, 0x93, 0xa7, 0xd1, 0xbb, 0x03,
-	0xac, 0x17, 0xd8, 0x9f, 0x80, 0x55, 0xa9, 0xdc, 0x8f, 0xed, 0x48, 0x47, 0x97, 0x91, 0x13, 0x5d,
-	0x23, 0xec, 0xf1, 0x15, 0x14, 0x63, 0x86, 0x95, 0x85, 0x6a, 0x11, 0x26, 0x23, 0x71, 0x93, 0xd5,
-	0x0a, 0xfa, 0x00, 0x66, 0xd4, 0x3b, 0x86, 0x8e, 0xa0, 0xcb, 0xbd, 0x36, 0xeb, 0x37, 0x8e, 0x04,
-	0x4d, 0xcb, 0x09, 0xac, 0x17, 0x89, 0x08, 0x8f, 0x58, 0x49, 0xb5, 0x9f, 0x26, 0x4e, 0xcc, 0xd8,
-	0x7f, 0x99, 0x50, 0x48, 0x04, 0x60, 0x46, 0xfd, 0x9b, 0x69, 0x40, 0x2e, 0x43, 0x91, 0xca, 0xcb,
-	0xb5, 0xa6, 0x19, 0x40, 0x32, 0xe6, 0x3c, 0x5e, 0xa0, 0xc9, 0x2b, 0x57, 0xf4, 0xd3, 0x7e, 0x87,
-	0x78, 0xc9, 0x42, 0x78, 0x4e, 0x4c, 0xe4, 0x55, 0xd2, 0x33, 0x43, 0x2b, 0xe9, 0xd9, 0x6c, 0x25,
-	0xfd, 0x6f, 0x98, 0xf3, 0xba, 0x6e, 0x2d, 0xf0, 0x9f, 0xa9, 0xca, 0xd5, 0xc4, 0xb3, 0x5e, 0xd7,
-	0xc5, 0xfe, 0x33, 0x26, 0x7e, 0xb9, 0xc4, 0xad, 0x31, 0xfa, 0x92, 0x94, 0xe6, 0xd5, 0x2f, 0x97,
-	0xb8, 0xfb, 0xf4, 0x25, 0x89, 0xbb, 0x03, 0x38, 0x62, 0x77, 0x90, 0x2d, 0xdc, 0x0b, 0x6f, 0xaa,
-	0x70, 0xb7, 0xc6, 0x2a, 0xdc, 0xb7, 0x7e, 0xb0, 0xa0, 0x50, 0x71, 0xb8, 0xb3, 0xaf, 0x1e, 0xda,
-	0x50, 0x07, 0x90, 0xbc, 0xe4, 0xdd, 0x8e, 0xef, 0x45, 0x45, 0x39, 0xba, 0xd9, 0x47, 0x6c, 0x16,
-	0xaa, 0x29, 0xbb, 0x7c, 0xa5, 0xcf, 0x8a, 0x14, 0xdc, 0x9e, 0x40, 0xae, 0xd4, 0x28, 0x4e, 0xe3,
-	0x21, 0xad, 0x3f, 0x0e, 0x4f, 0x7e, 0x80, 0xc6, 0x14, 0x34, 0xd4, 0x98, 0xaa, 0xf5, 0xf5, 0x40,
-	0x15, 0x84, 0xe1, 0x0d, 0x6b, 0x4f, 0xa0, 0x27, 0xb0, 0x28, 0x6e, 0xbd, 0xe8, 0xf2, 0x0d, 0x15,
-	0x6e, 0xf5, 0x57, 0x98, 0x01, 0x1f, 0x51, 0xa5, 0x03, 0x56, 0xf2, 0x9d, 0x0f, 0xe5, 0x3d, 0x3e,
-	0xe4, 0x3c, 0x45, 0x96, 0xaf, 0x0e, 0xc5, 0x45, 0x2a, 0x76, 0x60, 0x5a, 0x52, 0x11, 0x5a, 0xc9,
-	0x63, 0xb0, 0xc4, 0x9b, 0x5e, 0x79, 0x50, 0x69, 0x60, 0x4f, 0xa0, 0x2f, 0xe1, 0x54, 0xea, 0x35,
-	0x05, 0x5d, 0xcb, 0x11, 0x99, 0xff, 0x2e, 0x56, 0xbe, 0x3e, 0x0a, 0x34, 0xe9, 0x97, 0xe4, 0x8b,
-	0x43, 0xae, 0x5f, 0x72, 0x5e, 0x4d, 0x72, 0xfd, 0x92, 0xf7, 0x74, 0x61, 0x4f, 0xa0, 0x26, 0x14,
-	0x7b, 0x6b, 0x1c, 0xb4, 0x9e, 0xb3, 0x38, 0xb7, 0xed, 0x2b, 0x5f, 0x1b, 0x01, 0x19, 0x29, 0x72,
-	0xe1, 0x74, 0xba, 0x95, 0x45, 0xd7, 0x07, 0x0a, 0xe8, 0xcd, 0x97, 0x1b, 0x23, 0x61, 0x23, 0x75,
-	0x2f, 0x64, 0x14, 0x67, 0x5a, 0x29, 0xb4, 0x91, 0x2f, 0xa6, 0x5f, 0x8f, 0x57, 0xde, 0x1c, 0x19,
-	0x1f, 0xa9, 0x26, 0x70, 0x26, 0xd3, 0x1a, 0xa1, 0x1b, 0x83, 0xe4, 0xa4, 0xca, 0xc7, 0xf2, 0xf0,
-	0xe6, 0xcd, 0x9e, 0x40, 0x5f, 0x1b, 0xf2, 0x89, 0x28, 0xaf, 0xdd, 0x40, 0xb7, 0xf2, 0xb5, 0x0d,
-	0xe8, 0x93, 0xca, 0x5b, 0x47, 0x59, 0x12, 0xed, 0xf5, 0x95, 0x6c, 0xd3, 0x73, 0x4a, 0xf6, 0x34,
-	0x3f, 0x85, 0xf2, 0xfa, 0xf7, 0x22, 0xe5, 0x5b, 0x47, 0x58, 0x11, 0x19, 0xe0, 0xa7, 0xdf, 0x24,
-	0x42, 0xba, 0xda, 0x1c, 0x1a, 0x9c, 0x63, 0x71, 0xd5, 0xd6, 0xef, 0x26, 0xcc, 0x89, 0xfb, 0x40,
-	0x12, 0xd5, 0x3f, 0x7f, 0x19, 0x9c, 0x00, 0x3b, 0x7f, 0x0e, 0xa7, 0x52, 0x6d, 0x4e, 0x2e, 0xe3,
-	0xe5, 0xb7, 0x42, 0xc3, 0xe8, 0xf4, 0x11, 0x2c, 0xf4, 0x74, 0x34, 0xe8, 0x6a, 0x3f, 0x7e, 0x4e,
-	0x93, 0xdc, 0x60, 0xc1, 0xdb, 0xb7, 0x3f, 0xbb, 0xd5, 0xa4, 0xbc, 0xd5, 0x3d, 0x10, 0x7f, 0x36,
-	0x15, 0xf4, 0xbf, 0xd4, 0xd7, 0x5f, 0x9b, 0xa1, 0x83, 0x36, 0xe5, 0xea, 0x4d, 0xa1, 0xa6, 0x73,
-	0x70, 0x30, 0x23, 0x47, 0xb7, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x57, 0xed, 0x03, 0x9a, 0x5c,
-	0x1b, 0x00, 0x00,
+	// 1794 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xeb, 0x6f, 0xdb, 0xc8,
+	0x11, 0x37, 0x2d, 0xc9, 0xb2, 0x47, 0x94, 0x1c, 0xaf, 0x5d, 0x47, 0x55, 0x12, 0x3f, 0x98, 0x26,
+	0x71, 0x12, 0xd4, 0x4e, 0xe4, 0xa2, 0x0f, 0x14, 0xfd, 0x10, 0x47, 0x8d, 0x21, 0xc4, 0x0e, 0x5c,
+	0x2a, 0x6d, 0x80, 0x06, 0x85, 0x40, 0x4b, 0x6b, 0x79, 0x1b, 0x91, 0x54, 0xb8, 0x54, 0x5e, 0x5f,
+	0x52, 0xb4, 0xfd, 0x54, 0x14, 0x17, 0xdc, 0x01, 0xf7, 0xfd, 0xee, 0x80, 0x03, 0x0e, 0xb8, 0xff,
+	0xec, 0x70, 0x7f, 0xc4, 0x61, 0x1f, 0x7c, 0x53, 0x12, 0x2d, 0x27, 0xe7, 0x6f, 0xdc, 0xe5, 0xbc,
+	0x76, 0x76, 0xe6, 0xb7, 0x33, 0x03, 0xa8, 0x6b, 0xb8, 0x46, 0x9b, 0x62, 0xe7, 0x15, 0xe9, 0xe0,
+	0xed, 0x81, 0x63, 0xbb, 0x36, 0x5a, 0x32, 0x49, 0xff, 0xd5, 0x90, 0x8a, 0xd5, 0x36, 0x23, 0xa8,
+	0xa9, 0x1d, 0xdb, 0x34, 0x6d, 0x4b, 0x6c, 0xd5, 0x2a, 0xc4, 0x72, 0xb1, 0x63, 0x19, 0x7d, 0xb9,
+	0x56, 0xc3, 0x0c, 0x35, 0x95, 0x76, 0x4e, 0xb1, 0x69, 0x88, 0x95, 0xf6, 0x1e, 0x96, 0x75, 0xdc,
+	0x23, 0xd4, 0xc5, 0xce, 0x13, 0xbb, 0x8b, 0x75, 0xfc, 0x72, 0x88, 0xa9, 0x8b, 0xee, 0x41, 0xfe,
+	0xd8, 0xa0, 0xb8, 0xaa, 0x6c, 0x28, 0x5b, 0xa5, 0xfa, 0xd5, 0xed, 0x88, 0x4a, 0xa9, 0xec, 0x90,
+	0xf6, 0xf6, 0x0c, 0x8a, 0x75, 0x4e, 0x89, 0x7e, 0x0b, 0x45, 0xa3, 0xdb, 0x75, 0x30, 0xa5, 0xd5,
+	0xd9, 0x31, 0x4c, 0x0f, 0x04, 0x8d, 0xee, 0x11, 0x6b, 0x1f, 0x14, 0x58, 0x89, 0x5a, 0x40, 0x07,
+	0xb6, 0x45, 0x31, 0xda, 0x83, 0x12, 0xb1, 0x88, 0xdb, 0x1e, 0x18, 0x8e, 0x61, 0x52, 0x69, 0xc9,
+	0x66, 0x54, 0xa8, 0x7f, 0xd0, 0xa6, 0x45, 0xdc, 0x23, 0x4e, 0xa8, 0x03, 0xf1, 0xbf, 0xd1, 0x2e,
+	0xcc, 0x51, 0xd7, 0x70, 0x87, 0x9e, 0x4d, 0x57, 0x52, 0x6d, 0x6a, 0x71, 0x12, 0x5d, 0x92, 0x6a,
+	0x6f, 0x40, 0x7d, 0xd4, 0x1f, 0xd2, 0xd3, 0xe9, 0x7d, 0x81, 0x20, 0xdf, 0x3d, 0x6e, 0x36, 0xb8,
+	0xd2, 0x9c, 0xce, 0xbf, 0x91, 0x06, 0x6a, 0xc7, 0xee, 0xf7, 0x71, 0xc7, 0x25, 0xb6, 0xd5, 0x6c,
+	0x54, 0xf3, 0xfc, 0x5f, 0x64, 0x4f, 0xfb, 0x5c, 0x81, 0x4b, 0x2d, 0xdc, 0x33, 0xb1, 0xe5, 0x36,
+	0x1b, 0x9e, 0xfa, 0x15, 0x28, 0x74, 0xec, 0xa1, 0xe5, 0x72, 0xfd, 0x65, 0x5d, 0x2c, 0xd0, 0x26,
+	0xa8, 0x9d, 0x53, 0xc3, 0xb2, 0x70, 0xbf, 0x6d, 0x19, 0x26, 0xe6, 0xaa, 0x16, 0xf4, 0x92, 0xdc,
+	0x7b, 0x62, 0x98, 0x38, 0xa1, 0x31, 0x97, 0xd4, 0x88, 0x36, 0xa0, 0x34, 0x30, 0x1c, 0x97, 0x44,
+	0x8c, 0x0a, 0x6f, 0x69, 0x5f, 0x29, 0xb0, 0xfa, 0x80, 0x52, 0xd2, 0xb3, 0x12, 0x96, 0xad, 0xc2,
+	0x9c, 0x65, 0x77, 0x71, 0xb3, 0xc1, 0x4d, 0xcb, 0xe9, 0x72, 0x85, 0xae, 0xc0, 0xc2, 0x00, 0x63,
+	0xa7, 0xed, 0xd8, 0x7d, 0xcf, 0xb0, 0x79, 0xb6, 0xa1, 0xdb, 0x7d, 0x8c, 0xfe, 0x02, 0x4b, 0x34,
+	0x26, 0x88, 0x56, 0x73, 0x1b, 0xb9, 0xad, 0x52, 0xfd, 0xfa, 0x76, 0x22, 0xb2, 0xb7, 0xe3, 0x4a,
+	0xf5, 0x24, 0xb7, 0xf6, 0xaf, 0x59, 0x58, 0xf6, 0xe9, 0x84, 0xad, 0xec, 0x9b, 0x79, 0x8e, 0xe2,
+	0x9e, 0x6f, 0x9e, 0x58, 0x64, 0xf1, 0x9c, 0xef, 0xf2, 0x5c, 0xd8, 0xe5, 0x19, 0x6e, 0x30, 0xee,
+	0xcf, 0x42, 0xc2, 0x9f, 0x68, 0x1d, 0x4a, 0xf8, 0xcd, 0x80, 0x38, 0xb8, 0xed, 0x12, 0x13, 0x57,
+	0xe7, 0x36, 0x94, 0xad, 0xbc, 0x0e, 0x62, 0xeb, 0x29, 0x31, 0x71, 0x28, 0x66, 0x8b, 0xd9, 0x63,
+	0xf6, 0x1b, 0x05, 0x2e, 0x27, 0x6e, 0x49, 0x26, 0x92, 0x0e, 0x97, 0xf8, 0xc9, 0x03, 0xcf, 0xb0,
+	0x6c, 0x62, 0x0e, 0xbf, 0x39, 0xce, 0xe1, 0x01, 0xb9, 0x9e, 0xe0, 0x9f, 0x2e, 0xb1, 0xbe, 0x56,
+	0x60, 0xb9, 0x75, 0x6a, 0xbf, 0x96, 0x2a, 0xe8, 0xf4, 0x09, 0x16, 0xbf, 0x8a, 0xd9, 0xc9, 0x57,
+	0x91, 0x4b, 0x5e, 0x85, 0x97, 0xa6, 0xf9, 0x20, 0x4d, 0xb5, 0x17, 0xb0, 0x12, 0x35, 0x51, 0x3a,
+	0x71, 0x0d, 0xc0, 0x0f, 0x3c, 0xe1, 0xbe, 0x9c, 0x1e, 0xda, 0x99, 0xce, 0x21, 0x2f, 0xe0, 0xf2,
+	0x3e, 0x76, 0xa5, 0x2e, 0xf6, 0x0f, 0x9f, 0xc3, 0x27, 0x51, 0x0b, 0x67, 0xe3, 0x16, 0x6a, 0x5f,
+	0xe6, 0x7c, 0x70, 0xe1, 0xaa, 0x9a, 0xd6, 0x89, 0x8d, 0xae, 0xc2, 0x82, 0x4f, 0x22, 0xd3, 0x24,
+	0xd8, 0x40, 0xbf, 0x83, 0x02, 0xb3, 0x54, 0xe4, 0x48, 0x25, 0x0e, 0xbe, 0xde, 0x99, 0x42, 0x32,
+	0x75, 0x41, 0xcf, 0x82, 0xbc, 0xe3, 0x60, 0xc3, 0x95, 0x41, 0x9e, 0x13, 0x41, 0x2e, 0xb6, 0x78,
+	0x90, 0xaf, 0x43, 0x89, 0x62, 0xa3, 0x8f, 0xbb, 0x82, 0x20, 0x2f, 0x08, 0xc4, 0x16, 0x27, 0xd8,
+	0x04, 0xf5, 0x84, 0x81, 0xb0, 0x47, 0x51, 0xe0, 0x14, 0x25, 0xb9, 0xc7, 0x49, 0x9a, 0x50, 0xa1,
+	0xae, 0xe1, 0xb8, 0xed, 0x81, 0x4d, 0xf9, 0x95, 0xf2, 0x64, 0x2a, 0xd5, 0xb5, 0x11, 0x6f, 0xc4,
+	0x21, 0xed, 0x1d, 0x49, 0x4a, 0xbd, 0xcc, 0x39, 0xbd, 0x25, 0xfa, 0x33, 0xa8, 0xd8, 0xea, 0x06,
+	0x82, 0x8a, 0x99, 0x05, 0x95, 0xb0, 0xd5, 0xf5, 0xc5, 0x04, 0x41, 0x30, 0x9f, 0x3d, 0x08, 0xfe,
+	0xaf, 0x40, 0x35, 0x19, 0x05, 0x32, 0xec, 0x02, 0x89, 0x4a, 0x66, 0x89, 0xe8, 0x8f, 0x82, 0x09,
+	0x8b, 0x28, 0x18, 0x8b, 0xab, 0x7e, 0x24, 0xe8, 0x92, 0x45, 0x23, 0xf0, 0x8b, 0xc0, 0x1a, 0xfe,
+	0xe7, 0x93, 0x45, 0xe4, 0x7f, 0x14, 0x58, 0x8d, 0xeb, 0x3a, 0xcf, 0xb9, 0x7f, 0x03, 0x05, 0x62,
+	0x9d, 0xd8, 0xde, 0xb1, 0xd7, 0xc6, 0xa0, 0x1b, 0xd3, 0x25, 0x88, 0x35, 0x13, 0xae, 0xec, 0x63,
+	0xb7, 0x69, 0x51, 0xec, 0xb8, 0x7b, 0xc4, 0xea, 0xdb, 0xbd, 0x23, 0xc3, 0x3d, 0x3d, 0x47, 0x22,
+	0x46, 0x72, 0x6a, 0x36, 0x96, 0x53, 0xda, 0x77, 0x0a, 0x5c, 0x4d, 0xd7, 0x27, 0x8f, 0x5e, 0x83,
+	0xf9, 0x13, 0x82, 0xfb, 0xdd, 0x00, 0x67, 0xfc, 0x35, 0x4b, 0xc8, 0x01, 0x23, 0x96, 0x27, 0x1c,
+	0x55, 0x0d, 0xb5, 0x5c, 0x87, 0x58, 0xbd, 0x03, 0x42, 0x5d, 0x5d, 0xd0, 0x87, 0xfc, 0x99, 0xcb,
+	0x1e, 0x99, 0xff, 0x15, 0x91, 0x29, 0x4c, 0x7d, 0x28, 0xde, 0x47, 0xfa, 0x69, 0xab, 0xa2, 0x94,
+	0x1a, 0x45, 0xfb, 0x9f, 0x02, 0x6b, 0xfb, 0xd8, 0x7d, 0xe8, 0xef, 0x31, 0x33, 0x09, 0x75, 0x49,
+	0xe7, 0x02, 0x8c, 0xf9, 0xa0, 0xc0, 0xfa, 0x48, 0x63, 0xe4, 0x0d, 0x4a, 0xd8, 0xf4, 0x5e, 0xd9,
+	0x74, 0xd8, 0x7c, 0x8c, 0xdf, 0xfe, 0xcd, 0xe8, 0x0f, 0xf1, 0x91, 0x41, 0x1c, 0x01, 0x9b, 0x53,
+	0x3e, 0x22, 0xdf, 0x2b, 0x70, 0x6d, 0x1f, 0xb3, 0x8a, 0x57, 0x3c, 0x6c, 0x17, 0xe8, 0x9d, 0x0c,
+	0xe5, 0xe4, 0x67, 0xe2, 0x32, 0x53, 0xad, 0xbd, 0x10, 0xf7, 0xad, 0xf1, 0x74, 0x0c, 0xe1, 0x82,
+	0x0c, 0x74, 0xe9, 0x3c, 0xcd, 0x86, 0xd5, 0x67, 0x86, 0xdb, 0x39, 0x6d, 0x98, 0xe7, 0xcf, 0x80,
+	0xeb, 0x50, 0x0e, 0x97, 0x9e, 0x22, 0x8d, 0x17, 0x74, 0x35, 0x54, 0x7b, 0x52, 0x56, 0x70, 0xaf,
+	0xf0, 0xfe, 0xe3, 0xfc, 0x65, 0xd2, 0xb4, 0xd7, 0x18, 0x05, 0xee, 0x7c, 0x02, 0xb8, 0xdf, 0x00,
+	0x48, 0xe3, 0x0e, 0x69, 0x6f, 0x0a, 0xbb, 0x7e, 0x0f, 0x45, 0x29, 0x4d, 0xde, 0xd4, 0x24, 0xa8,
+	0xf6, 0xc8, 0xb5, 0x16, 0xac, 0xca, 0xfd, 0x47, 0x0c, 0x13, 0x05, 0x7e, 0x1e, 0x62, 0xd7, 0x40,
+	0x55, 0x28, 0x4a, 0x98, 0x94, 0x75, 0x8c, 0xb7, 0x64, 0xb5, 0xc6, 0x31, 0xa7, 0x6b, 0x33, 0x2c,
+	0x94, 0xf5, 0x3e, 0x1c, 0xfb, 0xd0, 0xab, 0xfd, 0x03, 0xca, 0x8d, 0xc6, 0x41, 0x48, 0xd6, 0x4d,
+	0x58, 0xec, 0x76, 0xfb, 0xed, 0x30, 0x97, 0xc2, 0xb9, 0xca, 0xdd, 0x6e, 0x3f, 0xc0, 0x6c, 0xf4,
+	0x2b, 0xa8, 0xb8, 0xb4, 0x9d, 0x14, 0xae, 0xba, 0x34, 0xa0, 0xd2, 0x0e, 0xa1, 0xc2, 0x8d, 0xe5,
+	0x97, 0x3a, 0xc1, 0xd6, 0x4d, 0x50, 0x43, 0xe2, 0xbc, 0x00, 0x29, 0x05, 0xc6, 0x52, 0x06, 0x87,
+	0x5e, 0x1d, 0x17, 0x48, 0x1c, 0x5f, 0xc7, 0x5d, 0x03, 0x20, 0xb4, 0x2d, 0x6b, 0x27, 0x6e, 0xe3,
+	0xbc, 0xbe, 0x40, 0xe8, 0x23, 0xb1, 0x81, 0xfe, 0x00, 0x73, 0x5c, 0x3f, 0xad, 0x16, 0xd2, 0x32,
+	0x8e, 0xdf, 0x46, 0xf4, 0x04, 0xba, 0x64, 0xd0, 0xfe, 0x0a, 0x6a, 0xa3, 0x71, 0x10, 0xd8, 0x11,
+	0x8f, 0x2e, 0x25, 0x25, 0xba, 0x32, 0x9c, 0xf1, 0x3d, 0x54, 0x02, 0x84, 0xe5, 0x85, 0x6a, 0x05,
+	0x66, 0x7d, 0x71, 0xb3, 0xcd, 0x06, 0xfa, 0x13, 0xcc, 0x89, 0x39, 0x86, 0x8c, 0xa0, 0x1b, 0x51,
+	0x9b, 0xe5, 0x8c, 0x23, 0x04, 0xd3, 0x7c, 0x43, 0x97, 0x4c, 0x2c, 0xc2, 0x7d, 0x54, 0x12, 0xed,
+	0x67, 0x4e, 0x0f, 0xed, 0x68, 0x3f, 0xe6, 0xa0, 0x14, 0x0a, 0xc0, 0x84, 0xfa, 0x8f, 0xd3, 0x80,
+	0xdc, 0x80, 0x0a, 0xe1, 0x8f, 0x6b, 0x5b, 0x22, 0x00, 0x47, 0xcc, 0x05, 0xbd, 0x4c, 0xc2, 0x4f,
+	0x2e, 0xeb, 0xa7, 0xed, 0x01, 0xb6, 0xc2, 0x85, 0xf0, 0x3c, 0xdb, 0x48, 0xab, 0xa4, 0xe7, 0x26,
+	0x56, 0xd2, 0xc5, 0x64, 0x25, 0xfd, 0x4b, 0x98, 0xb7, 0x86, 0x66, 0xdb, 0xb1, 0x5f, 0x8b, 0xca,
+	0x35, 0xa7, 0x17, 0xad, 0xa1, 0xa9, 0xdb, 0xaf, 0x29, 0xfb, 0x65, 0x62, 0xb3, 0x4d, 0xc9, 0x3b,
+	0x5c, 0x5d, 0x10, 0xbf, 0x4c, 0x6c, 0xb6, 0xc8, 0x3b, 0x1c, 0x74, 0x07, 0x70, 0xc6, 0xee, 0x20,
+	0x59, 0xb8, 0x97, 0x3e, 0x56, 0xe1, 0xae, 0x4e, 0x55, 0xb8, 0x6b, 0xbb, 0x50, 0x6a, 0x36, 0xea,
+	0x2c, 0xf6, 0x58, 0xd1, 0x94, 0xb8, 0xed, 0x15, 0x28, 0x1c, 0x85, 0x42, 0x55, 0x2c, 0xb4, 0x2f,
+	0xf2, 0xb0, 0xda, 0x32, 0x5e, 0xe1, 0x4f, 0x5f, 0x34, 0x66, 0x02, 0xed, 0x03, 0x58, 0xe2, 0x49,
+	0x59, 0x0f, 0xd9, 0xc3, 0xe3, 0x29, 0x1d, 0x5e, 0x43, 0xe7, 0xd5, 0x93, 0x8c, 0xe8, 0x09, 0x20,
+	0x26, 0xbd, 0xfe, 0x94, 0x86, 0xc5, 0x15, 0x32, 0x89, 0x4b, 0xe1, 0x44, 0x47, 0xb0, 0xcc, 0x77,
+	0x1b, 0x61, 0x00, 0xa5, 0xb2, 0x63, 0x9b, 0x24, 0x30, 0x8d, 0x15, 0x3d, 0x86, 0xc5, 0x68, 0x14,
+	0xd1, 0x6a, 0x91, 0xc3, 0x57, 0x96, 0xdb, 0xaf, 0x44, 0xc2, 0x88, 0xa2, 0x7d, 0x28, 0x87, 0xe3,
+	0x88, 0xa5, 0x41, 0x56, 0x51, 0x6a, 0x28, 0x90, 0x68, 0xfd, 0x07, 0x15, 0x4a, 0x0d, 0xc3, 0x35,
+	0x5a, 0x62, 0x64, 0x8b, 0x06, 0x80, 0x78, 0xb9, 0x68, 0x0e, 0x6c, 0xcb, 0x6f, 0xef, 0xd0, 0xbd,
+	0x11, 0x72, 0x93, 0xa4, 0x32, 0xa2, 0x6a, 0x37, 0x47, 0x70, 0xc4, 0xc8, 0xb5, 0x19, 0x64, 0x72,
+	0x8d, 0x2c, 0xaf, 0x9f, 0x92, 0xce, 0x0b, 0x0f, 0x43, 0xc6, 0x68, 0x8c, 0x91, 0x7a, 0x1a, 0x63,
+	0x5d, 0xa3, 0x5c, 0x88, 0xd6, 0xc2, 0xab, 0xd5, 0xb4, 0x19, 0xf4, 0x12, 0x56, 0x58, 0xfd, 0xe4,
+	0x97, 0x71, 0x9e, 0xc2, 0xfa, 0x68, 0x85, 0x09, 0xe2, 0x33, 0xaa, 0x34, 0x40, 0x0d, 0x4f, 0x8c,
+	0x51, 0xda, 0x18, 0x2b, 0x65, 0xa8, 0x5d, 0xbb, 0x35, 0x91, 0xce, 0x57, 0xb1, 0x0f, 0x05, 0xfe,
+	0xa8, 0xa1, 0xf5, 0xb4, 0xb7, 0x30, 0x34, 0x1d, 0xae, 0x8d, 0x2b, 0x32, 0xb5, 0x19, 0xf4, 0x4f,
+	0x58, 0x8c, 0xcd, 0xe5, 0xd0, 0xed, 0x14, 0x91, 0xe9, 0x13, 0xd6, 0xda, 0x9d, 0x2c, 0xa4, 0x61,
+	0xbf, 0x84, 0x67, 0x57, 0xa9, 0x7e, 0x49, 0x99, 0xbf, 0xa5, 0xfa, 0x25, 0x6d, 0x08, 0xa6, 0xcd,
+	0xa0, 0x1e, 0x54, 0xa2, 0xd5, 0x32, 0xda, 0x4a, 0x61, 0x4e, 0x1d, 0x20, 0xd4, 0x6e, 0x67, 0xa0,
+	0xf4, 0x15, 0x99, 0x70, 0x29, 0x3e, 0x14, 0x41, 0x77, 0xc6, 0x0a, 0x88, 0xe6, 0xcb, 0xdd, 0x4c,
+	0xb4, 0xbe, 0xba, 0xb7, 0x3c, 0x8a, 0x13, 0x4d, 0x39, 0xda, 0x4e, 0x17, 0x33, 0x6a, 0x5a, 0x50,
+	0xdb, 0xc9, 0x4c, 0xef, 0xab, 0xc6, 0xb0, 0x94, 0x68, 0xb2, 0xd1, 0xdd, 0x71, 0x72, 0x62, 0x8d,
+	0x48, 0x6d, 0xf2, 0x18, 0x40, 0x9b, 0x41, 0xff, 0x56, 0xf8, 0xb0, 0x31, 0xad, 0x71, 0x45, 0xf7,
+	0xd3, 0xb5, 0x8d, 0xe9, 0xb8, 0x6b, 0xf5, 0xb3, 0xb0, 0xf8, 0x67, 0x7d, 0xcf, 0x07, 0x3e, 0x29,
+	0xcd, 0x5f, 0x1c, 0x9f, 0x3c, 0x79, 0xa3, 0xbb, 0xda, 0xda, 0xfd, 0x33, 0x70, 0xf8, 0x06, 0xd8,
+	0xf1, 0xe9, 0x96, 0x07, 0x57, 0x3b, 0x13, 0x83, 0x73, 0x3a, 0xac, 0x7a, 0x0e, 0x8b, 0xb1, 0x1a,
+	0x21, 0x35, 0xff, 0xd3, 0xeb, 0x88, 0x09, 0xe0, 0x52, 0xff, 0x36, 0x07, 0xf3, 0xec, 0xb1, 0xe1,
+	0x28, 0xf8, 0xf3, 0xbf, 0x34, 0x17, 0x00, 0xfd, 0xcf, 0x61, 0x31, 0xd6, 0x8d, 0xa7, 0xba, 0x33,
+	0xbd, 0x63, 0x9f, 0x84, 0xd5, 0xcf, 0xa0, 0x1c, 0x69, 0xbc, 0xd1, 0xad, 0x51, 0xe0, 0x1f, 0x47,
+	0xd0, 0xf1, 0x82, 0xf7, 0x76, 0xff, 0x7e, 0xbf, 0x47, 0xdc, 0xd3, 0xe1, 0x31, 0xfb, 0xb3, 0x23,
+	0x48, 0x7f, 0x4d, 0x6c, 0xf9, 0xb5, 0xe3, 0x39, 0x68, 0x87, 0x73, 0xef, 0x30, 0x35, 0x83, 0xe3,
+	0xe3, 0x39, 0xbe, 0xda, 0xfd, 0x29, 0x00, 0x00, 0xff, 0xff, 0x24, 0xe1, 0x51, 0x20, 0x03, 0x1e,
+	0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1978,6 +2130,7 @@ type DataServiceClient interface {
 	GetCollectionStatistics(ctx context.Context, in *GetCollectionStatisticsRequest, opts ...grpc.CallOption) (*GetCollectionStatisticsResponse, error)
 	GetPartitionStatistics(ctx context.Context, in *GetPartitionStatisticsRequest, opts ...grpc.CallOption) (*GetPartitionStatisticsResponse, error)
 	GetSegmentInfoChannel(ctx context.Context, in *GetSegmentInfoChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
+	SaveBinlogPaths(ctx context.Context, in *SaveBinlogPathsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 }
 
 type dataServiceClient struct {
@@ -2114,6 +2267,15 @@ func (c *dataServiceClient) GetSegmentInfoChannel(ctx context.Context, in *GetSe
 	return out, nil
 }
 
+func (c *dataServiceClient) SaveBinlogPaths(ctx context.Context, in *SaveBinlogPathsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/SaveBinlogPaths", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // DataServiceServer is the server API for DataService service.
 type DataServiceServer interface {
 	GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
@@ -2130,6 +2292,7 @@ type DataServiceServer interface {
 	GetCollectionStatistics(context.Context, *GetCollectionStatisticsRequest) (*GetCollectionStatisticsResponse, error)
 	GetPartitionStatistics(context.Context, *GetPartitionStatisticsRequest) (*GetPartitionStatisticsResponse, error)
 	GetSegmentInfoChannel(context.Context, *GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error)
+	SaveBinlogPaths(context.Context, *SaveBinlogPathsRequest) (*commonpb.Status, error)
 }
 
 // UnimplementedDataServiceServer can be embedded to have forward compatible implementations.
@@ -2178,6 +2341,9 @@ func (*UnimplementedDataServiceServer) GetPartitionStatistics(ctx context.Contex
 func (*UnimplementedDataServiceServer) GetSegmentInfoChannel(ctx context.Context, req *GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetSegmentInfoChannel not implemented")
 }
+func (*UnimplementedDataServiceServer) SaveBinlogPaths(ctx context.Context, req *SaveBinlogPathsRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method SaveBinlogPaths not implemented")
+}
 
 func RegisterDataServiceServer(s *grpc.Server, srv DataServiceServer) {
 	s.RegisterService(&_DataService_serviceDesc, srv)
@@ -2435,6 +2601,24 @@ func _DataService_GetSegmentInfoChannel_Handler(srv interface{}, ctx context.Con
 	return interceptor(ctx, in, info, handler)
 }
 
+func _DataService_SaveBinlogPaths_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SaveBinlogPathsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DataServiceServer).SaveBinlogPaths(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.data.DataService/SaveBinlogPaths",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DataServiceServer).SaveBinlogPaths(ctx, req.(*SaveBinlogPathsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _DataService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "milvus.proto.data.DataService",
 	HandlerType: (*DataServiceServer)(nil),
@@ -2495,6 +2679,10 @@ var _DataService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetSegmentInfoChannel",
 			Handler:    _DataService_GetSegmentInfoChannel_Handler,
 		},
+		{
+			MethodName: "SaveBinlogPaths",
+			Handler:    _DataService_SaveBinlogPaths_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "data_service.proto",