push

type BasicHandler struct {
	Repo       remotetypes.LocalRepo     // The target repository
	Server     core.RemoteServer         // The repository remote server
	OldState   remotetypes.RepoRefsState // The old state of the repo before the current push was written
	PushReader *Reader                   // The push reader for reading pushed git objects
	NoteID     string                    // The push note unique ID

	ChangeValidator validation.ChangeValidatorFunc      // Repository state change validator
	Reverter        plumbing.RevertFunc                 // Repository state reverser function
	MergeChecker    validation.MergeComplianceCheckFunc // Merge request checker function

	TxDetails            remotetypes.ReferenceTxDetails // Map of references to their transaction details
	ReferenceHandler     HandleReferenceFunc            // Pushed reference handler function
	AuthorizationHandler HandleAuthorizationFunc        // Authorization handler function
	PolicyChecker        policy.PolicyChecker           // Policy checker function
	// contains filtered or unexported fields
}

type HandleAuthorizationFunc func(ur *packp.ReferenceUpdateRequest) error

type HandleReferenceFunc func(ref string) []error

type Handler interface {

	// HandleStream starts the process of handling a pushed packfile.
	//
	// It reads the pushed updates from the packfile, extracts useful
	// information and writes the update to gitReceive which is the
	// git-receive-pack process.
	//
	// Access the git-receive-pack process using gitReceiveCmd.
	//
	// pktEnc provides access to the git output encoder.
	HandleStream(packfile io.Reader, gitReceive io.WriteCloser, gitRcvCmd util.Cmd, pktEnc *pktline.Encoder) error

	// EnsureReferencesHaveTxDetail checks that each pushed reference
	// have a transaction detail that provide more information about
	// the transaction.
	EnsureReferencesHaveTxDetail() error

	// DoAuth performs authorization checks on the specified target reference.
	// If targetRef is unset, all references are checked. If ignorePostRefs is
	// true, post references like issue and merge references are not checked.
	DoAuth(ur *packp.ReferenceUpdateRequest, targetRef string, ignorePostRefs bool) error

	// HandleAuthorization performs authorization checks on all pushed references.
	HandleAuthorization(ur *packp.ReferenceUpdateRequest) error

	// HandleReferences process pushed references.
	HandleReferences() error

	// HandleRepoSize performs garbage collection and repo size validation.
	//
	// It will return error if repo size exceeds the allowed maximum.
	//
	// It will also reload the repository handle since GC makes
	// go-git internal state stale.
	HandleGCAndSizeCheck() error

	// HandleUpdate creates a push note to represent the push operation and
	// adds it to the push pool and then have it broadcast to peers.
	HandleUpdate(targetNote types.PushNote) error

	// HandleReference performs validation and update reversion for a single pushed reference.
	// // When revertOnly is true, only reversion operation is performed.
	HandleReference(ref string) []error

	// HandleReversion reverts the pushed references back to their pre-push state.
	HandleReversion() []error

	// HandlePushNote implements Handler by handing incoming push note
	HandlePushNote(note types.PushNote) (err error)
}

type MakeReferenceUpdateRequestPackFunc func(tx pushtypes.PushNote) (io.ReadSeeker, error)

type ObjectObserver struct {
	Objects     []*PackObject
	MaxBlobSize int64
	// contains filtered or unexported fields
}

type PackObject struct {
	Type plumbing.ObjectType
	Hash plumbing.Hash
}

type PackedReferenceObject struct {
	OldHash string
	NewHash string
}

type PackedReferences map[string]*PackedReferenceObject

type PushedObjects []*PackObject

type Reader struct {
	References PackedReferences
	Objects    PushedObjects
	// contains filtered or unexported fields
}