git

package
v16.8.4 Latest Latest
Warning

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

 Go to latest Published: Mar 6, 2024 License: MIT Imports: 52 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// ReferenceTransactionHook represents the reference-transaction git hook.
	ReferenceTransactionHook = Hook(1 << iota)
	// UpdateHook represents the update git hook.
	UpdateHook
	// PreReceiveHook represents the pre-receive git hook.
	PreReceiveHook
	// PostReceiveHook represents the post-receive git hook.
	PostReceiveHook
	// PackObjectsHook represents the pack-objects git hook.
	PackObjectsHook
	// ProcReceiveHook represents the proc-receive git hook.
	ProcReceiveHook

	// AllHooks is the bitwise set of all hooks supported by Gitaly.
	AllHooks = ReferenceTransactionHook | UpdateHook | PreReceiveHook | PostReceiveHook | PackObjectsHook
	// ReceivePackHooks includes the set of hooks which shall be executed in
	// a typical "push" or an emulation thereof (e.g. `updateReferenceWithHooks()`).
	ReceivePackHooks = ReferenceTransactionHook | UpdateHook | PreReceiveHook | PostReceiveHook
)
View Source 
const (
	// ProtocolV1 is the special value used by Git clients to request protocol v1
	ProtocolV1 = "version=1"
	// ProtocolV2 is the special value used by Git clients to request protocol v2
	ProtocolV2 = "version=2"
)
View Source 
const (
	// InternalReferenceTypeHidden indicates that a reference should never be advertised or
	// writeable.
	InternalReferenceTypeHidden = InternalReferenceType(iota + 1)
	// InternalReferenceTypeReadonly indicates that a reference should be advertised, but not
	// writeable.
	InternalReferenceTypeReadonly
)
View Source 
const (
	// BigFileThresholdMB is the threshold we configure via `core.bigFileThreshold` and determines the maximum size
	// after which Git considers files to be big. Please refer to `GlobalConfiguration()` for more details.
	BigFileThresholdMB = 50
)
View Source 
const DefaultBranch = "main"

DefaultBranch is the default reference written to HEAD when a repository is created

View Source 
const DefaultRef = ReferenceName("refs/heads/" + DefaultBranch)

DefaultRef is the reference that GitLab will use if HEAD of the bare repository is not found, or other edge cases to detect the default branch.

View Source 
const (
	// EnvHooksPayload is the name of the environment variable used
	// to hold the hooks payload.
	EnvHooksPayload = "GITALY_HOOKS_PAYLOAD"
)
View Source 
const (
	// InternalGitalyURL is a special URL that indicates Gitaly wants to push to or fetch from
	// another internal Gitaly instance.
	InternalGitalyURL = "ssh://gitaly/internal.git"
)
View Source 
const LegacyDefaultRef = ReferenceName("refs/heads/master")

LegacyDefaultRef is the reference that used to be the default HEAD of the bare repository. If the default reference is not found, Gitaly will still test the legacy default.

View Source 
const MirrorRefSpec = "+refs/*:refs/*"

MirrorRefSpec is the refspec used when --mirror is specified on git clone.

View Source 
const ObjectPoolRefNamespace = "refs/remotes/origin"

ObjectPoolRefNamespace is the namespace used for the references of the primary pool member part of an object pool.

View Source 
const ZeroChecksum = "0000000000000000000000000000000000000000"

ZeroChecksum is the hex representation of a checksum with no references added.

Variables

View Source 
var (
	// ErrInvalidArg represent family of errors to report about bad argument used to make a call.
	ErrInvalidArg = errors.New("invalid argument")
	// ErrHookPayloadRequired indicates a HookPayload is needed but
	// absent from the command.
	ErrHookPayloadRequired = errors.New("hook payload is required but not configured")
)
View Source 
var (
	// ObjectHashSHA1 is the implementation of an object ID via SHA1.
	ObjectHashSHA1 = ObjectHash{
		Hash:         sha1.New,
		EmptyTreeOID: ObjectID("4b825dc642cb6eb9a060e54bf8d69288fbee4904"),
		ZeroOID:      ObjectID("0000000000000000000000000000000000000000"),
		Format:       "sha1",
		ProtoFormat:  gitalypb.ObjectFormat_OBJECT_FORMAT_SHA1,
	}

	// ObjectHashSHA256 is the implementation of an object ID via SHA256.
	ObjectHashSHA256 = ObjectHash{
		Hash:         sha256.New,
		EmptyTreeOID: ObjectID("6ef19b41225c5369f1c104d45d8d85efa9b057b53b14b4b9b939dd74decc5321"),
		ZeroOID:      ObjectID("0000000000000000000000000000000000000000000000000000000000000000"),
		Format:       "sha256",
		ProtoFormat:  gitalypb.ObjectFormat_OBJECT_FORMAT_SHA256,
	}
)
View Source 
var (
	// ErrReferenceNotFound represents an error when a reference was not
	// found.
	ErrReferenceNotFound = errors.New("reference not found")
	// ErrReferenceAmbiguous represents an error when a reference couldn't
	// unambiguously be resolved.
	ErrReferenceAmbiguous = errors.New("reference is ambiguous")

	// ErrAlreadyExists represents an error when the resource is already exists.
	ErrAlreadyExists = errors.New("already exists")
	// ErrNotFound represents an error when the resource can't be found.
	ErrNotFound = errors.New("not found")
)
View Source 
var (
	// ErrNotConfigured may be returned by an ExecutionEnvironmentConstructor in case an
	// environment was not configured.
	ErrNotConfigured = errors.New("execution environment is not configured")
)
View Source 
var ErrPayloadNotFound = errors.New("no hooks payload found in environment")

ErrPayloadNotFound is returned by HooksPayloadFromEnv if the given environment variables don't have a hooks payload.

View Source 
var InternalRefPrefixes = map[string]InternalReferenceType{

	"refs/environments/": InternalReferenceTypeReadonly,

	"refs/keep-around/": InternalReferenceTypeHidden,

	"refs/merge-requests/": InternalReferenceTypeReadonly,

	"refs/pipelines/": InternalReferenceTypeReadonly,

	"refs/remotes/": InternalReferenceTypeHidden,

	"refs/tmp/": InternalReferenceTypeHidden,
}

