api

type Broker interface {

	// Starts the broker (non-blocking method)
	Start() error

	// Shuts down the broker
	Stop()
}

type CircuitBreakerConfig struct {
	MaxRequests uint32 `yaml:"maxRequests,omitempty" json:"maxRequests,omitempty"`
	Interval    int    `yaml:"interval,omitempty" json:"interval,omitempty"`
	Timeout     int    `yaml:"timeout,omitempty" json:"timeout,omitempty"`
}

type CollectionAgentDTO struct {
	XMLName             xml.Name                 `xml:"agent"`
	IPAddress           string                   `xml:"address,attr"`
	StoreByFS           bool                     `xml:"store-by-fs,attr"`
	NodeID              int                      `xml:"node-id,attr"`
	NodeLabel           string                   `xml:"node-label,attr"`
	ForeignSource       string                   `xml:"foreign-source,attr,omitempty"`
	ForeignID           string                   `xml:"foreign-id,attr,omitempty"`
	Location            string                   `xml:"location,attr,omitempty"`
	StorageResourcePath string                   `xml:"storage-resource-path,attr"`
	SysUpTime           int64                    `xml:"sys-up-time,attr"`
	Attributes          []CollectionAttributeDTO `xml:"attribute,omitempty"`
}

type CollectionAttributeDTO struct {
	XMLName xml.Name `xml:"attribute"`
	Key     string   `xml:"key,attr"`
	Content string   `xml:",innerxml"`
}

type CollectionResourceDTO struct {
	XMLName           xml.Name                `xml:"collection-resource"`
	Name              string                  `xml:"name,attr,omitempty"`
	ResourceType      interface{}             // NodeLevelResourceDTO, InterfaceLevelResourceDTO, or GenericTypeResourceDTO
	Resources         []CollectionResourceDTO `xml:"resource"`
	NumericAttributes []ResourceAttributeDTO  `xml:"numeric-attribute"`
	StringAttributes  []ResourceAttributeDTO  `xml:"string-attribute"`
}

type CollectionSetBuilder struct {
	Agent *CollectionAgentDTO
	// contains filtered or unexported fields
}

type CollectionSetDTO struct {
	XMLName                   xml.Name                `xml:"collection-set"`
	Timestamp                 *Timestamp              `xml:"timestamp,attr"`
	Status                    string                  `xml:"collection-status,attr"`
	DisableCounterPersistence bool                    `xml:"disable-counter-persistence,attr,omitempty"`
	SequenceNumber            int                     `xml:"sequence-number,attr,omitempty"`
	Agent                     *CollectionAgentDTO     `xml:"agent"`
	Resources                 []CollectionResourceDTO `xml:"collection-resource"`
}

type CollectorRequestDTO struct {
	XMLName                    xml.Name                 `xml:"collector-request"`
	Location                   string                   `xml:"location,attr"`
	SystemID                   string                   `xml:"system-id,attr"`
	ClassName                  string                   `xml:"class-name,attr"`
	AttributesNeedUnmarshaling bool                     `xml:"attributes-need-unmarshaling,attr"`
	CollectionAgent            *CollectionAgentDTO      `xml:"agent,omitempty"`
	Attributes                 []CollectionAttributeDTO `xml:"attribute,omitempty"`
}

type CollectorResponseDTO struct {
	XMLName       xml.Name          `xml:"collector-response"`
	Error         string            `xml:"error,attr,omitempty"`
	CollectionSet *CollectionSetDTO `xml:"collection-set"`
}

type DNSConfig struct {
	NameServer           string               `yaml:"nameServer,omitempty" json:"nameServer,omitempty"`
	Timeout              int                  `yaml:"timeout,omitempty" json:"timeout,omitempty"`
	CacheRefreshDuration int                  `yaml:"cacheRefreshDuration,omitempty" json:"cacheRefreshDuration,omitempty"`
	CircuitBreaker       CircuitBreakerConfig `yaml:"circuitBreaker" json:"circuitBreaker"`
}

type DNSLookupRequestDTO struct {
	XMLName     xml.Name `xml:"dns-lookup-request"`
	Location    string   `xml:"location,attr"`
	SystemID    string   `xml:"system-id,attr"`
	HostRequest string   `xml:"host-request,attr"`
	QueryType   string   `xml:"query-type,attr"`
}

type DNSLookupResponseDTO struct {
	XMLName      xml.Name `xml:"dns-lookup-response"`
	HostResponse string   `xml:"host-response,attr,omitempty"`
	Error        string   `xml:"error,attr,omitempty"`
}

