knx

type Config struct {
	Connection Connection `json:",omitempty"`
	// MetricsPrefix is a short prefix which will be added in front of the actual metric name.
	MetricsPrefix  string
	AddressConfigs GroupAddressConfigSet
	// ReadStartupInterval is the intervall to wait between read of group addresses after startup.
	ReadStartupInterval Duration `json:",omitempty"`
}

type Connection struct {
	// Type of the actual connection. Can be either Tunnel or Router
	Type ConnectionType
	// Endpoint defines the IP address or hostname and port to where it should connect.
	Endpoint string
	// PhysicalAddress defines how the knx-exporter should identify itself within the KNX system.
	PhysicalAddress PhysicalAddress
	// RouterConfig contains some the specific configurations if connection Type is Router
	RouterConfig RouterConfig
	// TunnelConfig contains some the specific configurations if connection Type is Tunnel
	TunnelConfig TunnelConfig
}

type ConnectionType string

type DPT interface {
	Pack() []byte
	Unpack(data []byte) error
	Unit() string
	String() string
}

type Duration time.Duration

type GroupAddress cemi.GroupAddr

type GroupAddressConfig struct {
	// Name defines the prometheus metric name without the MetricsPrefix.
	Name string
	// Comment to identify the group address.
	Comment string `json:",omitempty"`
	// DPT defines the DPT at the knx bus. This is required to parse the values correctly.
	DPT string
	// MetricType is the type that prometheus uses when exporting it. i.e. gauge or counter
	MetricType string
	// Export the metric to prometheus
	Export bool
	// ReadStartup allows the exporter to actively send `GroupValueRead` telegrams to actively read the value at startup instead waiting for it.
	ReadStartup bool `json:",omitempty"`
	// ReadActive allows the exporter to actively send `GroupValueRead` telegrams to actively poll the value instead waiting for it.
	ReadActive bool `json:",omitempty"`
	// MaxAge of a value until it will actively send a `GroupValueRead` telegram to read the value if ReadActive is set to true.
	MaxAge Duration `json:",omitempty"`
	// Labels defines static labels that should be set when exporting the metric using prometheus.
	Labels map[string]string `json:",omitempty"`
}

type GroupAddressConfigSet map[GroupAddress]GroupAddressConfig

type GroupClient interface {
	Send(event knx.GroupEvent) error
	Inbound() <-chan knx.GroupEvent
	Close()
}

type Listener interface {
	Run()
	IsActive() bool
}

type MetricSnapshotHandler interface {
	// AddSnapshot adds a new snapshot that should be exported as metric.
	AddSnapshot(snapshot *Snapshot)
	// FindSnapshot finds a given snapshot by the snapshots key.
	FindSnapshot(key SnapshotKey) (*Snapshot, error)
	// FindYoungestSnapshot finds the youngest snapshot with the given metric name.
	// It don't matter from which device the snapshot was received.
	FindYoungestSnapshot(name string) *Snapshot
	// GetValueFunc returns a function that returns the current value for the given snapshot key.
	GetValueFunc(key SnapshotKey) func() float64
	// Run let the MetricSnapshotHandler listen for new snapshots on the Snapshot channel.
	Run()
	// GetMetricsChannel returns the channel to send new snapshots to this MetricSnapshotHandler.
	GetMetricsChannel() chan *Snapshot
	// Close stops listening for new Snapshots and closes the Snapshot channel.
	Close()
	// IsActive indicates that this handler is active and waits for new metric snapshots
	IsActive() bool
}

type MetricsExporter interface {
	Run() error
	Close()
	IsAlive() error
}

type PhysicalAddress cemi.IndividualAddr

type Poller interface {
	// Run starts the polling.
	Run()
	// Close stops the polling.
	Close()
}

type RouterConfig struct {
	// RetainCount specifies how many sent messages to retain. This is important for when a router indicates that it has
	// lost some messages. If you do not expect to saturate the router, keep this low.
	RetainCount uint
	// Interface specifies the network interface used to send and receive KNXnet/IP packets. If the interface is nil, the
	// system-assigned multicast interface is used.
	Interface string
	// MulticastLoopbackEnabled specifies if Multicast Loopback should be enabled.
	MulticastLoopbackEnabled bool
	// PostSendPauseDuration specifies the pause duration after sending. 0 means disabled. According to the specification,
	// we may choose to always pause for 20 ms after transmitting, but we should always pause for at least 5 ms on a
	// multicast address.
	PostSendPauseDuration time.Duration
}

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

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

type StartupReader interface {
	// Run starts the startup reading.
	Run()
	// Close stops the startup reading.
	Close()
}

type TunnelConfig struct {
	// ResendInterval is the interval with which requests will be resent if no response is received.
	ResendInterval time.Duration

	// HeartbeatInterval specifies the time interval which triggers a heartbeat check.
	HeartbeatInterval time.Duration

	// ResponseTimeout specifies how long to wait for a response.
	ResponseTimeout time.Duration

	// SendLocalAddress specifies if local address should be sent on connection request.
	SendLocalAddress bool

	// UseTCP configures whether to connect to the gateway using TCP.
	UseTCP bool
}