go-git.v4: gopkg.in/src-d/go-git.v4/plumbing/protocol/packp Index | Examples | Files | Directories

package packp

import "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"

Index

Examples

Package Files

advrefs.go advrefs_decode.go advrefs_encode.go common.go doc.go report_status.go shallowupd.go srvresp.go ulreq.go ulreq_decode.go ulreq_encode.go updreq.go updreq_decode.go updreq_encode.go uppackreq.go uppackresp.go

Constants

const (
    Create  Action = "create"
    Update         = "update"
    Delete         = "delete"
    Invalid        = "invalid"
)

Variables

var (
    // ErrEmptyAdvRefs is returned by Decode if it gets an empty advertised
    // references message.
    ErrEmptyAdvRefs = errors.New("empty advertised-ref message")
    // ErrEmptyInput is returned by Decode if the input is empty.
    ErrEmptyInput = errors.New("empty input")
)
var (
    ErrEmptyCommands    = errors.New("commands cannot be empty")
    ErrMalformedCommand = errors.New("malformed command")
)
var (
    ErrEmpty = errors.New("empty update-request message")
)
var ErrUploadPackResponseNotDecoded = errors.New("upload-pack-response should be decoded")

ErrUploadPackResponseNotDecoded is returned if Read is called without decoding first

func NewErrUnexpectedData Uses

func NewErrUnexpectedData(msg string, data []byte) error

NewErrUnexpectedData returns a new ErrUnexpectedData containing the data and the message given

type Action Uses

type Action string

type AdvRefs Uses

type AdvRefs struct {
    // Prefix stores prefix payloads.
    //
    // When using this message over (smart) HTTP, you have to add a pktline
    // before the whole thing with the following payload:
    //
    // '# service=$servicename" LF
    //
    // Moreover, some (all) git HTTP smart servers will send a flush-pkt
    // just after the first pkt-line.
    //
    // To accommodate both situations, the Prefix field allow you to store
    // any data you want to send before the actual pktlines.  It will also
    // be filled up with whatever is found on the line.
    Prefix [][]byte
    // Head stores the resolved HEAD reference if present.
    // This can be present with git-upload-pack, not with git-receive-pack.
    Head *plumbing.Hash
    // Capabilities are the capabilities.
    Capabilities *capability.List
    // References are the hash references.
    References map[string]plumbing.Hash
    // Peeled are the peeled hash references.
    Peeled map[string]plumbing.Hash
    // Shallows are the shallow object ids.
    Shallows []plumbing.Hash
}

AdvRefs values represent the information transmitted on an advertised-refs message. Values from this type are not zero-value safe, use the New function instead.

func NewAdvRefs Uses

func NewAdvRefs() *AdvRefs

NewAdvRefs returns a pointer to a new AdvRefs value, ready to be used.

func (*AdvRefs) AddReference Uses

func (a *AdvRefs) AddReference(r *plumbing.Reference) error

func (*AdvRefs) AllReferences Uses

func (a *AdvRefs) AllReferences() (memory.ReferenceStorage, error)

func (*AdvRefs) Decode Uses

func (a *AdvRefs) Decode(r io.Reader) error

Decode reads the next advertised-refs message form its input and stores it in the AdvRefs.

Code:

// Here is a raw advertised-ref message.
raw := "" +
    "0065a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 HEAD\x00multi_ack ofs-delta symref=HEAD:/refs/heads/master\n" +
    "003fa6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n" +
    "00441111111111111111111111111111111111111111 refs/tags/v2.6.11-tree\n" +
    "00475555555555555555555555555555555555555555 refs/tags/v2.6.11-tree^{}\n" +
    "0035shallow 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c\n" +
    "0000"

// Use the raw message as our input.
input := strings.NewReader(raw)

// Decode the input into a newly allocated AdvRefs value.
ar := NewAdvRefs()
_ = ar.Decode(input) // error check ignored for brevity

