Implement set segment state call from RootCoord to DataCoord. (#16374)

/kind feature

issue: #15604
Signed-off-by: Yuchen Gao <yuchen.gao@zilliz.com>

internal/datacoord/server.go

@@ -93,8 +93,8 @@ var _ types.DataCoord = (*Server)(nil)
 
 var Params paramtable.ComponentParam
 
-// Server implements `types.Datacoord`
-// handles Data Cooridinator related jobs
+// Server implements `types.DataCoord`
+// handles Data Coordinator related jobs
 type Server struct {
 	ctx              context.Context
 	serverLoopCtx    context.Context

internal/datacoord/server_test.go

@@ -31,6 +31,7 @@ import (
 	"time"
 
 	"github.com/milvus-io/milvus/internal/common"
+	"github.com/milvus-io/milvus/internal/kv"
 	"github.com/milvus-io/milvus/internal/log"
 	"github.com/milvus-io/milvus/internal/mq/msgstream"
 	"github.com/milvus-io/milvus/internal/proto/commonpb"
@@ -2261,6 +2262,116 @@ func TestGetFlushState(t *testing.T) {
 	})
 }
 
+type mockTxnKVext struct {
+	kv.MockTxnKV
+}
+
+func (m *mockTxnKVext) LoadWithPrefix(prefix string) ([]string, []string, error) {
+	return []string{}, []string{}, nil
+}
+
+func (m *mockTxnKVext) MultiSave(kvs map[string]string) error {
+	return errors.New("(testing only) injected error")
+}
+
+func TestDataCoordServer_SetSegmentState(t *testing.T) {
+	t.Run("normal case", func(t *testing.T) {
+		svr := newTestServer(t, nil)
+		defer closeTestServer(t, svr)
+		segment := &datapb.SegmentInfo{
+			ID:            1000,
+			CollectionID:  100,
+			PartitionID:   0,
+			InsertChannel: "c1",
+			NumOfRows:     0,
+			State:         commonpb.SegmentState_Growing,
+			StartPosition: &internalpb.MsgPosition{
+				ChannelName: "c1",
+				MsgID:       []byte{},
+				MsgGroup:    "",
+				Timestamp:   0,
+			},
+		}
+		err := svr.meta.AddSegment(NewSegmentInfo(segment))
+		assert.Nil(t, err)
+		// Set segment state.
+		svr.SetSegmentState(context.TODO(), &datapb.SetSegmentStateRequest{
+			SegmentId: 1000,
+			NewState:  commonpb.SegmentState_Flushed,
+		})
+		// Verify that the state has been updated.
+		resp, err := svr.GetSegmentStates(context.TODO(), &datapb.GetSegmentStatesRequest{
+			Base: &commonpb.MsgBase{
+				MsgType:   0,
+				MsgID:     0,
+				Timestamp: 0,
+				SourceID:  0,
+			},
+			SegmentIDs: []int64{1000},
+		})
+		assert.Nil(t, err)
+		assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+		assert.EqualValues(t, 1, len(resp.States))
+		assert.EqualValues(t, commonpb.SegmentState_Flushed, resp.States[0].State)
+	})
+
+	t.Run("dataCoord meta set state error", func(t *testing.T) {
+		svr := newTestServer(t, nil)
+		svr.meta.Lock()
+		func() {
+			defer svr.meta.Unlock()
+			svr.meta, _ = newMeta(&mockTxnKVext{})
+		}()
+		defer closeTestServer(t, svr)
+		segment := &datapb.SegmentInfo{
+			ID:            1000,
+			CollectionID:  100,
+			PartitionID:   0,
+			InsertChannel: "c1",
+			NumOfRows:     0,
+			State:         commonpb.SegmentState_Growing,
+			StartPosition: &internalpb.MsgPosition{
+				ChannelName: "c1",
+				MsgID:       []byte{},
+				MsgGroup:    "",
+				Timestamp:   0,
+			},
+		}
+		svr.meta.AddSegment(NewSegmentInfo(segment))
+		// Set segment state.
+		svr.SetSegmentState(context.TODO(), &datapb.SetSegmentStateRequest{
+			SegmentId: 1000,
+			NewState:  commonpb.SegmentState_Flushed,
+		})
+		// Verify that the state has been updated.
+		resp, err := svr.GetSegmentStates(context.TODO(), &datapb.GetSegmentStatesRequest{
+			Base: &commonpb.MsgBase{
+				MsgType:   0,
+				MsgID:     0,
+				Timestamp: 0,
+				SourceID:  0,
+			},
+			SegmentIDs: []int64{1000},
+		})
+		assert.Nil(t, err)
+		assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+		assert.EqualValues(t, 1, len(resp.States))
+		assert.EqualValues(t, commonpb.SegmentState_Flushed, resp.States[0].State)
+	})
+
+	t.Run("with closed server", func(t *testing.T) {
+		svr := newTestServer(t, nil)
+		closeTestServer(t, svr)
+		resp, err := svr.SetSegmentState(context.TODO(), &datapb.SetSegmentStateRequest{
+			SegmentId: 1000,
+			NewState:  commonpb.SegmentState_Flushed,
+		})
+		assert.Nil(t, err)
+		assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetStatus().GetErrorCode())
+		assert.Equal(t, serverNotServingErrMsg, resp.GetStatus().GetReason())
+	})
+}
+
 func TestImport(t *testing.T) {
 	t.Run("normal case", func(t *testing.T) {
 		svr := newTestServer(t, nil)
@@ -2279,9 +2390,7 @@ func TestImport(t *testing.T) {
 		})
 		assert.Nil(t, err)
 		assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.GetErrorCode())
-
 		etcd.StopEtcdServer()
-
 	})
 
 	t.Run("no free node", func(t *testing.T) {
@@ -2302,9 +2411,7 @@ func TestImport(t *testing.T) {
 		})
 		assert.Nil(t, err)
 		assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.GetErrorCode())
-
 		etcd.StopEtcdServer()
-
 	})
 
 	t.Run("no datanode available", func(t *testing.T) {
@@ -2319,9 +2426,7 @@ func TestImport(t *testing.T) {
 		})
 		assert.Nil(t, err)
 		assert.EqualValues(t, commonpb.ErrorCode_UnexpectedError, resp.Status.GetErrorCode())
-
 		etcd.StopEtcdServer()
-
 	})
 
 	t.Run("with closed server", func(t *testing.T) {

internal/datacoord/services.go

@@ -446,6 +446,35 @@ func (s *Server) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtual
 	return resp, nil
 }
 
+// SetSegmentState reset the state of the given segment.
+func (s *Server) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) {
+	if s.isClosed() {
+		return &datapb.SetSegmentStateResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_UnexpectedError,
+				Reason:    serverNotServingErrMsg,
+			},
+		}, nil
+	}
+	err := s.meta.SetState(req.GetSegmentId(), req.GetNewState())
+	if err != nil {
+		log.Error("failed to updated segment state in dataCoord meta",
+			zap.Int64("segment ID", req.SegmentId),
+			zap.String("to state", req.GetNewState().String()))
+		return &datapb.SetSegmentStateResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_UnexpectedError,
+				Reason:    err.Error(),
+			},
+		}, nil
+	}
+	return &datapb.SetSegmentStateResponse{
+		Status: &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_Success,
+		},
+	}, nil
+}
+
 // GetComponentStates returns DataCoord's current state
 func (s *Server) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
 	nodeID := common.NotRegisteredID

internal/distributed/datacoord/client/client.go

@@ -487,6 +487,20 @@ func (c *Client) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtual
 	return ret.(*datapb.DropVirtualChannelResponse), err
 }
 
+// SetSegmentState sets the state of a given segment.
+func (c *Client) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) {
+	ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
+		if !funcutil.CheckCtxValid(ctx) {
+			return nil, ctx.Err()
+		}
+		return client.(datapb.DataCoordClient).SetSegmentState(ctx, req)
+	})
+	if err != nil || ret == nil {
+		return nil, err
+	}
+	return ret.(*datapb.SetSegmentStateResponse), err
+}
+
 // Import data files(json, numpy, etc.) on MinIO/S3 storage, read and parse them into sealed segments
 func (c *Client) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error) {
 	ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {

internal/distributed/datacoord/service.go

@@ -325,6 +325,11 @@ func (s *Server) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtual
 	return s.dataCoord.DropVirtualChannel(ctx, req)
 }
 
+// SetSegmentState sets the state of a segment.
+func (s *Server) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) {
+	return s.dataCoord.SetSegmentState(ctx, req)
+}
+
 // Import data files(json, numpy, etc.) on MinIO/S3 storage, read and parse them into sealed segments
 func (s *Server) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error) {
 	return s.dataCoord.Import(ctx, req)

internal/distributed/datacoord/service_test.go

@@ -55,6 +55,7 @@ type MockDataCoord struct {
 	watchChannelsResp    *datapb.WatchChannelsResponse
 	getFlushStateResp    *milvuspb.GetFlushStateResponse
 	dropVChanResp        *datapb.DropVirtualChannelResponse
+	setSegmentStateResp  *datapb.SetSegmentStateResponse
 	importResp           *datapb.ImportTaskResponse
 }
 
@@ -165,6 +166,10 @@ func (m *MockDataCoord) DropVirtualChannel(ctx context.Context, req *datapb.Drop
 	return m.dropVChanResp, m.err
 }
 
+func (m *MockDataCoord) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) {
+	return m.setSegmentStateResp, m.err
+}
+
 func (m *MockDataCoord) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error) {
 	return m.importResp, m.err
 }
@@ -379,6 +384,15 @@ func Test_NewServer(t *testing.T) {
 		assert.NotNil(t, resp)
 	})
 
