packp: client-side filter capability support

edigaryev · edigaryev · commit 6b7fe1c16401 · 2024-01-15T00:06:20.000+04:00
diff --git a/plumbing/protocol/packp/filter.go b/plumbing/protocol/packp/filter.go
@@ -0,0 +1,45 @@
+package packp
+
+import (
+	"fmt"
+	"github.com/go-git/go-git/v5/plumbing"
+	"net/url"
+	"strings"
+)
+
+// Filter values enable the partial clone capability which causes
+// the server to omit objects that match the filter.
+type Filter string
+
+// FilterBlobNone omits all blobs.
+func FilterBlobNone() Filter {
+	return "blob:none"
+}
+
+// FilterBlobLimit omits blobs of size at least n bytes. n can be zero,
+// in which case all blobs will be omitted.
+func FilterBlobLimit(n uint64) Filter {
+	return Filter(fmt.Sprintf("blob:limit=%d", n))
+}
+
+// FilterTreeDepth omits all blobs and trees whose depth from the root tree
+// is larger or equal to depth.
+func FilterTreeDepth(depth uint64) Filter {
+	return Filter(fmt.Sprintf("tree:%d", depth))
+}
+
+// FilterObjectType omits all objects which are not of the requested type t.
+func FilterObjectType(t plumbing.ObjectType) Filter {
+	return Filter(fmt.Sprintf("object:type=%s", t.String()))
+}
+
+// FilterCombine combines multiple Filter values together.
+func FilterCombine(filters ...Filter) Filter {
+	var escapedFilters []string
+
+	for _, filter := range filters {
+		escapedFilters = append(escapedFilters, url.QueryEscape(string(filter)))
+	}
+
+	return Filter(fmt.Sprintf("combine:%s", strings.Join(escapedFilters, "+")))
+}
diff --git a/plumbing/protocol/packp/filter_test.go b/plumbing/protocol/packp/filter_test.go
@@ -0,0 +1,38 @@
+package packp
+
+import (
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestFilterBlobNone(t *testing.T) {
+	require.EqualValues(t, "blob:none", FilterBlobNone())
+}
+
+func TestFilterBlobLimit(t *testing.T) {
+	require.EqualValues(t, "blob:limit=0", FilterBlobLimit(0))
+	require.EqualValues(t, "blob:limit=1000", FilterBlobLimit(1000))
+}
+
+func TestFilterTreeDepth(t *testing.T) {
+	require.EqualValues(t, "tree:0", FilterTreeDepth(0))
+	require.EqualValues(t, "tree:1", FilterTreeDepth(1))
+	require.EqualValues(t, "tree:2", FilterTreeDepth(2))
+}
+
+func TestFilterObjectType(t *testing.T) {
+	require.EqualValues(t, "object:type=tag", FilterObjectType(plumbing.TagObject))
+	require.EqualValues(t, "object:type=commit", FilterObjectType(plumbing.CommitObject))
+	require.EqualValues(t, "object:type=tree", FilterObjectType(plumbing.TreeObject))
+	require.EqualValues(t, "object:type=blob", FilterObjectType(plumbing.BlobObject))
+}
+
+func TestFilterCombine(t *testing.T) {
+	require.EqualValues(t, "combine:tree%3A2+blob%3Anone",
+		FilterCombine(
+			FilterTreeDepth(2),
+			FilterBlobNone(),
+		),
+	)
+}
diff --git a/plumbing/protocol/packp/ulreq.go b/plumbing/protocol/packp/ulreq.go
@@ -17,6 +17,7 @@ type UploadRequest struct {
 	Wants        []plumbing.Hash
 	Shallows     []plumbing.Hash
 	Depth        Depth
+	Filter       Filter
 }
 
 // Depth values stores the desired depth of the requested packfile: see
diff --git a/plumbing/protocol/packp/ulreq_encode.go b/plumbing/protocol/packp/ulreq_encode.go
@@ -132,6 +132,17 @@ func (e *ulReqEncoder) encodeDepth() stateFn {
 		return nil
 	}
 
+	return e.encodeFilter
+}
+
+func (e *ulReqEncoder) encodeFilter() stateFn {
+	if filter := e.data.Filter; filter != "" {
+		if err := e.pe.Encodef("filter %s\n", filter); err != nil {
+			e.err = fmt.Errorf("encoding filter %s: %s", filter, err)
+			return nil
+		}
+	}
+
 	return e.encodeFlush
 }
 
diff --git a/plumbing/protocol/packp/ulreq_encode_test.go b/plumbing/protocol/packp/ulreq_encode_test.go
@@ -273,6 +273,20 @@ func (s *UlReqEncodeSuite) TestDepthReference(c *C) {
 	testUlReqEncode(c, ur, expected)
 }
 
+func (s *UlReqEncodeSuite) TestFilter(c *C) {
+	ur := NewUploadRequest()
+	ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
+	ur.Filter = FilterTreeDepth(0)
+
+	expected := []string{
+		"want 1111111111111111111111111111111111111111\n",
+		"filter tree:0\n",
+		pktline.FlushString,
+	}
+
+	testUlReqEncode(c, ur, expected)
+}
+
 func (s *UlReqEncodeSuite) TestAll(c *C) {
 	ur := NewUploadRequest()
 	ur.Wants = append(ur.Wants,

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ type UploadRequest struct {`
`17`	`17`	`Wants []plumbing.Hash`
`18`	`18`	`Shallows []plumbing.Hash`
`19`	`19`	`Depth Depth`
	`20`	`+ Filter Filter`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`// Depth values stores the desired depth of the requested packfile: see`