InternalRefPrefixes is an array of all reference prefixes which are used internally by GitLab. These need special treatment in some cases, e.g. to restrict writing to them.

View Source 
var OutputToStdout = StaticOption{/* contains filtered or unexported fields */}

OutputToStdout is used indicate the output should be sent to STDOUT Seen in: git bundle create

Functions

func AlternateObjectDirectories 

func AlternateObjectDirectories(ctx context.Context, logger log.Logger, storageRoot, repoPath string) ([]string, error)

AlternateObjectDirectories reads the alternates file of the repository and returns absolute paths to its alternate object directories, if any. The returned directories are verified to exist and that they are within the storage root. The alternate directories are returned recursively, not only the immediate alternates.

func BuildSSHInvocation 

func BuildSSHInvocation(ctx context.Context, logger log.Logger, sshKey, knownHosts string) (string, func(), error)

BuildSSHInvocation builds a command line to invoke SSH with the provided key and known hosts. Both are optional.

func ConfigPairsToGitEnvironment 

func ConfigPairsToGitEnvironment(configPairs []ConfigPair) []string

ConfigPairsToGitEnvironment converts the given config pairs into a set of environment variables that can be injected into a Git executable.

func DefaultTrace2HooksFor 

func DefaultTrace2HooksFor(ctx context.Context, subCmd string) []trace2.Hook

DefaultTrace2HooksFor creates a list of all Trace2 hooks. It doesn't mean all hooks are triggered. Each hook's activation status will be evaluated before the command starts.

func FormatSignatureTime added in v16.4.0 

func FormatSignatureTime(t time.Time) string

FormatSignatureTime formats a time such that it can be embedded into a tag or commit object directly.

This function should not be used in all other contexts. Refer to `FormatTime()` for the reasoning.

func FormatTime added in v16.4.0 

func FormatTime(t time.Time) string

FormatTime formats the given time such that it can be used by Git.

The formatted string uses RFC2822, which is typically used in the context of emails to format dates and which is well understood by Git in many contexts. This is _not_ usable though when you want to write a signature date directly into a Git object. In all other contexts, e.g. when passing a date via `GIT_COMMITTER_DATE`, it is preferable to use this format as it is unambiguous to Git. Unix timestamps are only recognized once they have at least 8 digits, which would thus rule all commit dates before 1970-04-26 17:46:40 +0000 UTC. While this is only ~4 months that we'd be missing since the birth of Unix timestamps, especially the zero date is likely going to come up frequently.

If you need to format a time to be used in signatures directly, e.g. because it is passed to git-hash-object(1), you can use `FormatSignatureTime()` instead.

func IsInvalidArgErr 

func IsInvalidArgErr(err error) bool

IsInvalidArgErr relays if the error is due to an argument validation failure

func IsLFSPointer 

func IsLFSPointer(b []byte) bool

IsLFSPointer checks to see if a blob is an LFS pointer. TODO: this is incomplete as it does not recognize pre-release version of LFS blobs with the "https://hawser.github.com/spec/v1" version. For compatibility with the Ruby RPC, we leave this as-is for now though.

func NewTreeEntry 

func NewTreeEntry(commitOid, rootPath string, filename, oidBytes, modeBytes []byte) (*gitalypb.TreeEntry, error)

NewTreeEntry is a helper to construct a gitalypb.TreeEntry from the provided parameters.

func ObjectDirectories 

func ObjectDirectories(ctx context.Context, logger log.Logger, storageRoot, repoPath string) ([]string, error)

ObjectDirectories looks for Git object directories, including alternates specified in objects/info/alternates.

CAVEAT Git supports quoted strings in here, but we do not. We should never need those on a Gitaly server.

func ValidateReference added in v16.2.0 

func ValidateReference(name string) error

ValidateReference checks whether a reference looks valid. It aims to be a faithful implementation of Git's own `check_or_sanitize_refname()` function and all divergent behaviour is considered to be a bug. Please also refer to https://git-scm.com/docs/git-check-ref-format#_description for further information on the actual rules.

func ValidateRevision 

func ValidateRevision(revision []byte, opts ...ValidateRevisionOption) error

ValidateRevision checks if a revision looks valid. The default behaviour can be changed by passing ValidateRevisionOptions.

func WarnIfTooManyBitmaps 

func WarnIfTooManyBitmaps(ctx context.Context, logger log.Logger, locator storage.Locator, storageName, repoPath string)

WarnIfTooManyBitmaps checks for too many (more than one) bitmaps in repoPath, and if it finds any, it logs a warning. This is to help us investigate https://gitlab.com/gitlab-org/gitaly/issues/1728.

Types

type BundledGitEnvironmentConstructor 

type BundledGitEnvironmentConstructor struct {
	// Suffix is the version suffix used for this specific bundled Git environment. In case
	// multiple sets of bundled Git versions are installed it is possible to also have multiple
	// of these bundled Git environments with different suffixes.
	Suffix string
	// FeatureFlags is the set of feature flags which must be enabled in order for the bundled
	// Git environment to be enabled. Note that _all_ feature flags must be set to `true` in the
	// context.
	FeatureFlags []featureflag.FeatureFlag
}

BundledGitEnvironmentConstructor sets up an ExecutionEnvironment for a bundled Git installation. Bundled Git is a partial Git installation, where only a subset of Git binaries are installed into Gitaly's binary directory. The binaries must have a `gitaly-` prefix like e.g. `gitaly-git`. Bundled Git installations can be installed with Gitaly's Makefile via `make install WITH_BUNDLED_GIT=YesPlease`.

func (BundledGitEnvironmentConstructor) Construct 

func (c BundledGitEnvironmentConstructor) Construct(cfg config.Cfg) (_ ExecutionEnvironment, returnedErr error)

Construct sets up an ExecutionEnvironment for a bundled Git installation. Because bundled Git installations are not complete Git installations we need to set up a usable environment at runtime. This is done by creating a temporary directory into which we symlink the bundled binaries with their usual names as expected by Git. Furthermore, we configure the GIT_EXEC_PATH environment variable to point to that directory such that Git is able to locate its auxiliary binaries.

