policy

type BudgetDocument ¶

type BudgetDocument struct {
	PerRescue *float64 `yaml:"perRescue"`
	Weekly    *float64 `yaml:"weekly"`
}

BudgetDocument is the rescue budget in US dollars. Neither figure is enforced yet; see pr.BudgetEnforced.

type ConcurrencyDocument ¶

type ConcurrencyDocument struct {
	PerTeam *int `yaml:"perTeam"`
	PerRepo *int `yaml:"perRepo"`
}

ConcurrencyDocument is the concurrency section of a policy file.

type Document ¶

type Document struct {
	UpdateTypes  map[string][]string  `yaml:"updateTypes"`
	Schedule     *string              `yaml:"schedule"`
	Rescue       *RescueDocument      `yaml:"rescue"`
	Concurrency  *ConcurrencyDocument `yaml:"concurrency"`
	ModelConfig  *string              `yaml:"modelConfig"`
	SlackChannel *string              `yaml:"slackChannel"`
	// contains filtered or unexported fields
}

Document is one policy file. Every field is optional and an absent field keeps what the file before it said. UpdateTypes replaces the list of the kinds it names and leaves every other kind alone.

The names a file writes are also held in their resolved form, which ParseDocument fills. Only ParseDocument builds a Document, so a Document that exists has been resolved, and applying one needs no second pass over the names and no error a caller has to discard.

func ParseDocument(path, content string) (*Document, error)

type Exception ¶

type Exception struct {
	Enabled     *bool    `yaml:"enabled"`
	UpdateTypes []string `yaml:"updateTypes"`
	Rescue      *bool    `yaml:"rescue"`
}

Exception is one repository's deviation, written under the botPRsSweep key of its entry in repositories/team-<name>.yaml. Three keys are allowed and each one only narrows: switch the sweep off, restrict the update types that merge, switch the rescues off.

type File ¶

type File struct {
	Path string
	Doc  *Document
}

File is one policy file and the path it was read from. The path travels with the document so a resolved policy can name the files that made it.

type GitHubSource ¶

type GitHubSource struct {
	Client *github.Client
	Owner  string
	Repo   string
}

GitHubSource reads the files from the default branch of one repository, giantswarm/github in every real run.

func (g GitHubSource) List(ctx context.Context, dir string) ([]string, bool, error)

func (g GitHubSource) Read(ctx context.Context, path string) (string, bool, error)

func (g GitHubSource) String() string

type Loader ¶

type Loader struct {
	Source Source
	// Owner is the GitHub organisation the repository lists name their
	// entries under. It is a property of what the files say, not of where
	// they are read from, so it stays on the loader.
	Owner string
}

Loader resolves a sweep's scope and policy from the files of one Source.

func (l Loader) QueryScope(ctx context.Context) (Scope, error)

func (l Loader) TeamScope(ctx context.Context, team string) (Scope, error)

func (l Loader) Teams(ctx context.Context) ([]string, error)

type RescueDocument ¶

type RescueDocument struct {
	Enabled *bool           `yaml:"enabled"`
	Timeout *string         `yaml:"timeout"`
	Weekly  *int            `yaml:"weekly"`
	Budget  *BudgetDocument `yaml:"budget"`
	Confirm *string         `yaml:"confirm"`
	// contains filtered or unexported fields
}

RescueDocument is the rescue section of a policy file.

type Scope ¶

type Scope struct {
	Repos    []string
	Policies *Set
}

Scope is what one sweep resolves before it starts: the repositories it covers and the policy they are swept under. Repos is nil outside the team scope, where the PRs come from a GitHub search instead.

type Set ¶

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

Set is the policy of one sweep: the policy every repository of the scope is swept under, and the repositories whose own exception deviates from it. A Set is read-only once built, so the sweep's goroutines share one.

func NewSet(files []File, exceptions map[string]Exception) (*Set, error)

func (s *Set) Base() pr.Policy

func (s *Set) For(owner, name string) pr.Policy

type Source ¶

type Source interface {
	fmt.Stringer
	Read(ctx context.Context, path string) (content string, found bool, err error)
	// List returns the paths of the files directly under dir, and reports
	// found false for a directory the source does not hold.
	List(ctx context.Context, dir string) (paths []string, found bool, err error)
}

Source holds the policy files. Read returns the content of path, and reports found false for a path the source does not hold, which is not an error: an absent policy file falls back to the company defaults. A Source names where it looked in its String, so an error can say so.

GitHubSource is the only source the sweep ships. Nothing else in the package knows where a file was read from.