updateref

Documentation

Index

• Variables
• type AlreadyLockedError
  • func (e AlreadyLockedError) Error() string
  • func (e AlreadyLockedError) ErrorMetadata() []structerr.MetadataItem
• type FileDirectoryConflictError
  • func (e FileDirectoryConflictError) Error() string
  • func (e FileDirectoryConflictError) ErrorMetadata() []structerr.MetadataItem
• type InTransactionConflictError
  • func (e InTransactionConflictError) Error() string
  • func (e InTransactionConflictError) ErrorMetadata() []structerr.MetadataItem
• type InvalidReferenceFormatError
  • func (e InvalidReferenceFormatError) Error() string
  • func (e InvalidReferenceFormatError) ErrorMetadata() []structerr.MetadataItem
• type MismatchingStateError
  • func (e MismatchingStateError) Error() string
  • func (e MismatchingStateError) ErrorMetadata() []structerr.MetadataItem
• type MultipleUpdatesError
  • func (e MultipleUpdatesError) Error() string
  • func (e MultipleUpdatesError) ErrorMetadata() []structerr.MetadataItem
• type NonCommitObjectError
  • func (e NonCommitObjectError) Error() string
  • func (e NonCommitObjectError) ErrorMetadata() []structerr.MetadataItem
• type NonExistentObjectError
  • func (e NonExistentObjectError) Error() string
  • func (e NonExistentObjectError) ErrorMetadata() []structerr.MetadataItem
• type ReferenceAlreadyExistsError
  • func (e ReferenceAlreadyExistsError) Error() string
  • func (e ReferenceAlreadyExistsError) ErrorMetadata() []structerr.MetadataItem
• type Updater
  • func New(ctx context.Context, repo git.RepositoryExecutor, opts ...UpdaterOpt) (*Updater, error)
  • func (u *Updater) Close() error
  • func (u *Updater) Commit() error
  • func (u *Updater) Create(reference git.ReferenceName, oid git.ObjectID) error
  • func (u *Updater) Delete(reference git.ReferenceName) error
  • func (u *Updater) Prepare() error
  • func (u *Updater) Start() error
  • func (u *Updater) Update(reference git.ReferenceName, newOID, oldOID git.ObjectID) error
• type UpdaterOpt
  • func WithDisabledTransactions() UpdaterOpt
  • func WithNoDeref() UpdaterOpt

Variables

var (

	// ErrPackedRefsLocked indicates an operation failed due to the 'packed-refs' being locked. This is
	// the case if either `packed-refs.new` or `packed-refs.lock` exists in the repository.
	ErrPackedRefsLocked = errors.New("packed-refs locked")
)

Types

type AlreadyLockedError

type AlreadyLockedError struct {
	// ReferenceName is the name of the reference that is already locked.
	ReferenceName string
}

AlreadyLockedError indicates a reference cannot be locked because another process has already locked it.

func (AlreadyLockedError) Error

func (e AlreadyLockedError) Error() string

func (AlreadyLockedError) ErrorMetadata

func (e AlreadyLockedError) ErrorMetadata() []structerr.MetadataItem

ErrorMetadata implements the `structerr.ErrorMetadater` interface and provides the name of the reference that was locked already.

type FileDirectoryConflictError

type FileDirectoryConflictError struct {
	// ConflictingReferenceName is the name of the reference that would have conflicted.
	ConflictingReferenceName string
	// ExistingReferenceName is the name of the already existing reference.
	ExistingReferenceName string
}

FileDirectoryConflictError is returned when an operation would causes a file-directory conflict in the reference store.

func (FileDirectoryConflictError) Error

func (e FileDirectoryConflictError) Error() string

func (FileDirectoryConflictError) ErrorMetadata

func (e FileDirectoryConflictError) ErrorMetadata() []structerr.MetadataItem

ErrorMetadata implements the `structerr.ErrorMetadater` interface and provides the name of preexisting and conflicting reference names.