For testing purposes, this function will automatically enable use of bundled Git in case the `GITALY_TESTING_BUNDLED_GIT_PATH` environment variable is set.

type Checksum 

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

Checksum is a hash representation of all references in a repository. Checksum must not be copied after first use.

func (*Checksum) Add 

func (c *Checksum) Add(ref Reference)

Add adds a reference to the checksum.

func (*Checksum) AddBytes 

func (c *Checksum) AddBytes(line []byte)

AddBytes adds a reference to the checksum that is a line in the output format of `git-show-ref`.

func (*Checksum) Bytes 

func (c *Checksum) Bytes() []byte

Bytes returns the checksum as a slice of bytes.

func (*Checksum) IsZero 

func (c *Checksum) IsZero() bool

IsZero returns true when no references have been added to the checksum.

func (*Checksum) String 

func (c *Checksum) String() string

String returns the checksum as a hex encoded string.

type CmdOpt 

type CmdOpt func(context.Context, config.Cfg, CommandFactory, *cmdCfg) error

CmdOpt is an option for running a command

func ConvertGlobalOptions 

func ConvertGlobalOptions(options *gitalypb.GlobalOptions) []CmdOpt

ConvertGlobalOptions converts a protobuf message to a CmdOpt.

func WithConfig 

func WithConfig(configPairs ...ConfigPair) CmdOpt

WithConfig adds git configuration entries to the command.

func WithConfigEnv 

func WithConfigEnv(configPairs ...ConfigPair) CmdOpt

WithConfigEnv adds git configuration entries to the command's environment. This should be used in place of `WithConfig()` in case config entries may contain secrets which shouldn't leak e.g. via the process's command line.

func WithDisabledHooks 

func WithDisabledHooks() CmdOpt

WithDisabledHooks returns an option that satisfies the requirement to set up hooks, but won't in fact set up hook execution.

func WithEnv 

func WithEnv(envs ...string) CmdOpt

WithEnv adds environment variables to the command.

func WithFinalizer 

func WithFinalizer(finalizer func(context.Context, *command.Command)) CmdOpt

WithFinalizer sets up the finalizer to be run when the command is being wrapped up. It will be called after `Wait()` has returned.

func WithGitProtocol 

func WithGitProtocol(logger log.Logger, req RequestWithGitProtocol) CmdOpt

WithGitProtocol checks whether the request has Git protocol v2 and sets this in the environment.

func WithGitalyGPG added in v16.2.0 

func WithGitalyGPG() CmdOpt

WithGitalyGPG sets gpg.prgoram to gitaly-gpg for commit signing

func WithGlobalOption 

func WithGlobalOption(opts ...GlobalOption) CmdOpt

WithGlobalOption adds the global options to the command. These are universal options which work across all git commands.

func WithInternalFetch 

func WithInternalFetch(req *gitalypb.SSHUploadPackRequest) CmdOpt

WithInternalFetch returns an option which sets up git-fetch(1) to fetch from another internal Gitaly node.

func WithInternalFetchWithSidechannel 

func WithInternalFetchWithSidechannel(req *gitalypb.SSHUploadPackWithSidechannelRequest) CmdOpt

WithInternalFetchWithSidechannel returns an option which sets up git-fetch(1) to fetch from another internal Gitaly node. In contrast to WithInternalFetch, this will call SSHUploadPackWithSidechannel instead of SSHUploadPack.

func WithPackObjectsHookEnv 

func WithPackObjectsHookEnv(repo *gitalypb.Repository, protocol string) CmdOpt

WithPackObjectsHookEnv provides metadata for gitaly-hooks so it can act as a pack-objects hook.

func WithReceivePackHooks 

func WithReceivePackHooks(req ReceivePackRequest, protocol string) CmdOpt

WithReceivePackHooks returns an option that populates the safe command with the environment variables necessary to properly execute the pre-receive, update and post-receive hooks for git-receive-pack(1).

func WithRefTxHook 

func WithRefTxHook(repo storage.Repository) CmdOpt

WithRefTxHook returns an option that populates the safe command with the environment variables necessary to properly execute a reference hook for repository changes that may possibly update references

func WithSetupStdin 

func WithSetupStdin() CmdOpt

WithSetupStdin sets up the command so that it can be `Write()`en to.

func WithSetupStdout added in v16.4.0 

func WithSetupStdout() CmdOpt

WithSetupStdout sets up the command so that it can be `Read()` from.

func WithStderr 

func WithStderr(w io.Writer) CmdOpt

WithStderr sets the command's stderr.

func WithStdin 

func WithStdin(r io.Reader) CmdOpt

WithStdin sets the command's stdin. Pass `command.SetupStdin` to make the command suitable for `Write()`ing to.

func WithStdout 

func WithStdout(w io.Writer) CmdOpt

WithStdout sets the command's stdout.

func WithWorktree 

func WithWorktree(worktreePath string) CmdOpt

WithWorktree sets up the Git command to run in the given worktree path by using the `-C` switch.

type Command 

type Command struct {
	// Name is the name of the Git command to run, e.g. "log", "cat-flie" or "worktree".
	Name string
	// Action is the action of the Git command, e.g. "set-url" in `git remote set-url`
	Action string
	// Flags is the number of optional flags to pass before positional arguments, e.g.
	// `--oneline` or `--format=fuller`.
	Flags []Option
	// Args is the arguments that shall be passed after all flags. These arguments must not be
	// flags and thus cannot start with `-`. Note that it may be unsafe to use this field in the
	// case where arguments are directly user-controlled. In that case it is advisable to use
	// `PostSepArgs` instead.
	Args []string
	// PostSepArgs is the arguments that shall be passed as positional arguments after the `--`
	// separator. Git recognizes that separator as the point where it should stop expecting any
	// options and treat the remaining arguments as positionals. This should be used when
	// passing user-controlled input of arbitrary form like for example paths, which may start
	// with a `-`.
	PostSepArgs []string
}

Command represent a Git command.

func (Command) CommandArgs 

func (c Command) CommandArgs() ([]string, error)

CommandArgs checks all arguments in the sub command and validates them

type CommandFactory 

