node

type FetchTaggedResultsIter interface {
	// NumIDs returns the total number of series IDs in the result.
	NumIDs() int

	// Exhaustive returns true if NumIDs is all IDs that the query could have returned.
	Exhaustive() bool

	// WaitedIndex counts how many times index querying had to wait for permits.
	WaitedIndex() int

	// WaitedSeriesRead counts how many times series being read had to wait for permits.
	WaitedSeriesRead() int

	// Namespace is the namespace.
	Namespace() ident.ID

	// Next advances to the next element, returning if one exists.
	//
	// Iterators that embed this interface should expose a Current() function to return the element retrieved by Next.
	// If an error occurs this returns false and it can be retrieved with Err.
	Next(ctx context.Context) bool

	// Err returns a non-nil error if an error occurred when calling Next().
	Err() error

	// Current returns the current IDResult fetched with Next. The result is only valid if Err is nil.
	Current() IDResult

	// Close closes the iterator. The provided error is non-nil if the client of the Iterator encountered an error
	// while iterating.
	Close(err error)
}

type IDResult interface {
	// ID returns the series ID.
	ID() []byte

	// WriteTags writes the encoded tags to provided slice. Callers must use the returned reference in case the slice needs
	// to grow, just like append().
	WriteTags(dst []byte) ([]byte, error)

	// WriteSegments writes the Segments to the provided slice. Callers must use the returned reference in case the slice
	// needs to grow, just like append().
	// This method blocks until segment data is available or the context deadline expires.
	WriteSegments(ctx context.Context, dst []*rpc.Segments) ([]*rpc.Segments, error)
}

type NewTChanChannelFn func(
	service Service,
	channelName string,
	opts *tchannel.ChannelOptions,
) (*tchannel.Channel, error)

type NewTChanNodeServerFn func(
	service Service,
	iOpts instrument.Options,
) thrift.TChanServer

type Options interface {
	// SetChannelOptions sets a tchan channel options.
	SetChannelOptions(value *tchannel.ChannelOptions) Options

	// ChannelOptions returns the tchan channel options.
	ChannelOptions() *tchannel.ChannelOptions

	// SetTChanChannelFn sets a tchan node channel registration.
	SetTChanChannelFn(value NewTChanChannelFn) Options

	// TChanChannelFn returns a tchan node channel registration.
	TChanChannelFn() NewTChanChannelFn

	// SetTChanNodeServerFn sets a tchan node server builder.
	SetTChanNodeServerFn(value NewTChanNodeServerFn) Options

	// TChanNodeServerFn returns a tchan node server builder.
	TChanNodeServerFn() NewTChanNodeServerFn

	// SetInstrumentOptions sets the instrumentation options.
	SetInstrumentOptions(value instrument.Options) Options

	// InstrumentOptions returns the instrumentation options.
	InstrumentOptions() instrument.Options
}

type Service interface {
	rpc.TChanNode

	// FetchTaggedIter returns an iterator for the results of FetchTagged.
	// It is the responsibility of the caller to close the returned iterator.
	FetchTaggedIter(ctx context.Context, req *rpc.FetchTaggedRequest) (FetchTaggedResultsIter, error)

	// SetDatabase only safe to be called one time once the service has started.
	SetDatabase(db storage.Database) error

	// Database returns the current database.
	Database() (storage.Database, error)

	// SetMetadata sets a metadata key to the given value.
	SetMetadata(key, value string)

	// Metadata returns the metadata for the given key and a bool indicating
	// if it is present.
	Metadata(key string) (string, bool)
}