dispatcher

type AfterHandlerSelectedHook interface {
	AfterHandlerSelection(ctx context.Context, info *session.Info, rw any,
		handler i.Outbound) (context.Context, any, error)
}

type BeforeHandlerSelectionHook interface {
	BeforeHandlerSelection(ctx context.Context, info *session.Info,
		rw any) (context.Context, any, error)
}

type DebugHook struct {
}

type Dispatcher struct {
	BeforeHandlerSelectionHooks []BeforeHandlerSelectionHook
	Router                      i.Router
	OnHandlerSelectedHooks      []AfterHandlerSelectedHook
	SessionStartHooks           []SessionStartHook
	SessionEndHooks             []SessionEndHook
	TimeoutSetting              i.TimeoutSetting
	OnFallbacks                 []OnFallback
	FallbackTimeout             time.Duration

	OutStats *OutStats

	SessionStats        bool
	RewriteIpv6ToDomain bool
	HandlerLinkStats    bool
	HandlerMeter        bool

	Flows       atomic.Int32
	PacketConns atomic.Int32

	HandlerErrorObservers []i.HandlerErrorObserver
	// contains filtered or unexported fields
}

type Fallback interface {
	Fallback(ctx context.Context, info *session.Info,
		rw buf.ReaderWriter, handler i.Outbound, err error) error
}

type GetCounters interface {
	GetCounters(ctx context.Context, info *session.Info, handler i.Outbound) (session.UpCounters, session.DownCounters)
}

type IdleHook struct {
	TimeoutPolicy i.TimeoutSetting
}

type NullSessionErrorLogger struct{}

type OnFallback interface {
	OnFallback(info *session.Info, previousTag, tag string)
}

type OnHandlerErrorFunc func(tag string, err error)

type OutStats struct {
	sync.Mutex
	Map map[string]*OutboundHandlerStats
	// contains filtered or unexported fields
}

type OutboundHandlerStats struct {
	UpCounter   atomic.Uint64
	DownCounter atomic.Uint64
	// The time when the up/down counter is reset
	Interval   atomic.Value
	Throughput atomic.Uint64
	Ping       atomic.Uint64
	// The time when this handler is selected to handle
	Time atomic.Value
	// The time when there is response traffic from this handler
	ActiveTime atomic.Value //time.Time
}

type RealIpPacketConn struct {
	udp.PacketReaderWriter
	// contains filtered or unexported fields
}

type RewriteDestinationHook struct {
	Sniff               bool
	Sniffer             *sniff.Sniffer
	DestinationOverride []string
	FakeDns             i.FakeDnsPool
	Dns                 i.IPResolver
}

type SessionEndHook interface {
	// should return quickly
	FlowSessionEnd(ctx context.Context, info *session.Info, err error)
	PacketConnSessionEnd(ctx context.Context, info *session.Info, err error)
}

type SessionErrorLogger interface {
	LogSessionError(info *session.Info, err error)
}

type SessionStartHook interface {
	SessionStart(ctx context.Context, info *session.Info)
}

type StatsDeadlineRW struct {
	i.DeadlineRW
	// contains filtered or unexported fields
}

type StatsPacketConn struct {
	udp.PacketReaderWriter
	// contains filtered or unexported fields
}

type StatsReaderWriter struct {
	buf.ReaderWriter
	// contains filtered or unexported fields
}

type TimeoutDeadlineRW struct {
	i.DeadlineRW
	// contains filtered or unexported fields
}

type TimeoutPacketConn struct {
	udp.PacketReaderWriter
	// contains filtered or unexported fields
}

type TimeoutReaderWriter struct {
	buf.ReaderWriter
	// contains filtered or unexported fields
}