type CommandFactory interface {
	// New creates a new command for the repo repository.
	New(ctx context.Context, repo storage.Repository, sc Command, opts ...CmdOpt) (*command.Command, error)
	// NewWithoutRepo creates a command without a target repository.
	NewWithoutRepo(ctx context.Context, sc Command, opts ...CmdOpt) (*command.Command, error)
	// GetExecutionEnvironment returns parameters required to execute Git commands.
	GetExecutionEnvironment(context.Context) ExecutionEnvironment
	// HooksPath returns the path where Gitaly's Git hooks reside.
	HooksPath(context.Context) string
	// GitVersion returns the Git version used by the command factory.
	GitVersion(context.Context) (Version, error)
}

CommandFactory is designed to create and run git commands in a protected and fully managed manner.

type ConfigPair 

type ConfigPair = config.GitConfig

ConfigPair is a GlobalOption that can be passed to Git commands to inject per-command config entries via the `git -c` switch.

func ConvertConfigOptions 

func ConvertConfigOptions(options []string) ([]ConfigPair, error)

ConvertConfigOptions converts `<key>=<value>` config entries into `ConfigPairs`.

func GetURLAndResolveConfig 

func GetURLAndResolveConfig(remoteURL string, resolvedAddress string) (string, []ConfigPair, error)

GetURLAndResolveConfig parses the given repository's URL and resolved address to generate the modified URL and configuration to avoid DNS rebinding.

In Git v2.37.0 we added the functionality for `http.curloptResolve` which like its curl counterpart when provided with a `HOST:PORT:ADDRESS` value, uses the IP Address provided directly for the given HOST:PORT combination for HTTP/HTTPS protocols, without requiring DNS resolution.

This functions currently does the following operations:

- Git Protocol: Replaces the hostname with the resolved IP address. - SSH Protocol: Replaces the hostname with the resolved IP address (supports both the regular syntax `ssh://[user@]server/project.git` and scp-like syntax `[user@]server:project.git`). - HTTP/HTTPS Protocol: Keeps the URL as is, but adds the `http.curloptResolve` flag.

SideNote: We cannot replace the hostname with IP in HTTPS protocol because the protocol demands the hostname to be present, as it is required for the SSL verification.

type DistributedGitEnvironmentConstructor 

type DistributedGitEnvironmentConstructor struct{}

DistributedGitEnvironmentConstructor creates ExecutionEnvironments via the Git binary path configured in the Gitaly configuration. This expects a complete Git installation with all its components. The installed distribution must either have its prefix compiled into the binaries or alternatively be compiled with runtime-detection of the prefix such that Git is able to locate its auxiliary helper binaries correctly.

func (DistributedGitEnvironmentConstructor) Construct 

func (c DistributedGitEnvironmentConstructor) Construct(cfg config.Cfg) (ExecutionEnvironment, error)

Construct sets up an ExecutionEnvironment for a complete Git distribution. No setup needs to be performed given that the Git environment is expected to be self-contained.

For testing purposes, this function overrides the configured Git binary path if the `GITALY_TESTING_GIT_BINARY` environment variable is set.

type ExecCommandFactory 

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

ExecCommandFactory knows how to properly construct different types of commands.

func NewExecCommandFactory 

func NewExecCommandFactory(cfg config.Cfg, logger log.Logger, opts ...ExecCommandFactoryOption) (_ *ExecCommandFactory, _ func(), returnedErr error)

NewExecCommandFactory returns a new instance of initialized ExecCommandFactory. The returned cleanup function shall be executed when the server shuts down.

func (*ExecCommandFactory) Collect 

func (cf *ExecCommandFactory) Collect(metrics chan<- prometheus.Metric)

Collect is used to collect Prometheus metrics.

func (*ExecCommandFactory) Describe 

func (cf *ExecCommandFactory) Describe(descs chan<- *prometheus.Desc)

Describe is used to describe Prometheus metrics.

func (*ExecCommandFactory) GetExecutionEnvironment 

func (cf *ExecCommandFactory) GetExecutionEnvironment(ctx context.Context) ExecutionEnvironment

GetExecutionEnvironment returns parameters required to execute Git commands.

func (*ExecCommandFactory) GitVersion 

func (cf *ExecCommandFactory) GitVersion(ctx context.Context) (Version, error)

GitVersion returns the Git version in use. The version is cached as long as the binary remains unchanged as determined by stat(3P).

func (*ExecCommandFactory) GlobalConfiguration 

func (cf *ExecCommandFactory) GlobalConfiguration(ctx context.Context) ([]ConfigPair, error)

GlobalConfiguration returns the global Git configuration that should be applied to every Git command.

func (*ExecCommandFactory) HooksPath 

func (cf *ExecCommandFactory) HooksPath(ctx context.Context) string

HooksPath returns the path where Gitaly's Git hooks reside.

func (*ExecCommandFactory) New 

func (cf *ExecCommandFactory) New(ctx context.Context, repo storage.Repository, sc Command, opts ...CmdOpt) (*command.Command, error)

New creates a new command for the repo repository.

func (*ExecCommandFactory) NewWithoutRepo 

func (cf *ExecCommandFactory) NewWithoutRepo(ctx context.Context, sc Command, opts ...CmdOpt) (*command.Command, error)

NewWithoutRepo creates a command without a target repository.

type ExecCommandFactoryOption 

type ExecCommandFactoryOption func(*execCommandFactoryConfig)

ExecCommandFactoryOption is an option that can be passed to NewExecCommandFactory.

func WithCgroupsManager 

func WithCgroupsManager(cgroupsManager cgroups.Manager) ExecCommandFactoryOption

WithCgroupsManager overrides the Cgroups manager used by the command factory.

func WithExecutionEnvironmentConstructors 

func WithExecutionEnvironmentConstructors(constructors ...ExecutionEnvironmentConstructor) ExecCommandFactoryOption

WithExecutionEnvironmentConstructors overrides the default Git execution environments used by the command factory.

func WithGitBinaryPath 

func WithGitBinaryPath(path string) ExecCommandFactoryOption

WithGitBinaryPath overrides the path to the Git binary that shall be executed.

func WithHooksPath 

func WithHooksPath(hooksPath string) ExecCommandFactoryOption