// Do something interesting with the AdvRefs, e.g. print its contents.
fmt.Println("head =", ar.Head)
fmt.Println("capabilities =", ar.Capabilities.String())
fmt.Println("...")
fmt.Println("shallows =", ar.Shallows)

Output:

head = a6930aaee06755d1bdcfd943fbf614e4d92bb0c7
capabilities = multi_ack ofs-delta symref=HEAD:/refs/heads/master
...
shallows = [5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c]

func (*AdvRefs) Encode Uses

func (a *AdvRefs) Encode(w io.Writer) error

Encode writes the AdvRefs encoding to a writer.

All the payloads will end with a newline character. Capabilities, references and shallows are written in alphabetical order, except for peeled references that always follow their corresponding references.

Code:

// Create an AdvRefs with the contents you want...
ar := NewAdvRefs()

// ...add a hash for the HEAD...
head := plumbing.NewHash("1111111111111111111111111111111111111111")
ar.Head = &head

// ...add some server capabilities...
ar.Capabilities.Add(capability.MultiACK)
ar.Capabilities.Add(capability.OFSDelta)
ar.Capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")

// ...add a couple of references...
ar.References["refs/heads/master"] = plumbing.NewHash("2222222222222222222222222222222222222222")
ar.References["refs/tags/v1"] = plumbing.NewHash("3333333333333333333333333333333333333333")

// ...including a peeled ref...
ar.Peeled["refs/tags/v1"] = plumbing.NewHash("4444444444444444444444444444444444444444")

// ...and finally add a shallow
ar.Shallows = append(ar.Shallows, plumbing.NewHash("5555555555555555555555555555555555555555"))

// Encode the packpContents to a bytes.Buffer.
// You can encode into stdout too, but you will not be able
// see the '\x00' after "HEAD".
var buf bytes.Buffer
_ = ar.Encode(&buf) // error checks ignored for brevity

// Print the contents of the buffer as a quoted string.
// Printing is as a non-quoted string will be prettier but you
// will miss the '\x00' after "HEAD".
fmt.Printf("%q", buf.String())

Output:

"00651111111111111111111111111111111111111111 HEAD\x00multi_ack ofs-delta symref=HEAD:/refs/heads/master\n003f2222222222222222222222222222222222222222 refs/heads/master\n003a3333333333333333333333333333333333333333 refs/tags/v1\n003d4444444444444444444444444444444444444444 refs/tags/v1^{}\n0035shallow 5555555555555555555555555555555555555555\n0000"

type Command Uses

type Command struct {
    Name plumbing.ReferenceName
    Old  plumbing.Hash
    New  plumbing.Hash
}

func (*Command) Action Uses

func (c *Command) Action() Action

type CommandStatus Uses

type CommandStatus struct {
    ReferenceName plumbing.ReferenceName
    Status        string
}

CommandStatus is the status of a reference in a report status. See ReportStatus struct.

func (*CommandStatus) Error Uses

func (s *CommandStatus) Error() error

Error returns the error, if any.

type Depth Uses

type Depth interface {
    IsZero() bool
    // contains filtered or unexported methods
}

Depth values stores the desired depth of the requested packfile: see DepthCommit, DepthSince and DepthReference.

type DepthCommits Uses

type DepthCommits int

DepthCommits values stores the maximum number of requested commits in the packfile. Zero means infinite. A negative value will have undefined consequences.

func (DepthCommits) IsZero Uses

func (d DepthCommits) IsZero() bool

type DepthReference Uses

type DepthReference string

DepthReference requests only commits not to found in the specified reference.

func (DepthReference) IsZero Uses

func (d DepthReference) IsZero() bool

type DepthSince Uses

type DepthSince time.Time

DepthSince values requests only commits newer than the specified time.

func (DepthSince) IsZero Uses

func (d DepthSince) IsZero() bool

type ErrUnexpectedData Uses

type ErrUnexpectedData struct {
    Msg  string
    Data []byte
}