type DetectorAttributeDTO struct {
	Key   string `xml:"key,attr"`
	Value string `xml:",chardata"`
}

type DetectorRequestDTO struct {
	XMLName   xml.Name `xml:"detector-request"`
	Location  string   `xml:"location,attr"`
	SystemID  string   `xml:"system-id,attr"`
	ClassName string   `xml:"class-name,attr"`
	IPAddress string   `xml:"address,attr"`

	DetectorAttributes []DetectorAttributeDTO `xml:"detector-attribute,omitempty"`
	RuntimeAttributes  []DetectorAttributeDTO `xml:"runtime-attribute,omitempty"`
}

type DetectorResponseDTO struct {
	XMLName    xml.Name               `xml:"detector-response"`
	Error      string                 `xml:"error,attr,omitempty"`
	Detected   bool                   `xml:"detected,attr"`
	Attributes []DetectorAttributeDTO `xml:"attribute,omitempty"`
}

type EchoRequest struct {
	XMLName     xml.Name `xml:"echo-request"`
	ID          int64    `xml:"id,attr"`
	Message     string   `xml:"message,attr"`
	Body        string   `xml:"body,omitempty"`
	Location    string   `xml:"location,attr"`
	SystemID    string   `xml:"system-id,attr"`
	Delay       int64    `xml:"delay,attr"`
	ShouldThrow bool     `xml:"throw,attr"`
}

type EchoResponse struct {
	XMLName xml.Name `xml:"echo-response"`
	ID      int64    `xml:"id,attr"`
	Message string   `xml:"message,attr,omitempty"`
	Body    string   `xml:"body,omitempty"`
	Error   string   `xml:"error,attr,omitempty"`
}

type GenericTypeResourceDTO struct {
	XMLName   xml.Name              `xml:"generic-type-resource"`
	Node      *NodeLevelResourceDTO `xml:"node-level-resource"`
	Name      string                `xml:"name,attr"`
	Fallback  string                `xml:"fallback,attr"`
	Instance  string                `xml:"instance,attr"`
	Timestamp *Timestamp            `xml:"timestamp,attr,omitempty"`
}

type HTTPAttribute struct {
	XMLName    xml.Name `xml:"attrib"`
	Alias      string   `xml:"alias,attr"`
	MatchGroup int      `xml:"match-group,attr"`
	Type       string   `xml:"type,attr"`
}

type HTTPAttributeList struct {
	XMLName       xml.Name        `xml:"attributes"`
	AttributeList []HTTPAttribute `xml:"attrib"`
}

type HTTPCollection struct {
	XMLName xml.Name     `xml:"http-collection"`
	Name    string       `xml:"name,attr"`
	RRD     *RRD         `xml:"rrd"`
	URIs    *HTTPUriList `xml:"uris"`
}

type HTTPUri struct {
	XMLName    xml.Name           `xml:"uri"`
	Name       string             `xml:"name,attr"`
	URL        *HTTPUrl           `xml:"url"`
	Attributes *HTTPAttributeList `xml:"attributes"`
}

type HTTPUriList struct {
	XMLName xml.Name  `xml:"uris"`
	URIList []HTTPUri `xml:"uri"`
}

type HTTPUrl struct {
	XMLName       xml.Name `xml:"url"`
	Path          string   `xml:"path,attr"`
	UserAgent     string   `xml:"user-agent,attr"`
	Matches       string   `xml:"matches,attr"`
	ResponseRange string   `xml:"response-range,attr"`
}

type InterfaceLevelResourceDTO struct {
	XMLName   xml.Name              `xml:"interface-level-resource"`
	Node      *NodeLevelResourceDTO `xml:"node-level-resource"`
	IntfName  string                `xml:"if-name,attr"`
	Timestamp *Timestamp            `xml:"timestamp,attr,omitempty"`
}

type Metrics struct {
	SinkMsgDeliverySucceeded *prometheus.CounterVec // Sink messages successfully delivered
	SinkMsgDeliveryFailed    *prometheus.CounterVec // Failed attempts to send Sink messages
	RPCReqReceivedSucceeded  *prometheus.CounterVec // RPC requests successfully received
	RPCReqReceivedFailed     *prometheus.CounterVec // Failed attempts to receive RPC requests
	RPCReqProcessedSucceeded *prometheus.CounterVec // RPC requests successfully processed
	RPCReqProcessedFailed    *prometheus.CounterVec // Failed attempts to process RPC requests
	RPCResSentSucceeded      *prometheus.CounterVec // RPC responses successfully sent
	RPCResSentFailed         *prometheus.CounterVec // Failed attempts to send RPC responses
}

