core

type ChannelObject struct {
	Msg      interface{}
	Sideline Sideline
	Version  int32
}

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

type ControlSignal uint8

type Distributor interface {
	//Distribute method take incoming data interface and number of outbound channels
	//to return the index of channel to be selected for Distribution of this message
	Distribute(data interface{}, size int) int
}

type DistributorType string

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

type DmuxConf struct {
	Size            int             `json:"size"`
	SourceQSize     int             `json:"source_queue_size"`
	SinkQSize       int             `json:"sink_queue_size"`
	DistributorType DistributorType `json:"distributor_type"`
	BatchSize       int             `json:"batch_size"`
	Version         int             `json:"version"`
	Sideline        Sideline        `json:"sideline"`
}

type DmuxOptionalParams struct {
	EnableDebugLog bool
}

type Duration struct {
	time.Duration
}

type Hasher interface {
	//ComputeHash method has to be implemented by Client to define how to distribute
	// when using HashDistributor
	ComputeHash(data interface{}) int
}

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

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

type Sideline struct {
	Retries               int         `json:"retries"`
	SidelineResponseCodes []int       `json:"sidelineResponseCodes"`
	ConsumerGroupName     string      `json:"consumerGroupName"`
	ClusterName           string      `json:"clusterName"`
	ConnectionType        string      `json:"type"`
	SidelineMeta          interface{} `json:"sidelineMeta"`
}

type Sink interface {
	// Clone method is expected to return instance of Sink. If Sink is Stateless
	// this can return selfRefrence back. If Sink is Stateful, its good idea to
	// create new instnace of Sink.
	Clone() Sink

	// Consume method gets The interface.
	//TODO currently this method does not return error, need to solve for error
	// handling
	Consume(msg interface{}, retries int, sidelineResponseCodes []int) error

	//BatchConsume method is invoked in batch_size is configured
	BatchConsume(msg []interface{}, version int)
}

type Source interface {
	//Generate method takes output channel to which it writes data. The
	//implementation can write to to this using multiple goroutines
	//This method is not expected to return, its run in a separate goroutine
	Generate(out chan<- interface{})
	//Method used to trigger GracefulStop of Source
	Stop()
	// GetKey Method to get key for a message
	GetKey(msg interface{}) []byte
	// GetPartition Method to get partition for a message
	GetPartition(msg interface{}) int32
	// GetValue Method to get value for a message
	GetValue(msg interface{}) []byte
	// GetOffset Method to get offsets
	GetOffset(msg interface{}) int64
}