type InTransactionConflictError

type InTransactionConflictError struct {
	// FirstReferenceName is the name of the first reference that was modified.
	FirstReferenceName string
	// SecondReferenceName is the name of the second reference that was modified.
	SecondReferenceName string
}

InTransactionConflictError is returned when attempting to modify two references in the same transaction in a manner that is not allowed. For example, modifying 'refs/heads/parent' and creating 'refs/heads/parent/child' is not allowed.

func (InTransactionConflictError) Error

func (e InTransactionConflictError) Error() string

func (InTransactionConflictError) ErrorMetadata

func (e InTransactionConflictError) ErrorMetadata() []structerr.MetadataItem

ErrorMetadata implements the `structerr.ErrorMetadater` interface and provides the name of the first and second conflicting reference names.

type InvalidReferenceFormatError

type InvalidReferenceFormatError struct {
	// ReferenceName is the invalid reference name.
	ReferenceName string
}

InvalidReferenceFormatError indicates a reference name was invalid.

func (InvalidReferenceFormatError) Error

func (e InvalidReferenceFormatError) Error() string

func (InvalidReferenceFormatError) ErrorMetadata

func (e InvalidReferenceFormatError) ErrorMetadata() []structerr.MetadataItem

ErrorMetadata implements the `structerr.ErrorMetadater` interface and provides the name of the reference that was invalid.

type MismatchingStateError

type MismatchingStateError struct {
	// ReferenceName is the name of the reference that was being updated.
	ReferenceName string
	// ExpectedObjectID is the expected object ID as specified by the caller.
	ExpectedObjectID string
	// ActualObjectID is the actual object ID that the reference was pointing to.
	ActualObjectID string
}

MismatchingStateError is returned when attempting to update a reference where the expected object ID does not match the actual object ID that the reference currently points to.

func (MismatchingStateError) Error

func (e MismatchingStateError) Error() string

func (MismatchingStateError) ErrorMetadata

func (e MismatchingStateError) ErrorMetadata() []structerr.MetadataItem

ErrorMetadata implements the `structerr.ErrorMetadater` interface and provides error metadata about the expected and actual object ID of the failed reference update.

type MultipleUpdatesError

type MultipleUpdatesError struct {
	// ReferenceName is the name of the reference that has multiple updates.
	ReferenceName string
}

MultipleUpdatesError indicates that a reference cannot have multiple updates within the same transaction.

func (MultipleUpdatesError) Error

func (e MultipleUpdatesError) Error() string

func (MultipleUpdatesError) ErrorMetadata

func (e MultipleUpdatesError) ErrorMetadata() []structerr.MetadataItem

ErrorMetadata implements the `structerr.ErrorMetadater` interface and provides the name of the reference that has multiple updates.

type NonCommitObjectError

type NonCommitObjectError struct {
	// ReferenceName is the name of the branch that was being updated.
	ReferenceName string
	// ObjectID is the object ID of the non-commit object.
	ObjectID string
}

NonCommitObjectError is returned when attempting to point a branch to an object that is not an object.

func (NonCommitObjectError) Error

func (e NonCommitObjectError) Error() string

func (NonCommitObjectError) ErrorMetadata

func (e NonCommitObjectError) ErrorMetadata() []structerr.MetadataItem

ErrorMetadata implements the `structerr.ErrorMetadater` interface and provides the object that is not a commit as well as the reference that should have been updated to point to it.

type NonExistentObjectError

type NonExistentObjectError struct {
	// ReferenceName is the name of the reference that was being updated.
	ReferenceName string
	// ObjectID is the object ID of the non-existent object.
	ObjectID string
}

NonExistentObjectError is returned when attempting to point a reference to an object that does not exist in the object database.

func (NonExistentObjectError) Error

func (e NonExistentObjectError) Error() string

func (NonExistentObjectError) ErrorMetadata

