dagger

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

type ComputationPlugin interface {
	GetInfo(definition string) (*ComputationPluginInfo, error)
	SubmitRecord(t *Record) (*ComputationPluginResponse, error)
	GetSnapshot() ([]byte, error)
	ApplySnapshot([]byte) error
	Stop() error
}

type ComputationPluginInfo struct {
	Inputs   []StreamID
	Stateful bool
}

type ComputationPluginResponse struct {
	Records []*Record
}

type ComputationPluginState struct {
	State []byte
}

type Config struct {
	SubscribersTTL time.Duration
	LevelDBFile    string
}

type ConsulConfig struct {
	Address   string
	TTL       string
	LockDelay time.Duration
}

type Coordinator interface {
	// GetSubscribers(string) ([]string, error)
	// GetConfig(string) (string, error)
	SubscribeCoordinator
	PublishCoordinator
	TaskCoordinator
	ReplicationCoordinator
	RegisterSession() (string, error)
	RenewSession(string) error
	Start(net.Addr, chan error) error
	Stop()
}

type Deduplicator interface {
	Seen(t *Record) (bool, error)
}

type Dispatcher struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type DispatcherConfig struct {
	PipeliningLimit int
}

type GroupHandler interface {
	GetStatus() (bool, string, error)
}

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

type HttpAPIConfig struct {
	Port string
}

type InputManager interface {
	SubscribeTo(StreamID, Timestamp, RecordProcessor)
	UnsubscribeFrom(StreamID, RecordProcessor)
	SetTaskManager(TaskManager)
}

type LWMTracker interface {
	RecordProcessor
	SentTracker
	BeforeDispatching([]*Record)
	GetCombinedLWM() Timestamp
	GetLocalLWM() Timestamp
	GetUpstreamLWM() Timestamp
}

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

type LinearizedRecordProcessor interface {
	ProcessRecordLinearized(*Record) error
}

type Linearizer struct {
	LWM Timestamp
	// contains filtered or unexported fields
}

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

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

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

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

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

type NewSubscriber struct {
	Addr string
	From Timestamp
}

type Persister interface {
	Close()
	TaskPersister
	StreamBuffer
	SentTracker
	ReceivedTracker
}

type PersisterConfig struct {
	Dir string
}

type PublishCoordinator interface {
	GetSubscribers(streamID StreamID) ([]string, error) // DEPRECATE
	WatchSubscribers(StreamID, chan struct{}) (chan string, chan string, chan error)
	GetSubscriberPosition(StreamID, string) (Timestamp, error)
	WatchSubscriberPosition(StreamID, string, chan struct{}) (chan Timestamp, chan error)
	RegisterAsPublisher(streamID StreamID) error
	RegisterAsPublisherWithSession(session string, streamID StreamID) error
	DeregisterAsPublisher(streamID StreamID) error
}

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

type ReceivedTracker interface {
	PersistReceivedRecords(StreamID, []*Record) error
	GetRecentReceived(StreamID) ([]string, error)
	ReceivedAlready(StreamID, *Record) (bool, error)
}

type Receiver interface {
	InputManager
	ListenAddr() net.Addr
	Listen(chan error)
}

type ReceiverConfig struct {
	Addr string
	Port string
}

type Record struct {
	ID string `json:"id"`

	StreamID  StreamID    `json:"stream_id"`
	LWM       Timestamp   `json:"lwm"`
	Timestamp Timestamp   `json:"timestamp"`
	Data      interface{} `json:"data"`
}

type RecordProcessor interface {
	ProcessRecord(*Record) error
}

type ReplicationCoordinator interface {
	JoinGroup(streamID StreamID) (GroupHandler, error)
}

type SentTracker interface {
	SentSuccessfuly(StreamID, *Record) error
}

type Session interface {
	ID() string
	Renew() error
}

type StreamBuffer interface {
	Insert(compID StreamID, bufID string, t *Record) error
	ReadBuffer(compID StreamID, bufID string, from Timestamp, to Timestamp, recCh chan<- *Record, errc chan<- error, readCompleted chan struct{})
}

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

type StreamID string

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

type SubscribeCoordinator interface {
	SubscribeTo(streamID StreamID, from Timestamp) error
	EnsurePublisherNum(StreamID, int, chan struct{}) chan error
	CheckpointPosition(streamID StreamID, from Timestamp) error
	UnsubscribeFrom(streamID StreamID) error
	WatchTagMatch(topic StreamID, addedRet chan string, droppedRet chan string, errc chan error)
}

type Tags map[string]string

type Task interface {
	RecordProcessor
	GetSnapshot() ([]byte, error)
	Sync() (Timestamp, error)
	Run(chan error)
	Stop()
}

type TaskCoordinator interface {
	// WatchTasks creates a watcher that watches when new tasks show up or
	// are dropped
	WatchTasks(chan struct{}) (chan []string, chan error)
	// AcquireTask tries to take a task from the task list. If another worker
	// manages to take the task, the call returns false.
	AcquireTask(StreamID) (bool, error)
	// TaskAcquired marks the task as successfuly acquired
	TaskAcquired(StreamID) error
	// ReleaseTask releases the lock on the task so others can try to acquire it
	ReleaseTask(StreamID) (bool, error)
}

type TaskInfo struct {
	StreamID StreamID
	Task     Task
	Inputs   []StreamID
	From     Timestamp
}

type TaskManager interface {
	ManageTasks() error
	GetTaskSnapshot(StreamID) ([]byte, error)
	Stop()
}

type TaskPersister interface {
	CommitComputation(compID StreamID, in *Record, out []*Record) error
	GetLastTimestamp(compID StreamID) (Timestamp, error)
	GetSnapshot(compID StreamID) ([]byte, error)
	ApplySnapshot(compID StreamID, snapshot []byte) error
}

type TaskStarter interface {
	StartTask(StreamID, string, string) (*TaskInfo, error)
}

type Timestamp int64