common

type AccessLogContext struct {
	BPF            *bpf.Loader
	Queue          *Queue
	ConnectionMgr  *ConnectionManager
	Config         *Config
	RuntimeContext context.Context
}

type ActiveConnection struct {
	RandomID       uint64
	PID            uint32
	SocketFD       uint32
	Role           uint32
	SocketFamily   uint32
	Protocol       uint8
	SSL            uint8
	SkipDataUpload uint8
	// PAD for make sure it have same size when marshal data to the BPF
	PAD0 uint8
	PAD1 uint32
}

type CloseEventWithNotify struct {
	*events.SocketCloseEvent
	// contains filtered or unexported fields
}

type Config struct {
	module.Config

	Active            bool                  `mapstructure:"active"`
	ExcludeNamespaces string                `mapstructure:"exclude_namespaces"`
	ExcludeClusters   string                `mapstructure:"exclude_cluster"`
	Flush             FlushConfig           `mapstructure:"flush"`
	ProtocolAnalyze   ProtocolAnalyzeConfig `mapstructure:"protocol_analyze"`
}

type ConnectEventWithSocket struct {
	*events.SocketConnectEvent
	SocketPair *ip.SocketPair
}

type ConnectionInfo struct {
	ConnectionID  uint64
	RandomID      uint64
	RPCConnection *v3.AccessLogConnection
	MarkDeletable bool
	PID           uint32
	Socket        *ip.SocketPair
}

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

type ConnectionProcessFinishCallback func()

type ConnectionProcessor interface {
	OnConnectionClose(event *events.SocketCloseEvent, callback ConnectionProcessFinishCallback)
}

type FlushConfig struct {
	MaxCountOneStream int    `mapstructure:"max_count"`
	Period            string `mapstructure:"period"`
}

type FlusherListener interface {
	// ReadyToFlushConnection notify which connection ready to flush
	ReadyToFlushConnection(connection *ConnectionInfo, getConnectionFromEvent events.Event)
}

type KernelLog struct {
	Type  LogType
	Event events.Event
}

type LogType int

type MonitorFilter interface {
	// ShouldIncludeProcesses returns true if the processes should be included in monitoring.
	ShouldIncludeProcesses(process []api.ProcessInterface) []api.ProcessInterface
	// ExcludeNamespaces returns a list of namespaces that should be excluded from monitoring.
	ExcludeNamespaces() []string
}

type ProcessListener interface {
	OnNewProcessMonitoring(pid int32)
	OnProcessRemoved(pid int32)
}

type ProtocolAnalyzeConfig struct {
	PerCPUBufferSize string `mapstructure:"per_cpu_buffer"`
	Parallels        int    `mapstructure:"parallels"`
	QueueSize        int    `mapstructure:"queue_size"`
}

type ProtocolLog struct {
	KernelLogs []*events.SocketDetailEvent
	Protocol   *v3.AccessLogProtocolLogs
}

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

type QueueConsumer interface {
	Consume(kernels chan *KernelLog, protocols chan *ProtocolLog)
}

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