type MinionConfig struct {
	ID               string            `yaml:"id" json:"id"`
	Location         string            `yaml:"location" json:"location"`
	BrokerURL        string            `yaml:"brokerUrl" json:"brokerUrl"`
	BrokerType       string            `yaml:"brokerType" json:"brokerType"`
	BrokerProperties map[string]string `yaml:"brokerProperties,omitempty" json:"brokerProperties,omitempty"`
	TrapPort         int               `yaml:"trapPort" json:"trapPort"`
	SyslogPort       int               `yaml:"syslogPort" json:"syslogPort"`
	StatsPort        int               `yaml:"statsPort" json:"statsPort"`
	LogLevel         string            `yaml:"logLevel" json:"logLevel"`
	DNS              *DNSConfig        `yaml:"dns,omitempty" json:"dns,omitempty"`
	Listeners        []MinionListener  `yaml:"listeners,omitempty" json:"listeners,omitempty"`
}

type MinionIdentityDTO struct {
	XMLName   xml.Name   `xml:"minion"`
	ID        string     `xml:"id"`
	Location  string     `xml:"location"`
	Timestamp *Timestamp `xml:"timestamp"`
}

type MinionListener struct {
	Name       string            `yaml:"name" json:"name"`
	Parser     string            `yaml:"parser" json:"parser"`
	Port       int               `yaml:"port" json:"port"`
	Properties map[string]string `yaml:"properties,omitempty" json:"properties,omitempty"`
}

type NodeLevelResourceDTO struct {
	XMLName   xml.Name   `xml:"node-level-resource"`
	NodeID    int        `xml:"node-id,attr"`
	Path      string     `xml:"path,attr,omitempty"`
	Timestamp *Timestamp `xml:"timestamp,attr,omitempty"`
}

type PingRequest struct {
	XMLName    xml.Name `xml:"ping-request"`
	Location   string   `xml:"location,attr"`
	SystemID   string   `xml:"system-id,attr"`
	Retries    int      `xml:"retries,attr"`
	Timeout    int      `xml:"timeout,attr"`
	Address    string   `xml:"address"`
	PacketSize int      `xml:"packet-size"`
}

type PingResponse struct {
	XMLName xml.Name `xml:"ping-response"`
	RTT     float64  `xml:"rtt,omitempty"`
	Error   string   `xml:"error,attr,omitempty"`
}

type PollStatus struct {
	XMLName      xml.Name                `xml:"poll-status"`
	Timestamp    *Timestamp              `xml:"time,attr,omitempty"`
	Reason       string                  `xml:"reason,attr,omitempty"`
	ResponseTime float64                 `xml:"response-time,attr"`
	StatusCode   int                     `xml:"code,attr"`
	StatusName   string                  `xml:"name,attr"`
	Properties   *PollStatusPropertyList `xml:"properties,omitempty"`
}

type PollStatusProperty struct {
	XMLName xml.Name `xml:"property"`
	Key     string   `xml:"key,attr"`
	Value   float64  `xml:",chardata"`
}

type PollStatusPropertyList struct {
	XMLName      xml.Name             `xml:"properties"`
	PropertyList []PollStatusProperty `xml:"property"`
}

type PollerAttributeDTO struct {
	Key     string `xml:"key,attr"`
	Value   string `xml:"value,attr"`
	Content string `xml:",innerxml"`
}

type PollerRequestDTO struct {
	XMLName      xml.Name             `xml:"poller-request"`
	Location     string               `xml:"location,attr"`
	SystemID     string               `xml:"system-id,attr"`
	ClassName    string               `xml:"class-name,attr"`
	ServiceName  string               `xml:"service-name,attr"`
	IPAddress    string               `xml:"address,attr"`
	NodeID       string               `xml:"node-id,attr"`
	NodeLabel    string               `xml:"node-label,attr"`
	NodeLocation string               `xml:"node-location,attr"`
	Attributes   []PollerAttributeDTO `xml:"attribute,omitempty"`
}

type PollerResponseDTO struct {
	XMLName xml.Name    `xml:"poller-response"`
	Error   string      `xml:"error,attr,omitempty"`
	Status  *PollStatus `xml:"poll-status,omitempty"`
}

type RPCModule interface {

	// Returns the ID of the RPC Module implementation
	GetID() string

	// Executes an RPC request and returns the response
	// The response tells if the operation was successful or not
	Execute(request *ipc.RpcRequestProto) *ipc.RpcResponseProto
}

type RRA struct {
	XMLName xml.Name `xml:"rra"`
	Content string   `xml:",chardata"`
}