WithHooksPath will override the path where hooks are to be found.

func WithSkipHooks 

func WithSkipHooks() ExecCommandFactoryOption

WithSkipHooks will skip any use of hooks in this command factory.

func WithTrace2Hooks 

func WithTrace2Hooks(hooks []trace2.Hook) ExecCommandFactoryOption

WithTrace2Hooks overrides default trace2 hooks used by trace2 manager

type ExecutionEnvironment 

type ExecutionEnvironment struct {
	// BinaryPath is the path to the Git binary.
	BinaryPath string
	// EnvironmentVariables are variables which must be set when running the Git binary.
	EnvironmentVariables []string
	// contains filtered or unexported fields
}

ExecutionEnvironment describes the environment required to execute a Git command

func (ExecutionEnvironment) Cleanup 

func (e ExecutionEnvironment) Cleanup() error

Cleanup cleans up any state set up by this ExecutionEnvironment.

func (ExecutionEnvironment) IsEnabled 

func (e ExecutionEnvironment) IsEnabled(ctx context.Context) bool

IsEnabled checks whether the ExecutionEnvironment is enabled in the given context. An execution environment will typically be enabled by default, except if it's feature-flagged.

type ExecutionEnvironmentConstructor 

type ExecutionEnvironmentConstructor interface {
	Construct(config.Cfg) (ExecutionEnvironment, error)
}

ExecutionEnvironmentConstructor is an interface for constructors of Git execution environments. A constructor should be able to set up an environment in which it is possible to run Git executables.

type FallbackGitEnvironmentConstructor 

type FallbackGitEnvironmentConstructor struct{}

FallbackGitEnvironmentConstructor sets up a fallback execution environment where Git is resolved via the `PATH` environment variable. This is only intended as a last resort in case no other environments have been set up.

func (FallbackGitEnvironmentConstructor) Construct 

func (c FallbackGitEnvironmentConstructor) Construct(config.Cfg) (ExecutionEnvironment, error)

Construct sets up an execution environment by searching `PATH` for a `git` executable.

type FeatureFlagWithValue 

type FeatureFlagWithValue struct {
	// Flag is the feature flag.
	Flag featureflag.FeatureFlag `json:"flag"`
	// Enabled indicates whether the flag is enabled or not.
	Enabled bool `json:"enabled"`
}

FeatureFlagWithValue is used as part of the HooksPayload to pass on feature flags with their values to gitaly-hooks.

type FetchPorcelainScanner added in v16.6.0 

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

FetchPorcelainScanner scans the output of `git fetch` when the porcelain option is enabled, allowing information about references to be gathered.

func NewFetchPorcelainScanner added in v16.6.0 

func NewFetchPorcelainScanner(r io.Reader, hash ObjectHash) *FetchPorcelainScanner

NewFetchPorcelainScanner returns a FetchPorcelainScanner.

func (*FetchPorcelainScanner) Err added in v16.6.0 

func (f *FetchPorcelainScanner) Err() error

Err returns any error encountered while scanning.

func (*FetchPorcelainScanner) Scan added in v16.6.0 

func (f *FetchPorcelainScanner) Scan() bool

Scan parses the next fetch status line from the fetch command output.

func (*FetchPorcelainScanner) StatusLine added in v16.6.0 

func (f *FetchPorcelainScanner) StatusLine() FetchPorcelainStatusLine

StatusLine returns the status line information from the last scanned line.

type FetchPorcelainStatusLine added in v16.6.0 

type FetchPorcelainStatusLine struct {
	Type      RefUpdateType
	OldOID    ObjectID
	NewOID    ObjectID
	Reference string
}

FetchPorcelainStatusLine represents a line of status output from `git fetch` when the porcelain option is enabled.

type FetchScanner 

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

FetchScanner scans the output of `git fetch`, allowing information about the updated refs to be gathered

func NewFetchScanner 

func NewFetchScanner(r io.Reader) *FetchScanner

NewFetchScanner returns a new FetchScanner

func (*FetchScanner) Err 

func (f *FetchScanner) Err() error

Err returns any error encountered while scanning the reader supplied to NewFetchScanner(). Note that lines not matching the expected format are not an error.

func (*FetchScanner) Scan 

func (f *FetchScanner) Scan() bool

Scan looks for the next fetch status line in the reader supplied to NewFetchScanner(). Any lines that are not valid status lines are discarded without error. It returns true if you should call Scan() again, and false if scanning has come to an end.

func (*FetchScanner) StatusLine 

func (f *FetchScanner) StatusLine() FetchStatusLine

StatusLine returns the most recent fetch status line encountered by the FetchScanner. It changes after each call to Scan(), unless there is an error.

type FetchStatusLine 

type FetchStatusLine struct {
	// Type encodes the kind of change that git fetch has made
	Type RefUpdateType
	// Summary is a brief description of the change. This may be text such as
	// [new tag], or a compact-form SHA range showing the old and new values of
	// the updated reference, depending on the type of update
	Summary string
	// From is usually the name of the remote ref being fetched from, missing
	// the refs/<type>/ prefix. If a ref is being deleted, this will be "(none)"
	From string
	// To is the name of the local ref being updated, missing the refs/<type>/
	// prefix.
	To string
	// Reason optionally contains human-readable information about the change. It
	// is typically used to explain why making a given change failed (e.g., the
	// type will be RefUpdateTypeUpdateFailed). It may be empty.
	Reason string
}

FetchStatusLine represents a line of status output from `git fetch`, as documented here: https://git-scm.com/docs/git-fetch/2.30.0#_output. Each line is a change to a git reference in the local repository that was caused by the fetch

func (FetchStatusLine) IsTagAdded 

func (f FetchStatusLine) IsTagAdded() bool

IsTagAdded returns true if this status line indicates a new tag was added

func (FetchStatusLine) IsTagUpdated 

func (f FetchStatusLine) IsTagUpdated() bool

IsTagUpdated returns true if this status line indicates a tag was changed

type Flag 

type Flag struct {
	Name string
}

Flag is a single token optional command line argument that enables or disables functionality (e.g. "-L")

func (Flag) GlobalArgs 

func (f Flag) GlobalArgs() ([]string, error)