+	t.Run("set segment state", func(t *testing.T) {
+		server.dataCoord = &MockDataCoord{
+			setSegmentStateResp: &datapb.SetSegmentStateResponse{},
+		}
+		resp, err := server.SetSegmentState(ctx, nil)
+		assert.Nil(t, err)
+		assert.NotNil(t, resp)
+	})
+
 	t.Run("Import", func(t *testing.T) {
 		server.dataCoord = &MockDataCoord{
 			importResp: &datapb.ImportTaskResponse{

internal/distributed/proxy/service_test.go

@@ -470,6 +470,10 @@ func (m *MockDataCoord) DropVirtualChannel(ctx context.Context, req *datapb.Drop
 	return &datapb.DropVirtualChannelResponse{}, nil
 }
 
+func (m *MockDataCoord) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) {
+	return &datapb.SetSegmentStateResponse{}, nil
+}
+
 func (m *MockDataCoord) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error) {
 	return nil, nil
 }

internal/distributed/rootcoord/service_test.go

@@ -164,16 +164,20 @@ func TestGrpcService(t *testing.T) {
 		return nil
 	}
 
-	segs := []typeutil.UniqueID{}
+	var segs []typeutil.UniqueID
 	segLock := sync.Mutex{}
 	core.CallGetFlushedSegmentsService = func(ctx context.Context, collID, partID typeutil.UniqueID) ([]typeutil.UniqueID, error) {
 		segLock.Lock()
 		defer segLock.Unlock()
-		ret := []typeutil.UniqueID{}
+		var ret []typeutil.UniqueID
 		ret = append(ret, segs...)
 		return ret, nil
 	}
 
+	core.CallUpdateSegmentStateService = func(ctx context.Context, segID typeutil.UniqueID, ss commonpb.SegmentState) error {
+		return nil
+	}
+
 	var binlogLock sync.Mutex
 	binlogPathArray := make([]string, 0, 16)
 	core.CallBuildIndexService = func(ctx context.Context, binlog []string, field *schemapb.FieldSchema, idxInfo *etcdpb.IndexInfo, numRows int64) (typeutil.UniqueID, error) {

internal/kv/mock_kv.go

@@ -24,67 +24,67 @@ import (
 	"go.uber.org/zap"
 )
 
-type mockBaseKV struct {
+type MockBaseKV struct {
 	InMemKv map[string]string
 }
 
-func (m *mockBaseKV) Load(key string) (string, error) {
+func (m *MockBaseKV) Load(key string) (string, error) {
 	if val, ok := m.InMemKv[key]; ok {
 		return val, nil
 	}
 	return "", nil
 }
 
-func (m *mockBaseKV) MultiLoad(keys []string) ([]string, error) {
+func (m *MockBaseKV) MultiLoad(keys []string) ([]string, error) {
 	panic("not implemented") // TODO: Implement
 }
 
-func (m *mockBaseKV) LoadWithPrefix(key string) ([]string, []string, error) {
+func (m *MockBaseKV) LoadWithPrefix(key string) ([]string, []string, error) {
 	panic("not implemented") // TODO: Implement
 }
 
-func (m *mockBaseKV) Save(key string, value string) error {
+func (m *MockBaseKV) Save(key string, value string) error {
 	panic("not implemented") // TODO: Implement
 }
 
-func (m *mockBaseKV) MultiSave(kvs map[string]string) error {
+func (m *MockBaseKV) MultiSave(kvs map[string]string) error {
 	panic("not implemented") // TODO: Implement
 }
 
-func (m *mockBaseKV) Remove(key string) error {
+func (m *MockBaseKV) Remove(key string) error {
 	panic("not implemented") // TODO: Implement
 }
 
-func (m *mockBaseKV) MultiRemove(keys []string) error {
+func (m *MockBaseKV) MultiRemove(keys []string) error {
 	panic("not implemented") // TODO: Implement
 }
 
-func (m *mockBaseKV) RemoveWithPrefix(key string) error {
+func (m *MockBaseKV) RemoveWithPrefix(key string) error {
 	panic("not implemented") // TODO: Implement
 }
 
-func (m *mockBaseKV) Close() {
+func (m *MockBaseKV) Close() {
 	panic("not implemented") // TODO: Implement
 }
 
-type mockTxnKV struct {
-	mockBaseKV
+type MockTxnKV struct {
+	MockBaseKV
 }
 
-func (m *mockTxnKV) MultiSaveAndRemove(saves map[string]string, removals []string) error {
+func (m *MockTxnKV) MultiSaveAndRemove(saves map[string]string, removals []string) error {
 	panic("not implemented") // TODO: Implement
 }
 
-func (m *mockTxnKV) MultiRemoveWithPrefix(keys []string) error {
+func (m *MockTxnKV) MultiRemoveWithPrefix(keys []string) error {
 	panic("not implemented") // TODO: Implement
 }
 
-func (m *mockTxnKV) MultiSaveAndRemoveWithPrefix(saves map[string]string, removals []string) error {
+func (m *MockTxnKV) MultiSaveAndRemoveWithPrefix(saves map[string]string, removals []string) error {
 	panic("not implemented") // TODO: Implement
 }
 
 type MockMetaKV struct {
-	mockTxnKV
+	MockTxnKV
 }
 
 func (m *MockMetaKV) GetPath(key string) string {

internal/proto/data_coord.proto

@@ -42,6 +42,7 @@ service DataCoord {
   rpc GetFlushState(milvus.GetFlushStateRequest) returns (milvus.GetFlushStateResponse) {}
   rpc DropVirtualChannel(DropVirtualChannelRequest) returns (DropVirtualChannelResponse) {}
 
+  rpc SetSegmentState(SetSegmentStateRequest) returns (SetSegmentStateResponse) {}
   // https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load
   rpc Import(ImportTaskRequest) returns (ImportTaskResponse) {}
 }
@@ -397,6 +398,16 @@ message WatchChannelsResponse {
   common.Status status = 1;
 }
 
+message SetSegmentStateRequest {
+  common.MsgBase base = 1;
+  int64 segment_id = 2;
+  common.SegmentState new_state = 3;
+}
+
+message SetSegmentStateResponse {
+  common.Status status = 1;
+}
+
 message DropVirtualChannelRequest {
   common.MsgBase base = 1; 
   string channel_name = 2; 

internal/proto/datapb/data_coord.pb.go

@@ -2924,6 +2924,100 @@ func (m *WatchChannelsResponse) GetStatus() *commonpb.Status {
 	return nil
 }
 
+type SetSegmentStateRequest struct {
+	Base                 *commonpb.MsgBase     `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	SegmentId            int64                 `protobuf:"varint,2,opt,name=segment_id,json=segmentId,proto3" json:"segment_id,omitempty"`
+	NewState             commonpb.SegmentState `protobuf:"varint,3,opt,name=new_state,json=newState,proto3,enum=milvus.proto.common.SegmentState" json:"new_state,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+	XXX_unrecognized     []byte                `json:"-"`
+	XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *SetSegmentStateRequest) Reset()         { *m = SetSegmentStateRequest{} }
+func (m *SetSegmentStateRequest) String() string { return proto.CompactTextString(m) }
+func (*SetSegmentStateRequest) ProtoMessage()    {}
+func (*SetSegmentStateRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_82cd95f524594f49, []int{47}
+}
+
+func (m *SetSegmentStateRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SetSegmentStateRequest.Unmarshal(m, b)
+}
+func (m *SetSegmentStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SetSegmentStateRequest.Marshal(b, m, deterministic)
+}
+func (m *SetSegmentStateRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetSegmentStateRequest.Merge(m, src)
+}
+func (m *SetSegmentStateRequest) XXX_Size() int {
+	return xxx_messageInfo_SetSegmentStateRequest.Size(m)
+}
+func (m *SetSegmentStateRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetSegmentStateRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetSegmentStateRequest proto.InternalMessageInfo
+
+func (m *SetSegmentStateRequest) GetBase() *commonpb.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *SetSegmentStateRequest) GetSegmentId() int64 {
+	if m != nil {
+		return m.SegmentId
+	}
+	return 0
+}
+
+func (m *SetSegmentStateRequest) GetNewState() commonpb.SegmentState {
+	if m != nil {
+		return m.NewState
+	}
+	return commonpb.SegmentState_SegmentStateNone
+}
+
+type SetSegmentStateResponse struct {
+	Status               *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *SetSegmentStateResponse) Reset()         { *m = SetSegmentStateResponse{} }
+func (m *SetSegmentStateResponse) String() string { return proto.CompactTextString(m) }
+func (*SetSegmentStateResponse) ProtoMessage()    {}
+func (*SetSegmentStateResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_82cd95f524594f49, []int{48}
+}
+
+func (m *SetSegmentStateResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SetSegmentStateResponse.Unmarshal(m, b)
+}
+func (m *SetSegmentStateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SetSegmentStateResponse.Marshal(b, m, deterministic)
+}
+func (m *SetSegmentStateResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetSegmentStateResponse.Merge(m, src)
+}
+func (m *SetSegmentStateResponse) XXX_Size() int {
+	return xxx_messageInfo_SetSegmentStateResponse.Size(m)
+}
+func (m *SetSegmentStateResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetSegmentStateResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetSegmentStateResponse proto.InternalMessageInfo
+
+func (m *SetSegmentStateResponse) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
 type DropVirtualChannelRequest struct {
 	Base                 *commonpb.MsgBase            `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
 	ChannelName          string                       `protobuf:"bytes,2,opt,name=channel_name,json=channelName,proto3" json:"channel_name,omitempty"`
@@ -2937,7 +3031,7 @@ func (m *DropVirtualChannelRequest) Reset()         { *m = DropVirtualChannelReq
 func (m *DropVirtualChannelRequest) String() string { return proto.CompactTextString(m) }
 func (*DropVirtualChannelRequest) ProtoMessage()    {}
 func (*DropVirtualChannelRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_82cd95f524594f49, []int{47}
+	return fileDescriptor_82cd95f524594f49, []int{49}
 }
 
 func (m *DropVirtualChannelRequest) XXX_Unmarshal(b []byte) error {
@@ -2997,7 +3091,7 @@ func (m *DropVirtualChannelSegment) Reset()         { *m = DropVirtualChannelSeg
 func (m *DropVirtualChannelSegment) String() string { return proto.CompactTextString(m) }
 func (*DropVirtualChannelSegment) ProtoMessage()    {}
 func (*DropVirtualChannelSegment) Descriptor() ([]byte, []int) {
-	return fileDescriptor_82cd95f524594f49, []int{48}
+	return fileDescriptor_82cd95f524594f49, []int{50}
 }
 
 func (m *DropVirtualChannelSegment) XXX_Unmarshal(b []byte) error {
@@ -3085,7 +3179,7 @@ func (m *DropVirtualChannelResponse) Reset()         { *m = DropVirtualChannelRe
 func (m *DropVirtualChannelResponse) String() string { return proto.CompactTextString(m) }
 func (*DropVirtualChannelResponse) ProtoMessage()    {}
 func (*DropVirtualChannelResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_82cd95f524594f49, []int{49}
+	return fileDescriptor_82cd95f524594f49, []int{51}
 }
 
 func (m *DropVirtualChannelResponse) XXX_Unmarshal(b []byte) error {
@@ -3130,7 +3224,7 @@ func (m *ImportTask) Reset()         { *m = ImportTask{} }
 func (m *ImportTask) String() string { return proto.CompactTextString(m) }
 func (*ImportTask) ProtoMessage()    {}
 func (*ImportTask) Descriptor() ([]byte, []int) {
-	return fileDescriptor_82cd95f524594f49, []int{50}
+	return fileDescriptor_82cd95f524594f49, []int{52}
 }
 
 func (m *ImportTask) XXX_Unmarshal(b []byte) error {
@@ -3215,7 +3309,7 @@ func (m *ImportTaskState) Reset()         { *m = ImportTaskState{} }
 func (m *ImportTaskState) String() string { return proto.CompactTextString(m) }
 func (*ImportTaskState) ProtoMessage()    {}
 func (*ImportTaskState) Descriptor() ([]byte, []int) {
-	return fileDescriptor_82cd95f524594f49, []int{51}
+	return fileDescriptor_82cd95f524594f49, []int{53}
 }
 
 func (m *ImportTaskState) XXX_Unmarshal(b []byte) error {
@@ -3291,7 +3385,7 @@ func (m *ImportTaskInfo) Reset()         { *m = ImportTaskInfo{} }
 func (m *ImportTaskInfo) String() string { return proto.CompactTextString(m) }
 func (*ImportTaskInfo) ProtoMessage()    {}
 func (*ImportTaskInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_82cd95f524594f49, []int{52}
+	return fileDescriptor_82cd95f524594f49, []int{54}
 }
 
 func (m *ImportTaskInfo) XXX_Unmarshal(b []byte) error {
@@ -3394,7 +3488,7 @@ func (m *ImportTaskResponse) Reset()         { *m = ImportTaskResponse{} }
 func (m *ImportTaskResponse) String() string { return proto.CompactTextString(m) }
 func (*ImportTaskResponse) ProtoMessage()    {}
 func (*ImportTaskResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_82cd95f524594f49, []int{53}
+	return fileDescriptor_82cd95f524594f49, []int{55}
 }
 
 func (m *ImportTaskResponse) XXX_Unmarshal(b []byte) error {
@@ -3442,7 +3536,7 @@ func (m *ImportTaskRequest) Reset()         { *m = ImportTaskRequest{} }
 func (m *ImportTaskRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportTaskRequest) ProtoMessage()    {}
 func (*ImportTaskRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_82cd95f524594f49, []int{54}
+	return fileDescriptor_82cd95f524594f49, []int{56}
 }
 
 func (m *ImportTaskRequest) XXX_Unmarshal(b []byte) error {
@@ -3534,6 +3628,8 @@ func init() {
 	proto.RegisterType((*SegmentFieldBinlogMeta)(nil), "milvus.proto.data.SegmentFieldBinlogMeta")
 	proto.RegisterType((*WatchChannelsRequest)(nil), "milvus.proto.data.WatchChannelsRequest")
 	proto.RegisterType((*WatchChannelsResponse)(nil), "milvus.proto.data.WatchChannelsResponse")
+	proto.RegisterType((*SetSegmentStateRequest)(nil), "milvus.proto.data.SetSegmentStateRequest")
+	proto.RegisterType((*SetSegmentStateResponse)(nil), "milvus.proto.data.SetSegmentStateResponse")
 	proto.RegisterType((*DropVirtualChannelRequest)(nil), "milvus.proto.data.DropVirtualChannelRequest")
 	proto.RegisterType((*DropVirtualChannelSegment)(nil), "milvus.proto.data.DropVirtualChannelSegment")
 	proto.RegisterType((*DropVirtualChannelResponse)(nil), "milvus.proto.data.DropVirtualChannelResponse")
@@ -3547,212 +3643,216 @@ func init() {
 func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
 
 var fileDescriptor_82cd95f524594f49 = []byte{
-	// 3270 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x3b, 0x5b, 0x6f, 0x1b, 0xc7,
-	0xd5, 0x5e, 0xde, 0x44, 0x1e, 0x5e, 0x44, 0x8d, 0x1d, 0x99, 0xa6, 0x6d, 0x59, 0x5e, 0xc7, 0x8e,
-	0xe2, 0x38, 0x76, 0x22, 0x7f, 0x41, 0x82, 0x2f, 0x37, 0x44, 0x52, 0xa4, 0x10, 0x9f, 0xe4, 0x4f,
-	0x59, 0x29, 0x71, 0xd1, 0x14, 0x25, 0x56, 0xdc, 0x11, 0xb5, 0xd1, 0x5e, 0x98, 0x9d, 0xa5, 0x65,
-	0xe7, 0x25, 0x46, 0x03, 0x14, 0x68, 0x11, 0xa4, 0x2d, 0xfa, 0x54, 0xa0, 0x0f, 0x45, 0x81, 0x02,
-	0xbd, 0xbc, 0xb4, 0x8f, 0x6d, 0xd1, 0xf7, 0x20, 0xfd, 0x21, 0x45, 0x5f, 0xfa, 0x1b, 0x8a, 0xb9,
-	0xec, 0xec, 0x85, 0x4b, 0x72, 0x25, 0xd9, 0xf1, 0x9b, 0xe6, 0xec, 0x39, 0x33, 0x67, 0xce, 0xfd,
-	0x1c, 0x8e, 0xa0, 0x69, 0xe8, 0xbe, 0xde, 0xed, 0xb9, 0xae, 0x67, 0xdc, 0x1e, 0x78, 0xae, 0xef,
-	0xa2, 0x39, 0xdb, 0xb4, 0x1e, 0x0c, 0x09, 0x5f, 0xdd, 0xa6, 0x9f, 0xdb, 0xb5, 0x9e, 0x6b, 0xdb,
-	0xae, 0xc3, 0x41, 0xed, 0x86, 0xe9, 0xf8, 0xd8, 0x73, 0x74, 0x4b, 0xac, 0x6b, 0x51, 0x82, 0x76,
-	0x8d, 0xf4, 0x0e, 0xb0, 0xad, 0xf3, 0x95, 0xfa, 0x10, 0x6a, 0xeb, 0xd6, 0x90, 0x1c, 0x68, 0xf8,
-	0xb3, 0x21, 0x26, 0x3e, 0x7a, 0x05, 0x0a, 0x7b, 0x3a, 0xc1, 0x2d, 0x65, 0x51, 0x59, 0xaa, 0x2e,
-	0x5f, 0xba, 0x1d, 0x3b, 0x4b, 0x9c, 0xb2, 0x45, 0xfa, 0x2b, 0x3a, 0xc1, 0x1a, 0xc3, 0x44, 0x08,
-	0x0a, 0xc6, 0x5e, 0x67, 0xad, 0x95, 0x5b, 0x54, 0x96, 0xf2, 0x1a, 0xfb, 0x1b, 0xa9, 0x50, 0xeb,
-	0xb9, 0x96, 0x85, 0x7b, 0xbe, 0xe9, 0x3a, 0x9d, 0xb5, 0x56, 0x81, 0x7d, 0x8b, 0xc1, 0xd4, 0x5f,
-	0x2b, 0x50, 0x17, 0x47, 0x93, 0x81, 0xeb, 0x10, 0x8c, 0xee, 0x42, 0x89, 0xf8, 0xba, 0x3f, 0x24,
-	0xe2, 0xf4, 0x8b, 0xa9, 0xa7, 0xef, 0x30, 0x14, 0x4d, 0xa0, 0x66, 0x3a, 0x3e, 0x3f, 0x7a, 0x3c,
-	0x5a, 0x00, 0x20, 0xb8, 0x6f, 0x63, 0xc7, 0xef, 0xac, 0x91, 0x56, 0x61, 0x31, 0xbf, 0x94, 0xd7,
-	0x22, 0x10, 0xf5, 0x17, 0x0a, 0x34, 0x77, 0x82, 0x65, 0x20, 0x9d, 0x73, 0x50, 0xec, 0xb9, 0x43,
-	0xc7, 0x67, 0x0c, 0xd6, 0x35, 0xbe, 0x40, 0x57, 0xa1, 0xd6, 0x3b, 0xd0, 0x1d, 0x07, 0x5b, 0x5d,
-	0x47, 0xb7, 0x31, 0x63, 0xa5, 0xa2, 0x55, 0x05, 0xec, 0x9e, 0x6e, 0xe3, 0x4c, 0x1c, 0x2d, 0x42,
-	0x75, 0xa0, 0x7b, 0xbe, 0x19, 0x93, 0x59, 0x14, 0xa4, 0xfe, 0x46, 0x81, 0xf9, 0xf7, 0x08, 0x31,
-	0xfb, 0xce, 0x08, 0x67, 0xf3, 0x50, 0x72, 0x5c, 0x03, 0x77, 0xd6, 0x18, 0x6b, 0x79, 0x4d, 0xac,
-	0xd0, 0x45, 0xa8, 0x0c, 0x30, 0xf6, 0xba, 0x9e, 0x6b, 0x05, 0x8c, 0x95, 0x29, 0x40, 0x73, 0x2d,
-	0x8c, 0x3e, 0x84, 0x39, 0x92, 0xd8, 0x88, 0xb4, 0xf2, 0x8b, 0xf9, 0xa5, 0xea, 0xf2, 0xb5, 0xdb,
-	0x23, 0x56, 0x76, 0x3b, 0x79, 0xa8, 0x36, 0x4a, 0xad, 0x3e, 0xce, 0xc1, 0x59, 0x89, 0xc7, 0x79,
-	0xa5, 0x7f, 0x53, 0xc9, 0x11, 0xdc, 0x97, 0xec, 0xf1, 0x45, 0x16, 0xc9, 0x49, 0x91, 0xe7, 0xa3,
-	0x22, 0xcf, 0x60, 0x60, 0x49, 0x79, 0x16, 0x47, 0xe4, 0x89, 0xae, 0x40, 0x15, 0x3f, 0x1c, 0x98,
-	0x1e, 0xee, 0xfa, 0xa6, 0x8d, 0x5b, 0xa5, 0x45, 0x65, 0xa9, 0xa0, 0x01, 0x07, 0xed, 0x9a, 0x76,
-	0xd4, 0x22, 0x67, 0x32, 0x5b, 0xa4, 0xfa, 0x5b, 0x05, 0xce, 0x8f, 0x68, 0x49, 0x98, 0xb8, 0x06,
-	0x4d, 0x76, 0xf3, 0x50, 0x32, 0xd4, 0xd8, 0xa9, 0xc0, 0x6f, 0x4c, 0x12, 0x78, 0x88, 0xae, 0x8d,
-	0xd0, 0x47, 0x98, 0xcc, 0x65, 0x67, 0xf2, 0x10, 0xce, 0x6f, 0x60, 0x5f, 0x1c, 0x40, 0xbf, 0x61,
-	0x72, 0xf2, 0x10, 0x10, 0xf7, 0xa5, 0xdc, 0x88, 0x2f, 0xfd, 0x39, 0x27, 0x7d, 0x89, 0x1d, 0xd5,
-	0x71, 0xf6, 0x5d, 0x74, 0x09, 0x2a, 0x12, 0x45, 0x58, 0x45, 0x08, 0x40, 0xaf, 0x43, 0x91, 0x72,
-	0xca, 0x4d, 0xa2, 0xb1, 0x7c, 0x35, 0xfd, 0x4e, 0x91, 0x3d, 0x35, 0x8e, 0x8f, 0x3a, 0xd0, 0x20,
-	0xbe, 0xee, 0xf9, 0xdd, 0x81, 0x4b, 0x98, 0x9e, 0x99, 0xe1, 0x54, 0x97, 0xd5, 0xf8, 0x0e, 0x32,
-	0x44, 0x6e, 0x91, 0xfe, 0xb6, 0xc0, 0xd4, 0xea, 0x8c, 0x32, 0x58, 0xa2, 0xf7, 0xa1, 0x86, 0x1d,
-	0x23, 0xdc, 0xa8, 0x90, 0x79, 0xa3, 0x2a, 0x76, 0x0c, 0xb9, 0x4d, 0xa8, 0x9f, 0x62, 0x76, 0xfd,
-	0x7c, 0xa5, 0x40, 0x6b, 0x54, 0x41, 0xa7, 0x09, 0x94, 0x6f, 0x72, 0x22, 0xcc, 0x15, 0x34, 0xd1,
-	0xc3, 0xa5, 0x92, 0x34, 0x41, 0xa2, 0x9a, 0xf0, 0x5c, 0xc8, 0x0d, 0xfb, 0xf2, 0xd4, 0x8c, 0xe5,
-	0x4b, 0x05, 0xe6, 0x93, 0x67, 0x9d, 0xe6, 0xde, 0xff, 0x03, 0x45, 0xd3, 0xd9, 0x77, 0x83, 0x6b,
-	0x2f, 0x4c, 0xf0, 0x33, 0x7a, 0x16, 0x47, 0x56, 0x6d, 0xb8, 0xb8, 0x81, 0xfd, 0x8e, 0x43, 0xb0,
-	0xe7, 0xaf, 0x98, 0x8e, 0xe5, 0xf6, 0xb7, 0x75, 0xff, 0xe0, 0x14, 0x3e, 0x12, 0x33, 0xf7, 0x5c,
-	0xc2, 0xdc, 0xd5, 0xdf, 0x2b, 0x70, 0x29, 0xfd, 0x3c, 0x71, 0xf5, 0x36, 0x94, 0xf7, 0x4d, 0x6c,
-	0x19, 0x54, 0x66, 0x0a, 0x93, 0x99, 0x5c, 0x53, 0x5f, 0x19, 0x50, 0x64, 0x71, 0xc3, 0xab, 0x63,
-	0x0c, 0x74, 0xc7, 0xf7, 0x4c, 0xa7, 0xbf, 0x69, 0x12, 0x5f, 0xe3, 0xf8, 0x11, 0x79, 0xe6, 0xb3,
-	0x5b, 0xe6, 0x4f, 0x15, 0x58, 0xd8, 0xc0, 0xfe, 0xaa, 0x0c, 0xb5, 0xf4, 0xbb, 0x49, 0x7c, 0xb3,
-	0x47, 0x9e, 0x6e, 0x11, 0x91, 0x92, 0x33, 0xd5, 0x9f, 0x29, 0x70, 0x65, 0x2c, 0x33, 0x42, 0x74,
-	0x22, 0x94, 0x04, 0x81, 0x36, 0x3d, 0x94, 0xfc, 0x1f, 0x7e, 0xf4, 0xb1, 0x6e, 0x0d, 0xf1, 0xb6,
-	0x6e, 0x7a, 0x3c, 0x94, 0x9c, 0x30, 0xb0, 0xfe, 0x49, 0x81, 0xcb, 0x1b, 0xd8, 0xdf, 0x0e, 0xd2,
-	0xcc, 0x33, 0x94, 0x4e, 0x86, 0x8a, 0xe2, 0x6b, 0xae, 0xcc, 0x54, 0x6e, 0x9f, 0x89, 0xf8, 0x16,
-	0x98, 0x1f, 0x44, 0x1c, 0x72, 0x95, 0xd7, 0x02, 0x42, 0x78, 0xea, 0xe3, 0x3c, 0xd4, 0x3e, 0x16,
-	0xf5, 0x01, 0x4b, 0x23, 0x49, 0x39, 0x28, 0xe9, 0x72, 0x88, 0x94, 0x14, 0x69, 0x55, 0xc6, 0x06,
-	0xd4, 0x09, 0xc6, 0x87, 0x27, 0x49, 0x1a, 0x35, 0x4a, 0x28, 0x83, 0xfd, 0x26, 0xcc, 0x0d, 0x9d,
-	0x7d, 0x5a, 0xd6, 0x62, 0x43, 0xdc, 0x82, 0x57, 0x97, 0xd3, 0x23, 0xcf, 0x28, 0x21, 0xfa, 0x00,
-	0x66, 0x93, 0x7b, 0x15, 0x33, 0xed, 0x95, 0x24, 0x43, 0x1d, 0x68, 0x1a, 0x9e, 0x3b, 0x18, 0x60,
-	0xa3, 0x4b, 0x82, 0xad, 0x4a, 0xd9, 0xb6, 0x12, 0x74, 0xc1, 0x56, 0xea, 0x4f, 0x14, 0x98, 0xbf,
-	0xaf, 0xfb, 0xbd, 0x83, 0x35, 0x5b, 0x28, 0xe7, 0x14, 0xa6, 0xfd, 0x36, 0x54, 0x1e, 0x08, 0x45,
-	0x04, 0xf1, 0xeb, 0x4a, 0x0a, 0x43, 0x51, 0x95, 0x6b, 0x21, 0x85, 0xfa, 0x8d, 0x02, 0xe7, 0x58,
-	0x13, 0x11, 0x70, 0xf7, 0xdd, 0x3b, 0xd9, 0x94, 0x46, 0x02, 0xdd, 0x80, 0x86, 0xad, 0x7b, 0x87,
-	0x3b, 0x21, 0x4e, 0x91, 0xe1, 0x24, 0xa0, 0xea, 0x43, 0x00, 0xb1, 0xda, 0x22, 0xfd, 0x13, 0xf0,
-	0xff, 0x06, 0xcc, 0x88, 0x53, 0x85, 0xbf, 0x4d, 0x53, 0x6c, 0x80, 0xae, 0x7e, 0xab, 0x40, 0x23,
-	0x8c, 0xa0, 0xcc, 0xab, 0x1a, 0x90, 0x93, 0xbe, 0x94, 0xeb, 0xac, 0xa1, 0xb7, 0xa1, 0xc4, 0xdb,
-	0x46, 0xb1, 0xf7, 0xf5, 0xf8, 0xde, 0xa2, 0xa5, 0x8c, 0x84, 0x61, 0x06, 0xd0, 0x04, 0x11, 0x95,
-	0x91, 0x8c, 0x3a, 0xbc, 0xc3, 0xc8, 0x6b, 0x11, 0x08, 0xea, 0xc0, 0x6c, 0xbc, 0x68, 0x0b, 0x7c,
-	0x66, 0x71, 0x5c, 0xb4, 0x59, 0xd3, 0x7d, 0x9d, 0x05, 0x9b, 0x46, 0xac, 0x66, 0x23, 0xea, 0x7f,
-	0x8a, 0x50, 0x8d, 0xdc, 0x72, 0xe4, 0x26, 0x49, 0x95, 0xe6, 0xa6, 0xc7, 0xcd, 0xfc, 0x68, 0xe7,
-	0x70, 0x1d, 0x1a, 0x26, 0xcb, 0xd5, 0x5d, 0x61, 0x8a, 0x2c, 0xb8, 0x56, 0xb4, 0x3a, 0x87, 0x0a,
-	0xbf, 0x40, 0x0b, 0x50, 0x75, 0x86, 0x76, 0xd7, 0xdd, 0xef, 0x7a, 0xee, 0x11, 0x11, 0x2d, 0x48,
-	0xc5, 0x19, 0xda, 0xff, 0xbf, 0xaf, 0xb9, 0x47, 0x24, 0xac, 0x72, 0x4b, 0xc7, 0xac, 0x72, 0x17,
-	0xa0, 0x6a, 0xeb, 0x0f, 0xe9, 0xae, 0x5d, 0x67, 0x68, 0xb3, 0xee, 0x24, 0xaf, 0x55, 0x6c, 0xfd,
-	0xa1, 0xe6, 0x1e, 0xdd, 0x1b, 0xda, 0x68, 0x09, 0x9a, 0x96, 0x4e, 0xfc, 0x6e, 0xb4, 0xbd, 0x29,
-	0xb3, 0xf6, 0xa6, 0x41, 0xe1, 0xef, 0x87, 0x2d, 0xce, 0x68, 0xbd, 0x5c, 0x39, 0x45, 0xbd, 0x6c,
-	0xd8, 0x56, 0xb8, 0x11, 0x64, 0xaf, 0x97, 0x0d, 0xdb, 0x92, 0xdb, 0xbc, 0x01, 0x33, 0x7b, 0xac,
-	0x02, 0x22, 0xad, 0xea, 0xd8, 0x08, 0xb5, 0x4e, 0x8b, 0x1f, 0x5e, 0x28, 0x69, 0x01, 0x3a, 0x7a,
-	0x0b, 0x2a, 0x2c, 0xf5, 0x30, 0xda, 0x5a, 0x26, 0xda, 0x90, 0x80, 0x52, 0x1b, 0xd8, 0xf2, 0x75,
-	0x46, 0x5d, 0xcf, 0x46, 0x2d, 0x09, 0xd0, 0x2b, 0x70, 0xb6, 0xe7, 0x61, 0xdd, 0xc7, 0xc6, 0xca,
-	0xa3, 0x55, 0xd7, 0x1e, 0xe8, 0xcc, 0x98, 0x5a, 0x8d, 0x45, 0x65, 0xa9, 0xac, 0xa5, 0x7d, 0xa2,
-	0x81, 0xa1, 0x27, 0x57, 0xeb, 0x9e, 0x6b, 0xb7, 0x66, 0x79, 0x60, 0x88, 0x43, 0xd1, 0x65, 0x80,
-	0x20, 0x74, 0xeb, 0x7e, 0xab, 0xc9, 0xb4, 0x58, 0x11, 0x90, 0xf7, 0x7c, 0xf5, 0x0b, 0x38, 0x17,
-	0x5a, 0x48, 0x44, 0x1b, 0xa3, 0x8a, 0x55, 0x4e, 0xaa, 0xd8, 0xc9, 0xb5, 0xeb, 0x5f, 0x0a, 0x30,
-	0xbf, 0xa3, 0x3f, 0xc0, 0x4f, 0xbf, 0x4c, 0xce, 0x14, 0x8f, 0x37, 0x61, 0x8e, 0x55, 0xc6, 0xcb,
-	0x11, 0x7e, 0x26, 0x64, 0xe0, 0xa8, 0x3a, 0x47, 0x09, 0xd1, 0xbb, 0xb4, 0x74, 0xc0, 0xbd, 0xc3,
-	0x6d, 0xd7, 0x0c, 0xb3, 0xef, 0xe5, 0x94, 0x7d, 0x56, 0x25, 0x96, 0x16, 0xa5, 0x40, 0xdb, 0xa3,
-	0xa1, 0x8d, 0xe7, 0xdd, 0x17, 0x26, 0xf6, 0x5f, 0xa1, 0xf4, 0x93, 0x11, 0x0e, 0xb5, 0x60, 0x46,
-	0x64, 0x77, 0xe6, 0xf7, 0x65, 0x2d, 0x58, 0xa2, 0x6d, 0x38, 0xcb, 0x6f, 0xb0, 0x23, 0x8c, 0x9a,
-	0x5f, 0xbe, 0x9c, 0xe9, 0xf2, 0x69, 0xa4, 0x71, 0x9f, 0xa8, 0x1c, 0xd7, 0x27, 0x5a, 0x30, 0x23,
-	0xec, 0x94, 0xc5, 0x82, 0xb2, 0x16, 0x2c, 0x69, 0x13, 0x01, 0xa1, 0xc4, 0xa6, 0xcc, 0x02, 0xde,
-	0x81, 0xb2, 0xb4, 0xe1, 0x5c, 0x66, 0x1b, 0x96, 0x34, 0xc9, 0x28, 0x9c, 0x4f, 0x44, 0x61, 0xf5,
-	0x9f, 0x0a, 0xd4, 0xd6, 0x28, 0xd3, 0x9b, 0x6e, 0x9f, 0xe5, 0x8c, 0xeb, 0xd0, 0xf0, 0x70, 0xcf,
-	0xf5, 0x8c, 0x2e, 0x76, 0x7c, 0xcf, 0xc4, 0xbc, 0xdf, 0x2c, 0x68, 0x75, 0x0e, 0x7d, 0x9f, 0x03,
-	0x29, 0x1a, 0x0d, 0xac, 0xc4, 0xd7, 0xed, 0x41, 0x77, 0x9f, 0x3a, 0x70, 0x8e, 0xa3, 0x49, 0x28,
-	0xf3, 0xdf, 0xab, 0x50, 0x0b, 0xd1, 0x7c, 0x97, 0x9d, 0x5f, 0xd0, 0xaa, 0x12, 0xb6, 0xeb, 0xa2,
-	0xe7, 0xa1, 0xc1, 0xa4, 0xd6, 0xb5, 0xdc, 0x7e, 0x97, 0xf6, 0x66, 0x22, 0x9d, 0xd4, 0x0c, 0xc1,
-	0x16, 0xd5, 0x46, 0x1c, 0x8b, 0x98, 0x9f, 0x63, 0x91, 0x50, 0x24, 0xd6, 0x8e, 0xf9, 0x39, 0xa6,
-	0xd9, 0xbc, 0x4e, 0xb3, 0xe3, 0x3d, 0xd7, 0xc0, 0xbb, 0x27, 0xac, 0x25, 0x32, 0xcc, 0xe5, 0x2e,
-	0x41, 0x45, 0xde, 0x40, 0x5c, 0x29, 0x04, 0xa0, 0x75, 0x68, 0x04, 0x65, 0x66, 0x97, 0x77, 0x0f,
-	0x85, 0xb1, 0xb5, 0x5d, 0x24, 0xbf, 0x11, 0xad, 0x1e, 0x90, 0xb1, 0xa5, 0xba, 0x0e, 0xb5, 0xe8,
-	0x67, 0x7a, 0xea, 0x4e, 0xd2, 0x50, 0x24, 0x80, 0xda, 0xdb, 0xbd, 0xa1, 0x4d, 0x75, 0x2a, 0x42,
-	0x47, 0xb0, 0x54, 0xbf, 0x54, 0xa0, 0x2e, 0x92, 0xf2, 0x8e, 0x9c, 0x1b, 0xb3, 0xab, 0x29, 0xec,
-	0x6a, 0xec, 0x6f, 0xf4, 0xbf, 0xf1, 0xa1, 0xd3, 0xf3, 0xa9, 0x6e, 0xce, 0x36, 0x61, 0xf5, 0x6f,
-	0x2c, 0x23, 0x67, 0xe9, 0x56, 0x1f, 0x53, 0x43, 0x13, 0xaa, 0x61, 0x86, 0xd6, 0x82, 0x19, 0xdd,
-	0x30, 0x3c, 0x4c, 0x88, 0xe0, 0x23, 0x58, 0xd2, 0x2f, 0x0f, 0xb0, 0x47, 0x02, 0x93, 0xcf, 0x6b,
-	0xc1, 0x12, 0xbd, 0x05, 0x65, 0x59, 0x30, 0xe7, 0xd3, 0x8a, 0xa4, 0x28, 0x9f, 0xa2, 0xbb, 0x92,
-	0x14, 0xea, 0xd7, 0x39, 0x68, 0x08, 0x81, 0xad, 0x88, 0xac, 0x39, 0xd9, 0xf9, 0x56, 0xa0, 0xb6,
-	0x1f, 0x7a, 0xf7, 0xa4, 0x29, 0x4a, 0x34, 0x08, 0xc4, 0x68, 0xa6, 0x39, 0x60, 0x3c, 0x6f, 0x17,
-	0x4e, 0x95, 0xb7, 0x8b, 0xc7, 0x8c, 0x51, 0xea, 0x0f, 0xa0, 0x1a, 0xf9, 0xc2, 0x82, 0x2b, 0x9f,
-	0xab, 0x08, 0x51, 0x04, 0x4b, 0x74, 0x37, 0x2c, 0x4b, 0xb8, 0x0c, 0x2e, 0xa4, 0x1c, 0x92, 0xa8,
-	0x48, 0xd4, 0x3f, 0x28, 0x50, 0x12, 0x3b, 0x5f, 0x81, 0xaa, 0x88, 0x26, 0xac, 0x64, 0xe3, 0xbb,
-	0x83, 0x00, 0xd1, 0x9a, 0xed, 0xc9, 0x85, 0x93, 0x0b, 0x50, 0x4e, 0x04, 0x92, 0x19, 0x11, 0xd1,
-	0x83, 0x4f, 0x91, 0xe8, 0x41, 0x3f, 0xb1, 0xc0, 0xf1, 0x8d, 0xc2, 0x66, 0xc2, 0x1a, 0xee, 0xb9,
-	0x0f, 0xb0, 0xf7, 0xe8, 0xf4, 0x93, 0xb7, 0x37, 0x23, 0x96, 0x9a, 0xb1, 0xb5, 0x93, 0x04, 0xe8,
-	0xcd, 0x50, 0xdc, 0xf9, 0xb4, 0xc1, 0x43, 0x34, 0x74, 0x08, 0x3b, 0x0b, 0xc5, 0xfe, 0x73, 0x3e,
-	0x43, 0x8c, 0x5f, 0xe5, 0xa4, 0x25, 0xc9, 0x13, 0xe9, 0x18, 0xd4, 0x5f, 0x2a, 0x70, 0x61, 0x03,
-	0xfb, 0xeb, 0xf1, 0xbe, 0xfc, 0x59, 0x73, 0x65, 0x43, 0x3b, 0x8d, 0xa9, 0xd3, 0x68, 0xbd, 0x0d,
-	0x65, 0x39, 0x61, 0xe0, 0xd3, 0x5d, 0xb9, 0x56, 0x7f, 0xac, 0x40, 0x4b, 0x9c, 0xc2, 0xce, 0xa4,
-	0xd5, 0xb0, 0x85, 0x7d, 0x6c, 0x7c, 0xd7, 0x2d, 0xef, 0x3f, 0x14, 0x68, 0x46, 0x43, 0x39, 0x8b,
-	0xc6, 0xaf, 0x41, 0x91, 0x4d, 0x16, 0x04, 0x07, 0x53, 0x8d, 0x95, 0x63, 0xd3, 0x90, 0xc1, 0x2a,
-	0xb4, 0x5d, 0x99, 0x75, 0xc4, 0x32, 0xcc, 0x27, 0xf9, 0xe3, 0xe7, 0x13, 0x91, 0x5f, 0xdd, 0x21,
-	0xdd, 0x97, 0x4f, 0xee, 0x42, 0x80, 0xfa, 0x55, 0x0e, 0x5a, 0x61, 0x2b, 0xf1, 0x9d, 0x07, 0xf4,
-	0x31, 0x85, 0x66, 0xfe, 0x09, 0x15, 0x9a, 0x85, 0xe3, 0x06, 0xf1, 0xbf, 0xe7, 0xa0, 0x11, 0x8a,
-	0x63, 0xdb, 0xd2, 0x1d, 0x34, 0x0f, 0xa5, 0x81, 0xa5, 0x87, 0x13, 0x41, 0xb1, 0x42, 0x3b, 0xb2,
-	0x32, 0x89, 0x0b, 0xe0, 0xa5, 0x34, 0xe5, 0x8c, 0x91, 0xb0, 0x96, 0xd8, 0x82, 0xb6, 0x68, 0xbc,
-	0xc8, 0x67, 0x8d, 0xb6, 0xa8, 0x86, 0xb8, 0x15, 0xd0, 0x1e, 0xfb, 0x16, 0x20, 0xa1, 0xba, 0xae,
-	0xe9, 0x74, 0x09, 0xee, 0xb9, 0x8e, 0xc1, 0x95, 0x5a, 0xd4, 0x9a, 0xe2, 0x4b, 0xc7, 0xd9, 0xe1,
-	0x70, 0xf4, 0x1a, 0x14, 0xfc, 0x47, 0x03, 0x1e, 0x9e, 0x1b, 0xa9, 0x61, 0x2f, 0xe4, 0x6b, 0xf7,
-	0xd1, 0x00, 0x6b, 0x0c, 0x1d, 0x2d, 0x00, 0xd0, 0xad, 0x7c, 0x4f, 0x7f, 0x80, 0xad, 0xe0, 0xb7,
-	0xcc, 0x10, 0x42, 0xcd, 0x34, 0x98, 0x55, 0xcc, 0xf0, 0x9c, 0x20, 0x96, 0xea, 0x5f, 0x73, 0xd0,
-	0x0c, 0xb7, 0xd4, 0x30, 0x19, 0x5a, 0xfe, 0x58, 0xf9, 0x4d, 0x6e, 0xd0, 0xa6, 0x65, 0xfa, 0x77,
-	0xa1, 0x2a, 0xe6, 0x26, 0xc7, 0x50, 0x34, 0x70, 0x92, 0xcd, 0x09, 0x96, 0x57, 0x7c, 0x42, 0x96,
-	0x57, 0x3a, 0xae, 0xe5, 0xed, 0xc0, 0x7c, 0x10, 0xd0, 0x42, 0x84, 0x2d, 0xec, 0xeb, 0x13, 0x2a,
-	0x89, 0x2b, 0x50, 0xe5, 0x89, 0x8a, 0x67, 0x68, 0x5e, 0x5c, 0xc3, 0x9e, 0xec, 0x3a, 0xd5, 0x1f,
-	0xc2, 0x39, 0x16, 0x10, 0x92, 0xe3, 0xd5, 0x2c, 0xb3, 0x6e, 0x55, 0x96, 0xee, 0xb4, 0x4c, 0xe7,
-	0xd6, 0x5d, 0xd1, 0x62, 0x30, 0x75, 0x13, 0x9e, 0x4b, 0xec, 0x7f, 0x8a, 0x80, 0xaf, 0xfe, 0x4d,
-	0x81, 0x0b, 0x6b, 0x9e, 0x3b, 0xf8, 0xd8, 0xf4, 0xfc, 0xa1, 0x6e, 0xc5, 0x07, 0xf6, 0x4f, 0xa7,
-	0xf9, 0xf8, 0x20, 0x92, 0x63, 0x78, 0xd0, 0xb9, 0x95, 0xa2, 0xb2, 0x51, 0xa6, 0x84, 0xaa, 0x22,
-	0x19, 0xe9, 0x5f, 0xf9, 0x34, 0xe6, 0x05, 0xde, 0x94, 0x48, 0x9a, 0x25, 0x05, 0xa7, 0x4e, 0x23,
-	0xf2, 0x27, 0x9d, 0x46, 0x8c, 0xb1, 0xfe, 0xc2, 0x13, 0xb2, 0xfe, 0xe3, 0x16, 0xcf, 0xe8, 0x03,
-	0x88, 0x4f, 0x8a, 0x58, 0xd8, 0x39, 0xd1, 0x88, 0x69, 0x05, 0x20, 0x9c, 0x9a, 0x88, 0xd7, 0x16,
-	0x59, 0xb6, 0x89, 0x50, 0x51, 0x6d, 0xc9, 0x48, 0xc3, 0xa6, 0x9d, 0xb1, 0x2e, 0xff, 0x43, 0x68,
-	0xa7, 0x59, 0xe9, 0x69, 0x2c, 0xff, 0xeb, 0x1c, 0x40, 0xc7, 0x1e, 0xb8, 0x9e, 0xbf, 0xab, 0x93,
-	0xc3, 0x93, 0x95, 0x4b, 0xd7, 0xa0, 0x1e, 0x1a, 0x4c, 0xd7, 0x34, 0x52, 0xac, 0xc8, 0xa0, 0x2e,
-	0x21, 0xab, 0x36, 0x8a, 0x33, 0x52, 0xc9, 0x19, 0xe8, 0x22, 0x54, 0x3c, 0xf7, 0xa8, 0x4b, 0x3d,
-	0xc8, 0x60, 0xa9, 0xa5, 0xac, 0x95, 0x3d, 0xf7, 0x88, 0xfa, 0x95, 0x81, 0xce, 0xc3, 0x8c, 0xaf,
-	0x93, 0x43, 0x4a, 0xca, 0x8b, 0xfe, 0x12, 0x5d, 0x76, 0x0c, 0x74, 0x0e, 0x8a, 0xfb, 0xa6, 0x85,
-	0x79, 0xe0, 0xab, 0x68, 0x7c, 0x81, 0x5e, 0x0f, 0x7e, 0x32, 0x9f, 0xc9, 0xfc, 0x93, 0x1f, 0xff,
-	0xd5, 0xfc, 0x1b, 0x05, 0x66, 0x43, 0x81, 0xb0, 0x7a, 0x06, 0xbd, 0xc3, 0x9b, 0x3b, 0xbc, 0xea,
-	0x1a, 0x3c, 0x0a, 0x34, 0xc6, 0x4c, 0xf5, 0x39, 0x21, 0x2f, 0x82, 0x42, 0x92, 0x49, 0xf5, 0x24,
-	0xbd, 0x17, 0xbd, 0xb4, 0x69, 0x04, 0x3f, 0x2a, 0x94, 0x3c, 0xf7, 0xa8, 0x63, 0x90, 0x40, 0x1a,
-	0xfc, 0xe5, 0x10, 0xaf, 0x9e, 0xa8, 0x34, 0x56, 0xd9, 0xe3, 0xa1, 0x6b, 0x50, 0xc7, 0x9e, 0xe7,
-	0x7a, 0x5d, 0x1b, 0x13, 0xa2, 0xf7, 0x79, 0xa6, 0xad, 0x68, 0x35, 0x06, 0xdc, 0xe2, 0x30, 0xf5,
-	0xdb, 0x1c, 0x34, 0xc2, 0xab, 0x04, 0x3f, 0x25, 0x98, 0x46, 0xf0, 0x53, 0x82, 0x69, 0xd0, 0xac,
-	0xef, 0xf1, 0x28, 0x17, 0xea, 0xad, 0x22, 0x20, 0x1d, 0x83, 0x86, 0x79, 0xea, 0x3b, 0x8e, 0x6b,
-	0xe0, 0x50, 0x67, 0x10, 0x80, 0x3a, 0xc6, 0xa8, 0xea, 0x0b, 0x19, 0x54, 0x5f, 0x1c, 0x55, 0xfd,
-	0x3c, 0x94, 0xf6, 0x86, 0xbd, 0x43, 0xec, 0x33, 0xf7, 0xab, 0x68, 0x62, 0x15, 0x37, 0x89, 0x99,
-	0x84, 0x49, 0x48, 0xcd, 0x97, 0xa3, 0x9a, 0xbf, 0x08, 0x15, 0x3e, 0xaa, 0xee, 0xfa, 0x84, 0xfd,
-	0x10, 0x90, 0xd7, 0xca, 0x1c, 0xb0, 0x4b, 0xd0, 0x1b, 0x41, 0x39, 0x9b, 0x3a, 0xd8, 0x67, 0x71,
-	0x22, 0xa1, 0x7c, 0x51, 0xcc, 0xaa, 0x9f, 0x02, 0x0a, 0xbf, 0x9c, 0xae, 0xbd, 0x48, 0x48, 0x35,
-	0x97, 0x94, 0xaa, 0xfa, 0x47, 0x05, 0xe6, 0xa2, 0x87, 0x9d, 0x34, 0x0d, 0xbd, 0x03, 0x55, 0x93,
-	0x6d, 0xd3, 0xa5, 0xbe, 0x22, 0x1a, 0x8c, 0xcb, 0x13, 0xef, 0xac, 0x81, 0x19, 0x46, 0x83, 0x6b,
-	0x50, 0x3f, 0x72, 0xbd, 0x43, 0xd3, 0xe9, 0x77, 0x29, 0x67, 0x81, 0x85, 0xd6, 0x04, 0xf0, 0x1e,
-	0x85, 0xdd, 0xfc, 0x95, 0x02, 0x73, 0x23, 0x2d, 0x00, 0x6a, 0x00, 0x7c, 0xe4, 0xf4, 0x44, 0x6f,
-	0xd4, 0x3c, 0x83, 0x6a, 0x50, 0x0e, 0x3a, 0xa5, 0xa6, 0x82, 0xaa, 0x30, 0xb3, 0xeb, 0x32, 0xec,
-	0x66, 0x0e, 0x35, 0xa1, 0xc6, 0x09, 0x87, 0xbd, 0x1e, 0x26, 0xa4, 0x99, 0x97, 0x90, 0x75, 0xdd,
-	0xb4, 0x86, 0x1e, 0x6e, 0x16, 0x50, 0x1d, 0x2a, 0xbb, 0xae, 0x86, 0x2d, 0xac, 0x13, 0xdc, 0x2c,
-	0x22, 0x04, 0x0d, 0xb1, 0x08, 0x88, 0x4a, 0x11, 0x58, 0x40, 0x36, 0x73, 0x73, 0x3f, 0x5a, 0x53,
-	0xd3, 0x42, 0x13, 0x9d, 0x87, 0xb3, 0x1f, 0x39, 0x06, 0xde, 0x37, 0x1d, 0x6c, 0x84, 0x9f, 0x9a,
-	0x67, 0xd0, 0x59, 0x98, 0xed, 0x38, 0x0e, 0xf6, 0x22, 0x40, 0x85, 0x02, 0xb7, 0xb0, 0xd7, 0xc7,
-	0x11, 0x60, 0x0e, 0xcd, 0x41, 0x7d, 0xcb, 0x7c, 0x18, 0x01, 0xe5, 0x97, 0xff, 0x7d, 0x16, 0x2a,
-	0x6b, 0xba, 0xaf, 0xaf, 0xba, 0xae, 0x67, 0xa0, 0x01, 0x20, 0xf6, 0xa0, 0xc3, 0x1e, 0xb8, 0x8e,
-	0x7c, 0xf9, 0x84, 0x5e, 0x19, 0x93, 0x0a, 0x46, 0x51, 0x85, 0xc2, 0xdb, 0x37, 0xc6, 0x50, 0x24,
-	0xd0, 0xd5, 0x33, 0xc8, 0x66, 0x27, 0xd2, 0x42, 0x7d, 0xd7, 0xec, 0x1d, 0x06, 0x3f, 0xdd, 0x4d,
-	0x38, 0x31, 0x81, 0x1a, 0x9c, 0x98, 0x78, 0x50, 0x25, 0x16, 0xfc, 0xd5, 0x4d, 0x60, 0xf3, 0xea,
-	0x19, 0xf4, 0x19, 0x9c, 0xdb, 0xc0, 0x7e, 0xf8, 0xd0, 0x22, 0x38, 0x70, 0x79, 0xfc, 0x81, 0x23,
-	0xc8, 0xc7, 0x3c, 0x72, 0x13, 0x8a, 0xac, 0xdd, 0x46, 0x69, 0x2d, 0x6d, 0xf4, 0xf9, 0x6f, 0x7b,
-	0x71, 0x3c, 0x82, 0xdc, 0xed, 0x53, 0x98, 0x4d, 0x3c, 0x6f, 0x44, 0x2f, 0xa6, 0x90, 0xa5, 0x3f,
-	0x54, 0x6d, 0xdf, 0xcc, 0x82, 0x2a, 0xcf, 0xea, 0x43, 0x23, 0xfe, 0x1c, 0x04, 0x2d, 0xa5, 0xd0,
-	0xa7, 0x3e, 0x4d, 0x6b, 0xbf, 0x98, 0x01, 0x53, 0x1e, 0x64, 0x43, 0x33, 0xf9, 0xdc, 0x0e, 0xdd,
-	0x9c, 0xb8, 0x41, 0xdc, 0xdc, 0x5e, 0xca, 0x84, 0x2b, 0x8f, 0x7b, 0xc4, 0x8c, 0x60, 0xe4, 0xb9,
-	0x17, 0xba, 0x9d, 0xbe, 0xcd, 0xb8, 0x77, 0x68, 0xed, 0x3b, 0x99, 0xf1, 0xe5, 0xd1, 0x3f, 0xe2,
-	0x63, 0xbe, 0xb4, 0x27, 0x53, 0xe8, 0xd5, 0xf4, 0xed, 0x26, 0xbc, 0xf5, 0x6a, 0x2f, 0x1f, 0x87,
-	0x44, 0x32, 0xf1, 0x05, 0x9b, 0xcf, 0xa5, 0x3c, 0x3b, 0x4a, 0xfa, 0x5d, 0xb0, 0xdf, 0xf8, 0xf7,
-	0x54, 0xed, 0x57, 0x8f, 0x41, 0x21, 0x19, 0x70, 0x93, 0x0f, 0x1a, 0x03, 0x37, 0xbc, 0x33, 0xd5,
-	0x6a, 0x4e, 0xe6, 0x83, 0x9f, 0xc0, 0x6c, 0xe2, 0x47, 0xd2, 0x54, 0xaf, 0x49, 0xff, 0x21, 0xb5,
-	0x3d, 0x29, 0x35, 0x72, 0x97, 0x4c, 0x8c, 0x3b, 0xd1, 0x18, 0xeb, 0x4f, 0x19, 0x89, 0xb6, 0x6f,
-	0x66, 0x41, 0x95, 0x17, 0x21, 0x2c, 0x5c, 0x26, 0x46, 0x86, 0xe8, 0x56, 0xfa, 0x1e, 0xe9, 0xe3,
-	0xce, 0xf6, 0xcb, 0x19, 0xb1, 0xe5, 0xa1, 0x5d, 0x80, 0x0d, 0xec, 0x6f, 0x61, 0xdf, 0xa3, 0x36,
-	0x72, 0x23, 0x55, 0xe4, 0x21, 0x42, 0x70, 0xcc, 0x0b, 0x53, 0xf1, 0xe4, 0x01, 0xdf, 0x03, 0x14,
-	0xa4, 0xd8, 0xc8, 0x4f, 0xf4, 0xd7, 0x26, 0x0e, 0x5f, 0xf8, 0xa4, 0x64, 0x9a, 0x6e, 0x3e, 0x83,
-	0xe6, 0x96, 0xee, 0xd0, 0x96, 0x23, 0xdc, 0xf7, 0x56, 0x2a, 0x63, 0x49, 0xb4, 0x31, 0xd2, 0x1a,
-	0x8b, 0x2d, 0x2f, 0x73, 0x24, 0x73, 0xa8, 0x2e, 0x5d, 0x10, 0x27, 0x63, 0x4b, 0x28, 0x8d, 0x04,
-	0xe2, 0x98, 0xd8, 0x32, 0x01, 0x5f, 0x1e, 0xfc, 0x58, 0x61, 0xcf, 0x66, 0x13, 0x08, 0xf7, 0x4d,
-	0xff, 0x60, 0xdb, 0xd2, 0x1d, 0x92, 0x85, 0x05, 0x86, 0x78, 0x0c, 0x16, 0x04, 0xbe, 0x64, 0xc1,
-	0x80, 0x7a, 0x6c, 0xb6, 0x81, 0xd2, 0x7e, 0x67, 0x4f, 0x9b, 0xae, 0xb4, 0x97, 0xa6, 0x23, 0xca,
-	0x53, 0x0e, 0xa0, 0x1e, 0xd8, 0x2b, 0x17, 0xee, 0x8b, 0xe3, 0x38, 0x0d, 0x71, 0xc6, 0xb8, 0x5b,
-	0x3a, 0x6a, 0xd4, 0xdd, 0x46, 0xdb, 0x56, 0x94, 0x6d, 0xdc, 0x31, 0xc9, 0xdd, 0xc6, 0xf7, 0xc2,
-	0xea, 0x19, 0x74, 0x1f, 0x4a, 0xbc, 0xaa, 0x45, 0xcf, 0x4f, 0x2e, 0x78, 0xc5, 0x01, 0xd7, 0xa7,
-	0x60, 0x05, 0x1b, 0x2f, 0xff, 0xae, 0x08, 0xe5, 0xe0, 0x17, 0xd0, 0x67, 0x50, 0xea, 0x3d, 0x83,
-	0xda, 0xeb, 0x13, 0x98, 0x4d, 0x3c, 0x96, 0x4c, 0x0d, 0xcd, 0xe9, 0x0f, 0x2a, 0xa7, 0xc5, 0x96,
-	0xfb, 0xe2, 0x5f, 0xa8, 0x64, 0x18, 0x7e, 0x61, 0x5c, 0xfd, 0x96, 0x8c, 0xc0, 0x53, 0x36, 0x7e,
-	0xea, 0xf1, 0xf6, 0x1e, 0x40, 0x24, 0x1e, 0x4e, 0x1e, 0x72, 0x53, 0x17, 0x9f, 0xc6, 0xf0, 0xd6,
-	0x31, 0x2d, 0x76, 0xf2, 0x76, 0x2b, 0x77, 0xbf, 0xff, 0x6a, 0xdf, 0xf4, 0x0f, 0x86, 0x7b, 0xf4,
-	0xcb, 0x1d, 0x8e, 0xfa, 0xb2, 0xe9, 0x8a, 0xbf, 0xee, 0x04, 0x06, 0x72, 0x87, 0x51, 0xdf, 0xa1,
-	0x67, 0x0c, 0xf6, 0xf6, 0x4a, 0x6c, 0x75, 0xf7, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x9b,
-	0xc9, 0x27, 0xb3, 0x37, 0x00, 0x00,
+	// 3333 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5b, 0xcb, 0x6f, 0x1b, 0xd7,
+	0xd5, 0xf7, 0xf0, 0x25, 0xf2, 0xf0, 0x21, 0xea, 0x5a, 0x91, 0x69, 0xda, 0x96, 0xe5, 0x71, 0xec,
+	0x28, 0x8e, 0x63, 0x27, 0xf2, 0x17, 0x24, 0xf8, 0xf2, 0x42, 0x24, 0x45, 0x0a, 0xf1, 0x49, 0xfa,
+	0x94, 0x91, 0x12, 0x17, 0x4d, 0x51, 0x62, 0xc4, 0xb9, 0xa2, 0x26, 0xe2, 0xcc, 0x30, 0x73, 0x87,
+	0x96, 0x9d, 0x4d, 0x8c, 0x06, 0x28, 0xd0, 0x22, 0x48, 0x5b, 0x74, 0x55, 0xa0, 0x8b, 0xa2, 0x40,
+	0x81, 0x3e, 0x36, 0xed, 0xb2, 0x2d, 0xba, 0x0f, 0xd2, 0x75, 0xff, 0x86, 0xee, 0xfa, 0x37, 0x14,
+	0xf7, 0x31, 0x77, 0x1e, 0x1c, 0x92, 0x23, 0xca, 0x8e, 0x77, 0xba, 0x87, 0xe7, 0xdc, 0xc7, 0xb9,
+	0xe7, 0xfc, 0xce, 0x63, 0xae, 0xa0, 0x6e, 0xe8, 0x9e, 0xde, 0xee, 0x38, 0x8e, 0x6b, 0xdc, 0xe9,
+	0xbb, 0x8e, 0xe7, 0xa0, 0x39, 0xcb, 0xec, 0x3d, 0x18, 0x10, 0x3e, 0xba, 0x43, 0x7f, 0x6e, 0x56,
+	0x3a, 0x8e, 0x65, 0x39, 0x36, 0x27, 0x35, 0x6b, 0xa6, 0xed, 0x61, 0xd7, 0xd6, 0x7b, 0x62, 0x5c,
+	0x09, 0x0b, 0x34, 0x2b, 0xa4, 0x73, 0x84, 0x2d, 0x9d, 0x8f, 0xd4, 0x87, 0x50, 0xd9, 0xe8, 0x0d,
+	0xc8, 0x91, 0x86, 0x3f, 0x1b, 0x60, 0xe2, 0xa1, 0x57, 0x20, 0x77, 0xa0, 0x13, 0xdc, 0x50, 0x96,
+	0x94, 0xe5, 0xf2, 0xca, 0xe5, 0x3b, 0x91, 0xb5, 0xc4, 0x2a, 0xdb, 0xa4, 0xbb, 0xaa, 0x13, 0xac,
+	0x31, 0x4e, 0x84, 0x20, 0x67, 0x1c, 0xb4, 0xd6, 0x1b, 0x99, 0x25, 0x65, 0x39, 0xab, 0xb1, 0xbf,
+	0x91, 0x0a, 0x95, 0x8e, 0xd3, 0xeb, 0xe1, 0x8e, 0x67, 0x3a, 0x76, 0x6b, 0xbd, 0x91, 0x63, 0xbf,
+	0x45, 0x68, 0xea, 0xaf, 0x15, 0xa8, 0x8a, 0xa5, 0x49, 0xdf, 0xb1, 0x09, 0x46, 0xf7, 0xa0, 0x40,
+	0x3c, 0xdd, 0x1b, 0x10, 0xb1, 0xfa, 0xa5, 0xc4, 0xd5, 0xf7, 0x18, 0x8b, 0x26, 0x58, 0x53, 0x2d,
+	0x9f, 0x1d, 0x5e, 0x1e, 0x2d, 0x02, 0x10, 0xdc, 0xb5, 0xb0, 0xed, 0xb5, 0xd6, 0x49, 0x23, 0xb7,
+	0x94, 0x5d, 0xce, 0x6a, 0x21, 0x8a, 0xfa, 0x0b, 0x05, 0xea, 0x7b, 0xfe, 0xd0, 0xd7, 0xce, 0x3c,
+	0xe4, 0x3b, 0xce, 0xc0, 0xf6, 0xd8, 0x06, 0xab, 0x1a, 0x1f, 0xa0, 0x6b, 0x50, 0xe9, 0x1c, 0xe9,
+	0xb6, 0x8d, 0x7b, 0x6d, 0x5b, 0xb7, 0x30, 0xdb, 0x4a, 0x49, 0x2b, 0x0b, 0xda, 0x8e, 0x6e, 0xe1,
+	0x54, 0x3b, 0x5a, 0x82, 0x72, 0x5f, 0x77, 0x3d, 0x33, 0xa2, 0xb3, 0x30, 0x49, 0xfd, 0x8d, 0x02,
+	0x0b, 0xef, 0x11, 0x62, 0x76, 0xed, 0xa1, 0x9d, 0x2d, 0x40, 0xc1, 0x76, 0x0c, 0xdc, 0x5a, 0x67,
+	0x5b, 0xcb, 0x6a, 0x62, 0x84, 0x2e, 0x41, 0xa9, 0x8f, 0xb1, 0xdb, 0x76, 0x9d, 0x9e, 0xbf, 0xb1,
+	0x22, 0x25, 0x68, 0x4e, 0x0f, 0xa3, 0x0f, 0x61, 0x8e, 0xc4, 0x26, 0x22, 0x8d, 0xec, 0x52, 0x76,
+	0xb9, 0xbc, 0x72, 0xfd, 0xce, 0x90, 0x95, 0xdd, 0x89, 0x2f, 0xaa, 0x0d, 0x4b, 0xab, 0x8f, 0x33,
+	0x70, 0x5e, 0xf2, 0xf1, 0xbd, 0xd2, 0xbf, 0xa9, 0xe6, 0x08, 0xee, 0xca, 0xed, 0xf1, 0x41, 0x1a,
+	0xcd, 0x49, 0x95, 0x67, 0xc3, 0x2a, 0x4f, 0x61, 0x60, 0x71, 0x7d, 0xe6, 0x87, 0xf4, 0x89, 0xae,
+	0x42, 0x19, 0x3f, 0xec, 0x9b, 0x2e, 0x6e, 0x7b, 0xa6, 0x85, 0x1b, 0x85, 0x25, 0x65, 0x39, 0xa7,
+	0x01, 0x27, 0xed, 0x9b, 0x56, 0xd8, 0x22, 0x67, 0x52, 0x5b, 0xa4, 0xfa, 0x5b, 0x05, 0x2e, 0x0c,
+	0xdd, 0x92, 0x30, 0x71, 0x0d, 0xea, 0xec, 0xe4, 0x81, 0x66, 0xa8, 0xb1, 0x53, 0x85, 0xdf, 0x1c,
+	0xa7, 0xf0, 0x80, 0x5d, 0x1b, 0x92, 0x0f, 0x6d, 0x32, 0x93, 0x7e, 0x93, 0xc7, 0x70, 0x61, 0x13,
+	0x7b, 0x62, 0x01, 0xfa, 0x1b, 0x26, 0xd3, 0x43, 0x40, 0xd4, 0x97, 0x32, 0x43, 0xbe, 0xf4, 0xe7,
+	0x8c, 0xf4, 0x25, 0xb6, 0x54, 0xcb, 0x3e, 0x74, 0xd0, 0x65, 0x28, 0x49, 0x16, 0x61, 0x15, 0x01,
+	0x01, 0xbd, 0x0e, 0x79, 0xba, 0x53, 0x6e, 0x12, 0xb5, 0x95, 0x6b, 0xc9, 0x67, 0x0a, 0xcd, 0xa9,
+	0x71, 0x7e, 0xd4, 0x82, 0x1a, 0xf1, 0x74, 0xd7, 0x6b, 0xf7, 0x1d, 0xc2, 0xee, 0x99, 0x19, 0x4e,
+	0x79, 0x45, 0x8d, 0xce, 0x20, 0x21, 0x72, 0x9b, 0x74, 0x77, 0x05, 0xa7, 0x56, 0x65, 0x92, 0xfe,
+	0x10, 0xbd, 0x0f, 0x15, 0x6c, 0x1b, 0xc1, 0x44, 0xb9, 0xd4, 0x13, 0x95, 0xb1, 0x6d, 0xc8, 0x69,
+	0x82, 0xfb, 0xc9, 0xa7, 0xbf, 0x9f, 0xaf, 0x14, 0x68, 0x0c, 0x5f, 0xd0, 0x59, 0x80, 0xf2, 0x4d,
+	0x2e, 0x84, 0xf9, 0x05, 0x8d, 0xf5, 0x70, 0x79, 0x49, 0x9a, 0x10, 0x51, 0x4d, 0x78, 0x2e, 0xd8,
+	0x0d, 0xfb, 0xe5, 0xa9, 0x19, 0xcb, 0x97, 0x0a, 0x2c, 0xc4, 0xd7, 0x3a, 0xcb, 0xb9, 0xff, 0x07,
+	0xf2, 0xa6, 0x7d, 0xe8, 0xf8, 0xc7, 0x5e, 0x1c, 0xe3, 0x67, 0x74, 0x2d, 0xce, 0xac, 0x5a, 0x70,
+	0x69, 0x13, 0x7b, 0x2d, 0x9b, 0x60, 0xd7, 0x5b, 0x35, 0xed, 0x9e, 0xd3, 0xdd, 0xd5, 0xbd, 0xa3,
+	0x33, 0xf8, 0x48, 0xc4, 0xdc, 0x33, 0x31, 0x73, 0x57, 0x7f, 0xaf, 0xc0, 0xe5, 0xe4, 0xf5, 0xc4,
+	0xd1, 0x9b, 0x50, 0x3c, 0x34, 0x71, 0xcf, 0xa0, 0x3a, 0x53, 0x98, 0xce, 0xe4, 0x98, 0xfa, 0x4a,
+	0x9f, 0x32, 0x8b, 0x13, 0x5e, 0x1b, 0x61, 0xa0, 0x7b, 0x9e, 0x6b, 0xda, 0xdd, 0x2d, 0x93, 0x78,
+	0x1a, 0xe7, 0x0f, 0xe9, 0x33, 0x9b, 0xde, 0x32, 0x7f, 0xaa, 0xc0, 0xe2, 0x26, 0xf6, 0xd6, 0x24,
+	0xd4, 0xd2, 0xdf, 0x4d, 0xe2, 0x99, 0x1d, 0xf2, 0x74, 0x93, 0x88, 0x84, 0x98, 0xa9, 0xfe, 0x4c,
+	0x81, 0xab, 0x23, 0x37, 0x23, 0x54, 0x27, 0xa0, 0xc4, 0x07, 0xda, 0x64, 0x28, 0xf9, 0x3f, 0xfc,
+	0xe8, 0x63, 0xbd, 0x37, 0xc0, 0xbb, 0xba, 0xe9, 0x72, 0x28, 0x99, 0x12, 0x58, 0xff, 0xa4, 0xc0,
+	0x95, 0x4d, 0xec, 0xed, 0xfa, 0x61, 0xe6, 0x19, 0x6a, 0x27, 0x45, 0x46, 0xf1, 0x35, 0xbf, 0xcc,
+	0xc4, 0xdd, 0x3e, 0x13, 0xf5, 0x2d, 0x32, 0x3f, 0x08, 0x39, 0xe4, 0x1a, 0xcf, 0x05, 0x84, 0xf2,
+	0xd4, 0xc7, 0x59, 0xa8, 0x7c, 0x2c, 0xf2, 0x03, 0x16, 0x46, 0xe2, 0x7a, 0x50, 0x92, 0xf5, 0x10,
+	0x4a, 0x29, 0x92, 0xb2, 0x8c, 0x4d, 0xa8, 0x12, 0x8c, 0x8f, 0xa7, 0x09, 0x1a, 0x15, 0x2a, 0x28,
+	0xc1, 0x7e, 0x0b, 0xe6, 0x06, 0xf6, 0x21, 0x4d, 0x6b, 0xb1, 0x21, 0x4e, 0xc1, 0xb3, 0xcb, 0xc9,
+	0xc8, 0x33, 0x2c, 0x88, 0x3e, 0x80, 0xd9, 0xf8, 0x5c, 0xf9, 0x54, 0x73, 0xc5, 0xc5, 0x50, 0x0b,
+	0xea, 0x86, 0xeb, 0xf4, 0xfb, 0xd8, 0x68, 0x13, 0x7f, 0xaa, 0x42, 0xba, 0xa9, 0x84, 0x9c, 0x3f,
+	0x95, 0xfa, 0x13, 0x05, 0x16, 0xee, 0xeb, 0x5e, 0xe7, 0x68, 0xdd, 0x12, 0x97, 0x73, 0x06, 0xd3,
+	0x7e, 0x1b, 0x4a, 0x0f, 0xc4, 0x45, 0xf8, 0xf8, 0x75, 0x35, 0x61, 0x43, 0xe1, 0x2b, 0xd7, 0x02,
+	0x09, 0xf5, 0x1b, 0x05, 0xe6, 0x59, 0x11, 0xe1, 0xef, 0xee, 0xbb, 0x77, 0xb2, 0x09, 0x85, 0x04,
+	0xba, 0x09, 0x35, 0x4b, 0x77, 0x8f, 0xf7, 0x02, 0x9e, 0x3c, 0xe3, 0x89, 0x51, 0xd5, 0x87, 0x00,
+	0x62, 0xb4, 0x4d, 0xba, 0x53, 0xec, 0xff, 0x0d, 0x98, 0x11, 0xab, 0x0a, 0x7f, 0x9b, 0x74, 0xb1,
+	0x3e, 0xbb, 0xfa, 0xad, 0x02, 0xb5, 0x00, 0x41, 0x99, 0x57, 0xd5, 0x20, 0x23, 0x7d, 0x29, 0xd3,
+	0x5a, 0x47, 0x6f, 0x43, 0x81, 0x97, 0x8d, 0x62, 0xee, 0x1b, 0xd1, 0xb9, 0x45, 0x49, 0x19, 0x82,
+	0x61, 0x46, 0xd0, 0x84, 0x10, 0xd5, 0x91, 0x44, 0x1d, 0x5e, 0x61, 0x64, 0xb5, 0x10, 0x05, 0xb5,
+	0x60, 0x36, 0x9a, 0xb4, 0xf9, 0x3e, 0xb3, 0x34, 0x0a, 0x6d, 0xd6, 0x75, 0x4f, 0x67, 0x60, 0x53,
+	0x8b, 0xe4, 0x6c, 0x44, 0xfd, 0x4f, 0x1e, 0xca, 0xa1, 0x53, 0x0e, 0x9d, 0x24, 0x7e, 0xa5, 0x99,
+	0xc9, 0xb8, 0x99, 0x1d, 0xae, 0x1c, 0x6e, 0x40, 0xcd, 0x64, 0xb1, 0xba, 0x2d, 0x4c, 0x91, 0x81,
+	0x6b, 0x49, 0xab, 0x72, 0xaa, 0xf0, 0x0b, 0xb4, 0x08, 0x65, 0x7b, 0x60, 0xb5, 0x9d, 0xc3, 0xb6,
+	0xeb, 0x9c, 0x10, 0x51, 0x82, 0x94, 0xec, 0x81, 0xf5, 0xff, 0x87, 0x9a, 0x73, 0x42, 0x82, 0x2c,
+	0xb7, 0x70, 0xca, 0x2c, 0x77, 0x11, 0xca, 0x96, 0xfe, 0x90, 0xce, 0xda, 0xb6, 0x07, 0x16, 0xab,
+	0x4e, 0xb2, 0x5a, 0xc9, 0xd2, 0x1f, 0x6a, 0xce, 0xc9, 0xce, 0xc0, 0x42, 0xcb, 0x50, 0xef, 0xe9,
+	0xc4, 0x6b, 0x87, 0xcb, 0x9b, 0x22, 0x2b, 0x6f, 0x6a, 0x94, 0xfe, 0x7e, 0x50, 0xe2, 0x0c, 0xe7,
+	0xcb, 0xa5, 0x33, 0xe4, 0xcb, 0x86, 0xd5, 0x0b, 0x26, 0x82, 0xf4, 0xf9, 0xb2, 0x61, 0xf5, 0xe4,
+	0x34, 0x6f, 0xc0, 0xcc, 0x01, 0xcb, 0x80, 0x48, 0xa3, 0x3c, 0x12, 0xa1, 0x36, 0x68, 0xf2, 0xc3,
+	0x13, 0x25, 0xcd, 0x67, 0x47, 0x6f, 0x41, 0x89, 0x85, 0x1e, 0x26, 0x5b, 0x49, 0x25, 0x1b, 0x08,
+	0x50, 0x69, 0x03, 0xf7, 0x3c, 0x9d, 0x49, 0x57, 0xd3, 0x49, 0x4b, 0x01, 0xf4, 0x0a, 0x9c, 0xef,
+	0xb8, 0x58, 0xf7, 0xb0, 0xb1, 0xfa, 0x68, 0xcd, 0xb1, 0xfa, 0x3a, 0x33, 0xa6, 0x46, 0x6d, 0x49,
+	0x59, 0x2e, 0x6a, 0x49, 0x3f, 0x51, 0x60, 0xe8, 0xc8, 0xd1, 0x86, 0xeb, 0x58, 0x8d, 0x59, 0x0e,
+	0x0c, 0x51, 0x2a, 0xba, 0x02, 0xe0, 0x43, 0xb7, 0xee, 0x35, 0xea, 0xec, 0x16, 0x4b, 0x82, 0xf2,
+	0x9e, 0xa7, 0x7e, 0x01, 0xf3, 0x81, 0x85, 0x84, 0x6e, 0x63, 0xf8, 0x62, 0x95, 0x69, 0x2f, 0x76,
+	0x7c, 0xee, 0xfa, 0x97, 0x1c, 0x2c, 0xec, 0xe9, 0x0f, 0xf0, 0xd3, 0x4f, 0x93, 0x53, 0xe1, 0xf1,
+	0x16, 0xcc, 0xb1, 0xcc, 0x78, 0x25, 0xb4, 0x9f, 0x31, 0x11, 0x38, 0x7c, 0x9d, 0xc3, 0x82, 0xe8,
+	0x5d, 0x9a, 0x3a, 0xe0, 0xce, 0xf1, 0xae, 0x63, 0x06, 0xd1, 0xf7, 0x4a, 0xc2, 0x3c, 0x6b, 0x92,
+	0x4b, 0x0b, 0x4b, 0xa0, 0xdd, 0x61, 0x68, 0xe3, 0x71, 0xf7, 0x85, 0xb1, 0xf5, 0x57, 0xa0, 0xfd,
+	0x38, 0xc2, 0xa1, 0x06, 0xcc, 0x88, 0xe8, 0xce, 0xfc, 0xbe, 0xa8, 0xf9, 0x43, 0xb4, 0x0b, 0xe7,
+	0xf9, 0x09, 0xf6, 0x84, 0x51, 0xf3, 0xc3, 0x17, 0x53, 0x1d, 0x3e, 0x49, 0x34, 0xea, 0x13, 0xa5,
+	0xd3, 0xfa, 0x44, 0x03, 0x66, 0x84, 0x9d, 0x32, 0x2c, 0x28, 0x6a, 0xfe, 0x90, 0x16, 0x11, 0x10,
+	0x68, 0x6c, 0x42, 0x2f, 0xe0, 0x1d, 0x28, 0x4a, 0x1b, 0xce, 0xa4, 0xb6, 0x61, 0x29, 0x13, 0x47,
+	0xe1, 0x6c, 0x0c, 0x85, 0xd5, 0x7f, 0x2a, 0x50, 0x59, 0xa7, 0x9b, 0xde, 0x72, 0xba, 0x2c, 0x66,
+	0xdc, 0x80, 0x9a, 0x8b, 0x3b, 0x8e, 0x6b, 0xb4, 0xb1, 0xed, 0xb9, 0x26, 0xe6, 0xf5, 0x66, 0x4e,
+	0xab, 0x72, 0xea, 0xfb, 0x9c, 0x48, 0xd9, 0x28, 0xb0, 0x12, 0x4f, 0xb7, 0xfa, 0xed, 0x43, 0xea,
+	0xc0, 0x19, 0xce, 0x26, 0xa9, 0xcc, 0x7f, 0xaf, 0x41, 0x25, 0x60, 0xf3, 0x1c, 0xb6, 0x7e, 0x4e,
+	0x2b, 0x4b, 0xda, 0xbe, 0x83, 0x9e, 0x87, 0x1a, 0xd3, 0x5a, 0xbb, 0xe7, 0x74, 0xdb, 0xb4, 0x36,
+	0x13, 0xe1, 0xa4, 0x62, 0x88, 0x6d, 0xd1, 0xdb, 0x88, 0x72, 0x11, 0xf3, 0x73, 0x2c, 0x02, 0x8a,
+	0xe4, 0xda, 0x33, 0x3f, 0xc7, 0x34, 0x9a, 0x57, 0x69, 0x74, 0xdc, 0x71, 0x0c, 0xbc, 0x3f, 0x65,
+	0x2e, 0x91, 0xa2, 0x2f, 0x77, 0x19, 0x4a, 0xf2, 0x04, 0xe2, 0x48, 0x01, 0x01, 0x6d, 0x40, 0xcd,
+	0x4f, 0x33, 0xdb, 0xbc, 0x7a, 0xc8, 0x8d, 0xcc, 0xed, 0x42, 0xf1, 0x8d, 0x68, 0x55, 0x5f, 0x8c,
+	0x0d, 0xd5, 0x0d, 0xa8, 0x84, 0x7f, 0xa6, 0xab, 0xee, 0xc5, 0x0d, 0x45, 0x12, 0xa8, 0xbd, 0xed,
+	0x0c, 0x2c, 0x7a, 0xa7, 0x02, 0x3a, 0xfc, 0xa1, 0xfa, 0xa5, 0x02, 0x55, 0x11, 0x94, 0xf7, 0x64,
+	0xdf, 0x98, 0x1d, 0x4d, 0x61, 0x47, 0x63, 0x7f, 0xa3, 0xff, 0x8d, 0x36, 0x9d, 0x9e, 0x4f, 0x74,
+	0x73, 0x36, 0x09, 0xcb, 0x7f, 0x23, 0x11, 0x39, 0x4d, 0xb5, 0xfa, 0x98, 0x1a, 0x9a, 0xb8, 0x1a,
+	0x66, 0x68, 0x0d, 0x98, 0xd1, 0x0d, 0xc3, 0xc5, 0x84, 0x88, 0x7d, 0xf8, 0x43, 0xfa, 0xcb, 0x03,
+	0xec, 0x12, 0xdf, 0xe4, 0xb3, 0x9a, 0x3f, 0x44, 0x6f, 0x41, 0x51, 0x26, 0xcc, 0xd9, 0xa4, 0x24,
+	0x29, 0xbc, 0x4f, 0x51, 0x5d, 0x49, 0x09, 0xf5, 0xeb, 0x0c, 0xd4, 0x84, 0xc2, 0x56, 0x45, 0xd4,
+	0x1c, 0xef, 0x7c, 0xab, 0x50, 0x39, 0x0c, 0xbc, 0x7b, 0x5c, 0x17, 0x25, 0x0c, 0x02, 0x11, 0x99,
+	0x49, 0x0e, 0x18, 0x8d, 0xdb, 0xb9, 0x33, 0xc5, 0xed, 0xfc, 0x29, 0x31, 0x4a, 0xfd, 0x01, 0x94,
+	0x43, 0xbf, 0x30, 0x70, 0xe5, 0x7d, 0x15, 0xa1, 0x0a, 0x7f, 0x88, 0xee, 0x05, 0x69, 0x09, 0xd7,
+	0xc1, 0xc5, 0x84, 0x45, 0x62, 0x19, 0x89, 0xfa, 0x07, 0x05, 0x0a, 0x62, 0xe6, 0xab, 0x50, 0x16,
+	0x68, 0xc2, 0x52, 0x36, 0x3e, 0x3b, 0x08, 0x12, 0xcd, 0xd9, 0x9e, 0x1c, 0x9c, 0x5c, 0x84, 0x62,
+	0x0c, 0x48, 0x66, 0x04, 0xa2, 0xfb, 0x3f, 0x85, 0xd0, 0x83, 0xfe, 0xc4, 0x80, 0xe3, 0x1b, 0x85,
+	0xf5, 0x84, 0x35, 0xdc, 0x71, 0x1e, 0x60, 0xf7, 0xd1, 0xd9, 0x3b, 0x6f, 0x6f, 0x86, 0x2c, 0x35,
+	0x65, 0x69, 0x27, 0x05, 0xd0, 0x9b, 0x81, 0xba, 0xb3, 0x49, 0x8d, 0x87, 0x30, 0x74, 0x08, 0x3b,
+	0x0b, 0xd4, 0xfe, 0x73, 0xde, 0x43, 0x8c, 0x1e, 0x65, 0xda, 0x94, 0xe4, 0x89, 0x54, 0x0c, 0xea,
+	0x2f, 0x15, 0xb8, 0xb8, 0x89, 0xbd, 0x8d, 0x68, 0x5d, 0xfe, 0xac, 0x77, 0x65, 0x41, 0x33, 0x69,
+	0x53, 0x67, 0xb9, 0xf5, 0x26, 0x14, 0x65, 0x87, 0x81, 0x77, 0x77, 0xe5, 0x58, 0xfd, 0xb1, 0x02,
+	0x0d, 0xb1, 0x0a, 0x5b, 0x93, 0x66, 0xc3, 0x3d, 0xec, 0x61, 0xe3, 0xbb, 0x2e, 0x79, 0xff, 0xa1,
+	0x40, 0x3d, 0x0c, 0xe5, 0x0c, 0x8d, 0x5f, 0x83, 0x3c, 0xeb, 0x2c, 0x88, 0x1d, 0x4c, 0x34, 0x56,
+	0xce, 0x4d, 0x21, 0x83, 0x65, 0x68, 0xfb, 0x32, 0xea, 0x88, 0x61, 0x10, 0x4f, 0xb2, 0xa7, 0x8f,
+	0x27, 0x22, 0xbe, 0x3a, 0x03, 0x3a, 0x2f, 0xef, 0xdc, 0x05, 0x04, 0xf5, 0xab, 0x0c, 0x34, 0x82,
+	0x52, 0xe2, 0x3b, 0x07, 0xf4, 0x11, 0x89, 0x66, 0xf6, 0x09, 0x25, 0x9a, 0xb9, 0xd3, 0x82, 0xf8,
+	0xdf, 0x33, 0x50, 0x0b, 0xd4, 0xb1, 0xdb, 0xd3, 0x6d, 0xb4, 0x00, 0x85, 0x7e, 0x4f, 0x0f, 0x3a,
+	0x82, 0x62, 0x84, 0xf6, 0x64, 0x66, 0x12, 0x55, 0xc0, 0x4b, 0x49, 0x97, 0x33, 0x42, 0xc3, 0x5a,
+	0x6c, 0x0a, 0x5a, 0xa2, 0xf1, 0x24, 0x9f, 0x15, 0xda, 0x22, 0x1b, 0xe2, 0x56, 0x40, 0x6b, 0xec,
+	0xdb, 0x80, 0xc4, 0xd5, 0xb5, 0x4d, 0xbb, 0x4d, 0x70, 0xc7, 0xb1, 0x0d, 0x7e, 0xa9, 0x79, 0xad,
+	0x2e, 0x7e, 0x69, 0xd9, 0x7b, 0x9c, 0x8e, 0x5e, 0x83, 0x9c, 0xf7, 0xa8, 0xcf, 0xe1, 0xb9, 0x96,
+	0x08, 0x7b, 0xc1, 0xbe, 0xf6, 0x1f, 0xf5, 0xb1, 0xc6, 0xd8, 0xd1, 0x22, 0x00, 0x9d, 0xca, 0x73,
+	0xf5, 0x07, 0xb8, 0xe7, 0x7f, 0xcb, 0x0c, 0x28, 0xd4, 0x4c, 0xfd, 0x5e, 0xc5, 0x0c, 0x8f, 0x09,
+	0x62, 0xa8, 0xfe, 0x35, 0x03, 0xf5, 0x60, 0x4a, 0x0d, 0x93, 0x41, 0xcf, 0x1b, 0xa9, 0xbf, 0xf1,
+	0x05, 0xda, 0xa4, 0x48, 0xff, 0x2e, 0x94, 0x45, 0xdf, 0xe4, 0x14, 0x17, 0x0d, 0x5c, 0x64, 0x6b,
+	0x8c, 0xe5, 0xe5, 0x9f, 0x90, 0xe5, 0x15, 0x4e, 0x6b, 0x79, 0x7b, 0xb0, 0xe0, 0x03, 0x5a, 0xc0,
+	0xb0, 0x8d, 0x3d, 0x7d, 0x4c, 0x26, 0x71, 0x15, 0xca, 0x3c, 0x50, 0xf1, 0x08, 0xcd, 0x93, 0x6b,
+	0x38, 0x90, 0x55, 0xa7, 0xfa, 0x43, 0x98, 0x67, 0x80, 0x10, 0x6f, 0xaf, 0xa6, 0xe9, 0x75, 0xab,
+	0x32, 0x75, 0xa7, 0x69, 0x3a, 0xb7, 0xee, 0x92, 0x16, 0xa1, 0xa9, 0x5b, 0xf0, 0x5c, 0x6c, 0xfe,
+	0x33, 0x00, 0x3e, 0xcd, 0x71, 0x16, 0xf6, 0xa2, 0x9f, 0x2a, 0xa7, 0x0f, 0x6b, 0x57, 0x64, 0x37,
+	0xb5, 0x6d, 0x1a, 0x71, 0xfb, 0x32, 0xd0, 0x3b, 0x50, 0xb2, 0xf1, 0x49, 0x3b, 0x8c, 0xaa, 0x29,
+	0x9a, 0x66, 0x45, 0x1b, 0x9f, 0xb0, 0xbf, 0xd4, 0x1d, 0xb8, 0x30, 0xb4, 0xd5, 0xb3, 0x9c, 0xfd,
+	0x6f, 0x0a, 0x5c, 0x5c, 0x77, 0x9d, 0xfe, 0xc7, 0xa6, 0xeb, 0x0d, 0xf4, 0x5e, 0xf4, 0x63, 0xc5,
+	0xd3, 0x29, 0xbc, 0x3e, 0x08, 0xc5, 0x57, 0x0e, 0xb8, 0xb7, 0x13, 0xcc, 0x75, 0x78, 0x53, 0xe2,
+	0xd0, 0xa1, 0x68, 0xfc, 0xef, 0x6c, 0xd2, 0xe6, 0x05, 0xdf, 0x84, 0x28, 0x92, 0x26, 0xfd, 0x48,
+	0xec, 0xc4, 0x64, 0xa7, 0xed, 0xc4, 0x8c, 0xf0, 0xfc, 0xdc, 0x13, 0xf2, 0xfc, 0xd3, 0x16, 0x0e,
+	0xe8, 0x03, 0x88, 0x76, 0xc9, 0x18, 0xe4, 0x4e, 0xd5, 0x5e, 0x5b, 0x05, 0x08, 0x3a, 0x46, 0xe2,
+	0xa5, 0x49, 0x9a, 0x69, 0x42, 0x52, 0xf4, 0xb6, 0x24, 0xca, 0xb2, 0x4e, 0x6f, 0xa4, 0xc3, 0xf1,
+	0x21, 0x34, 0x93, 0xac, 0xf4, 0x2c, 0x96, 0xff, 0x75, 0x06, 0xa0, 0x65, 0xf5, 0x1d, 0xd7, 0xdb,
+	0xd7, 0xc9, 0xf1, 0x74, 0xa9, 0xe2, 0x75, 0xa8, 0x06, 0x06, 0x13, 0xf8, 0x7b, 0xd8, 0x8a, 0x0c,
+	0xea, 0x12, 0x32, 0x63, 0xa5, 0x3c, 0x43, 0x59, 0xac, 0x81, 0x2e, 0x41, 0xc9, 0x75, 0x4e, 0xda,
+	0xd4, 0x83, 0x0c, 0x16, 0x56, 0x8b, 0x5a, 0xd1, 0x75, 0x4e, 0xa8, 0x5f, 0x19, 0xe8, 0x02, 0xcc,
+	0x78, 0x3a, 0x39, 0xa6, 0xa2, 0xbc, 0xe0, 0x29, 0xd0, 0x61, 0xcb, 0x40, 0xf3, 0x90, 0x3f, 0x34,
+	0x7b, 0x98, 0x83, 0x7e, 0x49, 0xe3, 0x03, 0xf4, 0xba, 0xff, 0x5c, 0x60, 0x26, 0xf5, 0xe7, 0x4e,
+	0xfe, 0x62, 0xe0, 0x1b, 0x05, 0x66, 0x03, 0x85, 0x30, 0x6c, 0xa1, 0x70, 0xc5, 0xa0, 0x6a, 0xcd,
+	0x31, 0x38, 0x0a, 0xd4, 0x46, 0x7c, 0xd1, 0xe0, 0x82, 0x1c, 0x90, 0x02, 0x91, 0x71, 0xb9, 0x34,
+	0x3d, 0x17, 0x3d, 0xb4, 0x69, 0xf8, 0x1f, 0x54, 0x0a, 0xae, 0x73, 0xd2, 0x32, 0x88, 0xaf, 0x0d,
+	0xfe, 0x6a, 0x8a, 0x67, 0x8e, 0x54, 0x1b, 0x6b, 0xec, 0xe1, 0xd4, 0x75, 0xa8, 0x62, 0xd7, 0x75,
+	0xdc, 0xb6, 0x85, 0x09, 0xd1, 0xbb, 0x3c, 0xcb, 0x28, 0x69, 0x15, 0x46, 0xdc, 0xe6, 0x34, 0xf5,
+	0xdb, 0x0c, 0xd4, 0x82, 0xa3, 0xf8, 0x9f, 0x51, 0x4c, 0xc3, 0xff, 0x8c, 0x62, 0x1a, 0x14, 0xa7,
+	0x5d, 0x8e, 0x72, 0x21, 0x9c, 0x16, 0x94, 0x96, 0x41, 0x43, 0x1c, 0xf5, 0x1d, 0xdb, 0x31, 0x70,
+	0x70, 0x67, 0xe0, 0x93, 0x5a, 0xc6, 0xf0, 0xd5, 0xe7, 0x52, 0x5c, 0x7d, 0x7e, 0xf8, 0xea, 0x17,
+	0xa0, 0x70, 0x30, 0xe8, 0x1c, 0x63, 0x8f, 0xb9, 0x5f, 0x49, 0x13, 0xa3, 0xa8, 0x49, 0xcc, 0xc4,
+	0x4c, 0x42, 0xde, 0x7c, 0x31, 0x7c, 0xf3, 0x97, 0xa0, 0xc4, 0xdb, 0xf4, 0x6d, 0x8f, 0xb0, 0x8f,
+	0x20, 0x59, 0xad, 0xc8, 0x09, 0xfb, 0x04, 0xbd, 0xe1, 0xa7, 0xf2, 0x89, 0x1f, 0x35, 0x18, 0x4e,
+	0xc4, 0x2e, 0x5f, 0x24, 0xf2, 0xea, 0xa7, 0x80, 0x82, 0x5f, 0xce, 0x56, 0x5a, 0xc5, 0xb4, 0x9a,
+	0x89, 0x6b, 0x55, 0xfd, 0xa3, 0x02, 0x73, 0xe1, 0xc5, 0xa6, 0x0d, 0x43, 0xef, 0x40, 0xd9, 0x64,
+	0xd3, 0xb4, 0xa9, 0xaf, 0x88, 0xe2, 0xea, 0xca, 0xd8, 0x33, 0x6b, 0x60, 0x06, 0x68, 0x70, 0x1d,
+	0xaa, 0x27, 0x8e, 0x7b, 0x6c, 0xda, 0xdd, 0x36, 0xdd, 0x99, 0x6f, 0xa1, 0x15, 0x41, 0xdc, 0xa1,
+	0xb4, 0x5b, 0xbf, 0x52, 0x60, 0x6e, 0xa8, 0xfc, 0x41, 0x35, 0x80, 0x8f, 0xec, 0x8e, 0xa8, 0x0b,
+	0xeb, 0xe7, 0x50, 0x05, 0x8a, 0x7e, 0x95, 0x58, 0x57, 0x50, 0x19, 0x66, 0xf6, 0x1d, 0xc6, 0x5d,
+	0xcf, 0xa0, 0x3a, 0x54, 0xb8, 0xe0, 0xa0, 0xd3, 0xc1, 0x84, 0xd4, 0xb3, 0x92, 0xb2, 0xa1, 0x9b,
+	0xbd, 0x81, 0x8b, 0xeb, 0x39, 0x54, 0x85, 0xd2, 0xbe, 0xa3, 0xe1, 0x1e, 0xd6, 0x09, 0xae, 0xe7,
+	0x11, 0x82, 0x9a, 0x18, 0xf8, 0x42, 0x85, 0x10, 0xcd, 0x17, 0x9b, 0xb9, 0x75, 0x18, 0xae, 0x27,
+	0x68, 0x92, 0x8d, 0x2e, 0xc0, 0xf9, 0x8f, 0x6c, 0x03, 0x1f, 0x9a, 0x36, 0x36, 0x82, 0x9f, 0xea,
+	0xe7, 0xd0, 0x79, 0x98, 0x6d, 0xd9, 0x36, 0x76, 0x43, 0x44, 0x85, 0x12, 0xb7, 0xb1, 0xdb, 0xc5,
+	0x21, 0x62, 0x06, 0xcd, 0x41, 0x75, 0xdb, 0x7c, 0x18, 0x22, 0x65, 0x57, 0xfe, 0x35, 0x0f, 0xa5,
+	0x75, 0xdd, 0xd3, 0xd7, 0x1c, 0xc7, 0x35, 0x50, 0x1f, 0x10, 0x7b, 0xcc, 0x62, 0xf5, 0x1d, 0x5b,
+	0xbe, 0xfa, 0x42, 0xaf, 0x8c, 0x08, 0x05, 0xc3, 0xac, 0xe2, 0xc2, 0x9b, 0x37, 0x47, 0x48, 0xc4,
+	0xd8, 0xd5, 0x73, 0xc8, 0x62, 0x2b, 0xd2, 0x22, 0x65, 0xdf, 0xec, 0x1c, 0xfb, 0x9f, 0x2d, 0xc7,
+	0xac, 0x18, 0x63, 0xf5, 0x57, 0x8c, 0x3d, 0x26, 0x13, 0x03, 0xfe, 0xe2, 0xc8, 0xb7, 0x79, 0xf5,
+	0x1c, 0xfa, 0x0c, 0xe6, 0x37, 0xb1, 0x17, 0x3c, 0x32, 0xf1, 0x17, 0x5c, 0x19, 0xbd, 0xe0, 0x10,
+	0xf3, 0x29, 0x97, 0xdc, 0x82, 0x3c, 0x6b, 0x35, 0xa0, 0xa4, 0x72, 0x3e, 0xfc, 0xf4, 0xb9, 0xb9,
+	0x34, 0x9a, 0x41, 0xce, 0xf6, 0x29, 0xcc, 0xc6, 0x9e, 0x76, 0xa2, 0x17, 0x13, 0xc4, 0x92, 0x1f,
+	0xe9, 0x36, 0x6f, 0xa5, 0x61, 0x95, 0x6b, 0x75, 0xa1, 0x16, 0x7d, 0x0a, 0x83, 0x96, 0x13, 0xe4,
+	0x13, 0x9f, 0xe5, 0x35, 0x5f, 0x4c, 0xc1, 0x29, 0x17, 0xb2, 0xa0, 0x1e, 0x7f, 0x6a, 0x88, 0x6e,
+	0x8d, 0x9d, 0x20, 0x6a, 0x6e, 0x2f, 0xa5, 0xe2, 0x95, 0xcb, 0x3d, 0x62, 0x46, 0x30, 0xf4, 0xd4,
+	0x0d, 0xdd, 0x49, 0x9e, 0x66, 0xd4, 0x1b, 0xbc, 0xe6, 0xdd, 0xd4, 0xfc, 0x72, 0xe9, 0x1f, 0xf1,
+	0x16, 0x67, 0xd2, 0x73, 0x31, 0xf4, 0x6a, 0xf2, 0x74, 0x63, 0xde, 0xb9, 0x35, 0x57, 0x4e, 0x23,
+	0x22, 0x37, 0xf1, 0x05, 0xeb, 0x4d, 0x26, 0x3c, 0xb9, 0x8a, 0xfb, 0x9d, 0x3f, 0xdf, 0xe8, 0xb7,
+	0x64, 0xcd, 0x57, 0x4f, 0x21, 0x21, 0x37, 0xe0, 0xc4, 0x1f, 0x73, 0xfa, 0x6e, 0x78, 0x77, 0xa2,
+	0xd5, 0x4c, 0xe7, 0x83, 0x9f, 0xc0, 0x6c, 0xec, 0x03, 0x71, 0xa2, 0xd7, 0x24, 0x7f, 0x44, 0x6e,
+	0x8e, 0x0b, 0x8d, 0xdc, 0x25, 0x63, 0xad, 0x5e, 0x34, 0xc2, 0xfa, 0x13, 0xda, 0xc1, 0xcd, 0x5b,
+	0x69, 0x58, 0xe5, 0x41, 0x08, 0x83, 0xcb, 0x58, 0xbb, 0x14, 0xdd, 0x4e, 0x9e, 0x23, 0xb9, 0xd5,
+	0xdb, 0x7c, 0x39, 0x25, 0xb7, 0x5c, 0xb4, 0x0d, 0xb0, 0x89, 0xbd, 0x6d, 0xec, 0xb9, 0xd4, 0x46,
+	0x6e, 0x26, 0xaa, 0x3c, 0x60, 0xf0, 0x97, 0x79, 0x61, 0x22, 0x9f, 0x5c, 0xe0, 0x7b, 0x80, 0xfc,
+	0x10, 0x1b, 0x7a, 0x9e, 0x70, 0x7d, 0x6c, 0xe3, 0x89, 0x77, 0x89, 0x26, 0xdd, 0xcd, 0x67, 0x50,
+	0xdf, 0xd6, 0x6d, 0x5a, 0x72, 0x04, 0xf3, 0xde, 0x4e, 0xdc, 0x58, 0x9c, 0x6d, 0x84, 0xb6, 0x46,
+	0x72, 0xcb, 0xc3, 0x9c, 0xc8, 0x18, 0xaa, 0x4b, 0x17, 0xc4, 0x71, 0x6c, 0x09, 0xb4, 0x11, 0x63,
+	0x1c, 0x81, 0x2d, 0x63, 0xf8, 0xe5, 0xc2, 0x8f, 0x15, 0xf6, 0x64, 0x38, 0xc6, 0x70, 0xdf, 0xf4,
+	0x8e, 0x76, 0x7b, 0xba, 0x4d, 0xd2, 0x6c, 0x81, 0x31, 0x9e, 0x62, 0x0b, 0x82, 0x5f, 0x6e, 0xc1,
+	0x80, 0x6a, 0xa4, 0xaf, 0x83, 0x92, 0xde, 0x18, 0x24, 0x75, 0x96, 0x9a, 0xcb, 0x93, 0x19, 0xe5,
+	0x2a, 0x47, 0x50, 0xf5, 0xed, 0x95, 0x2b, 0xf7, 0xc5, 0x51, 0x3b, 0x0d, 0x78, 0x46, 0xb8, 0x5b,
+	0x32, 0x6b, 0xd8, 0xdd, 0x86, 0xcb, 0x56, 0x94, 0xae, 0xdd, 0x31, 0xce, 0xdd, 0x46, 0xd7, 0xc2,
+	0x1c, 0x4f, 0x62, 0x2d, 0xa2, 0x64, 0xb0, 0x4a, 0xec, 0x78, 0x25, 0xe2, 0xc9, 0x88, 0x8e, 0x93,
+	0x7a, 0x0e, 0xdd, 0x87, 0x02, 0xcf, 0xa0, 0xd1, 0xf3, 0xe3, 0x93, 0x6b, 0x31, 0xfb, 0x8d, 0x09,
+	0x5c, 0xfe, 0xc4, 0x2b, 0xbf, 0xcb, 0x43, 0xd1, 0xff, 0xd2, 0xfc, 0x0c, 0xd2, 0xca, 0x67, 0x90,
+	0xe7, 0x7d, 0x02, 0xb3, 0xb1, 0x47, 0xa9, 0x89, 0xd7, 0x96, 0xfc, 0x70, 0x75, 0x12, 0x8e, 0xdd,
+	0x17, 0xff, 0xaa, 0x26, 0x21, 0xff, 0x85, 0x51, 0xb9, 0x62, 0x1c, 0xed, 0x27, 0x4c, 0xfc, 0xd4,
+	0xb1, 0x7d, 0x07, 0x20, 0x84, 0xbd, 0xe3, 0x3f, 0x26, 0x50, 0x38, 0x99, 0xb4, 0xe1, 0xed, 0x53,
+	0x5a, 0xec, 0xf8, 0xe9, 0x56, 0xef, 0x7d, 0xff, 0xd5, 0xae, 0xe9, 0x1d, 0x0d, 0x0e, 0xe8, 0x2f,
+	0x77, 0x39, 0xeb, 0xcb, 0xa6, 0x23, 0xfe, 0xba, 0xeb, 0x1b, 0xc8, 0x5d, 0x26, 0x7d, 0x97, 0xae,
+	0xd1, 0x3f, 0x38, 0x28, 0xb0, 0xd1, 0xbd, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x6f, 0xfb, 0xf2,
+	0xac, 0x1b, 0x39, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3790,6 +3890,7 @@ type DataCoordClient interface {
 	WatchChannels(ctx context.Context, in *WatchChannelsRequest, opts ...grpc.CallOption) (*WatchChannelsResponse, error)
 	GetFlushState(ctx context.Context, in *milvuspb.GetFlushStateRequest, opts ...grpc.CallOption) (*milvuspb.GetFlushStateResponse, error)
 	DropVirtualChannel(ctx context.Context, in *DropVirtualChannelRequest, opts ...grpc.CallOption) (*DropVirtualChannelResponse, error)
+	SetSegmentState(ctx context.Context, in *SetSegmentStateRequest, opts ...grpc.CallOption) (*SetSegmentStateResponse, error)
 	// https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load
 	Import(ctx context.Context, in *ImportTaskRequest, opts ...grpc.CallOption) (*ImportTaskResponse, error)
 }
@@ -4000,6 +4101,15 @@ func (c *dataCoordClient) DropVirtualChannel(ctx context.Context, in *DropVirtua
 	return out, nil
 }
 
+func (c *dataCoordClient) SetSegmentState(ctx context.Context, in *SetSegmentStateRequest, opts ...grpc.CallOption) (*SetSegmentStateResponse, error) {
+	out := new(SetSegmentStateResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/SetSegmentState", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *dataCoordClient) Import(ctx context.Context, in *ImportTaskRequest, opts ...grpc.CallOption) (*ImportTaskResponse, error) {
 	out := new(ImportTaskResponse)
 	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/Import", in, out, opts...)
@@ -4034,6 +4144,7 @@ type DataCoordServer interface {
 	WatchChannels(context.Context, *WatchChannelsRequest) (*WatchChannelsResponse, error)
 	GetFlushState(context.Context, *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)
 	DropVirtualChannel(context.Context, *DropVirtualChannelRequest) (*DropVirtualChannelResponse, error)
+	SetSegmentState(context.Context, *SetSegmentStateRequest) (*SetSegmentStateResponse, error)
 	// https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load
 	Import(context.Context, *ImportTaskRequest) (*ImportTaskResponse, error)
 }
@@ -4108,6 +4219,9 @@ func (*UnimplementedDataCoordServer) GetFlushState(ctx context.Context, req *mil
 func (*UnimplementedDataCoordServer) DropVirtualChannel(ctx context.Context, req *DropVirtualChannelRequest) (*DropVirtualChannelResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method DropVirtualChannel not implemented")
 }
+func (*UnimplementedDataCoordServer) SetSegmentState(ctx context.Context, req *SetSegmentStateRequest) (*SetSegmentStateResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method SetSegmentState not implemented")
+}
 func (*UnimplementedDataCoordServer) Import(ctx context.Context, req *ImportTaskRequest) (*ImportTaskResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Import not implemented")
 }
@@ -4512,6 +4626,24 @@ func _DataCoord_DropVirtualChannel_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _DataCoord_SetSegmentState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SetSegmentStateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DataCoordServer).SetSegmentState(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.data.DataCoord/SetSegmentState",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DataCoordServer).SetSegmentState(ctx, req.(*SetSegmentStateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _DataCoord_Import_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(ImportTaskRequest)
 	if err := dec(in); err != nil {
@@ -4622,6 +4754,10 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{
 			MethodName: "DropVirtualChannel",
 			Handler:    _DataCoord_DropVirtualChannel_Handler,
 		},
+		{
+			MethodName: "SetSegmentState",
+			Handler:    _DataCoord_SetSegmentState_Handler,
+		},
 		{
 			MethodName: "Import",
 			Handler:    _DataCoord_Import_Handler,

internal/proxy/data_coord_mock_test.go

@@ -206,6 +206,10 @@ func (coord *DataCoordMock) DropVirtualChannel(ctx context.Context, req *datapb.
 	return &datapb.DropVirtualChannelResponse{}, nil
 }
 
+func (coord *DataCoordMock) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) {
+	return &datapb.SetSegmentStateResponse{}, nil
+}
+
 func (coord *DataCoordMock) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error) {
 	return &datapb.ImportTaskResponse{}, nil
 }

internal/rootcoord/import_manager.go

@@ -458,12 +458,6 @@ func (m *importManager) updateImportTaskStore(ti *datapb.ImportTaskInfo) error {
 	return nil
 }
 
-// bringSegmentsOnline brings the segments online so that data in these segments become searchable.
-func (m *importManager) bringSegmentsOnline(ti *datapb.ImportTaskInfo) {
-	log.Info("Bringing import tasks segments online!", zap.Int64("Task ID", ti.GetId()))
-	// TODO: Implement it.
-}
-
 // expireOldTasksLoop starts a loop that checks and expires old tasks every `ImportTaskExpiration` seconds.
 func (m *importManager) expireOldTasksLoop(wg *sync.WaitGroup) {
 	defer wg.Done()
@@ -476,7 +470,8 @@ func (m *importManager) expireOldTasksLoop(wg *sync.WaitGroup) {
 			return
 		case <-ticker.C:
 			log.Info("(in loop) starting expiring old tasks...",
-				zap.Any("cleaning up interval", time.Duration(Params.RootCoordCfg.ImportTaskExpiration)))
+				zap.Duration("cleaning up interval",
+					time.Duration(Params.RootCoordCfg.ImportTaskExpiration*1000)*time.Millisecond))
 			m.expireOldTasks()
 		}
 	}
@@ -490,7 +485,7 @@ func (m *importManager) expireOldTasks() {
 		defer m.pendingLock.Unlock()
 		for _, t := range m.pendingTasks {
 			if taskExpired(t) {
-				log.Info("a pending task has expired", zap.Any("task info", t))
+				log.Info("a pending task has expired", zap.Int64("task ID", t.GetId()))
 				t.State.StateCode = commonpb.ImportState_ImportFailed
 				t.State.ErrorMessage = taskExpiredMsgPrefix +
 					(time.Duration(Params.RootCoordCfg.ImportTaskExpiration*1000) * time.Millisecond).String()
@@ -505,7 +500,7 @@ func (m *importManager) expireOldTasks() {
 		for _, v := range m.workingTasks {
 			// Mark this expired task as failed.
 			if taskExpired(v) {
-				log.Info("a working task has expired", zap.Any("task info", v))
+				log.Info("a working task has expired", zap.Int64("task ID", v.GetId()))
 				v.State.StateCode = commonpb.ImportState_ImportFailed
 				v.State.ErrorMessage = taskExpiredMsgPrefix +
 					(time.Duration(Params.RootCoordCfg.ImportTaskExpiration*1000) * time.Millisecond).String()

internal/rootcoord/root_coord.go

@@ -147,6 +147,9 @@ type Core struct {
 
 	CallWatchChannels func(ctx context.Context, collectionID int64, channelNames []string) error
 
+	// Update segment state.
+	CallUpdateSegmentStateService func(ctx context.Context, segID typeutil.UniqueID, ss commonpb.SegmentState) error
+
 	//assign import task to data service
 	CallImportService func(ctx context.Context, req *datapb.ImportTaskRequest) *datapb.ImportTaskResponse
 
@@ -274,6 +277,9 @@ func (c *Core) checkInit() error {
 	if c.CallGetFlushedSegmentsService == nil {
 		return fmt.Errorf("callGetFlushedSegmentsService is nil")
 	}
+	if c.CallUpdateSegmentStateService == nil {
+		return fmt.Errorf("CallUpdateSegmentStateService is nil")
+	}
 	if c.CallWatchChannels == nil {
 		return fmt.Errorf("callWatchChannels is nil")
 	}
@@ -597,7 +603,7 @@ func (c *Core) SetNewProxyClient(f func(sess *sessionutil.Session) (types.Proxy,
 	}
 }
 
-// SetDataCoord set datacoord
+// SetDataCoord set dataCoord.
 func (c *Core) SetDataCoord(ctx context.Context, s types.DataCoord) error {
 	initCh := make(chan struct{})
 	go func() {
@@ -714,6 +720,29 @@ func (c *Core) SetDataCoord(ctx context.Context, s types.DataCoord) error {
 		return rsp.Segments, nil
 	}
 
+	c.CallUpdateSegmentStateService = func(ctx context.Context, segID typeutil.UniqueID, ss commonpb.SegmentState) (retErr error) {
+		defer func() {
+			if err := recover(); err != nil {
+				retErr = fmt.Errorf("update segment state from data coord panic, msg = %v", err)
+			}
+		}()
+		<-initCh
+		req := &datapb.SetSegmentStateRequest{
+			SegmentId: segID,
+			NewState:  ss,
+		}
+		resp, err := s.SetSegmentState(ctx, req)
+		if err != nil || resp.GetStatus().GetErrorCode() != commonpb.ErrorCode_Success {
+			log.Error("failed to update segment state",
+				zap.Any("request", req), zap.Any("response", resp), zap.Error(err))
+			return err
+		}
+		log.Info("successfully set segment state",
+			zap.Int64("segment ID", req.GetSegmentId()),
+			zap.String("new segment state", req.GetNewState().String()))
+		return nil
+	}
+
 	c.CallWatchChannels = func(ctx context.Context, collectionID int64, channelNames []string) (retErr error) {
 		defer func() {
 			if err := recover(); err != nil {
@@ -2263,13 +2292,14 @@ func (c *Core) GetImportState(ctx context.Context, req *milvuspb.GetImportStateR
 			Status: failStatus(commonpb.ErrorCode_UnexpectedError, "StateCode="+internalpb.StateCode_name[int32(code)]),
 		}, nil
 	}
-
-	return c.importManager.getTaskState(req.Task), nil
+	return c.importManager.getTaskState(req.GetTask()), nil
 }
 
 // ReportImport reports import task state to RootCoord.
 func (c *Core) ReportImport(ctx context.Context, ir *rootcoordpb.ImportResult) (*commonpb.Status, error) {
-	log.Info("receive import state report", zap.Any("import result", ir))
+	log.Info("receive import state report",
+		zap.Int64("task ID", ir.GetTaskId()),
+		zap.Any("import state", ir.GetState()))
 	if code, ok := c.checkHealthy(); !ok {
 		return failStatus(commonpb.ErrorCode_UnexpectedError, "StateCode="+internalpb.StateCode_name[int32(code)]), nil
 	}
@@ -2428,30 +2458,41 @@ func (c *Core) checkCompleteIndexLoop(ctx context.Context, ti *datapb.ImportTask
 	for {
 		select {
 		case <-c.ctx.Done():
-			log.Info("(in loop)context done, exiting checkCompleteIndexLoop",
+			log.Info("(in check complete index loop) context done, exiting checkCompleteIndexLoop",
 				zap.Int64("task ID", ti.GetId()))
 			return
 		case <-ticker.C:
-			log.Info("(in loop)check segments' index states", zap.Int64("task ID", ti.GetId()))
+			log.Info("(in check complete index loop) check segments' index states", zap.Int64("task ID", ti.GetId()))
 			if ct, err := c.CountCompleteIndex(ctx, colName, ti.GetCollectionId(), segIDs); err == nil &&
 				segmentsOnlineReady(ct, len(segIDs)) {
-				log.Info("(in loop)segment indices are ready",
+				log.Info("segment indices are ready",
 					zap.Int64("task ID", ti.GetId()),
 					zap.Int("total # of segments", len(segIDs)),
 					zap.Int("# of segments with index ready", ct))
-				c.importManager.bringSegmentsOnline(ti)
+				c.bringSegmentsOnline(ctx, segIDs)
 				return
 			}
 		case <-expireTicker.C:
-			log.Info("(in loop)waited for sufficiently long time, bring segments online",
+			log.Info("(in check complete index loop) waited for sufficiently long time, bring segments online",
 				zap.Int64("task ID", ti.GetId()))
-			c.importManager.bringSegmentsOnline(ti)
+			c.bringSegmentsOnline(ctx, segIDs)
 			return
 		}
 	}
 }
 
-// segmentsOnlineReady returns true if segments are ready to go up online (a.k.a. searchable).
+// bringSegmentsOnline brings the segments online so that data in these segments become searchable
+// it is done by changing segments' states from `importing` to `flushed`.
+func (c *Core) bringSegmentsOnline(ctx context.Context, segIDs []UniqueID) {
+	log.Info("bringing import task's segments online!", zap.Any("segment IDs", segIDs))
+	// TODO: Make update on segment states atomic.
+	for _, id := range segIDs {
+		// Explicitly mark segment states `flushed`.
+		c.CallUpdateSegmentStateService(ctx, id, commonpb.SegmentState_Flushed)
+	}
+}
+
+// segmentsOnlineReady returns true if segments are ready to go up online (a.k.a. become searchable).
 func segmentsOnlineReady(idxBuilt, segCount int) bool {
 	// Consider segments are ready when:
 	// (1) all but up to 2 segments have indices ready, or

internal/types/types.go

@@ -255,6 +255,8 @@ type DataCoord interface {
 	WatchChannels(ctx context.Context, req *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error)
 	// GetFlushState gets the flush state of multiple segments
 	GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)
+	// SetSegmentState updates a segment's state explicitly.
+	SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error)
 
 	// DropVirtualChannel notifies DataCoord a virtual channel is dropped and
 	// updates related segments binlogs(including insert binlogs, stats logs and delta logs)

internal/util/mock/datacoord_client.go

@@ -119,6 +119,10 @@ func (m *DataCoordClient) DropVirtualChannel(ctx context.Context, req *datapb.Dr
 	return &datapb.DropVirtualChannelResponse{}, m.Err
 }
 
+func (m *DataCoordClient) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest, opts ...grpc.CallOption) (*datapb.SetSegmentStateResponse, error) {
+	return &datapb.SetSegmentStateResponse{}, m.Err
+}
+
 func (m *DataCoordClient) Import(ctx context.Context, req *datapb.ImportTaskRequest, opts ...grpc.CallOption) (*datapb.ImportTaskResponse, error) {
 	return &datapb.ImportTaskResponse{}, m.Err
 }