connection

type AbstractConnection struct {
	Logger logger.Logger

	Conn    net.Conn
	Address string
	// contains filtered or unexported fields
}

type AbstractConnectionManager struct {
	Logger logger.Logger

	MinConnectionsNum int
	MaxConnectionsNum int

	RuntimeConfiguration runtime.Configuration
	Configuration        *ManagerConfigration
	// contains filtered or unexported fields
}

type AbstractControlMessageConnection struct {
	*AbstractConnection
	// contains filtered or unexported fields
}

type AbstractEventConnection struct {
	*AbstractConnection
	// contains filtered or unexported fields
}

type Connection struct {
	*AbstractEventConnection
}

type ConnectionAllocator struct {
	*AbstractConnectionManager
	// contains filtered or unexported fields
}

type ConnectionManager interface {

	// Prepare initializes resources or configurations necessary for the ConnectionManager
	Prepare() error

	// Start begins the operations required for the ConnectionManager to accept and manage connections
	Start() error

	// Stop halts the operations of the ConnectionManager
	Stop() error

	// Allocate provides an instance of EventConnection for handling event
	Allocate() (EventConnection, error)

	// GetAddressesForWrapperStart returns a list of addresses as required for starting a wrapper
	GetAddressesForWrapperStart() ([]string, string)

	// UpdateStatistics records performance or usage statistics based on the
	// duration of an event or process, specified in seconds
	UpdateStatistics(durationSec float64)

	// SetStatus updates the operational status of the ConnectionManager
	SetStatus(status.Status)
}

type ControlMessageSocket struct {
	*AbstractControlMessageConnection
	// contains filtered or unexported fields
}

type EventConnection interface {
	// WaitForStart waits for connection and handler to be ready for event processing
	WaitForStart()

	// Stop stops the event connection and performs any necessary cleanup tasks
	Stop()

	// ProcessEvent processes a single event item, using the provided functionLogger for any logging
	ProcessEvent(item interface{}, functionLogger logger.Logger) (*result.BatchedResults, error)

	// RunHandler starts the main event handler loop, managing incoming responses until the connection is stopped
	RunHandler()
}

type EventSocket struct {
	*AbstractEventConnection
	// contains filtered or unexported fields
}

type ManagerConfigration struct {
	Kind                        ManagerKind
	SupportControlCommunication bool
	WaitForStart                bool
	SocketType                  SocketType
	GetEventEncoderFunc         func(writer io.Writer) encoder.EventEncoder
	Statistics                  runtime.Statistics
	// contains filtered or unexported fields
}

type ManagerKind string

type SocketAllocator struct {
	*AbstractConnectionManager
	// contains filtered or unexported fields
}

type SocketType int