Documentation ¶
Index ¶
- Constants
- Variables
- func AlternateObjectDirectories(ctx context.Context, storageRoot, repoPath string) ([]string, error)
- func BuildSSHInvocation(ctx context.Context, sshKey, knownHosts string) (string, func(), error)
- func CheckRefFormat(ctx context.Context, gitCmdFactory CommandFactory, refName string) (bool, error)
- func IsInvalidArgErr(err error) bool
- func IsLFSPointer(b []byte) bool
- func NewTreeEntry(commitOid, rootOid, rootPath string, filename, oidBytes, modeBytes []byte) (*gitalypb.TreeEntry, error)
- func ObjectDirectories(ctx context.Context, storageRoot, repoPath string) ([]string, error)
- func ValidateObjectID(id string) error
- func ValidateRevision(revision []byte) error
- func ValidateRevisionAllowEmpty(revision []byte) error
- func WarnIfTooManyBitmaps(ctx context.Context, locator storage.Locator, storageName, repoPath string)
- type BundledGitEnvironmentConstructor
- type Checksum
- type Cmd
- type CmdOpt
- func ConvertGlobalOptions(options *gitalypb.GlobalOptions) []CmdOpt
- func WithConfig(configPairs ...ConfigPair) CmdOpt
- func WithConfigEnv(configPairs ...ConfigPair) CmdOpt
- func WithDisabledHooks() CmdOpt
- func WithEnv(envs ...string) CmdOpt
- func WithGitProtocol(req RequestWithGitProtocol) CmdOpt
- func WithGlobalOption(opts ...GlobalOption) CmdOpt
- func WithInternalFetch(req *gitalypb.SSHUploadPackRequest) CmdOpt
- func WithInternalFetchWithSidechannel(req *gitalypb.SSHUploadPackWithSidechannelRequest) CmdOpt
- func WithPackObjectsHookEnv(repo *gitalypb.Repository) CmdOpt
- func WithReceivePackHooks(req ReceivePackRequest, protocol string) CmdOpt
- func WithRefTxHook(repo repository.GitRepo) CmdOpt
- func WithStderr(w io.Writer) CmdOpt
- func WithStdin(r io.Reader) CmdOpt
- func WithStdout(w io.Writer) CmdOpt
- type CommandFactory
- type ConfigPair
- type DistributedGitEnvironmentConstructor
- type ExecCommandFactory
- func (cf *ExecCommandFactory) Collect(metrics chan<- prometheus.Metric)
- func (cf *ExecCommandFactory) Describe(descs chan<- *prometheus.Desc)
- func (cf *ExecCommandFactory) GetExecutionEnvironment(ctx context.Context) ExecutionEnvironment
- func (cf *ExecCommandFactory) GitVersion(ctx context.Context) (Version, error)
- func (cf *ExecCommandFactory) HooksPath(ctx context.Context) string
- func (cf *ExecCommandFactory) New(ctx context.Context, repo repository.GitRepo, sc Cmd, opts ...CmdOpt) (*command.Command, error)
- func (cf *ExecCommandFactory) NewWithDir(ctx context.Context, dir string, sc Cmd, opts ...CmdOpt) (*command.Command, error)
- func (cf *ExecCommandFactory) NewWithoutRepo(ctx context.Context, sc Cmd, opts ...CmdOpt) (*command.Command, error)
- type ExecCommandFactoryOption
- type ExecutionEnvironment
- type ExecutionEnvironmentConstructor
- type FallbackGitEnvironmentConstructor
- type FetchScanner
- type FetchStatusLine
- type Flag
- type GlobalOption
- type Hook
- type HooksPayload
- type Object
- type ObjectID
- type ObjectInfo
- type Option
- type ReceiveHooksPayload
- type ReceivePackRequest
- type RefUpdateType
- type Reference
- type ReferenceName
- type Repository
- type RepositoryExecutor
- type RequestWithGitProtocol
- type Revision
- type ShowRefDecoder
- type StaticOption
- type SubCmd
- type SubSubCmd
- type ValueFlag
- type Version
Constants ¶
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 // 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 )
const ( // EmptyTreeOID is the Git tree object hash that corresponds to an empty tree (directory) EmptyTreeOID = ObjectID("4b825dc642cb6eb9a060e54bf8d69288fbee4904") // ZeroOID is the special value that Git uses to signal a ref or object does not exist ZeroOID = ObjectID("0000000000000000000000000000000000000000") )
const DefaultBranch = "main"
DefaultBranch is the default reference written to HEAD when a repository is created
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.
const ( // EnvHooksPayload is the name of the environment variable used // to hold the hooks payload. EnvHooksPayload = "GITALY_HOOKS_PAYLOAD" )
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" )
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.
const (
// ProtocolV2 is the special value used by Git clients to request protocol v2
ProtocolV2 = "version=2"
)
Variables ¶
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") )
var ( // ErrNotConfigured may be returned by an ExecutionEnvironmentConstructor in case an // environment was not configured. ErrNotConfigured = errors.New("execution environment is not configured") // ExecutionEnvironmentConstructors is the list of Git environments supported by the Git // command factory. The order is important and signifies the priority in which the // environments will be used: the environment created by the first constructor is the one // that will be preferred when executing Git commands. Later environments may be used in // case `IsEnabled()` returns `false` though. ExecutionEnvironmentConstructors = []ExecutionEnvironmentConstructor{ BundledGitEnvironmentConstructor{ Suffix: "-v2.35.1.gl1", }, DistributedGitEnvironmentConstructor{}, FallbackGitEnvironmentConstructor{}, } )
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") )
var ( // ErrInvalidObjectID is returned in case an object ID's string // representation is not a valid one. ErrInvalidObjectID = errors.New("invalid object ID") )
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.
var FallbackTimeValue = time.Unix(1<<63-62135596801, 999999999)
FallbackTimeValue is the value returned by `SafeTimeParse` in case it encounters a parse error. It's the maximum time value possible in golang. See https://gitlab.com/gitlab-org/gitaly/issues/556#note_40289573
var InternalRefPrefixes = [...]string{
"refs/environments/",
"refs/keep-around/",
"refs/merge-requests/",
"refs/pipelines/",
}
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.
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, 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 ¶
BuildSSHInvocation builds a command line to invoke SSH with the provided key and known hosts. Both are optional.
func CheckRefFormat ¶
func CheckRefFormat(ctx context.Context, gitCmdFactory CommandFactory, refName string) (bool, error)
CheckRefFormat checks whether a fully-qualified refname is well well-formed using git-check-ref-format
func IsInvalidArgErr ¶
IsInvalidArgErr relays if the error is due to an argument validation failure
func IsLFSPointer ¶
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 ¶ added in v14.8.0
func NewTreeEntry(commitOid, rootOid, rootPath string, filename, oidBytes, modeBytes []byte) (*gitalypb.TreeEntry, error)
NewTreeEntry is a helper to construct a gitalypb.TreeEntry from the provided parameters.
func ObjectDirectories ¶
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 ValidateObjectID ¶
ValidateObjectID checks if id is a syntactically correct object ID. Abbreviated object IDs are not deemed to be valid. Returns an ErrInvalidObjectID if the id is not valid.
func ValidateRevision ¶
ValidateRevision checks if a revision looks valid
func ValidateRevisionAllowEmpty ¶
ValidateRevisionAllowEmpty checks if a revision looks valid, but allows empty strings
func WarnIfTooManyBitmaps ¶
func WarnIfTooManyBitmaps(ctx context.Context, 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 ¶ added in v14.9.0
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 ¶ added in v14.9.0
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 ¶ added in v14.5.0
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) AddBytes ¶ added in v14.5.0
AddBytes adds a reference to the checksum that is a line in the output format of `git-show-ref`.
type CmdOpt ¶
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 WithGitProtocol ¶
func WithGitProtocol(req RequestWithGitProtocol) CmdOpt
WithGitProtocol checks whether the request has Git protocol v2 and sets this in the environment.
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 ¶ added in v14.8.0
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 ¶ added in v14.9.0
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) 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 repository.GitRepo) 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
type CommandFactory ¶
type CommandFactory interface { // New creates a new command for the repo repository. New(ctx context.Context, repo repository.GitRepo, sc Cmd, opts ...CmdOpt) (*command.Command, error) // NewWithoutRepo creates a command without a target repository. NewWithoutRepo(ctx context.Context, sc Cmd, opts ...CmdOpt) (*command.Command, error) // NewWithDir creates a command without a target repository that would be executed in dir directory. NewWithDir(ctx context.Context, dir string, sc Cmd, 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 struct { Key string Value string // Origin shows the origin type: file, standard input, blob, command line. // https://git-scm.com/docs/git-config#Documentation/git-config.txt---show-origin Origin string // Scope shows the scope of this config value: local, global, system, command. // https://git-scm.com/docs/git-config#Documentation/git-config.txt---show-scope Scope string }
ConfigPair is a sub-command option for use with commands like "git config"
func ConvertConfigOptions ¶
func ConvertConfigOptions(options []string) ([]ConfigPair, error)
ConvertConfigOptions converts `<key>=<value>` config entries into `ConfigPairs`.
func (ConfigPair) GlobalArgs ¶
func (cp ConfigPair) GlobalArgs() ([]string, error)
GlobalArgs generates a git `-c <key>=<value>` flag. The key must pass validation by containing only alphanumeric sections separated by dots. No other characters are allowed for now as `git -c` may not correctly parse them, most importantly when they contain equals signs.
func (ConfigPair) OptionArgs ¶
func (cp ConfigPair) OptionArgs() ([]string, error)
OptionArgs validates the config pair args
type DistributedGitEnvironmentConstructor ¶ added in v14.9.0
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 ¶ added in v14.9.0
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, 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 ¶ added in v14.7.0
func (cf *ExecCommandFactory) GetExecutionEnvironment(ctx context.Context) ExecutionEnvironment
GetExecutionEnvironment returns parameters required to execute Git commands.
func (*ExecCommandFactory) GitVersion ¶ added in v14.7.0
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) HooksPath ¶ added in v14.7.0
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 repository.GitRepo, sc Cmd, opts ...CmdOpt) (*command.Command, error)
New creates a new command for the repo repository.
func (*ExecCommandFactory) NewWithDir ¶
func (cf *ExecCommandFactory) NewWithDir(ctx context.Context, dir string, sc Cmd, opts ...CmdOpt) (*command.Command, error)
NewWithDir creates a new command.Command whose working directory is set to dir. Arguments are validated before the command is being run. It is invalid to use an empty directory.
func (*ExecCommandFactory) NewWithoutRepo ¶
func (cf *ExecCommandFactory) NewWithoutRepo(ctx context.Context, sc Cmd, opts ...CmdOpt) (*command.Command, error)
NewWithoutRepo creates a command without a target repository.
type ExecCommandFactoryOption ¶ added in v14.7.0
type ExecCommandFactoryOption func(*execCommandFactoryConfig)
ExecCommandFactoryOption is an option that can be passed to NewExecCommandFactory.
func WithGitBinaryPath ¶ added in v14.8.0
func WithGitBinaryPath(path string) ExecCommandFactoryOption
WithGitBinaryPath overrides the path to the Git binary that shall be executed.
func WithHooksPath ¶ added in v14.7.0
func WithHooksPath(hooksPath string) ExecCommandFactoryOption
WithHooksPath will override the path where hooks are to be found.
func WithSkipHooks ¶ added in v14.7.0
func WithSkipHooks() ExecCommandFactoryOption
WithSkipHooks will skip any use of hooks in this command factory.
type ExecutionEnvironment ¶ added in v14.7.0
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 ¶ added in v14.9.0
func (e ExecutionEnvironment) Cleanup()
Cleanup cleans up any state set up by this ExecutionEnvironment.
func (ExecutionEnvironment) IsEnabled ¶ added in v14.9.0
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 ¶ added in v14.9.0
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 ¶ added in v14.9.0
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 ¶ added in v14.9.0
func (c FallbackGitEnvironmentConstructor) Construct(config.Cfg) (ExecutionEnvironment, error)
Construct sets up an execution environment by searching `PATH` for a `git` executable.
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 ¶
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 ¶
OptionArgs returns an error if the flag is not sanitary
type GlobalOption ¶
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"` // FeatureFlags contains feature flags with their values. They are set // into the outgoing context when calling HookService. FeatureFlags featureflag.Raw `json:"feature_flags,omitempty"` // Repo is the repository in which the hook is running. Repo *gitalypb.Repository `json:"-"` // 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"` // ReceiveHooksPayload contains information required when executing // git-receive-pack. ReceiveHooksPayload *ReceiveHooksPayload `json:"receive_hooks_payload"` }
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, tx *txinfo.Transaction, receiveHooksPayload *ReceiveHooksPayload, requestedHooks Hook, featureFlags featureflag.Raw, ) 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 Object ¶ added in v14.5.0
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 ObjectID ¶
type ObjectID string
ObjectID represents an object ID.
func NewObjectIDFromHex ¶
NewObjectIDFromHex constructs a new ObjectID from the given hex representation of the object ID. Returns ErrInvalidObjectID if the given OID is not valid.
type ObjectInfo ¶ added in v14.5.0
ObjectInfo is an interface encapsulating information about objects.
type ReceiveHooksPayload ¶
type ReceiveHooksPayload 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"` }
ReceiveHooksPayload contains all information which is required for hooks executed by git-receive-pack, namely the pre-receive, update or post-receive hook.
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 NewReference ¶
func NewReference(name ReferenceName, target string) Reference
NewReference creates a direct reference to an object.
func NewSymbolicReference ¶
func NewSymbolicReference(name ReferenceName, target string) 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) }
Repository is the common interface of different repository implementations.
type RepositoryExecutor ¶
type RepositoryExecutor interface { repository.GitRepo Exec(ctx context.Context, cmd Cmd, opts ...CmdOpt) (*command.Command, error) ExecAndWait(ctx context.Context, cmd Cmd, opts ...CmdOpt) error GitVersion(ctx context.Context) (Version, 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 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.
type ShowRefDecoder ¶ added in v14.6.0
type ShowRefDecoder struct {
// contains filtered or unexported fields
}
ShowRefDecoder parses the output format of git-show-ref
func NewShowRefDecoder ¶ added in v14.6.0
func NewShowRefDecoder(r io.Reader) *ShowRefDecoder
NewShowRefDecoder returns a new ShowRefDecoder
func (*ShowRefDecoder) Decode ¶ added in v14.6.0
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 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 SubCmd ¶
type SubCmd struct { Name string // e.g. "log", or "cat-file", or "worktree" Flags []Option // optional flags before the positional args Args []string // positional args after all flags PostSepArgs []string // post separator (i.e. "--") positional args }
SubCmd represents a specific git command
func (SubCmd) CommandArgs ¶
CommandArgs checks all arguments in the sub command and validates them
func (SubCmd) Subcommand ¶
Subcommand returns the subcommand name
type SubSubCmd ¶
type SubSubCmd struct { // Name is the name of the subcommand, e.g. "remote" in `git remote set-url` Name string // Action is the action of the subcommand, e.g. "set-url" in `git remote set-url` Action string // Flags are optional flags before the positional args Flags []Option // Args are positional arguments after all flags Args []string // PostSepArgs are positional args after the "--" separator PostSepArgs []string }
SubSubCmd is a positional argument that appears in the list of options for a subcommand.
func (SubSubCmd) CommandArgs ¶
CommandArgs checks all arguments in the SubSubCommand and validates them, returning the array of all arguments required to execute it.
func (SubSubCmd) Subcommand ¶
Subcommand returns the name of the given git command which this SubSubCmd executes. E.g. for `git remote add`, it would return "remote".
type ValueFlag ¶
ValueFlag is an optional command line argument that is comprised of pair of tokens (e.g. "-n 50")
func (ValueFlag) GlobalArgs ¶
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 ¶
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 (Version) FlushesUpdaterefStatus ¶ added in v14.3.0
FlushesUpdaterefStatus determines whether the given Git version properly flushes status messages in git-update-ref(1).
func (Version) IsSupported ¶
IsSupported checks if a version string corresponds to a Git version supported by Gitaly.
Source Files ¶
- bitmap.go
- checksum.go
- command.go
- command_description.go
- command_factory.go
- command_options.go
- decoder.go
- dirs.go
- execution_environment.go
- fetch_scanner.go
- hooks_options.go
- hooks_payload.go
- id.go
- lfs.go
- object.go
- proto.go
- protocol.go
- reference.go
- repository.go
- ssh.go
- staticargs.go
- tree_entry.go
- version.go