git

package
v1.24.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 24, 2021 License: Apache-2.0 Imports: 21 Imported by: 4

Documentation

Index

Constants

View Source 
const (
	MetricRepoReady   = 1
	MetricRepoUnready = 0
)
View Source 
const (
	CheckPushTagPrefix = "flux-write-check"
)

Variables

View Source 
var (
	ErrNoChanges  = errors.New("no changes made in repo")
	ErrNoConfig   = errors.New("git repo does not have valid config")
	ErrNotCloned  = errors.New("git repo has not been cloned yet")
	ErrClonedOnly = errors.New("git repo has been cloned but not yet checked for write access")
)
View Source 
var (
	ErrReadOnly = errors.New("cannot make a working clone of a read-only git repo")
)
View Source 
var NoRepoError = &fluxerr.Error{
	Type: fluxerr.User,
	Err:  errors.New("no repo in user config"),
	Help: `No Git repository URL in your config

We need to clone a git repo to proceed, and you haven't supplied
one. Please upload a config file, including a git repository URL, as
described in

    https://fluxcd.io/legacy/flux/references/fluxctl/

`,
}

Functions

func CloningError 

func CloningError(url string, actual error) error

func ErrUpstreamNotWritable 

func ErrUpstreamNotWritable(url string, actual error) error

func MakeAbsolutePaths 

func MakeAbsolutePaths(r interface{ Dir() string }, relativePaths []string) []string

MakeAbsolutePaths returns the absolute path for each of the relativePaths given, taking the repo's location as the base.

func PushError 

func PushError(url string, actual error) error

Types

type Branch 

type Branch string

type Checkout 

type Checkout struct {
	*Export
	// contains filtered or unexported fields
}

Checkout is a local working clone of the remote repo. It is intended to be used for one-off "transactions", e.g,. committing changes then pushing upstream. It has no locking.

func (*Checkout) AbsolutePaths 

func (c *Checkout) AbsolutePaths() []string

AbsolutePaths returns the absolute paths as configured. It ensures that at least one path is returned, so that it can be used with `Manifest.LoadManifests`.

func (*Checkout) Add 

func (c *Checkout) Add(ctx context.Context, path string) error

func (*Checkout) Checkout 

func (c *Checkout) Checkout(ctx context.Context, rev string) error

func (*Checkout) CommitAndPush 

func (c *Checkout) CommitAndPush(ctx context.Context, commitAction CommitAction, note interface{}, addUntracked bool) error

CommitAndPush commits changes made in this checkout, along with any extra data as a note, and pushes the commit and note to the remote repo.

func (*Checkout) HeadRevision 

func (c *Checkout) HeadRevision(ctx context.Context) (string, error)

func (*Checkout) MoveTagAndPush 

func (c *Checkout) MoveTagAndPush(ctx context.Context, tagAction TagAction) error

type Commit 

type Commit struct {
	Signature Signature
	Revision  string
	Message   string
}

type CommitAction 

type CommitAction struct {
	Author     string
	Message    string
	SigningKey string
}

CommitAction is a struct holding commit information

type Config 

type Config struct {
	Branch      string   // branch we're syncing to
	Paths       []string // paths within the repo containing files we care about
	NotesRef    string
	UserName    string
	UserEmail   string
	SigningKey  string
	SetAuthor   bool
	SkipMessage string
}

Config holds some values we use when working in the working clone of a repo.

type Export 

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

func (*Export) ChangedFiles 

func (e *Export) ChangedFiles(ctx context.Context, sinceRef string, paths []string) ([]string, error)

ChangedFiles does a git diff listing changed files

func (*Export) Clean 

func (e *Export) Clean() error

func (*Export) Dir 

func (e *Export) Dir() string

func (*Export) SecretUnseal 

func (e *Export) SecretUnseal(ctx context.Context) error

SecretUnseal unseals git secrets in the clone.

type GitRepoStatus 

type GitRepoStatus string

GitRepoStatus represents the progress made synchronising with a git repo. These are given below in expected order, but the status may go backwards if e.g., a deploy key is deleted. 

const (
	RepoNoConfig    GitRepoStatus = "unconfigured" // configuration is empty
	RepoNew         GitRepoStatus = "new"          // no attempt made to clone it yet
	RepoCloned      GitRepoStatus = "cloned"       // has been read (cloned); no attempt made to write
	RepoReady       GitRepoStatus = "ready"        // has been written to, so ready to sync
	RepoUnreachable GitRepoStatus = "unreachable"  // git repo is unreachable due to incorrect URL or DNS resolve failure
)

type IsReadOnly 

type IsReadOnly bool
var ReadOnly IsReadOnly = true

type Mirrors 

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

Maintains several git mirrors as a set, with a mechanism for signalling when some have had changes.

The advantage of it being a set is that you can add to it idempotently; if you need a repo to be mirrored, add it, and it will either already be mirrored, or that will be started.

func NewMirrors 

func NewMirrors() *Mirrors

func (*Mirrors) Changes 

func (m *Mirrors) Changes() <-chan map[string]struct{}

Changes gets a channel upon which notifications of which repos have changed will be sent.

func (*Mirrors) Get 

func (m *Mirrors) Get(name string) (*Repo, bool)

Get returns the named repo or nil, and a bool indicating whether the repo is being mirrored.

func (*Mirrors) Mirror 

func (m *Mirrors) Mirror(name string, remote Remote, options ...Option) bool