GlobalArgs returns the arguments for the given flag, which should typically only be the flag itself. It returns an error if the flag is not sanitary.

func (Flag) OptionArgs 

func (f Flag) OptionArgs() ([]string, error)

OptionArgs returns an error if the flag is not sanitary

type GetReferencesConfig added in v16.4.0 

type GetReferencesConfig struct {
	// Patterns limits the returned references to only those which match the given pattern. If no patterns are given
	// then all references will be returned.
	Patterns []string
	// Limit limits
	Limit uint
}

GetReferencesConfig is configuration that can be passed to GetReferences in order to change its default behaviour.

type GlobalOption 

type GlobalOption interface {
	GlobalArgs() ([]string, error)
}

GlobalOption is an interface for all options which can be globally applied to git commands. This is the command-inspecific part before the actual command that's being run, e.g. the `-c` part in `git -c foo.bar=value command`.

type Hook 

type Hook uint

Hook represents a git hook. See githooks(5) for more information about existing hooks.

type HooksPayload 

type HooksPayload struct {
	// RequestedHooks is a bitfield of requested Hooks. Hooks which
	// were not requested will not get executed.
	RequestedHooks Hook `json:"requested_hooks"`
	// FeatureFlagsWithValue contains feature flags with their values. They are set into the
	// outgoing context when calling HookService.
	FeatureFlagsWithValue []FeatureFlagWithValue `json:"feature_flags_with_value,omitempty"`

	// Repo is the repository in which the hook is running.
	Repo *gitalypb.Repository `json:"-"`
	// ObjectFormat is the object format used by the repository. Some hooks use it in order to
	// verify object IDs part of their input.
	ObjectFormat string `json:"object_format"`

	// RuntimeDir is the path to Gitaly's runtime directory.
	RuntimeDir string `json:"runtime_dir"`
	// InternalSocket is the path to Gitaly's internal socket.
	InternalSocket string `json:"internal_socket"`
	// InternalSocketToken is the token required to authenticate with
	// Gitaly's internal socket.
	InternalSocketToken string `json:"internal_socket_token"`

	// Transaction is used to identify a reference transaction. This is an optional field -- if
	// it's not set, no transactional voting will happen.
	Transaction *txinfo.Transaction `json:"transaction"`

	// UserDetails contains information required when executing
	// git-receive-pack or git-upload-pack
	UserDetails *UserDetails `json:"user_details"`

	// TransactionID identifies the storage transaction this hooks call runs in. It's
	// used to access the transaction in the hook manager.
	TransactionID storage.TransactionID `json:"transaction_id,omitempty"`
}

HooksPayload holds parameters required for all hooks.

func HooksPayloadFromEnv 

func HooksPayloadFromEnv(envs []string) (HooksPayload, error)

HooksPayloadFromEnv extracts the HooksPayload from the given environment variables. If no HooksPayload exists, it returns a ErrPayloadNotFound error.

func NewHooksPayload 

func NewHooksPayload(
	cfg config.Cfg,
	repo *gitalypb.Repository,
	objectHash ObjectHash,
	tx *txinfo.Transaction,
	userDetails *UserDetails,
	requestedHooks Hook,
	featureFlagsWithValue map[featureflag.FeatureFlag]bool,
	transactionID storage.TransactionID,
) HooksPayload

NewHooksPayload creates a new hooks payload which can then be encoded and passed to Git hooks.

func (HooksPayload) Env 

func (p HooksPayload) Env() (string, error)

Env encodes the given HooksPayload into an environment variable.

func (HooksPayload) IsHookRequested 

func (p HooksPayload) IsHookRequested(hook Hook) bool

IsHookRequested returns whether the HooksPayload is requesting execution of the given git hook.

type InternalReferenceType 

type InternalReferenceType int

InternalReferenceType is the type of an internal reference.

type InvalidObjectIDCharError 

type InvalidObjectIDCharError struct {
	OID     string
	BadChar rune
}

InvalidObjectIDCharError is returned when an object ID's string representation contains an invalid hexadecimal digit.

func (InvalidObjectIDCharError) Error 

func (e InvalidObjectIDCharError) Error() string

type InvalidObjectIDLengthError 

type InvalidObjectIDLengthError struct {
	OID           string
	CorrectLength int
	Length        int
}

InvalidObjectIDLengthError is returned when an object ID's string representation is not the required length.

func (InvalidObjectIDLengthError) Error 

func (e InvalidObjectIDLengthError) Error() string

type Object 

type Object interface {
	// ObjectInfo provides information about the object.
	ObjectInfo
	// Reader reads object data.
	io.Reader
	// WriterTo writes object data into a reader.
	io.WriterTo
}

Object is an interface encapsulating an object with contents.

type ObjectHash 

type ObjectHash struct {
	// Hash is the hashing function used to hash objects.
	Hash func() hash.Hash
	// EmptyTreeOID is the object ID of the tree object that has no directory entries.
	EmptyTreeOID ObjectID
	// ZeroOID is the special value that Git uses to signal a ref or object does not exist
	ZeroOID ObjectID
	// Format is the name of the object hash.
	Format string
	// ProtoFormat is the Protobuf representation of the object format.
	ProtoFormat gitalypb.ObjectFormat
}

ObjectHash is a hash-function specific implementation of an object ID.

func DetectObjectHash 

func DetectObjectHash(ctx context.Context, gitCmdFactory CommandFactory, repository storage.Repository) (ObjectHash, error)

DetectObjectHash detects the object-hash used by the given repository.

func ObjectHashByFormat 

func ObjectHashByFormat(format string) (ObjectHash, error)

ObjectHashByFormat looks up the ObjectHash by its format name.

func ObjectHashByProto 

func ObjectHashByProto(format gitalypb.ObjectFormat) (ObjectHash, error)

ObjectHashByProto looks up the ObjectHash by its Protobuf representation `gitalypb.ObjectFormat`. Returns an error in case the object format is not known.

func (ObjectHash) EncodedLen 

func (h ObjectHash) EncodedLen() int

EncodedLen returns the length of the hex-encoded string of a full object ID.

func (ObjectHash) FromHex 

func (h ObjectHash) FromHex(hex string) (ObjectID, error)