func (e NonExistentObjectError) ErrorMetadata() []structerr.MetadataItem

ErrorMetadata implements the `structerr.ErrorMetadater` interface and provides the missing object as well as the reference that should have been updated to point to it.

type ReferenceAlreadyExistsError

type ReferenceAlreadyExistsError struct {
	// ReferenceName is the name of the reference that already exists.
	ReferenceName string
}

ReferenceAlreadyExistsError is returned when attempting to create a reference that already exists.

func (ReferenceAlreadyExistsError) Error

func (e ReferenceAlreadyExistsError) Error() string

func (ReferenceAlreadyExistsError) ErrorMetadata

func (e ReferenceAlreadyExistsError) ErrorMetadata() []structerr.MetadataItem

ErrorMetadata implements the `structerr.ErrorMetadater` interface and provides the name of the reference that already existed.

type Updater

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

Updater wraps a `git update-ref --stdin` process, presenting an interface that allows references to be easily updated in bulk. It is not suitable for concurrent use.

Correct usage of the Updater is as follows:

1. Transaction must be started before anything else.
2. Transaction can't be started if there is an active transaction.
3. Updates can be staged only when there is an unprepared transaction.
4. Prepare can be called only with an unprepared transaction.
5. Commit can be called only with an active transaction. The transaction can be committed unprepared or prepared.
7. Close can be called at any time. The active transaction is aborted.
8. Any sort of error causes the updater to close.

func New

func New(ctx context.Context, repo git.RepositoryExecutor, opts ...UpdaterOpt) (*Updater, error)

New returns a new bulk updater, wrapping a `git update-ref` process. Call the various methods to enqueue updates, then call Commit() to attempt to apply all the updates at once.

It is important that ctx gets canceled somewhere. If it doesn't, the process spawned by New() may never terminate.

func (*Updater) Close

func (u *Updater) Close() error

Close closes the updater and aborts a possible open transaction. No changes will be written to disk, all lockfiles will be cleaned up and the process will exit.

func (*Updater) Commit

func (u *Updater) Commit() error

Commit applies the commands specified in other calls to the Updater. Commit finishes the reference transaction and another one must be started before further changes can be staged.

func (*Updater) Create

func (u *Updater) Create(reference git.ReferenceName, oid git.ObjectID) error

Create commands the reference to be created with the given object ID. The ref must not exist.

A reference transaction must be started before calling Create.

func (*Updater) Delete

func (u *Updater) Delete(reference git.ReferenceName) error

Delete commands the reference to be removed from the repository. This command will ignore any old state of the reference and just force-remove it.

A reference transaction must be started before calling Delete.

func (*Updater) Prepare

func (u *Updater) Prepare() error

Prepare prepares the reference transaction by locking all references and determining their current values. The updates are not yet committed and will be rolled back in case there is no call to `Commit()`. This call is optional.

func (*Updater) Start

func (u *Updater) Start() error

Start begins a new reference transaction. The reference changes are not perfromed until Commit is explicitly called.

func (*Updater) Update

func (u *Updater) Update(reference git.ReferenceName, newOID, oldOID git.ObjectID) error

Update commands the reference to be updated to point at the object ID specified in newOID. If newOID is the zero OID, then the branch will be deleted. If oldOID is a non-empty string, then the reference will only be updated if its current value matches the old value. If the old value is the zero OID, then the branch must not exist.

A reference transaction must be started before calling Update.

type UpdaterOpt

type UpdaterOpt func(*updaterConfig)

UpdaterOpt is a type representing options for the Updater.

func WithDisabledTransactions

func WithDisabledTransactions() UpdaterOpt

WithDisabledTransactions disables hooks such that no reference-transactions are used for the updater.

func WithNoDeref

func WithNoDeref() UpdaterOpt

WithNoDeref disables de-reference while updating ref. If this option is turned on, <ref> itself is overwritten, rather than the result of following the symbolic ref.