wire

type AckFrame struct {
	// ID of the [MessageFrame] being acknowledged.
	ID uint64
}

type Conn interface {
	// Send sends the provided Frame to the peer. Send blocks until the Frame
	// has been sent to the peer, but does not wait for the peer to acknowledge
	// receipt of the Frame.
	//
	// Send returns an error if the context is canceled or if the connection is
	// closed.
	Send(context.Context, Frame) error

	// Recv receives the next Frame from the peer. Recv blocks until a Frame is
	// available. Recv returns an error if the context is canceled or if the
	// connection is closed.
	//
	// Callers should take care to avoid long periods of where there is not an
	// active call to Recv to avoid blocking the peer's Send call.
	Recv(context.Context) (Frame, error)

	// Close closes the Conn. Close may be called by either side of the
	// connection. After the connection has been closed, calls to Send or Recv
	// return [ErrConnClosed].
	Close() error

	// LocalAddr returns the address of the local side of the connection.
	LocalAddr() net.Addr

	// RemoteAddr returns the address of the remote side of the connection.
	RemoteAddr() net.Addr
}

type Dialer interface {
	// Dial connects to the scheduler peer at the provided "to" address. The
	// "from" address is used to establish the address that can be used to
	// connect back to the caller. Dial returns an error if the context is
	// canceled or if the connection cannot be established.
	Dial(ctx context.Context, from, to net.Addr) (Conn, error)
}

type DiscardFrame struct {
	// ID of the [MessageFrame] being discarded.
	ID uint64
}

type Error struct {
	// Code is an HTTP status code representing the kind of error received.
	Code int32

	// Message is a human-readable description of the error.
	Message string
}

type Frame interface {
	FrameKind() FrameKind
	// contains filtered or unexported methods
}

type FrameKind int

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

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

type HTTP2ListenerOptFunc func(*http2ListenerOpts)

type Handler func(ctx context.Context, peer *Peer, message Message) error

type Listener interface {
	// Accept waits for and returns the next connection to the listener. Accept
	// returns an error if the context is canceled or if the listener is closed.
	Accept(ctx context.Context) (Conn, error)

	// Close closes the listener. Any blocked Accept operations will be
	// unblocked and return errors.
	Close(ctx context.Context) error

	// Addr returns the listener's advertised network address. Peers use this
	// address to connect to the listener.
	Addr() net.Addr
}

type Local struct {
	// Address to broadcast when connecting to peers. Should be [LocalScheduler]
	// for the scheduler and [LocalWorker] for the worker.
	Address net.Addr
	// contains filtered or unexported fields
}

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

type Message interface {

	// Kind returns the kind of message.
	Kind() MessageKind
	// contains filtered or unexported methods
}

type MessageFrame struct {
	// ID uniquely identifies the message. It is up to the sender to ensure that
	// IDs are unique within a stream.
	ID uint64

	// Message being sent to the peer.
	Message Message
}

type MessageKind int

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

type NackFrame struct {
	// ID of the [MessageFrame] being negatively acknowledged.
	ID uint64

	// Error is the error that occurred.
	Error *Error
}

type Peer struct {
	Logger  log.Logger
	Metrics *Metrics
	Conn    Conn    // Connection to use for communication.
	Handler Handler // Handler for incoming messages from the remote peer.
	Buffer  int     // Buffer size for incoming and outgoing messages.
	// contains filtered or unexported fields
}

type StreamBindMessage struct {
	StreamID ulid.ULID // ID of the stream.
	Receiver net.Addr  // Address of the stream receiver.
}

type StreamDataMessage struct {
	StreamID ulid.ULID         // ID of the stream.
	Data     arrow.RecordBatch // Payload data for the stream.
}

type StreamStatusMessage struct {
	StreamID ulid.ULID            // ID of the stream.
	State    workflow.StreamState // State of the stream.
}

type TaskAssignMessage struct {
	Task *workflow.Task // Task to run.

	// StreamStates holds the most recent state of each stream that the task
	// reads from.
	//
	// StreamStates does not have any entries for streams that the task
	// writes to.
	StreamStates map[ulid.ULID]workflow.StreamState

	// Metadata holds additional metadata about the task.
	Metadata http.Header
}

type TaskCancelMessage struct {
	ID ulid.ULID // ID of the Task to cancel.
}

type TaskFlagMessage struct {
	ID ulid.ULID // ID of the Task to update.

	// Interruptible indicates that tasks blocked on writing or reading to a
	// [Stream] can be paused, and that worker can accept new tasks to run.
	// Tasks are not interruptible by default.
	Interruptible bool
}

type TaskStatusMessage struct {
	ID     ulid.ULID           // ID of the Task to update.
	Status workflow.TaskStatus // Current status of the task.
}

type WorkerHelloMessage struct {
	// Threads is the number of threads the worker has available.
	//
	// The scheduler uses Threads to determine the maximum number of tasks
	// that can be assigned concurrently to a worker.
	Threads int
}

type WorkerReadyMessage struct {
}

type WorkerSubscribeMessage struct {
}