asyncp

type AsyncOption func(opt *AsyncOptions)

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

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

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

type ClusterExt interface {
	RegisterApplication(ctx context.Context, mux *TaskMux) error
	UnregisterApplication() error
	ReceiveEvent(event Event, err error) error
	ExecEvent(failover bool, event Event, execTime time.Duration, err error) error
	TargetEventsAfter(eventName string) []string
	AllTasks() map[string][]string
	AllTaskChains() map[string][]string
}

type ClusterOption = func(cluster *Cluster)

type ContextWrapperFnk func(ctx context.Context) context.Context

type ErrorHandlerFnk func(Task, Event, error)

type Event interface {
	fmt.Stringer

	// ID of the event
	ID() uuid.UUID

	// Name of the event
	Name() string

	// Payload returns the current message payload
	Payload() Payload

	// Err returns error response object
	Err() error

	// CreatedAt returns the date of the event generation
	CreatedAt() time.Time

	// Mux returns base executer server
	Mux() *TaskMux

	// SetMux set new mux object
	SetMux(*TaskMux)

	// Mux returns origin promise object
	Promise() Promise

	// Promise set origin promise object
	SetPromise(Promise)

	// WithName returns new event with new name and current payload and error
	WithName(name string) Event

	// WithPayload returns new event object with extended payload context
	WithPayload(payload any) Event

	// WithError returns new event object with extended error value
	WithError(err error) Event

	// SetComplete marks event as complited or no
	SetComplete(b bool)

	// IsComplete returns marker of event completion
	IsComplete() bool

	// Counters returns current counter state
	Counters() (sent, retranslated int)

	// After provided event
	After(e Event) Event

	// Repeat event
	Repeat(e Event) Event

	// DoneTasks returns the list of previous event names
	DoneTasks() []string

	// HasDoneTask checks is the tasks has been processed
	HasDoneTask(name string) bool

	// Encode event to byte array
	Encode() ([]byte, error)

	// Decode event by the byte array
	Decode(data []byte) error
}

type EventAllocator interface {
	Decode(msg Message) (Event, error)
	Release(event Event) error
}

type FuncTask func(ctx context.Context, event Event, responseWriter ResponseWriter) error

type Message = notificationcenter.Message

type Option func(opt *Options)

type Options struct {
	MainExecContext context.Context
	PanicHandler    PanicHandlerFnk
	ErrorHandler    ErrorHandlerFnk
	ContextWrapper  ContextWrapperFnk
	ResponseFactory ResponseWriterFactory
	Cluster         ClusterExt
	EventAllocator  EventAllocator
}

type PanicHandlerFnk func(Task, Event, any)

type Payload interface {
	// Encode payload data to the bytes
	Encode() ([]byte, error)

	// Decode payload data into the target
	Decode(target any) error
}

type Promise interface {
	// EventName accepted by the item
	EventName() string

	// TargetEventName returns name of target event
	TargetEventName() []string

	// AfterEventName map event in the event queue
	AfterEventName() string

	// TargetEvent define
	TargetEvent(name string) Promise

	// Then execute the next task if current succeeded
	Then(handler any) Promise

	// ThenEvent which need to execute
	ThenEvent(name string)

	// Parent promise item
	Parent() Promise

	// Task executor interface
	Task() Task

	// IsVirtual promise type
	IsVirtual() bool
}

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

type Publisher = notificationcenter.Publisher

type Receiver = notificationcenter.Receiver

type ResponseHandlerFnk func(response any) error

type ResponseWriter interface {
	// WriteResonse sends data into the stream response
	WriteResonse(response any) error

	// RepeatWithResponse send data into the same stream response
	RepeatWithResponse(response any) error

	// Release response writer stream
	Release() error
}

type ResponseWriterFactory interface {
	// Borrow response writer by event and task object
	Borrow(ctx context.Context, promise Promise, event Event) ResponseWriter

	// Release response writer object
	Release(w ResponseWriter)
}

type Stream = notificationcenter.Publisher

type Subscriber = notificationcenter.Subscriber

type Task interface {
	// Execute the list of subtasks with input data collection.
	// It returns the new data collection which will be used in the next tasks as input params.
	Execute(ctx context.Context, event Event, responseWriter ResponseWriter) error
}

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