type RRD struct {
	XMLName xml.Name `xml:"rrd"`
	Step    int      `xml:"step,attr"`
	RRAs    []RRA    `xml:"rra"`
}

type ResourceAttributeDTO struct {
	Group      string `xml:"group,attr"`
	Name       string `xml:"name,attr"`
	Type       string `xml:"type,attr"`
	Identifier string `xml:"identifier,attr,omitempty"`
	Value      string `xml:"value,attr"`
}

type SNMPAgentDTO struct {
	Address         string `xml:"address"`
	ProxyFor        string `xml:"proxyFor"`
	Version         int    `xml:"version"`
	VersionAsString string `xml:"versionAsString"`
	MaxRepetitions  int    `xml:"maxRepetitions"`
	MaxRequestSize  int    `xml:"maxRequestSize"`
	MaxVarsPerPdu   int    `xml:"maxVarsPerPdu"`
	Port            int    `xml:"port"`
	Retries         int    `xml:"retries"`
	Timeout         int    `xml:"timeout"`
	ReadCommunity   string `xml:"readCommunity"`
	WriteCommunity  string `xml:"writeCommunity"`
	SecurityLevel   int    `xml:"securityLevel"`
	SecurityName    string `xml:"securityName"`
	AuthPassPhrase  string `xml:"authPassPhrase"`
	AuthProtocol    string `xml:"authProtocol"`
	PrivPassPhrase  string `xml:"privPassPhrase"`
	PrivProtocol    string `xml:"privProtocol"`
	ContextName     string `xml:"contextName"`
	ContextEngineID string `xml:"contextEngineId"`
	EngineID        string `xml:"engineId"`
}

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

type SNMPGetRequestDTO struct {
	XMLName       xml.Name `xml:"get"`
	CorrelationID string   `xml:"correlation-id,attr"`
	OIDs          []string `xml:"oid,omitempty"`
}

type SNMPHandler interface {
	Connect() error
	Disconnect() error
	Version() string
	Target() string
	BulkWalk(rootOid string, walkFn gosnmp.WalkFunc) error
	Get(oid string) (result *gosnmp.SnmpPacket, err error)
}

type SNMPMultiResponseDTO struct {
	XMLName   xml.Name          `xml:"snmp-response"`
	Error     string            `xml:"error,attr,omitempty"`
	Responses []SNMPResponseDTO `xml:"response"`
}

type SNMPRequestDTO struct {
	XMLName     xml.Name             `xml:"snmp-request"`
	Location    string               `xml:"location,attr"`
	SystemID    string               `xml:"system-id,attr"`
	Description string               `xml:"description,attr"`
	Agent       SNMPAgentDTO         `xml:"agent"`
	Gets        []SNMPGetRequestDTO  `xml:"get,omitempty"`
	Walks       []SNMPWalkRequestDTO `xml:"walk,omitempty"`
}

type SNMPResponseDTO struct {
	XMLName       xml.Name        `xml:"response"`
	CorrelationID string          `xml:"correlation-id,attr"`
	Results       []SNMPResultDTO `xml:"result"`
}

type SNMPResultDTO struct {
	XMLName  xml.Name     `xml:"result"`
	Base     string       `xml:"base"`
	Instance string       `xml:"instance,omitempty"`
	Value    SNMPValueDTO `xml:"value"`
}

type SNMPResults struct {
	Results []SNMPResultDTO `xml:"result"`
}

type SNMPValueDTO struct {
	XMLName xml.Name `xml:"value"`
	Type    int      `xml:"type,attr"`
	Value   string   `xml:",chardata"`
}

type SNMPWalkRequestDTO struct {
	XMLName        xml.Name `xml:"walk"`
	CorrelationID  string   `xml:"correlation-id,attr"`
	MaxRepetitions int      `xml:"max-repetitions,attr,omitempty"`
	Instance       string   `xml:"instance,attr,omitempty"`
	OIDs           []string `xml:"oid,omitempty"`
}

type ServiceCollector interface {

	// Returns the ID of the Service Collector implementation
	GetID() string

	// Executes the data collection operation from the request
	// The response tells if the operation was successful or not
	Collect(request *CollectorRequestDTO) *CollectorResponseDTO
}

type ServiceDetector interface {

	// Returns the ID of the Service Detector implementation
	GetID() string

	// Executes the detection operation from the request
	// The response tells if the operation was successful or not
	Detect(request *DetectorRequestDTO) *DetectorResponseDTO
}

type ServiceMonitor interface {

	// Returns the ID of the Service Monitor implementation
	GetID() string

	// Executes the polling operation from the request
	// The response tells if the operation was successful or not
	Poll(request *PollerRequestDTO) *PollerResponseDTO
}

