api

type AlterDatabaseParam struct {
	ReplicateParam
	*milvuspb.AlterDatabaseRequest
}

type AlterIndexParam struct {
	ReplicateParam
	*milvuspb.AlterIndexRequest
}

type BaseTaskMsg struct {
	TaskID         string   `json:"task_id"`
	MsgID          string   `json:"msg_id"`
	TargetChannels []string `json:"target_channels"`
	ReadyChannels  []string `json:"ready_channels"`
}

type ChannelManager interface {
	SetCtx(ctx context.Context)
	AddDroppedCollection(ids []int64)
	AddDroppedPartition(ids []int64)

	StartReadCollection(ctx context.Context, db *model.DatabaseInfo, info *pb.CollectionInfo, seekPositions []*msgpb.MsgPosition, channelStartTsMap map[string]uint64) error
	StopReadCollection(ctx context.Context, info *pb.CollectionInfo) error
	AddPartition(ctx context.Context, dbInfo *model.DatabaseInfo, collectionInfo *pb.CollectionInfo, partitionInfo *pb.PartitionInfo) error

	GetChannelChan() <-chan string
	GetMsgChan(pChannel string) <-chan *ReplicateMsg
	GetEventChan() <-chan *ReplicateAPIEvent

	GetChannelLatestMsgID(ctx context.Context, channelName string) ([]byte, error)
}

type CollectionEventConsumer CollectionFilter

type CollectionFilter func(*pb.CollectionInfo) bool

type CreateCollectionParam struct {
	MsgBaseParam
	ReplicateParam
	Schema           *entity.Schema
	ShardsNum        int32
	ConsistencyLevel commonpb.ConsistencyLevel
	Properties       []*commonpb.KeyValuePair
}

type CreateDatabaseParam struct {
	ReplicateParam
	*milvuspb.CreateDatabaseRequest
}

type CreateIndexParam struct {
	ReplicateParam
	*milvuspb.CreateIndexRequest
}

type CreatePartitionParam struct {
	MsgBaseParam
	ReplicateParam
	CollectionName string
	PartitionName  string
}

type CreatePrivilegeGroupParam struct {
	ReplicateParam
	*milvuspb.CreatePrivilegeGroupRequest
}

type CreateRoleParam struct {
	ReplicateParam
	*milvuspb.CreateRoleRequest
}

type CreateUserParam struct {
	ReplicateParam
	*milvuspb.CreateCredentialRequest
}

type DataFormatter interface {
	Format(data any) ([]byte, error)
}

type DataHandler interface {
	CreateCollection(ctx context.Context, param *CreateCollectionParam) error
	DropCollection(ctx context.Context, param *DropCollectionParam) error
	CreatePartition(ctx context.Context, param *CreatePartitionParam) error
	DropPartition(ctx context.Context, param *DropPartitionParam) error

	// Deprecated
	Insert(ctx context.Context, param *InsertParam) error
	// Deprecated
	Delete(ctx context.Context, param *DeleteParam) error
	Flush(ctx context.Context, param *FlushParam) error

	LoadCollection(ctx context.Context, param *LoadCollectionParam) error
	ReleaseCollection(ctx context.Context, param *ReleaseCollectionParam) error
	LoadPartitions(ctx context.Context, param *LoadPartitionsParam) error
	ReleasePartitions(ctx context.Context, param *ReleasePartitionsParam) error

	CreateIndex(ctx context.Context, param *CreateIndexParam) error
	DropIndex(ctx context.Context, param *DropIndexParam) error
	AlterIndex(ctx context.Context, param *AlterIndexParam) error

	CreateDatabase(ctx context.Context, param *CreateDatabaseParam) error
	DropDatabase(ctx context.Context, param *DropDatabaseParam) error
	AlterDatabase(ctx context.Context, param *AlterDatabaseParam) error

	ReplicateMessage(ctx context.Context, param *ReplicateMessageParam) error

	DescribeCollection(ctx context.Context, param *DescribeCollectionParam) error
	DescribeDatabase(ctx context.Context, param *DescribeDatabaseParam) error
	DescribePartition(ctx context.Context, param *DescribePartitionParam) error

	CreateUser(ctx context.Context, param *CreateUserParam) error
	DeleteUser(ctx context.Context, param *DeleteUserParam) error
	UpdateUser(ctx context.Context, param *UpdateUserParam) error
	CreateRole(ctx context.Context, param *CreateRoleParam) error
	DropRole(ctx context.Context, param *DropRoleParam) error
	OperateUserRole(ctx context.Context, param *OperateUserRoleParam) error
	OperatePrivilege(ctx context.Context, param *OperatePrivilegeParam) error
	OperatePrivilegeV2(ctx context.Context, param *OperatePrivilegeV2Param) error
	CreatePrivilegeGroup(ctx context.Context, param *CreatePrivilegeGroupParam) error
	DropPrivilegeGroup(ctx context.Context, param *DropPrivilegeGroupParam) error
	OperatePrivilegeGroup(ctx context.Context, param *OperatePrivilegeGroupParam) error
}

