provider

type Alert struct {
	// Header contains metadata, for example propagated tracing information.
	Header map[string]string
	Data   *types.Alert
}

type AlertIterator interface {
	Iterator
	// Next returns a channel that will be closed once the iterator is
	// exhausted. It is not necessary to exhaust the iterator but Close must
	// be called in any case to release resources used by the iterator (even
	// if the iterator is exhausted).
	Next() <-chan *Alert
}

type Alerts interface {
	// Subscribe returns an iterator over active alerts that have not been
	// resolved and successfully notified about.
	// They are not guaranteed to be in chronological order.
	Subscribe(name string) AlertIterator

	// SlurpAndSubcribe returns a list of all active alerts which are available
	// in the provider before the call to SlurpAndSubcribe and an iterator
	// of all alerts available after the call to SlurpAndSubcribe.
	// SlurpAndSubcribe can be used by clients which need to build in memory state
	// to know when they've processed the 'initial' batch of alerts in a provider
	// after they reload their subscription.
	// Implementation of SlurpAndSubcribe is optional - providers may choose to
	// return an empty list for the first return value and the result of Subscribe
	// for the second return value.
	SlurpAndSubscribe(name string) ([]*types.Alert, AlertIterator)

	// GetPending returns an iterator over all alerts that have
	// pending notifications.
	GetPending() AlertIterator
	// Get returns the alert for a given fingerprint.
	Get(model.Fingerprint) (*types.Alert, error)
	// Put adds the given set of alerts to the set.
	Put(ctx context.Context, alerts ...*types.Alert) error
}

type Iterator interface {
	// Err returns the current error. It is not safe to call it concurrently
	// with other iterator methods or while reading from a channel returned
	// by the iterator.
	Err() error
	// Close must be called to release resources once the iterator is not
	// used anymore.
	Close()
}