type Sink interface {

	// Sends a Sink Message to OpenNMS
	Send(msg *ipc.SinkMessage) error
}

type SinkModule interface {

	// Returns the ID of the Sink Module implementation
	GetID() string

	// Starts the Sink Module (non-blocking method)
	Start(config *MinionConfig, sink Sink) error

	// Shuts down the Sink Module (including all listeners)
	Stop()
}

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

type SyslogMessageDTO struct {
	Timestamp string `xml:"timestamp,attr"`
	Content   []byte `xml:",chardata"`
}

type SyslogMessageLogDTO struct {
	XMLName       xml.Name           `xml:"syslog-message-log"`
	SystemID      string             `xml:"system-id,attr"`
	Location      string             `xml:"location,attr"`
	SourceAddress string             `xml:"source-address,attr"`
	SourcePort    int                `xml:"source-port,attr"`
	Messages      []SyslogMessageDTO `xml:"messages"`
}

type Timestamp struct {
	time.Time
}

type TrapDTO struct {
	AgentAddress string           `xml:"agent-address"`
	Community    string           `xml:"community"`
	Version      string           `xml:"version"`
	Timestamp    int64            `xml:"timestamp"`
	CreationTime int64            `xml:"creation-time"`
	PDULength    int              `xml:"pdu-length"`
	RawMessage   []byte           `xml:"raw-message,omitempty"`
	TrapIdentity *TrapIdentityDTO `xml:"trap-identity"`
	Results      *SNMPResults     `xml:"results"`
}

type TrapIdentityDTO struct {
	EnterpriseID string `xml:"enterprise-id,attr"`
	Generic      int    `xml:"generic,attr"`
	Specific     int    `xml:"specific,attr"`
}

type TrapLogDTO struct {
	XMLName     xml.Name  `xml:"trap-message-log"`
	Location    string    `xml:"location,attr"`
	SystemID    string    `xml:"system-id,attr"`
	TrapAddress string    `xml:"trap-address,attr"`
	Messages    []TrapDTO `xml:"messages"`
}

type XMLCollection struct {
	XMLName xml.Name    `xml:"xml-collection"`
	Name    string      `xml:"name,attr"`
	RRD     *RRD        `xml:"rrd"`
	Sources []XMLSource `xml:"xml-source"`
}

type XMLGroup struct {
	XMLName         xml.Name        `xml:"xml-group"`
	Name            string          `xml:"name,attr"`
	ResourceType    string          `xml:"resource-type,attr"`
	ResourceXPath   string          `xml:"resource-xpath,attr"`
	KeyXPath        string          `xml:"key-xpath,attr"`
	TimestampFormat string          `xml:"timestamp-format,attr"`
	TimestampXPath  string          `xml:"timestamp-xpath,attr"`
	Objects         []XMLObject     `xml:"xml-object,omitempty"`
	ResourceKey     *XMLResourceKey `xml:"resource-key,omitempty"`
}

type XMLObject struct {
	XMLName xml.Name `xml:"xml-object"`
	Name    string   `xml:"name,attr"`
	Type    string   `xml:"type,attr"`
	XPath   string   `xml:"xpath,attr"`
}

type XMLRequest struct {
	XMLName    xml.Name              `xml:"request"`
	Method     string                `xml:"method,attr"`
	Headers    []XMLRequestHeader    `xml:"header,omitempty"`
	Parameters []XMLRequestParameter `xml:"parameter,omitempty"`
	Content    *XMLRequestContent    `xml:"content,omitempty"`
}

type XMLRequestContent struct {
	XMLName xml.Name `xml:"content"`
	Type    string   `xml:"content-type,attr"`
	Value   string   `xml:",innerxml"`
}

type XMLRequestHeader struct {
	XMLName xml.Name `xml:"header"`
	Name    string   `xml:"name,attr"`
	Value   string   `xml:"value,attr"`
}

type XMLRequestParameter struct {
	XMLName xml.Name `xml:"parameter"`
	Name    string   `xml:"name,attr"`
	Value   string   `xml:"value,attr"`
}

type XMLResourceKey struct {
	XMLName   xml.Name `xml:"resource-key"`
	KeyXPaths []string `xml:"key-xpath"`
}

type XMLSource struct {
	XMLName xml.Name    `xml:"xml-source"`
	URL     string      `xml:"url,attr"`
	Groups  []XMLGroup  `xml:"xml-group"`
	Request *XMLRequest `xml:"request,omitempty"`
}