rulestore

Documentation

Index

• Constants
• Variables
• type Config
  • func (cfg *Config) RegisterFlags(f *flag.FlagSet)
• type RuleGroupList
  • func (l RuleGroupList) Formatted() map[string][]rulefmt.RuleGroup
• type RuleStore

Constants

const (
	ConfigDB = "configdb"

	Name = "ruler-storage"
)

Variables

var (
	// ErrGroupNotFound is returned if a rule group does not exist
	ErrGroupNotFound = errors.New("group does not exist")
	// ErrGroupNamespaceNotFound is returned if a namespace does not exist
	ErrGroupNamespaceNotFound = errors.New("group namespace does not exist")
	// ErrUserNotFound is returned if the user does not currently exist
	ErrUserNotFound = errors.New("no rule groups found for user")
)

Types

type Config

type Config struct {
	bucket.Config `yaml:",inline"`
	ConfigDB      client.Config `yaml:"configdb"`
}

Config configures a rule store.

func (*Config) RegisterFlags

func (cfg *Config) RegisterFlags(f *flag.FlagSet)

RegisterFlags registers the backend storage config.

type RuleGroupList

type RuleGroupList []*rulespb.RuleGroupDesc

RuleGroupList contains a set of rule groups

func (RuleGroupList) Formatted

func (l RuleGroupList) Formatted() map[string][]rulefmt.RuleGroup

Formatted returns the rule group list as a set of formatted rule groups mapped by namespace

type RuleStore

type RuleStore interface {
	// ListAllUsers returns all users with rule groups configured.
	ListAllUsers(ctx context.Context) ([]string, error)

	// ListAllRuleGroups returns all rule groups for all users.
	ListAllRuleGroups(ctx context.Context) (map[string]RuleGroupList, error)

	// ListRuleGroupsForUserAndNamespace returns all the active rule groups for a user from given namespace.
	// If namespace is empty, groups from all namespaces are returned.
	ListRuleGroupsForUserAndNamespace(ctx context.Context, userID string, namespace string) (RuleGroupList, error)

	// LoadRuleGroups loads rules for each rule group in the map.
	// Parameter with groups to load *MUST* be coming from one of the List methods.
	// Reason is that some implementations don't do anything, since their List method already loads the rules.
	LoadRuleGroups(ctx context.Context, groupsToLoad map[string]RuleGroupList) error

	GetRuleGroup(ctx context.Context, userID, namespace, group string) (*rulespb.RuleGroupDesc, error)
	SetRuleGroup(ctx context.Context, userID, namespace string, group *rulespb.RuleGroupDesc) error

	// DeleteRuleGroup deletes single rule group.
	DeleteRuleGroup(ctx context.Context, userID, namespace string, group string) error

	// DeleteNamespace lists rule groups for given user and namespace, and deletes all rule groups.
	// If namespace is empty, deletes all rule groups for user.
	DeleteNamespace(ctx context.Context, userID, namespace string) error
}

RuleStore is used to store and retrieve rules. Methods starting with "List" prefix may return partially loaded groups: with only group Name, Namespace and User fields set. To make sure that rules within each group are loaded, client must use LoadRuleGroups method.