type DefaultChannelManager struct{}

type DefaultDataFormatter struct{}

type DefaultDataHandler struct{}

type DefaultMessageManager struct{}

type DefaultMetaOp struct{}

type DefaultReader struct{}

type DefaultTargetAPI struct{}

type DefaultWriter struct{}

type DeleteParam struct {
	MsgBaseParam
	ReplicateParam
	CollectionName string
	PartitionName  string
	Column         column.Column
}

type DeleteUserParam struct {
	ReplicateParam
	*milvuspb.DeleteCredentialRequest
}

type DescribeCollectionParam struct {
	ReplicateParam
	Name string
}

type DescribeDatabaseParam struct {
	ReplicateParam
	Name string
}

type DescribePartitionParam struct {
	ReplicateParam
	CollectionName string
	PartitionName  string
}

type DropCollectionParam struct {
	MsgBaseParam
	ReplicateParam
	CollectionName string
}

type DropDatabaseParam struct {
	ReplicateParam
	*milvuspb.DropDatabaseRequest
}

type DropIndexParam struct {
	ReplicateParam
	*milvuspb.DropIndexRequest
}

type DropPartitionParam struct {
	MsgBaseParam
	ReplicateParam
	CollectionName string
	PartitionName  string
}

type DropPrivilegeGroupParam struct {
	ReplicateParam
	*milvuspb.DropPrivilegeGroupRequest
}

type DropRoleParam struct {
	ReplicateParam
	*milvuspb.DropRoleRequest
}

type FlushParam struct {
	ReplicateParam
	*milvuspb.FlushRequest
}

type InsertParam struct {
	MsgBaseParam
	ReplicateParam
	CollectionName string
	PartitionName  string
	Columns        []column.Column
}

type LoadCollectionParam struct {
	ReplicateParam
	*milvuspb.LoadCollectionRequest
}

type LoadPartitionsParam struct {
	ReplicateParam
	*milvuspb.LoadPartitionsRequest
}

type MessageManager interface {
	ReplicateMessage(message *ReplicateMessage)
	Close(channelName string)
}

type MetaMsg struct {
	Base BaseTaskMsg            `json:"base"`
	Type MetaMsgType            `json:"type"`
	Data map[string]interface{} `json:"data"`
}

type MetaMsgType int

type MetaOp interface {
	// WatchCollection its implementation should make sure it's only called once. The WatchPartition is same
	WatchCollection(ctx context.Context, filter CollectionFilter)
	WatchPartition(ctx context.Context, filter PartitionFilter)
	StartWatch()

	// SubscribeCollectionEvent an event only is consumed once. The SubscribePartitionEvent is same
	// TODO need to consider the many target, maybe try the method a meta op corresponds to a target
	SubscribeCollectionEvent(taskID string, consumer CollectionEventConsumer)
	SubscribePartitionEvent(taskID string, consumer PartitionEventConsumer)
	UnsubscribeEvent(taskID string, eventType WatchEventType)

	GetAllCollection(ctx context.Context, filter CollectionFilter) ([]*pb.CollectionInfo, error)
	GetAllPartition(ctx context.Context, filter PartitionFilter) ([]*pb.PartitionInfo, error)
	GetAllDroppedObj() map[string]map[string]uint64
	GetCollectionNameByID(ctx context.Context, id int64) string
	GetDatabaseInfoForCollection(ctx context.Context, id int64) model.DatabaseInfo
}

type MsgBaseParam struct {
	Base *commonpb.MsgBase
}

type OperatePrivilegeGroupParam struct {
	ReplicateParam
	*milvuspb.OperatePrivilegeGroupRequest
}

type OperatePrivilegeParam struct {
	ReplicateParam
	*milvuspb.OperatePrivilegeRequest
}