Mirror instructs the Mirrors to track a particular repo; if there is already a repo with the name given, nothing is done. Otherwise, the repo given will be mirrored, and changes signalled on the channel obtained with `Changes()`. The return value indicates whether the repo was already present (`true` if so, `false` otherwise).

func (*Mirrors) RefreshAll 

func (m *Mirrors) RefreshAll(timeout time.Duration) []error

RefreshAll instructs all the repos to refresh, this means fetching updated refs, and associated objects. The given timeout is the timeout per mirror and _not_ the timeout for the whole operation. It returns a collection of eventual errors it encountered.

func (*Mirrors) StopAllAndWait 

func (m *Mirrors) StopAllAndWait()

StopAllAndWait stops all the repos refreshing, and waits for them to indicate they've done so.

func (*Mirrors) StopOne 

func (m *Mirrors) StopOne(name string)

StopOne stops the repo given by `remote`, and cleans up after it (i.e., removes filesystem traces), if it is being tracked.

type NotReadyError 

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

func (NotReadyError) Error 

func (err NotReadyError) Error() string

func (NotReadyError) Unwrap added in v1.16.0 

func (err NotReadyError) Unwrap() error

type Option 

type Option interface {
	// contains filtered or unexported methods
}

type PollInterval 

type PollInterval time.Duration

type Remote 

type Remote struct {
	// URL is where we clone from
	URL string `json:"url"`
}

Remote points at a git repo somewhere.

func (Remote) Equivalent 

func (r Remote) Equivalent(u string) bool

Equivalent compares the given URL with the remote URL without taking protocols or `.git` suffixes into account.

func (Remote) SafeURL 

func (r Remote) SafeURL() string

type Repo 

type Repo struct {
	C chan struct{}
	// contains filtered or unexported fields
}

func NewRepo 

func NewRepo(origin Remote, opts ...Option) *Repo

NewRepo constructs a repo mirror which will sync itself.

func (*Repo) BranchHead 

func (r *Repo) BranchHead(ctx context.Context) (string, error)

BranchHead returns the HEAD revision (SHA1) of the configured branch

func (*Repo) Clean 

func (r *Repo) Clean()

Clean removes the mirrored repo. Syncing may continue with a new directory, so you may need to stop that first.

func (*Repo) Clone 

func (r *Repo) Clone(ctx context.Context, conf Config) (*Checkout, error)

Clone returns a local working clone of the sync'ed `*Repo`, using the config given.

func (*Repo) CommitsBefore 

func (r *Repo) CommitsBefore(ctx context.Context, ref string, firstParent bool, paths ...string) ([]Commit, error)

func (*Repo) CommitsBetween 

func (r *Repo) CommitsBetween(ctx context.Context, ref1, ref2 string, firstParent bool, paths ...string) ([]Commit, error)

func (*Repo) DeleteTag 

func (r *Repo) DeleteTag(ctx context.Context, tag string) error

func (*Repo) Dir 

func (r *Repo) Dir() string

Dir returns the local directory into which the repo has been cloned, if it has been cloned.

func (*Repo) Export 

func (r *Repo) Export(ctx context.Context, ref string) (*Export, error)

Export creates a minimal clone of the repo, at the ref given.

func (*Repo) GetNote 

func (r *Repo) GetNote(ctx context.Context, rev, notesRef string, note interface{}) (bool, error)

GetNote gets a note for the revision specified, or nil if there is no such note.

func (*Repo) NoteRevList 

func (r *Repo) NoteRevList(ctx context.Context, notesRef string) (map[string]struct{}, error)

func (*Repo) Notify 

func (r *Repo) Notify()

Notify tells the repo that it should fetch from the origin as soon as possible. It does not block.

func (*Repo) Origin 

func (r *Repo) Origin() Remote

Origin returns the Remote with which the Repo was constructed.

func (*Repo) Readonly 

func (r *Repo) Readonly() bool

Readonly returns `true` if the repo was marked as readonly, `false` otherwise

func (*Repo) Ready 

func (r *Repo) Ready(ctx context.Context) error

Ready tries to advance the cloning process along as far as possible, and returns an error if it is not able to get to a ready state.

func (*Repo) Refresh 

func (r *Repo) Refresh(ctx context.Context) error

func (*Repo) Revision 

func (r *Repo) Revision(ctx context.Context, ref string) (string, error)

Revision returns the revision (SHA1) of the ref passed in

func (*Repo) Start 

func (r *Repo) Start(shutdown <-chan struct{}, done *sync.WaitGroup) error

Start begins synchronising the repo by cloning it, then fetching the required tags and so on.

func (*Repo) Status 

func (r *Repo) Status() (GitRepoStatus, error)

Status reports that readiness status of this Git repo: whether it has been cloned and is writable, and if not, the error stopping it getting to the next state.

func (*Repo) VerifyCommit 

func (r *Repo) VerifyCommit(ctx context.Context, commit string) error

func (*Repo) VerifyTag 

func (r *Repo) VerifyTag(ctx context.Context, tag string) (string, error)

type Signature 

type Signature struct {
	Key    string
	Status string
}

Signature holds information about a GPG signature.

func (*Signature) Valid 

func (s *Signature) Valid() bool

Valid returns true if the signature is _G_ood (valid). https://github.com/git/git/blob/56d268bafff7538f82c01d3c9c07bdc54b2993b1/Documentation/pretty-formats.txt#L146-L153

type TagAction 

type TagAction struct {
	Tag        string
	Revision   string
	Message    string
	SigningKey string
}

TagAction is a struct holding tag parameters

type Timeout 

type Timeout time.Duration

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.