notifier

type Callback struct {
	NotificationID uuid.UUID `json:"notification_id"`
	Callback       url.URL   `json:"callback"`
}

type Deliverer interface {
	// A unique name for the deliverer implementation
	Name() string
	// Deliver will push the notification ID to subscribed clients.
	//
	// If delivery fails a clairerror.ErrDeliveryFailed error must be returned.
	Deliver(ctx context.Context, nID uuid.UUID) error
}

type Delivery struct {
	// a Deliverer implementation to invoke.
	Deliverer Deliverer
	// contains filtered or unexported fields
}

type DirectDeliverer interface {
	Notifications(ctx context.Context, n []Notification) error
}

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

type Locker interface {
	TryLock(context.Context, string) (context.Context, context.CancelFunc)
	Lock(context.Context, string) (context.Context, context.CancelFunc)
	Close(context.Context) error
}

type MockStore struct {
	Notifications_         func(ctx context.Context, id uuid.UUID, page *Page) ([]Notification, Page, error)
	PutNotifications_      func(ctx context.Context, opts PutOpts) error
	PutReceipt_            func(ctx context.Context, updater string, r Receipt) error
	CollectNotitfications_ func(ctx context.Context) error
	Receipt_               func(ctx context.Context, id uuid.UUID) (Receipt, error)
	ReceiptByUOID_         func(ctx context.Context, id uuid.UUID) (Receipt, error)
	Created_               func(ctx context.Context) ([]uuid.UUID, error)
	Failed_                func(ctx context.Context) ([]uuid.UUID, error)
	Deleted_               func(ctx context.Context) ([]uuid.UUID, error)
	SetDelivered_          func(ctx context.Context, id uuid.UUID) error
	SetDeliveredFailed_    func(ctx context.Context, id uuid.UUID) error
	SetDeleted_            func(ctx context.Context, id uuid.UUID) error
}

type Notification struct {
	ID            uuid.UUID        `json:"id"`
	Manifest      claircore.Digest `json:"manifest"`
	Reason        Reason           `json:"reason"`
	Vulnerability VulnSummary      `json:"vulnerability"`
}

type NotificationHandle struct {
	ID uuid.UUID `json:"id"`
}

type Notificationer interface {
	// Notifications retrieves the list of notifications associated with a
	// notification id
	//
	// If a Page is provided the returned notifications will be a subset of the total
	// and it's len will be no larger then Page.Size.
	//
	// This method should interpret the page.Next field as the requested page and
	// set the returned page.Next field to the next page to receive or -1 if
	// paging has been exhausted.
	//
	// Page maybe nil to receive all notifications.
	Notifications(ctx context.Context, id uuid.UUID, page *Page) ([]Notification, Page, error)
	// PutNotifications persists the provided notifications and associates
	// them with the provided notification id
	//
	// PutNotifications must update the latest update operation for the provided
	// updater in such a way that UpdateOperation returns the the provided update
	// operation id when queried with the updater name
	//
	// PutNotifications must create a Receipt with status created status on
	// successful persistence of notifications in such a way that Receipter.Created()
	// returns the persisted notification id.
	PutNotifications(ctx context.Context, opts PutOpts) error
	// PutReceipt allows for the caller to directly add a receipt to the store
	// without notifications being created.
	//
	// After this method returns all methods on the Receipter interface must work accordingly.
	PutReceipt(ctx context.Context, updater string, r Receipt) error
	// CollectNotifications garbage collects all notifications.
	//
	// Normally Receipter.SetDeleted will be issues first, however
	// application logic may decide to GC notifications which have not been
	// set deleted after some period of time, thus this condition should not
	// be checked.
	CollectNotifications(ctx context.Context) error
}

type Page struct {
	// the next id to retrieve
	Next *uuid.UUID `json:"next,omitempty"`
	// the max number of elements returned in a page
	Size int `json:"size"`
}

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

type PollerOpt func(*Poller) error

type Processor struct {

	// NoSummary controls whether per-manifest vulnerability summarization
	// should happen.
	//
	// The zero value makes the default behavior to do the summary.
	NoSummary bool
	// contains filtered or unexported fields
}

type PutOpts struct {
	// the updater triggering a notification
	Updater string
	// the update operation id triggering the notification
	UpdateID uuid.UUID
	// the notification id clients will use to retrieve the
	// list of notifications
	NotificationID uuid.UUID
	// a slice of notifications to persist. these notifications
	// will be retrievable via the notification id
	Notifications []Notification
}

type Reason string

type Receipt struct {
	// The update operation associated with this receipt
	UOID uuid.UUID
	// the id a client may use to retrieve a set of notifications
	NotificationID uuid.UUID
	// the current status  of the notification
	Status Status
	// the timestamp of the last status update
	TS time.Time
}

type Receipter interface {
	// Receipt returns the Receipt for a given notification id
	Receipt(ctx context.Context, id uuid.UUID) (Receipt, error)
	// ReceiptByUOID returns the Receipt for a given UOID
	ReceiptByUOID(ctx context.Context, id uuid.UUID) (Receipt, error)
	// Created returns a slice of notification ids in created status
	Created(ctx context.Context) ([]uuid.UUID, error)
	// Failed returns a slice of notification ids to in delivery failed status
	Failed(ctx context.Context) ([]uuid.UUID, error)
	// Deleted returns a slice of notification ids in deleted status
	Deleted(ctx context.Context) ([]uuid.UUID, error)
	// SetDelivered marks the provided notification id as delivered
	SetDelivered(ctx context.Context, id uuid.UUID) error
	// SetDeliveryFailed marks the provided notification id failed to be delivered
	SetDeliveryFailed(ctx context.Context, id uuid.UUID) error
	// SetDeleted marks the provided notification id as deleted
	SetDeleted(ctx context.Context, id uuid.UUID) error
}

type Service interface {
	// Retrieves an optional paginated set of notifications given an notification id
	Notifications(ctx context.Context, id uuid.UUID, page *Page) ([]Notification, Page, error)
	// Deletes the provided notification id
	DeleteNotifications(ctx context.Context, id uuid.UUID) error
}

type Status string

type Store interface {
	Notificationer
	Receipter
}

type VulnSummary struct {
	Name           string                  `json:"name"`
	Description    string                  `json:"description"`
	Package        *claircore.Package      `json:"package,omitempty"`
	Distribution   *claircore.Distribution `json:"distribution,omitempty"`
	Repo           *claircore.Repository   `json:"repo,omitempty"`
	Severity       string                  `json:"severity"`
	FixedInVersion string                  `json:"fixed_in_version"`
	Links          string                  `json:"links"`
}