type OperatePrivilegeV2Param struct {
	ReplicateParam
	*milvuspb.OperatePrivilegeV2Request
}

type OperateUserRoleParam struct {
	ReplicateParam
	*milvuspb.OperateUserRoleRequest
}

type PartitionEventConsumer PartitionFilter

type PartitionFilter func(info *pb.PartitionInfo) bool

type Reader interface {
	StartRead(ctx context.Context)
	QuitRead(ctx context.Context)
	ErrorChan() <-chan error
}

type ReleaseCollectionParam struct {
	ReplicateParam
	*milvuspb.ReleaseCollectionRequest
}

type ReleasePartitionsParam struct {
	ReplicateParam
	*milvuspb.ReleasePartitionsRequest
}

type ReplicateAPIEvent struct {
	EventType      ReplicateAPIEventType
	CollectionInfo *pb.CollectionInfo
	PartitionInfo  *pb.PartitionInfo
	ReplicateInfo  *commonpb.ReplicateInfo
	ReplicateParam ReplicateParam
	TaskID         string
	MsgID          string
	Error          error
}

type ReplicateAPIEventType int

type ReplicateMessage struct {
	Ctx         context.Context
	Param       *ReplicateMessageParam
	SuccessFunc func(param *ReplicateMessageParam)
	FailFunc    func(param *ReplicateMessageParam, err error)
}

type ReplicateMessageParam struct {
	MsgBaseParam
	ReplicateParam
	ChannelName                  string
	BeginTs, EndTs               uint64
	MsgsBytes                    [][]byte
	StartPositions, EndPositions []*msgpb.MsgPosition

	TargetMsgPosition string
}

type ReplicateMeta interface {
	UpdateTaskDropCollectionMsg(ctx context.Context, msg TaskDropCollectionMsg) (bool, error)
	GetTaskDropCollectionMsg(ctx context.Context, taskID string, msgID string) ([]TaskDropCollectionMsg, error)
	UpdateTaskDropPartitionMsg(ctx context.Context, msg TaskDropPartitionMsg) (bool, error)
	GetTaskDropPartitionMsg(ctx context.Context, taskID string, msgID string) ([]TaskDropPartitionMsg, error)
	RemoveTaskMsg(ctx context.Context, taskID string, msgID string) error
}

type ReplicateMsg struct {
	// source collection and channel info
	CollectionName string
	CollectionID   int64
	PChannelName   string
	TaskID         string
	MsgPack        *msgstream.MsgPack
}

type ReplicateParam struct {
	Database string
}

type ReplicateStore interface {
	Get(ctx context.Context, key string, withPrefix bool) ([]MetaMsg, error)
	Put(ctx context.Context, key string, value MetaMsg) error
	Remove(ctx context.Context, key string) error
}

type SimpleAttribution struct {
	Key   string
	Value string
}

type TargetAPI interface {
	GetCollectionInfo(ctx context.Context, collectionName, databaseName string) (*model.CollectionInfo, error)
	GetPartitionInfo(ctx context.Context, collectionName, databaseName string) (*model.CollectionInfo, error)
	GetDatabaseName(ctx context.Context, collectionName, databaseName string) (string, error)
}

type TaskDropCollectionMsg struct {
	Base           BaseTaskMsg `mapstructure:"-"`
	DatabaseName   string      `mapstructure:"database_name"`
	CollectionName string      `mapstructure:"collection_name"`
	DropTS         uint64      `mapstructure:"drop_ts"`
}

type TaskDropPartitionMsg struct {
	Base           BaseTaskMsg `mapstructure:"-"`
	DatabaseName   string      `mapstructure:"database_name"`
	CollectionName string      `mapstructure:"collection_name"`
	PartitionName  string      `mapstructure:"partition_name"`
	DropTS         uint64      `mapstructure:"drop_ts"`
}

type UpdateUserParam struct {
	ReplicateParam
	*milvuspb.UpdateCredentialRequest
}

type WatchEventType int

type Writer interface {
	HandleReplicateAPIEvent(ctx context.Context, apiEvent *ReplicateAPIEvent) error
	HandleReplicateMessage(ctx context.Context, channelName string, msgPack *msgstream.MsgPack) ([]byte, []byte, error)
	HandleOpMessagePack(ctx context.Context, msgPack *msgstream.MsgPack) ([]byte, error)
	RecoveryMetaMsg(ctx context.Context, taskID string) error
}