varlog

type Admin interface {

	// GetStorageNode returns the metadata of the storage node specified by the argument snid.
	// If the admin server does not check the heartbeat of the storage node
	// yet, some fields are zero values, for instance, LastHeartbeatTime,
	// and Storages, Status, and StartTime of StorageNodeMetadataDescriptor.
	// It returns the ErrNotExist if the storage node does not exist.
	// It returns the ErrUnavailable if the cluster metadata cannot be
	// fetched from the metadata repository.
	GetStorageNode(ctx context.Context, snid types.StorageNodeID, opts ...AdminCallOption) (*admpb.StorageNodeMetadata, error)
	// ListStorageNodes returns a list of storage node metadata.
	// If the admin server does not check the heartbeat of the storage node
	// yet, some fields are zero values, for instance, LastHeartbeatTime,
	// and Storages, Status, and StartTime of StorageNodeMetadataDescriptor.
	// It returns the ErrUnavailable if the cluster metadata cannot be fetched from the metadata repository.
	//
	// Note that it should return an empty slice rather than nil to encode
	// to an empty array in JSON if no storage node exists in the cluster.
	ListStorageNodes(ctx context.Context, opts ...AdminCallOption) ([]admpb.StorageNodeMetadata, error)
	// GetStorageNodes returns a map of StorageNodeIDs and their addresses.
	// If the admin server does not check the heartbeat of the storage node
	// yet, some fields are zero values, for instance, LastHeartbeatTime,
	// and Storages, Status, and StartTime of StorageNodeMetadataDescriptor.
	// It returns the ErrUnavailable if the cluster metadata cannot be fetched from the metadata repository.
	//
	// Deprecated: Use ListStorageNodes.
	GetStorageNodes(ctx context.Context, opts ...AdminCallOption) (map[types.StorageNodeID]admpb.StorageNodeMetadata, error)
	// AddStorageNode registers a storage node, whose ID and address are
	// the argument snid and addr respectively, to the cluster.
	// It is okay to call AddStorageNode more than one time to add the same
	// storage node.
	// Once the storage node is registered, the pair of snid and addr
	// should not be changed.
	AddStorageNode(ctx context.Context, snid types.StorageNodeID, addr string, opts ...AdminCallOption) (*admpb.StorageNodeMetadata, error)
	// UnregisterStorageNode unregisters a storage node identified by the
	// argument snid from the cluster.
	// It is okay to unregister not existed storage node.
	// If the storage node still has running log stream replicas, it
	// returns an error.
	UnregisterStorageNode(ctx context.Context, snid types.StorageNodeID, opts ...AdminCallOption) error

	// GetTopic returns the metadata of the topic specified by the argument
	// tpid.
	// It returns the ErrNotExist error if the topic does not exist.
	// If the admin could not fetch cluster metadata, it returns an error,
	// and users can retry this RPC.
	GetTopic(ctx context.Context, tpid types.TopicID, opts ...AdminCallOption) (*varlogpb.TopicDescriptor, error)
	// ListTopics returns a list of all topics in the cluster.
	//
	// Note that it should return an empty slice rather than nil to encode
	// to an empty array in JSON if no topic exists in the cluster.
	ListTopics(ctx context.Context, opts ...AdminCallOption) ([]varlogpb.TopicDescriptor, error)
	// AddTopic adds a new topic and returns its metadata including a
	// unique topid ID.
	// It returns an error if rejected by the metadata repository due to
	// redundant topic ID or something else, and users can retry this RPC.
	AddTopic(ctx context.Context, opts ...AdminCallOption) (*varlogpb.TopicDescriptor, error)
	// UnregisterTopic removes a topic identified by the argument tpid from
	// the cluster.
	// It is okay to delete not existed topic.
	// It returns an error if it tries to delete the topic which has active
	// log streams.
	// If the admin could not fetch cluster metadata, it returns an error,
	// and users can retry this RPC.
	UnregisterTopic(ctx context.Context, tpid types.TopicID, opts ...AdminCallOption) error

	// GetLogStream returns metadata of log stream specified by the argument tpid and lsid.
	// It returns an error if there is no topic or log stream.
	GetLogStream(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID, opts ...AdminCallOption) (*varlogpb.LogStreamDescriptor, error)
	// ListLogStreams returns a list of log streams belonging to the topic
	// tpid.
	//
	// Note that it should return an empty slice rather than nil to encode
	// to an empty array in JSON if no log stream exists in the topic.
	ListLogStreams(ctx context.Context, tpid types.TopicID, opts ...AdminCallOption) ([]varlogpb.LogStreamDescriptor, error)
	// DescribeTopic returns detailed metadata of the topic.
	// Deprecated: Use ListLogStreams.
	DescribeTopic(ctx context.Context, topicID types.TopicID, opts ...AdminCallOption) (*admpb.DescribeTopicResponse, error)
	// AddLogStream adds a new log stream to the topic tpid.
	// It returns the error code ResourceExhausted if the number of log streams
	// is reached the upper limit.
	//
	// The admin server chooses proper replicas if the argument replicas are empty.
	// Otherwise, if the argument replicas are defined, the admin server
	// creates a new log stream with the given configuration by the
	// argument replicas. Each
	// `proto/varlogpb.(ReplicaDescriptor).StorageNodePath` in the argument
	// replicas should be set. In this case, the following conditions
	// should be satisfied:
	// - The number of replicas should be equal to the replication factor.
	// - Each storage node for each replica should exist.
	// - The log stream, which tries to add,  should not exist.
	//
	// Internally, it waits for the log stream for being sealed and unsealed.
	AddLogStream(ctx context.Context, tpid types.TopicID, replicas []*varlogpb.ReplicaDescriptor, opts ...AdminCallOption) (*varlogpb.LogStreamDescriptor, error)
	// UpdateLogStream changes replicas of the log stream.
	// This method swaps two replicas - the argument poppedReplica and
	// pushedReplica. The poppedReplica is the old replica that belonged to
	// the log stream, however, pushedReplica is the new replica to be
	// added to the log stream. Note that
	// `proto/varlogpb.(ReplicaDescriptor).StorageNodePath` in the
	// poppedReplica and pushedReplica should be set.
	UpdateLogStream(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID, poppedReplica varlogpb.ReplicaDescriptor, pushedReplica varlogpb.ReplicaDescriptor, opts ...AdminCallOption) (*varlogpb.LogStreamDescriptor, error)
	// UnregisterLogStream unregisters a log stream from the cluster.
	UnregisterLogStream(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID, opts ...AdminCallOption) error

	// RemoveLogStreamReplica removes a log stream replica from the storage
	// node.
	RemoveLogStreamReplica(ctx context.Context, snid types.StorageNodeID, tpid types.TopicID, lsid types.LogStreamID, opts ...AdminCallOption) error

	// Seal seals the log stream identified by the argument tpid and lsid.
	Seal(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID, opts ...AdminCallOption) (*admpb.SealResponse, error)
	// Unseal unseals the log stream identified by the argument tpid and
	// lsid.
	Unseal(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID, opts ...AdminCallOption) (*varlogpb.LogStreamDescriptor, error)
	// Sync copies logs of the log stream identified by the argument tpid
	// and lsid from the source storage node to the destination storage
	// node.
	Sync(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID, srcid, dstid types.StorageNodeID, opts ...AdminCallOption) (*snpb.SyncStatus, error)
	// Trim deletes logs whose GLSNs are less than or equal to the argument
	// lastGLSN.
	// Note that the return type of this method can be changed soon.
	Trim(ctx context.Context, tpid types.TopicID, lastGLSN types.GLSN, opts ...AdminCallOption) (map[types.LogStreamID]map[types.StorageNodeID]error, error)

	GetMetadataRepositoryNode(ctx context.Context, nid types.NodeID, opts ...AdminCallOption) (*varlogpb.MetadataRepositoryNode, error)
	ListMetadataRepositoryNodes(ctx context.Context, opts ...AdminCallOption) ([]varlogpb.MetadataRepositoryNode, error)
	// GetMRMembers returns metadata repositories of the cluster.
	GetMRMembers(ctx context.Context, opts ...AdminCallOption) (*admpb.GetMRMembersResponse, error)
	AddMetadataRepositoryNode(ctx context.Context, raftURL, rpcAddr string, opts ...AdminCallOption) (*varlogpb.MetadataRepositoryNode, error)
	// AddMRPeer registers a new metadata repository to the cluster.
	AddMRPeer(ctx context.Context, raftURL, rpcAddr string, opts ...AdminCallOption) (types.NodeID, error)
	DeleteMetadataRepositoryNode(ctx context.Context, nid types.NodeID, opts ...AdminCallOption) error
	// RemoveMRPeer unregisters the metadata repository from the cluster.
	RemoveMRPeer(ctx context.Context, raftURL string, opts ...AdminCallOption) error

	// Close closes a connection to the admin server.
	// Once this method is called, the Client can't be used anymore.
	Close() error
}