ErrUnexpectedData represents an unexpected data decoding a message

func (*ErrUnexpectedData) Error Uses

func (err *ErrUnexpectedData) Error() string

type ReferenceUpdateRequest Uses

type ReferenceUpdateRequest struct {
    Capabilities *capability.List
    Commands     []*Command
    Shallow      *plumbing.Hash
    // Packfile contains an optional packfile reader.
    Packfile io.ReadCloser

    // Progress receives sideband progress messages from the server
    Progress sideband.Progress
}

ReferenceUpdateRequest values represent reference upload requests. Values from this type are not zero-value safe, use the New function instead.

func NewReferenceUpdateRequest Uses

func NewReferenceUpdateRequest() *ReferenceUpdateRequest

New returns a pointer to a new ReferenceUpdateRequest value.

func NewReferenceUpdateRequestFromCapabilities Uses

func NewReferenceUpdateRequestFromCapabilities(adv *capability.List) *ReferenceUpdateRequest

NewReferenceUpdateRequestFromCapabilities returns a pointer to a new ReferenceUpdateRequest value, the request capabilities are filled with the most optimal ones, based on the adv value (advertised capabilities), the ReferenceUpdateRequest contains no commands

It does set the following capabilities:

- agent
- report-status
- ofs-delta
- ref-delta
- delete-refs

It leaves up to the user to add the following capabilities later:

- atomic
- ofs-delta
- side-band
- side-band-64k
- quiet
- push-cert

func (*ReferenceUpdateRequest) Decode Uses

func (req *ReferenceUpdateRequest) Decode(r io.Reader) error

Decode reads the next update-request message form the reader and wr

func (*ReferenceUpdateRequest) Encode Uses

func (r *ReferenceUpdateRequest) Encode(w io.Writer) error

Encode writes the ReferenceUpdateRequest encoding to the stream.

type ReportStatus Uses

type ReportStatus struct {
    UnpackStatus    string
    CommandStatuses []*CommandStatus
}

ReportStatus is a report status message, as used in the git-receive-pack process whenever the 'report-status' capability is negotiated.

func NewReportStatus Uses

func NewReportStatus() *ReportStatus

NewReportStatus creates a new ReportStatus message.

func (*ReportStatus) Decode Uses

func (s *ReportStatus) Decode(r io.Reader) error

Decode reads from the given reader and decodes a report-status message. It does not read more input than what is needed to fill the report status.

func (*ReportStatus) Encode Uses

func (s *ReportStatus) Encode(w io.Writer) error

Encode writes the report status to a writer.

func (*ReportStatus) Error Uses

func (s *ReportStatus) Error() error

Error returns the first error if any.

type ServerResponse Uses

type ServerResponse struct {
    ACKs []plumbing.Hash
}

ServerResponse object acknowledgement from upload-pack service

func (*ServerResponse) Decode Uses

func (r *ServerResponse) Decode(reader *bufio.Reader, isMultiACK bool) error

Decode decodes the response into the struct, isMultiACK should be true, if the request was done with multi_ack or multi_ack_detailed capabilities.

func (*ServerResponse) Encode Uses

func (r *ServerResponse) Encode(w io.Writer) error

Encode encodes the ServerResponse into a writer.

type ShallowUpdate Uses

type ShallowUpdate struct {
    Shallows   []plumbing.Hash
    Unshallows []plumbing.Hash
}

func (*ShallowUpdate) Decode Uses

func (r *ShallowUpdate) Decode(reader io.Reader) error

func (*ShallowUpdate) Encode Uses

func (r *ShallowUpdate) Encode(w io.Writer) error

type UploadHaves Uses

type UploadHaves struct {
    Haves []plumbing.Hash
}

UploadHaves is a message to signal the references that a client has in a upload-pack. Do not use this directly. Use UploadPackRequest request instead.

func (*UploadHaves) Encode Uses

func (u *UploadHaves) Encode(w io.Writer, flush bool) error