FromHex constructs a new ObjectID from the given hex representation of the object ID. Returns ErrInvalidObjectID if the given object ID is not valid.

func (ObjectHash) HashData added in v16.3.0 

func (h ObjectHash) HashData(bytes []byte) ObjectID

HashData hashes the given bytes to an object ID.

func (ObjectHash) IsZeroOID 

func (h ObjectHash) IsZeroOID(oid ObjectID) bool

IsZeroOID checks whether the given object ID is the all-zeroes object ID for the given hash.

func (ObjectHash) ValidateHex 

func (h ObjectHash) ValidateHex(hex string) error

ValidateHex checks if `hex` is a syntactically correct object ID for the given hash. Abbreviated object IDs are not deemed to be valid. Returns an `ErrInvalidObjectID` if the `hex` is not valid.

type ObjectID 

type ObjectID string

ObjectID represents an object ID.

func WriteBlob added in v16.4.0 

func WriteBlob(ctx context.Context, repoExecutor RepositoryExecutor, content io.Reader, cfg WriteBlobConfig) (ObjectID, error)

WriteBlob writes a blob into the given repository.

func (ObjectID) Bytes 

func (oid ObjectID) Bytes() ([]byte, error)

Bytes returns the byte representation of the ObjectID.

func (ObjectID) Revision 

func (oid ObjectID) Revision() Revision

Revision returns a revision of the ObjectID. This directly returns the hex representation as every object ID is a valid revision.

func (ObjectID) String 

func (oid ObjectID) String() string

String returns the hex representation of the ObjectID.

type ObjectInfo 

type ObjectInfo interface {
	ObjectID() ObjectID
	ObjectType() string
	ObjectSize() int64
}

ObjectInfo is an interface encapsulating information about objects.

type Option 

type Option interface {
	OptionArgs() ([]string, error)
}

Option is a git command line flag with validation logic

type ReceivePackRequest 

type ReceivePackRequest interface {
	GetGlId() string
	GetGlUsername() string
	GetGlRepository() string
	GetRepository() *gitalypb.Repository
}

ReceivePackRequest abstracts away the different requests that end up spawning git-receive-pack.

type RefUpdateType 

type RefUpdateType byte

RefUpdateType represents the type of update a FetchStatusLine is. The valid types are documented here: https://git-scm.com/docs/git-fetch/2.30.0#Documentation/git-fetch.txt-flag 

const (
	// RefUpdateTypeFastForwardUpdate represents a 'fast forward update' fetch status line
	RefUpdateTypeFastForwardUpdate RefUpdateType = ' '
	// RefUpdateTypeForcedUpdate represents a 'forced update' fetch status line
	RefUpdateTypeForcedUpdate RefUpdateType = '+'
	// RefUpdateTypePruned represents a 'pruned' fetch status line
	RefUpdateTypePruned RefUpdateType = '-'
	// RefUpdateTypeTagUpdate represents a 'tag update' fetch status line
	RefUpdateTypeTagUpdate RefUpdateType = 't'
	// RefUpdateTypeFetched represents a 'fetched' fetch status line. This
	// indicates that a new reference has been created in the local repository
	RefUpdateTypeFetched RefUpdateType = '*'
	// RefUpdateTypeUpdateFailed represents an 'update failed' fetch status line
	RefUpdateTypeUpdateFailed RefUpdateType = '!'
	// RefUpdateTypeUnchanged represents an 'unchanged' fetch status line
	RefUpdateTypeUnchanged RefUpdateType = '='
)

func (RefUpdateType) Valid 

func (t RefUpdateType) Valid() bool

Valid checks whether the RefUpdateType is one of the seven valid types of update

type Reference 

type Reference struct {
	// Name is the name of the reference
	Name ReferenceName
	// Target is the target of the reference. For direct references it
	// contains the object ID, for symbolic references it contains the
	// target branch name.
	Target string
	// IsSymbolic tells whether the reference is direct or symbolic
	IsSymbolic bool
}

Reference represents a Git reference.

func GetReferences added in v16.4.0 

func GetReferences(ctx context.Context, repoExecutor RepositoryExecutor, cfg GetReferencesConfig) ([]Reference, error)

GetReferences enumerates references in the given repository. By default, it returns all references that exist in the repository. This behaviour can be tweaked via the `GetReferencesConfig`.

func GetSymbolicRef added in v16.4.0 

func GetSymbolicRef(ctx context.Context, repoExecutor RepositoryExecutor, refname ReferenceName) (Reference, error)

GetSymbolicRef reads the symbolic reference.

func NewReference 

func NewReference(name ReferenceName, target ObjectID) Reference

NewReference creates a direct reference to an object.

func NewSymbolicReference 

func NewSymbolicReference(name ReferenceName, target ReferenceName) Reference

NewSymbolicReference creates a symbolic reference to another reference.

type ReferenceName 

type ReferenceName string

ReferenceName represents the name of a git reference, e.g. "refs/heads/master". It does not support extended revision notation like a Revision does and must always contain a fully qualified reference.

func NewReferenceNameFromBranchName 

func NewReferenceNameFromBranchName(branch string) ReferenceName

NewReferenceNameFromBranchName returns a new ReferenceName from a given branch name. Note that branch is treated as an unqualified branch name. This function will thus always prepend "refs/heads/".

func (ReferenceName) Branch 

func (r ReferenceName) Branch() (string, bool)

Branch returns `true` and the branch name if the reference is a branch. E.g. if ReferenceName is "refs/heads/master", it will return "master". If it is not a branch, `false` is returned.

func (ReferenceName) Revision 

func (r ReferenceName) Revision() Revision

Revision converts the ReferenceName to a Revision. This is safe to do as a reference is always also a revision.

func (ReferenceName) String 

func (r ReferenceName) String() string

String returns the string representation of the ReferenceName.

type Repository 

