Google Git
Sign in
fuchsia / third_party / github.com / src-d / go-git / b4177b89c08b3cd7c791f223b4828b4a81a62312
commitb4177b89c08b3cd7c791f223b4828b4a81a62312[log] [tgz]
authorJoseph Vusich <jvusich@amazon.com>Mon Apr 02 21:31:40 2018 +0000
committerjvusich <jvusich@users.noreply.github.com>Mon Apr 02 23:36:59 2018 -0700
treed75d3fb55548d3cdbd87cc7e5c7cbe5d1baa3b8d
parent2cbff8d8ffa42dd1b399b3c94d094bdb2d1cdf5c [diff]
plumbing: format: pktline, Accept oversized pkt-lines up to 65524 bytes

The canonical Git client successfully decodes sideband packets up to
65524 bytes in length (4-byte header + 65520-byte payload). The Git
protocol documentation was updated in August 2016 to reduce the maximum
payload size to 65516 bytes, however old implementations still exist in
the wild emitting 65520-byte payloads.

As there is no technical difficulty with accepting (not emitting) larger
payload sizes, this change adjusts the limit check to allow successful
decoding of packets up to 65524 bytes. This change increases
compatibility with the current canonical Git implementation.

Doc changes from August 2016:
  https://github.com/git/git/commit/7841c4801ce51f1f62d376d164372e8677c6bc94#diff-52695c8fe91b78b70cea44562ae28297L67

Current packet buffer size is still LARGE_PACKET_MAX (+1 null):
  https://github.com/git/git/blob/468165c1d8a442994a825f3684528361727cd8c0/sideband.c#L24
  https://github.com/git/git/blob/468165c1d8a442994a825f3684528361727cd8c0/sideband.c#L36

LARGE_PACKET_MAX definition:
  https://github.com/git/git/blob/468165c1d8a442994a825f3684528361727cd8c0/pkt-line.h#L100

Signed-off-by: Joseph Vusich <jvusich@amazon.com>
3 files changed
tree: d75d3fb55548d3cdbd87cc7e5c7cbe5d1baa3b8d
  1. _examples/
  2. cli/
  3. config/
  4. internal/
  5. plumbing/
  6. storage/
  7. utils/
  8. .gitignore
  9. .travis.yml
  10. appveyor.yml
  11. blame.go
  12. blame_test.go
  13. CODE_OF_CONDUCT.md
  14. common.go
  15. common_test.go
  16. COMPATIBILITY.md
  17. CONTRIBUTING.md
  18. DCO
  19. doc.go
  20. example_test.go
  21. LICENSE
  22. MAINTAINERS
  23. Makefile
  24. object_walker.go
  25. options.go
  26. options_test.go
  27. prune.go
  28. prune_test.go
  29. README.md
  30. references.go
  31. references_test.go
  32. remote.go
  33. remote_test.go
  34. repository.go
  35. repository_test.go
  36. repository_unix_test.go
  37. repository_windows_test.go
  38. status.go
  39. submodule.go
  40. submodule_test.go
  41. worktree.go
  42. worktree_commit.go
  43. worktree_commit_test.go
  44. worktree_darwin.go
  45. worktree_linux.go
  46. worktree_status.go
  47. worktree_test.go
  48. worktree_windows.go
README.md

go-git logo GoDoc Build Status Build status codecov.io Go Report Card

go-git is a highly extensible git implementation library written in pure Go.

It can be used to manipulate git repositories at low level (plumbing) or high level (porcelain), through an idiomatic Go API. It also supports several type of storage, such as in-memory filesystems, or custom implementations thanks to the Storer interface.

It's being actively develop since 2015 and is being use extensively by source{d} and Keybase, and by many other libraries and tools.

Comparison with git

go-git aims to be fully compatible with git, all the porcelain operations are implemented to work exactly as git does.

git is a humongous project with years of development by thousands of contributors, making it challenging for go-git implement all the features. You can find a comparison of go-git vs git in the compatibility documentation.

Installation

The recommended way to install go-git is:

go get -u gopkg.in/src-d/go-git.v4/...

We use gopkg.in for having a versioned API, this means that when go get clones the package, is the latest tag matching v4.* cloned and not the master branch.

Examples

Please note that the functions CheckIfError and Info used in the examples are from the examples package just to be used in the examples.

Basic example

A basic example that mimics the standard git clone command

// Clone the given repository to the given directory
Info("git clone https://github.com/src-d/go-git")

_, err := git.PlainClone("/tmp/foo", false, &git.CloneOptions{
    URL:      "https://github.com/src-d/go-git",
    Progress: os.Stdout,
})

CheckIfError(err)

Outputs:

Counting objects: 4924, done.
Compressing objects: 100% (1333/1333), done.
Total 4924 (delta 530), reused 6 (delta 6), pack-reused 3533

In-memory example

Cloning a repository into memory and printing the history of HEAD, just like git log does

// Clones the given repository in memory, creating the remote, the local
// branches and fetching the objects, exactly as:
Info("git clone https://github.com/src-d/go-siva")

r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
    URL: "https://github.com/src-d/go-siva",
})

CheckIfError(err)

// Gets the HEAD history from HEAD, just like does:
Info("git log")

// ... retrieves the branch pointed by HEAD
ref, err := r.Head()
CheckIfError(err)


// ... retrieves the commit history
cIter, err := r.Log(&git.LogOptions{From: ref.Hash()})
CheckIfError(err)

// ... just iterates over the commits, printing it
err = cIter.ForEach(func(c *object.Commit) error {
	fmt.Println(c)
	return nil
})
CheckIfError(err)

Outputs:

commit ded8054fd0c3994453e9c8aacaf48d118d42991e
Author: Santiago M. Mola <santi@mola.io>
Date:   Sat Nov 12 21:18:41 2016 +0100

    index: ReadFrom/WriteTo returns IndexReadError/IndexWriteError. (#9)

commit df707095626f384ce2dc1a83b30f9a21d69b9dfc
Author: Santiago M. Mola <santi@mola.io>
Date:   Fri Nov 11 13:23:22 2016 +0100

    readwriter: fix bug when writing index. (#10)

    When using ReadWriter on an existing siva file, absolute offset for
    index entries was not being calculated correctly.
...

You can find this example and many others at the examples folder

Contribute

Contributions are more than welcome, if you are interested please take a look to our Contributing Guidelines.

License

Apache License Version 2.0, see LICENSE