Encode encodes the UploadHaves into the Writer. If flush is true, a flush command will be encoded at the end of the writer content.

type UploadPackRequest Uses

type UploadPackRequest struct {
    UploadRequest
    UploadHaves
}

UploadPackRequest represents a upload-pack request. Zero-value is not safe, use NewUploadPackRequest instead.

func NewUploadPackRequest Uses

func NewUploadPackRequest() *UploadPackRequest

NewUploadPackRequest creates a new UploadPackRequest and returns a pointer.

func NewUploadPackRequestFromCapabilities Uses

func NewUploadPackRequestFromCapabilities(adv *capability.List) *UploadPackRequest

NewUploadPackRequestFromCapabilities creates a new UploadPackRequest and returns a pointer. The request capabilities are filled with the most optiomal ones, based on the adv value (advertaised capabilities), the UploadPackRequest it has no wants, haves or shallows and an infinite depth

func (*UploadPackRequest) IsEmpty Uses

func (r *UploadPackRequest) IsEmpty() bool

IsEmpty a request if empty if Haves are contained in the Wants, or if Wants length is zero

type UploadPackResponse Uses

type UploadPackResponse struct {
    ShallowUpdate
    ServerResponse
    // contains filtered or unexported fields
}

UploadPackResponse contains all the information responded by the upload-pack service, the response implements io.ReadCloser that allows to read the packfile directly from it.

func NewUploadPackResponse Uses

func NewUploadPackResponse(req *UploadPackRequest) *UploadPackResponse

NewUploadPackResponse create a new UploadPackResponse instance, the request being responded by the response is required.

func NewUploadPackResponseWithPackfile Uses

func NewUploadPackResponseWithPackfile(req *UploadPackRequest,
    pf io.ReadCloser) *UploadPackResponse

NewUploadPackResponseWithPackfile creates a new UploadPackResponse instance, and sets its packfile reader.

func (*UploadPackResponse) Close Uses

func (r *UploadPackResponse) Close() error

Close the underlying reader, if any

func (*UploadPackResponse) Decode Uses

func (r *UploadPackResponse) Decode(reader io.ReadCloser) error

Decode decodes all the responses sent by upload-pack service into the struct and prepares it to read the packfile using the Read method

func (*UploadPackResponse) Encode Uses

func (r *UploadPackResponse) Encode(w io.Writer) (err error)

Encode encodes an UploadPackResponse.

func (*UploadPackResponse) Read Uses

func (r *UploadPackResponse) Read(p []byte) (int, error)

Read reads the packfile data, if the request was done with any Sideband capability the content read should be demultiplexed. If the methods wasn't called before the ErrUploadPackResponseNotDecoded will be return

type UploadRequest Uses

type UploadRequest struct {
    Capabilities *capability.List
    Wants        []plumbing.Hash
    Shallows     []plumbing.Hash
    Depth        Depth
}

UploadRequest values represent the information transmitted on a upload-request message. Values from this type are not zero-value safe, use the New function instead. This is a low level type, use UploadPackRequest instead.

func NewUploadRequest Uses

func NewUploadRequest() *UploadRequest

NewUploadRequest returns a pointer to a new UploadRequest value, ready to be used. It has no capabilities, wants or shallows and an infinite depth. Please note that to encode an upload-request it has to have at least one wanted hash.

func NewUploadRequestFromCapabilities Uses

func NewUploadRequestFromCapabilities(adv *capability.List) *UploadRequest

NewUploadRequestFromCapabilities returns a pointer to a new UploadRequest value, the request capabilities are filled with the most optiomal ones, based on the adv value (advertaised capabilities), the UploadRequest generated it has no wants or shallows and an infinite depth.

func (*UploadRequest) Decode Uses

func (u *UploadRequest) Decode(r io.Reader) error

Decode reads the next upload-request form its input and stores it in the UploadRequest.

Code:

// Here is a raw advertised-ref message.
raw := "" +
    "005bwant 1111111111111111111111111111111111111111 ofs-delta symref=HEAD:/refs/heads/master\n" +
    "0032want 2222222222222222222222222222222222222222\n" +
    "0032want 3333333333333333333333333333333333333333\n" +
    "0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" +
    "0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" +
    "001cdeepen-since 1420167845\n" + // 2015-01-02 03:04:05 +0000 UTC
    pktline.FlushString

// Use the raw message as our input.
input := strings.NewReader(raw)

// Create the Decoder reading from our input.
d := newUlReqDecoder(input)

// Decode the input into a newly allocated UlReq value.
ur := NewUploadRequest()
_ = d.Decode(ur) // error check ignored for brevity

// Do something interesting with the UlReq, e.g. print its contents.
fmt.Println("capabilities =", ur.Capabilities.String())
fmt.Println("wants =", ur.Wants)
fmt.Println("shallows =", ur.Shallows)
switch depth := ur.Depth.(type) {
case DepthCommits:
    fmt.Println("depth =", int(depth))
case DepthSince:
    fmt.Println("depth =", time.Time(depth))
case DepthReference:
    fmt.Println("depth =", string(depth))
}

Output:

capabilities = ofs-delta symref=HEAD:/refs/heads/master
wants = [1111111111111111111111111111111111111111 2222222222222222222222222222222222222222 3333333333333333333333333333333333333333]
shallows = [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb]
depth = 2015-01-02 03:04:05 +0000 UTC

func (*UploadRequest) Encode Uses

func (u *UploadRequest) Encode(w io.Writer) error

Encode writes the UlReq encoding of u to the stream.

All the payloads will end with a newline character. Wants and shallows are sorted alphabetically. A depth of 0 means no depth request is sent.

Code:

// Create an empty UlReq with the contents you want...
ur := NewUploadRequest()

// Add a couple of wants
ur.Wants = append(ur.Wants, plumbing.NewHash("3333333333333333333333333333333333333333"))
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Wants = append(ur.Wants, plumbing.NewHash("2222222222222222222222222222222222222222"))

// And some capabilities you will like the server to use
ur.Capabilities.Add(capability.OFSDelta)
ur.Capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")

// Add a couple of shallows
ur.Shallows = append(ur.Shallows, plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
ur.Shallows = append(ur.Shallows, plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))

// And retrict the answer of the server to commits newer than "2015-01-02 03:04:05 UTC"
since := time.Date(2015, time.January, 2, 3, 4, 5, 0, time.UTC)
ur.Depth = DepthSince(since)

// Create a new Encode for the stdout...
e := newUlReqEncoder(os.Stdout)
// ...and encode the upload-request to it.
_ = e.Encode(ur) // ignoring errors for brevity

Output:

005bwant 1111111111111111111111111111111111111111 ofs-delta symref=HEAD:/refs/heads/master
0032want 2222222222222222222222222222222222222222
0032want 3333333333333333333333333333333333333333
0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
001cdeepen-since 1420167845
0000

func (*UploadRequest) Validate Uses

func (r *UploadRequest) Validate() error

Validate validates the content of UploadRequest, following the next rules:

- Wants MUST have at least one reference
- capability.Shallow MUST be present if Shallows is not empty
- is a non-zero DepthCommits is given capability.Shallow MUST be present
- is a DepthSince is given capability.Shallow MUST be present
- is a DepthReference is given capability.DeepenNot MUST be present
- MUST contain only maximum of one of capability.Sideband and capability.Sideband64k
- MUST contain only maximum of one of capability.MultiACK and capability.MultiACKDetailed

Directories

PathSynopsis
capabilityPackage capability defines the server and client capabilities.
sidebandPackage sideband implements a sideband mutiplex/demultiplexer

Package packp imports 18 packages (graph) and is imported by 29 packages. Updated 2019-08-01. Refresh now. Tools for package owners.