type Repository interface {
	// ResolveRevision tries to resolve the given revision to its object
	// ID. This uses the typical DWIM mechanism of git, see gitrevisions(1)
	// for accepted syntax. This will not verify whether the object ID
	// exists. To do so, you can peel the reference to a given object type,
	// e.g. by passing `refs/heads/master^{commit}`.
	ResolveRevision(ctx context.Context, revision Revision) (ObjectID, error)
	// HasBranches returns whether the repository has branches.
	HasBranches(ctx context.Context) (bool, error)
	// GetDefaultBranch returns the default branch of the repository.
	GetDefaultBranch(ctx context.Context) (ReferenceName, error)
	// HeadReference returns the reference that HEAD points to for the
	// repository.
	HeadReference(ctx context.Context) (ReferenceName, error)
}

Repository is the common interface of different repository implementations.

type RepositoryExecutor 

type RepositoryExecutor interface {
	storage.Repository
	Exec(ctx context.Context, cmd Command, opts ...CmdOpt) (*command.Command, error)
	ExecAndWait(ctx context.Context, cmd Command, opts ...CmdOpt) error
	GitVersion(ctx context.Context) (Version, error)
	ObjectHash(ctx context.Context) (ObjectHash, error)
}

RepositoryExecutor is an interface which allows execution of Git commands in a specific repository.

type RequestWithGitProtocol 

type RequestWithGitProtocol interface {
	GetGitProtocol() string
}

RequestWithGitProtocol holds requests that respond to GitProtocol

type RequestWithUserAndTimestamp added in v16.5.0 

type RequestWithUserAndTimestamp interface {
	GetUser() *gitalypb.User
	GetTimestamp() *timestamppb.Timestamp
}

RequestWithUserAndTimestamp represents a collection of requests that contains information used to generate a signature for user.

type Revision 

type Revision string

Revision represents anything that resolves to either a commit, multiple commits or to an object different than a commit. This could be e.g. "master", "master^{commit}", an object hash or similar. See gitrevisions(1) for supported syntax.

func (Revision) String 

func (r Revision) String() string

String returns the string representation of the Revision.

type ShowRefDecoder 

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

ShowRefDecoder parses the output format of git-show-ref

func NewShowRefDecoder 

func NewShowRefDecoder(r io.Reader) *ShowRefDecoder

NewShowRefDecoder returns a new ShowRefDecoder

func (*ShowRefDecoder) Decode 

func (d *ShowRefDecoder) Decode(ref *Reference) error

Decode reads and parses the next reference. Returns io.EOF when the end of the reader has been reached.

type Signature added in v16.3.0 

type Signature struct {
	// Name of the author or the committer.
	Name string
	// Email of the author or the committer.
	Email string
	// When is the time of the commit.
	When time.Time
}

Signature represents a commits signature.

func NewSignature added in v16.3.0 

func NewSignature(name, email string, when time.Time) Signature

NewSignature creates a new sanitized signature.

func SignatureFromRequest added in v16.5.0 

func SignatureFromRequest(req RequestWithUserAndTimestamp) (Signature, error)

SignatureFromRequest generates and returns a signature from the request, respecting the timezone information of the user.

type StaticOption 

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

StaticOption are reusable trusted options

func (StaticOption) OptionArgs 

func (sa StaticOption) OptionArgs() ([]string, error)

OptionArgs just passes through the already trusted value. This never returns an error.

type UserDetails 

type UserDetails struct {
	// Username contains the name of the user who has caused the hook to be executed.
	Username string `json:"username"`
	// UserID contains the ID of the user who has caused the hook to be executed.
	UserID string `json:"userid"`
	// Protocol contains the protocol via which the hook was executed. This
	// can be one of "web", "ssh" or "smarthttp".
	Protocol string `json:"protocol"`
	// RemoteIP contains the original IP of the client who initiated the flow leading to this
	// target hook.
	RemoteIP string `json:"remote_ip"`
}

UserDetails contains all information which is required for hooks executed by git-receive-pack, namely the pre-receive, update or post-receive hook.

type ValidateRevisionOption added in v16.1.0 

type ValidateRevisionOption func(cfg *validateRevisionConfig)

ValidateRevisionOption is an option that can be passed to ValidateRevision.

func AllowEmptyRevision added in v16.1.0 

func AllowEmptyRevision() ValidateRevisionOption

AllowEmptyRevision changes ValidateRevision to not return an error in case the specified revision is empty.

func AllowPathScopedRevision added in v16.1.0 

func AllowPathScopedRevision() ValidateRevisionOption

AllowPathScopedRevision changes ValidateRevision to allow path-scoped revisions like `HEAD:README.md`. Note that path-scoped revisions may contain any character except for NUL bytes. Most importantly, a path-scoped revision may contain newlines.

func AllowPseudoRevision added in v16.1.0 

func AllowPseudoRevision() ValidateRevisionOption

AllowPseudoRevision changes ValidateRevision to allow pseudo-revisions understood by git-rev-list(1). This includes options like `--all`, `--not`, `--branches` or `--glob`.

type ValueFlag 

type ValueFlag struct {
	Name  string
	Value string
}

ValueFlag is an optional command line argument that is comprised of pair of tokens (e.g. "-n 50")

func (ValueFlag) GlobalArgs 

func (vf ValueFlag) GlobalArgs() ([]string, error)

GlobalArgs returns the arguments for the given value flag, which should typically be two arguments: the flag and its value. It returns an error if the value flag is not sanitary.

func (ValueFlag) OptionArgs 

func (vf ValueFlag) OptionArgs() ([]string, error)

OptionArgs returns an error if the flag is not sanitary

type Version 

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

Version represents the version of git itself.

func NewVersion 

func NewVersion(major, minor, patch, gl uint32) Version

NewVersion constructs a new Git version from the given components.

func (Version) IsSupported 

func (v Version) IsSupported() bool

IsSupported checks if a version string corresponds to a Git version supported by Gitaly.

func (Version) LessThan 

func (v Version) LessThan(other Version) bool

LessThan determines whether the version is older than another version.

func (Version) String 

func (v Version) String() string

String returns the string representation of the version.

type WriteBlobConfig added in v16.4.0 

type WriteBlobConfig struct {
	//  Path is used by git to decide which filters to run on the content.
	Path string
}

WriteBlobConfig is the configuration used to write blobs into the repository.

Source Files

View all Source files

Directories

Path Synopsis
Package pktline implements utility functions for working with the Git pkt-line format.
 Package pktline implements utility functions for working with the Git pkt-line format.

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.