type AdminCallOption interface {
	// contains filtered or unexported methods
}

type AdminOption interface {
	// contains filtered or unexported methods
}

type Allowlist interface {
	GetAll(topicID types.TopicID) []types.LogStreamID
	Pick(topicID types.TopicID) (types.LogStreamID, bool)
	Deny(topicID types.TopicID, logStreamID types.LogStreamID)
	Contains(topicID types.TopicID, logStreamID types.LogStreamID) bool
}

type AppendOption interface {
	// contains filtered or unexported methods
}

type AppendResult struct {
	Metadata []varlogpb.LogEntryMeta
	Err      error
}

type BatchCallback func([]varlogpb.LogEntryMeta, error)

type Log interface {
	io.Closer

	Append(ctx context.Context, topicID types.TopicID, data [][]byte, opts ...AppendOption) AppendResult

	// AppendTo writes a list of data to the log stream identified by the topicID and
	// logStreamID arguments.
	// This method returns an AppendResult that contains a list of metadata for each log entry
	// and an error if partial failures occur.
	// The length of the metadata list can be less than or equal to the number of data since
	// metadata for failed operations is not included in the metadata list.
	AppendTo(ctx context.Context, topicID types.TopicID, logStreamID types.LogStreamID, data [][]byte, opts ...AppendOption) AppendResult

	Subscribe(ctx context.Context, topicID types.TopicID, begin types.GLSN, end types.GLSN, onNextFunc OnNext, opts ...SubscribeOption) (SubscribeCloser, error)

	SubscribeTo(ctx context.Context, topicID types.TopicID, logStreamID types.LogStreamID, begin, end types.LLSN, opts ...SubscribeOption) Subscriber

	Trim(ctx context.Context, topicID types.TopicID, until types.GLSN, opts TrimOption) error

	// PeekLogStream returns the log sequence numbers at the first and the
	// last. It fetches the metadata for each replica of a log stream lsid
	// concurrently and takes a result from either appendable or sealed
	// replica. If none of the replicas' statuses is either appendable or
	// sealed, it returns an error.
	PeekLogStream(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (first varlogpb.LogSequenceNumber, last varlogpb.LogSequenceNumber, err error)

	// NewLogStreamAppender returns a new LogStreamAppender.
	NewLogStreamAppender(tpid types.TopicID, lsid types.LogStreamID, opts ...LogStreamAppenderOption) (LogStreamAppender, error)

	// AppendableLogStreams returns all writable log streams belonging to the
	// topic specified by the argument tpid.
	AppendableLogStreams(tpid types.TopicID) map[types.LogStreamID]struct{}
}

type LogStreamAppender interface {
	// AppendBatch appends dataBatch to the given log stream asynchronously.
	// Users can call this method without being blocked until the pipeline of
	// the LogStreamAppender is full. If the pipeline of the LogStreamAppender
	// is already full, it may become blocked. However, the process will
	// continue once a response is received from the storage node. A long block
	// duration with a configured WithCallTimeout can cause ErrCallTimeout to
	// occur.
	//
	// On completion of AppendBatch, the argument callback provided by users
	// will be invoked. All callback functions registered to the same
	// LogStreamAppender will be called by the same goroutine sequentially.
	// Therefore, the callback should be lightweight. If heavy work is
	// necessary for the callback, it would be better to use separate worker
	// goroutines.
	// Once the stream in the LogStreamAppender is either done or broken, the
	// AppendBatch returns an error. It returns an ErrClosed when the
	// LogStreamAppender is closed and an ErrCallTimeout when the call timeout
	// expires.
	//
	// It is safe to have multiple goroutines calling AppendBatch
	// simultaneously, but the order between them is not guaranteed.
	AppendBatch(dataBatch [][]byte, callback BatchCallback) error

	// Close closes the LogStreamAppender client. Once the client is closed,
	// calling AppendBatch will fail immediately. If AppendBatch still waits
	// for room of pipeline, Close will be blocked. It also waits for all
	// pending callbacks to be called.
	Close()
}

type LogStreamAppenderOption interface {
	// contains filtered or unexported methods
}

type LogStreamSelector interface {
	Select(topicID types.TopicID) (types.LogStreamID, bool)
	GetAll(topicID types.TopicID) []types.LogStreamID
}

type MetadataRefresher interface {
	Refresh(context.Context)
	Metadata() *varlogpb.MetadataDescriptor
	Close() error
}

type MockAdmin struct {
	// contains filtered or unexported fields
}

type MockAdminMockRecorder struct {
	// contains filtered or unexported fields
}

type MockLog struct {
	// contains filtered or unexported fields
}

type MockLogMockRecorder struct {
	// contains filtered or unexported fields
}

type MockLogStreamAppender struct {
	// contains filtered or unexported fields
}

type MockLogStreamAppenderMockRecorder struct {
	// contains filtered or unexported fields
}

type MockMetadataRefresher struct {
	// contains filtered or unexported fields
}

type MockMetadataRefresherMockRecorder struct {
	// contains filtered or unexported fields
}

type MockRenewableReplicasRetriever struct {
	// contains filtered or unexported fields
}

type MockRenewableReplicasRetrieverMockRecorder struct {
	// contains filtered or unexported fields
}

type MockReplicasRetriever struct {
	// contains filtered or unexported fields
}

type MockReplicasRetrieverMockRecorder struct {
	// contains filtered or unexported fields
}

type OnNext func(logEntry varlogpb.LogEntry, err error)

type Option interface {
	// contains filtered or unexported methods
}

type PriorityQueue []PriorityQueueItem

type PriorityQueueItem interface {
	Priority() uint64
}

type Renewable interface {
	Renew(metadata *varlogpb.MetadataDescriptor)
}

type RenewableAllowlist interface {
	Allowlist
	Renewable
	io.Closer
}

type RenewableReplicasRetriever interface {
	ReplicasRetriever
	Renewable
}

type ReplicasRetriever interface {
	Retrieve(topicID types.TopicID, logStreamID types.LogStreamID) ([]varlogpb.LogStreamReplica, bool)
	All(topicID types.TopicID) map[types.LogStreamID][]varlogpb.LogStreamReplica
}

type SubscribeCloser func()

type SubscribeOption interface {
	// contains filtered or unexported methods
}

type Subscriber interface {
	Next() (varlogpb.LogEntry, error)
	io.Closer
}

type TrimOption struct {
}