Merge branch 'zj-remove-commit-patch' into 'master'

Remove DiffService Patch RPC

Closes #2095

See merge request gitlab-org/gitaly!1560

9 files changed, 63 insertions, 397 deletions

diff --git a/internal/praefect/protoregistry/protoregistry_test.go b/internal/praefect/protoregistry/protoregistry_test.go
index f68804d67..aecb86ddc 100644
--- a/internal/praefect/protoregistry/protoregistry_test.go
+++ b/internal/praefect/protoregistry/protoregistry_test.go
@@ -52,7 +52,6 @@ func TestPopulatesProtoRegistry(t *testing.T) {
 		"DiffService": map[string]protoregistry.OpType{
 			"CommitDiff":  protoregistry.OpAccessor,
 			"CommitDelta": protoregistry.OpAccessor,
-			"CommitPatch": protoregistry.OpAccessor,
 			"RawDiff":     protoregistry.OpAccessor,
 			"RawPatch":    protoregistry.OpAccessor,
 			"DiffStats":   protoregistry.OpAccessor,
diff --git a/internal/service/diff/patch.go b/internal/service/diff/patch.go
deleted file mode 100644
index 2bd368053..000000000
--- a/internal/service/diff/patch.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package diff
-
-import (
-	"gitlab.com/gitlab-org/gitaly/internal/git"
-	"gitlab.com/gitlab-org/gitaly/internal/helper"
-	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
-	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
-)
-
-func (s *server) CommitPatch(in *gitalypb.CommitPatchRequest, stream gitalypb.DiffService_CommitPatchServer) error {
-	if err := git.ValidateRevision(in.Revision); err != nil {
-		return helper.ErrInvalidArgument(err)
-	}
-
-	ctx := stream.Context()
-
-	client, err := s.ruby.DiffServiceClient(ctx)
-	if err != nil {
-		return err
-	}
-
-	clientCtx, err := rubyserver.SetHeaders(ctx, in.GetRepository())
-	if err != nil {
-		return err
-	}
-
-	rubyStream, err := client.CommitPatch(clientCtx, in)
-	if err != nil {
-		return err
-	}
-
-	return rubyserver.Proxy(func() error {
-		resp, err := rubyStream.Recv()
-		if err != nil {
-			md := rubyStream.Trailer()
-			stream.SetTrailer(md)
-			return err
-		}
-		return stream.Send(resp)
-	})
-}
diff --git a/internal/service/diff/patch_test.go b/internal/service/diff/patch_test.go
deleted file mode 100644
index 4927f3083..000000000
--- a/internal/service/diff/patch_test.go
+++ /dev/null
@@ -1,94 +0,0 @@
-package diff
-
-import (
-	"io"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
-	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
-	"google.golang.org/grpc/codes"
-)
-
-func TestSuccessfulCommitPatchRequest(t *testing.T) {
-	server, serverSocketPath := runDiffServer(t)
-	defer server.Stop()
-
-	client, conn := newDiffClient(t, serverSocketPath)
-	defer conn.Close()
-
-	testRepo, _, cleanupFn := testhelper.NewTestRepo(t)
-	defer cleanupFn()
-
-	testCases := []struct {
-		desc     string
-		revision []byte
-		diff     []byte
-	}{
-		{
-			desc:     "With a commit id",
-			revision: []byte("2f63565e7aac07bcdadb654e253078b727143ec4"),
-			diff:     testhelper.MustReadFile(t, "testdata/binary-changes-patch.txt"),
-		},
-		{
-			desc:     "With a root commit id",
-			revision: []byte("1a0b36b3cdad1d2ee32457c102a8c0b7056fa863"),
-			diff:     testhelper.MustReadFile(t, "testdata/initial-commit-patch.txt"),
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.desc, func(t *testing.T) {
-			ctx, cancel := testhelper.Context()
-			defer cancel()
-
-			request := &gitalypb.CommitPatchRequest{
-				Repository: testRepo,
-				Revision:   testCase.revision,
-			}
-
-			c, err := client.CommitPatch(ctx, request)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			data := []byte{}
-			for {
-				r, err := c.Recv()
-				if err == io.EOF {
-					break
-				} else if err != nil {
-					t.Fatal(err)
-				}
-
-				data = append(data, r.GetData()...)
-			}
-
-			assert.Equal(t, testCase.diff, data)
-		})
-	}
-}
-
-func TestInvalidCommitPatchRequestRevision(t *testing.T) {
-	server, serverSocketPath := runDiffServer(t)
-	defer server.Stop()
-
-	client, conn := newDiffClient(t, serverSocketPath)
-	defer conn.Close()
-
-	testRepo, _, cleanupFn := testhelper.NewTestRepo(t)
-	defer cleanupFn()
-
-	ctx, cancel := testhelper.Context()
-	defer cancel()
-
-	stream, err := client.CommitPatch(ctx, &gitalypb.CommitPatchRequest{
-		Repository: testRepo,
-		Revision:   []byte("--output=/meow"),
-	})
-	require.NoError(t, err)
-
-	_, err = stream.Recv()
-	testhelper.RequireGrpcError(t, err, codes.InvalidArgument)
-}
diff --git a/proto/diff.proto b/proto/diff.proto
index 5f9b2f271..45403602d 100644
--- a/proto/diff.proto
+++ b/proto/diff.proto
@@ -21,12 +21,6 @@ service DiffService {
       target_repository_field: "1"
     };
   }
-  rpc CommitPatch(CommitPatchRequest) returns (stream CommitPatchResponse) {
-    option (op_type) = {
-      op: ACCESSOR
-      target_repository_field: "1"
-    };
-  }
   rpc RawDiff(RawDiffRequest) returns (stream RawDiffResponse) {
     option (op_type) = {
       op: ACCESSOR
@@ -117,15 +111,6 @@ message CommitDeltaResponse {
   repeated CommitDelta deltas = 1;
 }
 
-message CommitPatchRequest {
-  Repository repository = 1;
-  bytes revision = 2;
-}
-
-message CommitPatchResponse {
-  bytes data = 1;
-}
-
 message RawDiffRequest {
   Repository repository = 1;
   string left_commit_id = 2;
diff --git a/proto/go/gitalypb/diff.pb.go b/proto/go/gitalypb/diff.pb.go
index c11dde4dc..9d0dceb23 100644
--- a/proto/go/gitalypb/diff.pb.go
+++ b/proto/go/gitalypb/diff.pb.go
@@ -489,92 +489,6 @@ func (m *CommitDeltaResponse) GetDeltas() []*CommitDelta {
 	return nil
 }
 
-type CommitPatchRequest struct {
-	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
-	Revision             []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
-	XXX_unrecognized     []byte      `json:"-"`
-	XXX_sizecache        int32       `json:"-"`
-}
-
-func (m *CommitPatchRequest) Reset()         { *m = CommitPatchRequest{} }
-func (m *CommitPatchRequest) String() string { return proto.CompactTextString(m) }
-func (*CommitPatchRequest) ProtoMessage()    {}
-func (*CommitPatchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_686521effc814b25, []int{5}
-}
-
-func (m *CommitPatchRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CommitPatchRequest.Unmarshal(m, b)
-}
-func (m *CommitPatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CommitPatchRequest.Marshal(b, m, deterministic)
-}
-func (m *CommitPatchRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommitPatchRequest.Merge(m, src)
-}
-func (m *CommitPatchRequest) XXX_Size() int {
-	return xxx_messageInfo_CommitPatchRequest.Size(m)
-}
-func (m *CommitPatchRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommitPatchRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CommitPatchRequest proto.InternalMessageInfo
-
-func (m *CommitPatchRequest) GetRepository() *Repository {
-	if m != nil {
-		return m.Repository
-	}
-	return nil
-}
-
-func (m *CommitPatchRequest) GetRevision() []byte {
-	if m != nil {
-		return m.Revision
-	}
-	return nil
-}
-
-type CommitPatchResponse struct {
-	Data                 []byte   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *CommitPatchResponse) Reset()         { *m = CommitPatchResponse{} }
-func (m *CommitPatchResponse) String() string { return proto.CompactTextString(m) }
-func (*CommitPatchResponse) ProtoMessage()    {}
-func (*CommitPatchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_686521effc814b25, []int{6}
-}
-
-func (m *CommitPatchResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CommitPatchResponse.Unmarshal(m, b)
-}
-func (m *CommitPatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CommitPatchResponse.Marshal(b, m, deterministic)
-}
-func (m *CommitPatchResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommitPatchResponse.Merge(m, src)
-}
-func (m *CommitPatchResponse) XXX_Size() int {
-	return xxx_messageInfo_CommitPatchResponse.Size(m)
-}
-func (m *CommitPatchResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommitPatchResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CommitPatchResponse proto.InternalMessageInfo
-
-func (m *CommitPatchResponse) GetData() []byte {
-	if m != nil {
-		return m.Data
-	}
-	return nil
-}
-
 type RawDiffRequest struct {
 	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
 	LeftCommitId         string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
@@ -588,7 +502,7 @@ func (m *RawDiffRequest) Reset()         { *m = RawDiffRequest{} }
 func (m *RawDiffRequest) String() string { return proto.CompactTextString(m) }
 func (*RawDiffRequest) ProtoMessage()    {}
 func (*RawDiffRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_686521effc814b25, []int{7}
+	return fileDescriptor_686521effc814b25, []int{5}
 }
 
 func (m *RawDiffRequest) XXX_Unmarshal(b []byte) error {
@@ -641,7 +555,7 @@ func (m *RawDiffResponse) Reset()         { *m = RawDiffResponse{} }
 func (m *RawDiffResponse) String() string { return proto.CompactTextString(m) }
 func (*RawDiffResponse) ProtoMessage()    {}
 func (*RawDiffResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_686521effc814b25, []int{8}
+	return fileDescriptor_686521effc814b25, []int{6}
 }
 
 func (m *RawDiffResponse) XXX_Unmarshal(b []byte) error {
@@ -682,7 +596,7 @@ func (m *RawPatchRequest) Reset()         { *m = RawPatchRequest{} }
 func (m *RawPatchRequest) String() string { return proto.CompactTextString(m) }
 func (*RawPatchRequest) ProtoMessage()    {}
 func (*RawPatchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_686521effc814b25, []int{9}
+	return fileDescriptor_686521effc814b25, []int{7}
 }
 
 func (m *RawPatchRequest) XXX_Unmarshal(b []byte) error {
@@ -735,7 +649,7 @@ func (m *RawPatchResponse) Reset()         { *m = RawPatchResponse{} }
 func (m *RawPatchResponse) String() string { return proto.CompactTextString(m) }
 func (*RawPatchResponse) ProtoMessage()    {}
 func (*RawPatchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_686521effc814b25, []int{10}
+	return fileDescriptor_686521effc814b25, []int{8}
 }
 
 func (m *RawPatchResponse) XXX_Unmarshal(b []byte) error {
@@ -776,7 +690,7 @@ func (m *DiffStatsRequest) Reset()         { *m = DiffStatsRequest{} }
 func (m *DiffStatsRequest) String() string { return proto.CompactTextString(m) }
 func (*DiffStatsRequest) ProtoMessage()    {}
 func (*DiffStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_686521effc814b25, []int{11}
+	return fileDescriptor_686521effc814b25, []int{9}
 }
 
 func (m *DiffStatsRequest) XXX_Unmarshal(b []byte) error {
@@ -831,7 +745,7 @@ func (m *DiffStats) Reset()         { *m = DiffStats{} }
 func (m *DiffStats) String() string { return proto.CompactTextString(m) }
 func (*DiffStats) ProtoMessage()    {}
 func (*DiffStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_686521effc814b25, []int{12}
+	return fileDescriptor_686521effc814b25, []int{10}
 }
 
 func (m *DiffStats) XXX_Unmarshal(b []byte) error {
@@ -884,7 +798,7 @@ func (m *DiffStatsResponse) Reset()         { *m = DiffStatsResponse{} }
 func (m *DiffStatsResponse) String() string { return proto.CompactTextString(m) }
 func (*DiffStatsResponse) ProtoMessage()    {}
 func (*DiffStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_686521effc814b25, []int{13}
+	return fileDescriptor_686521effc814b25, []int{11}
 }
 
 func (m *DiffStatsResponse) XXX_Unmarshal(b []byte) error {
@@ -918,8 +832,6 @@ func init() {
 	proto.RegisterType((*CommitDeltaRequest)(nil), "gitaly.CommitDeltaRequest")
 	proto.RegisterType((*CommitDelta)(nil), "gitaly.CommitDelta")
 	proto.RegisterType((*CommitDeltaResponse)(nil), "gitaly.CommitDeltaResponse")
-	proto.RegisterType((*CommitPatchRequest)(nil), "gitaly.CommitPatchRequest")
-	proto.RegisterType((*CommitPatchResponse)(nil), "gitaly.CommitPatchResponse")
 	proto.RegisterType((*RawDiffRequest)(nil), "gitaly.RawDiffRequest")
 	proto.RegisterType((*RawDiffResponse)(nil), "gitaly.RawDiffResponse")
 	proto.RegisterType((*RawPatchRequest)(nil), "gitaly.RawPatchRequest")
@@ -932,64 +844,61 @@ func init() {
 func init() { proto.RegisterFile("diff.proto", fileDescriptor_686521effc814b25) }
 
 var fileDescriptor_686521effc814b25 = []byte{
-	// 904 bytes of a gzipped FileDescriptorProto
+	// 859 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x4d, 0x6f, 0xeb, 0x44,
 	0x14, 0x95, 0x9b, 0x8f, 0x3a, 0x37, 0x6e, 0xda, 0x4e, 0x51, 0x9f, 0x9b, 0xc7, 0x22, 0xb2, 0xde,
-	0x47, 0x10, 0xa2, 0x7d, 0x94, 0x0d, 0x0b, 0x56, 0x7d, 0x4f, 0xa0, 0x3e, 0xb5, 0xa2, 0xf2, 0x5b,
-	0x20, 0xc1, 0xc2, 0x9a, 0x64, 0xc6, 0xc9, 0x08, 0xdb, 0x13, 0x66, 0x86, 0xa6, 0xfd, 0x1b, 0x80,
-	0xc4, 0x1f, 0x40, 0x62, 0xc3, 0x5f, 0x63, 0x8f, 0x58, 0xa1, 0xb9, 0x63, 0x3b, 0x4e, 0x1b, 0x75,
-	0x53, 0x16, 0xdd, 0xf9, 0x9e, 0x73, 0x7c, 0xe7, 0xcc, 0xfd, 0x70, 0x02, 0xc0, 0x44, 0x9a, 0x1e,
-	0x2f, 0x94, 0x34, 0x92, 0x74, 0x67, 0xc2, 0xd0, 0xec, 0x76, 0x18, 0xe8, 0x39, 0x55, 0x9c, 0x39,
-	0x34, 0xfa, 0xa3, 0x0d, 0xfb, 0x6f, 0x65, 0x9e, 0x0b, 0xf3, 0x4e, 0xa4, 0x69, 0xcc, 0x7f, 0xfa,
-	0x99, 0x6b, 0x43, 0x4e, 0x01, 0x14, 0x5f, 0x48, 0x2d, 0x8c, 0x54, 0xb7, 0xa1, 0x37, 0xf2, 0xc6,
-	0xfd, 0x53, 0x72, 0xec, 0x12, 0x1c, 0xc7, 0x35, 0x13, 0x37, 0x54, 0xe4, 0x05, 0x0c, 0x32, 0x9e,
-	0x9a, 0x64, 0x8a, 0xd9, 0x12, 0xc1, 0xc2, 0xad, 0x91, 0x37, 0xee, 0xc5, 0x81, 0x45, 0xdd, 0x11,
-	0xe7, 0x8c, 0xbc, 0x82, 0x5d, 0x25, 0x66, 0xf3, 0xa6, 0xac, 0x85, 0xb2, 0x1d, 0x84, 0x6b, 0xdd,
-	0x97, 0x10, 0x8a, 0x59, 0x21, 0x15, 0x4f, 0x96, 0x73, 0x61, 0xb8, 0x5e, 0xd0, 0x29, 0x4f, 0xa6,
-	0x73, 0x5a, 0xcc, 0x78, 0xd8, 0x1e, 0x79, 0x63, 0x3f, 0x3e, 0x74, 0xfc, 0x77, 0x35, 0xfd, 0x16,
-	0x59, 0xf2, 0x11, 0x74, 0x16, 0xd4, 0xcc, 0x75, 0xd8, 0x19, 0xb5, 0xc6, 0x41, 0xec, 0x02, 0xf2,
-	0x12, 0x06, 0x53, 0x99, 0x65, 0x74, 0xa1, 0x79, 0x62, 0x8b, 0xa2, 0xc3, 0x2e, 0x66, 0xd9, 0xa9,
-	0x50, 0x7b, 0x7d, 0x94, 0xf1, 0x22, 0x95, 0x6a, 0xca, 0x93, 0x4c, 0xe4, 0xc2, 0xe8, 0x70, 0xdb,
-	0xc9, 0x4a, 0xf4, 0x02, 0x41, 0xf2, 0x1c, 0x7a, 0x39, 0xbd, 0x49, 0x52, 0x91, 0x71, 0x1d, 0xfa,
-	0x23, 0x6f, 0xdc, 0x89, 0xfd, 0x9c, 0xde, 0x7c, 0x6d, 0xe3, 0x8a, 0xcc, 0x44, 0xc1, 0x75, 0xd8,
-	0xab, 0xc9, 0x0b, 0x1b, 0x57, 0xe4, 0xe4, 0xd6, 0x70, 0x1d, 0x42, 0x4d, 0x9e, 0xd9, 0xd8, 0x16,
-	0xc7, 0x92, 0x0b, 0x6a, 0xa6, 0xf3, 0x52, 0x32, 0x40, 0xc9, 0x4e, 0x4e, 0x6f, 0xae, 0x2c, 0xea,
-	0x74, 0x2f, 0x60, 0xa0, 0x69, 0xca, 0x93, 0x95, 0x87, 0x3e, 0xca, 0x02, 0x8b, 0x5e, 0x56, 0x3e,
-	0x9a, 0x2a, 0x67, 0x26, 0x58, 0x53, 0x39, 0x43, 0x4d, 0x95, 0x3b, 0x72, 0x67, 0x4d, 0x85, 0x27,
-	0x46, 0xff, 0x6c, 0x01, 0x69, 0x8e, 0x89, 0x5e, 0xc8, 0x42, 0x73, 0x7b, 0x9b, 0x54, 0xc9, 0xdc,
-	0x3a, 0x9e, 0xe3, 0x98, 0x04, 0xb1, 0x6f, 0x81, 0x2b, 0x6a, 0xe6, 0xe4, 0x19, 0x6c, 0x1b, 0xe9,
-	0xa8, 0x2d, 0xa4, 0xba, 0x46, 0x56, 0x04, 0xbe, 0x55, 0xf7, 0xbe, 0x6b, 0xc3, 0x73, 0x46, 0x0e,
-	0xa0, 0x63, 0xa4, 0x85, 0xdb, 0x08, 0xb7, 0x8d, 0x3c, 0x67, 0xe4, 0x08, 0x7c, 0x99, 0xb1, 0x24,
-	0x97, 0x8c, 0x87, 0x1d, 0xb4, 0xb6, 0x2d, 0x33, 0x76, 0x29, 0x19, 0xb7, 0x54, 0xc1, 0x97, 0x8e,
-	0xea, 0x3a, 0xaa, 0xe0, 0x4b, 0xa4, 0x0e, 0xa1, 0x3b, 0x11, 0x05, 0x55, 0xb7, 0x65, 0x03, 0xcb,
-	0xc8, 0x5e, 0x57, 0xd1, 0x65, 0x59, 0x62, 0x46, 0x0d, 0xc5, 0x0e, 0x05, 0x71, 0xa0, 0xe8, 0x12,
-	0x2b, 0xfc, 0x8e, 0x1a, 0x4a, 0x46, 0x10, 0xf0, 0x82, 0x25, 0x32, 0x75, 0x42, 0x6c, 0x94, 0x1f,
-	0x03, 0x2f, 0xd8, 0xb7, 0x29, 0xaa, 0xc8, 0x6b, 0xd8, 0x95, 0xd7, 0x5c, 0xa5, 0x99, 0x5c, 0x26,
-	0x39, 0x55, 0x3f, 0x72, 0x85, 0x3d, 0xf0, 0xe3, 0x41, 0x05, 0x5f, 0x22, 0x4a, 0x3e, 0x86, 0x5e,
-	0x35, 0x62, 0x0c, 0x1b, 0xe0, 0xc7, 0x2b, 0xc0, 0x16, 0xd0, 0x48, 0x99, 0x64, 0x54, 0xcd, 0x38,
-	0x16, 0xde, 0x8f, 0x7d, 0x23, 0xe5, 0x85, 0x8d, 0xdf, 0xb7, 0x7d, 0x7f, 0xaf, 0x17, 0xfd, 0xe5,
-	0xd5, 0xa5, 0xe7, 0x99, 0xa1, 0x4f, 0x67, 0x45, 0xeb, 0x45, 0x6b, 0x37, 0x16, 0x2d, 0xfa, 0xd3,
-	0x83, 0x7e, 0xc3, 0xee, 0xd3, 0x1d, 0x91, 0xe8, 0x0c, 0x0e, 0xd6, 0xea, 0x5a, 0xce, 0xf4, 0xa7,
-	0xd0, 0x65, 0x16, 0xd0, 0xa1, 0x37, 0x6a, 0x8d, 0xfb, 0xa7, 0x07, 0x55, 0x51, 0x9b, 0xe2, 0x52,
-	0x12, 0xb1, 0xaa, 0x37, 0x38, 0x15, 0x8f, 0xe9, 0xcd, 0x10, 0x7c, 0xc5, 0xaf, 0x85, 0x16, 0xb2,
-	0x28, 0x6b, 0x51, 0xc7, 0xd1, 0x27, 0x95, 0xd3, 0xf2, 0x94, 0xd2, 0x29, 0x81, 0x36, 0x4e, 0xb0,
-	0xab, 0x2a, 0x3e, 0x47, 0xbf, 0x78, 0x30, 0x88, 0xe9, 0xf2, 0x49, 0x7d, 0xcc, 0xa3, 0x97, 0xb0,
-	0x5b, 0x7b, 0x7a, 0xc0, 0xfb, 0xaf, 0x1e, 0xea, 0x1e, 0x5d, 0xca, 0xff, 0xd7, 0xfc, 0x2b, 0xd8,
-	0x5b, 0x99, 0x7a, 0xc0, 0xfd, 0x6f, 0x1e, 0xec, 0xd9, 0x2b, 0x7e, 0x30, 0xd4, 0xe8, 0xa7, 0x63,
-	0xff, 0x07, 0xe8, 0xd5, 0xae, 0xac, 0xef, 0xc6, 0x1e, 0xe2, 0xb3, 0xfd, 0x40, 0x51, 0xc6, 0x84,
-	0x11, 0xb2, 0xd0, 0x78, 0x52, 0x27, 0x5e, 0x01, 0x96, 0x65, 0x3c, 0xe3, 0x8e, 0x6d, 0x39, 0xb6,
-	0x06, 0xa2, 0xaf, 0x60, 0xbf, 0x71, 0xe5, 0xb2, 0x38, 0xaf, 0xa1, 0xa3, 0x2d, 0x50, 0xee, 0xcf,
-	0x7e, 0x75, 0xdd, 0x95, 0xd2, 0xf1, 0xa7, 0x7f, 0xb7, 0xa0, 0x8f, 0x20, 0x57, 0xd7, 0x62, 0xca,
-	0xc9, 0x15, 0xc0, 0xea, 0x37, 0x86, 0x1c, 0xdd, 0xd9, 0xbb, 0xd5, 0x44, 0x0f, 0x87, 0x9b, 0x28,
-	0x77, 0x7a, 0xd4, 0xfb, 0xf7, 0xf7, 0x71, 0xc7, 0xdf, 0x1a, 0x7a, 0x9f, 0xbf, 0xf1, 0xc8, 0x87,
-	0xf5, 0x6f, 0xd1, 0x70, 0xd3, 0x2a, 0x97, 0x39, 0x9f, 0x6f, 0xe4, 0x1e, 0x4c, 0xea, 0x7e, 0x09,
-	0xee, 0x24, 0x6d, 0x4e, 0xef, 0xdd, 0xa4, 0x6b, 0x43, 0xb4, 0x9e, 0xf4, 0x1b, 0xd8, 0x2e, 0x57,
-	0x84, 0x1c, 0xd6, 0xf3, 0xb1, 0xb6, 0xc7, 0xc3, 0x67, 0xf7, 0xf0, 0x4d, 0x89, 0xde, 0x83, 0x5f,
-	0x8d, 0x2b, 0x69, 0xbe, 0xb1, 0xe6, 0x2b, 0xbc, 0x4f, 0x6c, 0xca, 0x75, 0xd9, 0x9c, 0x9d, 0xf0,
-	0x7e, 0x1f, 0xcb, 0x6c, 0x47, 0x1b, 0x98, 0x0d, 0xe9, 0xce, 0xde, 0x7c, 0x6f, 0x85, 0x19, 0x9d,
-	0x1c, 0x4f, 0x65, 0x7e, 0xe2, 0x1e, 0x3f, 0x93, 0x6a, 0x76, 0xe2, 0x5e, 0x3f, 0xc1, 0x7f, 0xa4,
-	0x27, 0x33, 0x59, 0xc6, 0x8b, 0xc9, 0xa4, 0x8b, 0xd0, 0x17, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff,
-	0x7b, 0x5b, 0x1a, 0xed, 0xc8, 0x0a, 0x00, 0x00,
+	0x47, 0x24, 0x44, 0xfb, 0x28, 0x1b, 0x16, 0xac, 0xfa, 0x9e, 0x40, 0x7d, 0x6a, 0x45, 0xe5, 0xb7,
+	0x40, 0x82, 0x85, 0x35, 0xc9, 0x8c, 0x93, 0x11, 0xb6, 0x27, 0xcc, 0x0c, 0x4d, 0xfb, 0x37, 0x00,
+	0x09, 0x7e, 0x00, 0x12, 0x1b, 0x7e, 0x20, 0x62, 0x85, 0xe6, 0x8e, 0xed, 0x38, 0xd4, 0x62, 0x9d,
+	0x9d, 0xef, 0x39, 0xc7, 0x77, 0xce, 0xdc, 0x0f, 0xcb, 0x00, 0x4c, 0xa4, 0xe9, 0xf9, 0x4a, 0x49,
+	0x23, 0x49, 0x7f, 0x21, 0x0c, 0xcd, 0x1e, 0xc7, 0x81, 0x5e, 0x52, 0xc5, 0x99, 0x43, 0xa3, 0x3f,
+	0xba, 0x70, 0xfc, 0x56, 0xe6, 0xb9, 0x30, 0xef, 0x44, 0x9a, 0xc6, 0xfc, 0xc7, 0x9f, 0xb8, 0x36,
+	0xe4, 0x12, 0x40, 0xf1, 0x95, 0xd4, 0xc2, 0x48, 0xf5, 0x18, 0x7a, 0x13, 0x6f, 0x3a, 0xbc, 0x24,
+	0xe7, 0x2e, 0xc1, 0x79, 0x5c, 0x33, 0x71, 0x43, 0x45, 0x5e, 0xc0, 0x28, 0xe3, 0xa9, 0x49, 0xe6,
+	0x98, 0x2d, 0x11, 0x2c, 0xdc, 0x9b, 0x78, 0xd3, 0x41, 0x1c, 0x58, 0xd4, 0x1d, 0x71, 0xcd, 0xc8,
+	0x2b, 0x38, 0x54, 0x62, 0xb1, 0x6c, 0xca, 0x3a, 0x28, 0x3b, 0x40, 0xb8, 0xd6, 0x7d, 0x01, 0xa1,
+	0x58, 0x14, 0x52, 0xf1, 0x64, 0xbd, 0x14, 0x86, 0xeb, 0x15, 0x9d, 0xf3, 0x64, 0xbe, 0xa4, 0xc5,
+	0x82, 0x87, 0xdd, 0x89, 0x37, 0xf5, 0xe3, 0x53, 0xc7, 0x7f, 0x5b, 0xd3, 0x6f, 0x91, 0x25, 0x1f,
+	0x41, 0x6f, 0x45, 0xcd, 0x52, 0x87, 0xbd, 0x49, 0x67, 0x1a, 0xc4, 0x2e, 0x20, 0x2f, 0x61, 0x34,
+	0x97, 0x59, 0x46, 0x57, 0x9a, 0x27, 0xb6, 0x28, 0x3a, 0xec, 0x63, 0x96, 0x83, 0x0a, 0xb5, 0xd7,
+	0x47, 0x19, 0x2f, 0x52, 0xa9, 0xe6, 0x3c, 0xc9, 0x44, 0x2e, 0x8c, 0x0e, 0xf7, 0x9d, 0xac, 0x44,
+	0x6f, 0x10, 0x24, 0xcf, 0x61, 0x90, 0xd3, 0x87, 0x24, 0x15, 0x19, 0xd7, 0xa1, 0x3f, 0xf1, 0xa6,
+	0xbd, 0xd8, 0xcf, 0xe9, 0xc3, 0x57, 0x36, 0xae, 0xc8, 0x4c, 0x14, 0x5c, 0x87, 0x83, 0x9a, 0xbc,
+	0xb1, 0x71, 0x45, 0xce, 0x1e, 0x0d, 0xd7, 0x21, 0xd4, 0xe4, 0x95, 0x8d, 0x6d, 0x71, 0x2c, 0xb9,
+	0xa2, 0x66, 0xbe, 0x2c, 0x25, 0x23, 0x94, 0x1c, 0xe4, 0xf4, 0xe1, 0xce, 0xa2, 0x4e, 0xf7, 0x02,
+	0x46, 0x9a, 0xa6, 0x3c, 0xd9, 0x78, 0x18, 0xa2, 0x2c, 0xb0, 0xe8, 0x6d, 0xe5, 0xa3, 0xa9, 0x72,
+	0x66, 0x82, 0x2d, 0x95, 0x33, 0xd4, 0x54, 0xb9, 0x23, 0x0f, 0xb6, 0x54, 0x78, 0x62, 0xf4, 0xf7,
+	0x1e, 0x90, 0xe6, 0x98, 0xe8, 0x95, 0x2c, 0x34, 0xb7, 0xb7, 0x49, 0x95, 0xcc, 0xad, 0xe3, 0x25,
+	0x8e, 0x49, 0x10, 0xfb, 0x16, 0xb8, 0xa3, 0x66, 0x49, 0x9e, 0xc1, 0xbe, 0x91, 0x8e, 0xda, 0x43,
+	0xaa, 0x6f, 0x64, 0x45, 0xe0, 0x5b, 0x75, 0xef, 0xfb, 0x36, 0xbc, 0x66, 0xe4, 0x04, 0x7a, 0x46,
+	0x5a, 0xb8, 0x8b, 0x70, 0xd7, 0xc8, 0x6b, 0x46, 0xce, 0xc0, 0x97, 0x19, 0x4b, 0x72, 0xc9, 0x78,
+	0xd8, 0x43, 0x6b, 0xfb, 0x32, 0x63, 0xb7, 0x92, 0x71, 0x4b, 0x15, 0x7c, 0xed, 0xa8, 0xbe, 0xa3,
+	0x0a, 0xbe, 0x46, 0xea, 0x14, 0xfa, 0x33, 0x51, 0x50, 0xf5, 0x58, 0x36, 0xb0, 0x8c, 0xec, 0x75,
+	0x15, 0x5d, 0x97, 0x25, 0x66, 0xd4, 0x50, 0xec, 0x50, 0x10, 0x07, 0x8a, 0xae, 0xb1, 0xc2, 0xef,
+	0xa8, 0xa1, 0x64, 0x02, 0x01, 0x2f, 0x58, 0x22, 0x53, 0x27, 0xc4, 0x46, 0xf9, 0x31, 0xf0, 0x82,
+	0x7d, 0x93, 0xa2, 0x8a, 0xbc, 0x86, 0x43, 0x79, 0xcf, 0x55, 0x9a, 0xc9, 0x75, 0x92, 0x53, 0xf5,
+	0x03, 0x57, 0xd8, 0x03, 0x3f, 0x1e, 0x55, 0xf0, 0x2d, 0xa2, 0xe4, 0x63, 0x18, 0x54, 0x23, 0xc6,
+	0xb0, 0x01, 0x7e, 0xbc, 0x01, 0x6c, 0x01, 0x8d, 0x94, 0x49, 0x46, 0xd5, 0x82, 0x63, 0xe1, 0xfd,
+	0xd8, 0x37, 0x52, 0xde, 0xd8, 0xf8, 0x7d, 0xd7, 0xf7, 0x8f, 0x06, 0xd1, 0x5f, 0x5e, 0x5d, 0x7a,
+	0x9e, 0x19, 0xba, 0x3b, 0x2b, 0x5a, 0x2f, 0x5a, 0xb7, 0xb1, 0x68, 0xd1, 0x9f, 0x1e, 0x0c, 0x1b,
+	0x76, 0x77, 0x77, 0x44, 0xa2, 0x2b, 0x38, 0xd9, 0xaa, 0x6b, 0x39, 0xd3, 0x9f, 0x40, 0x9f, 0x59,
+	0x40, 0x87, 0xde, 0xa4, 0x33, 0x1d, 0x5e, 0x9e, 0x54, 0x45, 0x6d, 0x8a, 0x4b, 0x49, 0xf4, 0xb3,
+	0x07, 0xa3, 0x98, 0xae, 0x77, 0xea, 0xdb, 0x19, 0xbd, 0x84, 0xc3, 0xda, 0x53, 0x79, 0x29, 0x02,
+	0x5d, 0x1c, 0x76, 0xd7, 0x00, 0x7c, 0x8e, 0x7e, 0xf1, 0x50, 0x87, 0xf3, 0xbc, 0x3b, 0xe6, 0x5f,
+	0xc1, 0xd1, 0xc6, 0xd4, 0xff, 0xb8, 0xff, 0xd5, 0x83, 0x23, 0x7b, 0xc5, 0x0f, 0x86, 0x1a, 0xbd,
+	0x3b, 0xf6, 0xbf, 0x87, 0x41, 0xed, 0xca, 0xfa, 0x6e, 0x8c, 0x3d, 0x3e, 0xdb, 0xef, 0x01, 0x65,
+	0x4c, 0x18, 0x21, 0x0b, 0x8d, 0x27, 0xf5, 0xe2, 0x0d, 0x60, 0x59, 0xc6, 0x33, 0xee, 0xd8, 0x8e,
+	0x63, 0x6b, 0x20, 0xfa, 0x12, 0x8e, 0x1b, 0x57, 0x2e, 0x8b, 0xf3, 0x1a, 0x7a, 0xda, 0x02, 0xe5,
+	0xb8, 0x1e, 0x57, 0xd7, 0xdd, 0x28, 0x1d, 0x7f, 0xf9, 0x7b, 0x07, 0x86, 0x08, 0x72, 0x75, 0x2f,
+	0xe6, 0x9c, 0xdc, 0x01, 0x6c, 0x3e, 0xe9, 0xe4, 0xec, 0x3f, 0x63, 0xbe, 0x99, 0xe8, 0xf1, 0xb8,
+	0x8d, 0x72, 0xa7, 0x47, 0x83, 0x7f, 0x7e, 0x9b, 0xf6, 0xfc, 0xbd, 0xb1, 0xf7, 0xd9, 0x1b, 0x8f,
+	0x7c, 0xd8, 0x5e, 0xfd, 0x71, 0xdb, 0xe6, 0x94, 0x39, 0x9f, 0xb7, 0x72, 0x6d, 0x49, 0xbf, 0x86,
+	0xfd, 0x72, 0x9a, 0xc9, 0x69, 0xdd, 0xca, 0xad, 0x95, 0x1b, 0x3f, 0x7b, 0x82, 0xb7, 0x25, 0x7a,
+	0x0f, 0x7e, 0x35, 0x59, 0xa4, 0xf9, 0x46, 0x73, 0x01, 0xc6, 0xe1, 0x53, 0xa2, 0x2d, 0xd7, 0x6d,
+	0xb3, 0xcd, 0xe1, 0xd3, 0x92, 0x97, 0xd9, 0xce, 0x5a, 0x98, 0x96, 0x74, 0x57, 0x6f, 0xbe, 0xb3,
+	0xc2, 0x8c, 0xce, 0xce, 0xe7, 0x32, 0xbf, 0x70, 0x8f, 0x9f, 0x4a, 0xb5, 0xb8, 0x70, 0xaf, 0x5f,
+	0xe0, 0xbf, 0xda, 0xc5, 0x42, 0x96, 0xf1, 0x6a, 0x36, 0xeb, 0x23, 0xf4, 0xf9, 0xbf, 0x01, 0x00,
+	0x00, 0xff, 0xff, 0x88, 0x53, 0x39, 0xed, 0xe2, 0x09, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1008,7 +917,6 @@ type DiffServiceClient interface {
 	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (DiffService_CommitDiffClient, error)
 	// Return a stream so we can divide the response in chunks of deltas
 	CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (DiffService_CommitDeltaClient, error)
-	CommitPatch(ctx context.Context, in *CommitPatchRequest, opts ...grpc.CallOption) (DiffService_CommitPatchClient, error)
 	RawDiff(ctx context.Context, in *RawDiffRequest, opts ...grpc.CallOption) (DiffService_RawDiffClient, error)
 	RawPatch(ctx context.Context, in *RawPatchRequest, opts ...grpc.CallOption) (DiffService_RawPatchClient, error)
 	DiffStats(ctx context.Context, in *DiffStatsRequest, opts ...grpc.CallOption) (DiffService_DiffStatsClient, error)
@@ -1086,40 +994,8 @@ func (x *diffServiceCommitDeltaClient) Recv() (*CommitDeltaResponse, error) {
 	return m, nil
 }
 
-func (c *diffServiceClient) CommitPatch(ctx context.Context, in *CommitPatchRequest, opts ...grpc.CallOption) (DiffService_CommitPatchClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[2], "/gitaly.DiffService/CommitPatch", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &diffServiceCommitPatchClient{stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
-}
-
-type DiffService_CommitPatchClient interface {
-	Recv() (*CommitPatchResponse, error)
-	grpc.ClientStream
-}
-
-type diffServiceCommitPatchClient struct {
-	grpc.ClientStream
-}
-
-func (x *diffServiceCommitPatchClient) Recv() (*CommitPatchResponse, error) {
-	m := new(CommitPatchResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
 func (c *diffServiceClient) RawDiff(ctx context.Context, in *RawDiffRequest, opts ...grpc.CallOption) (DiffService_RawDiffClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[3], "/gitaly.DiffService/RawDiff", opts...)
+	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[2], "/gitaly.DiffService/RawDiff", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -1151,7 +1027,7 @@ func (x *diffServiceRawDiffClient) Recv() (*RawDiffResponse, error) {
 }
 
 func (c *diffServiceClient) RawPatch(ctx context.Context, in *RawPatchRequest, opts ...grpc.CallOption) (DiffService_RawPatchClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[4], "/gitaly.DiffService/RawPatch", opts...)
+	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[3], "/gitaly.DiffService/RawPatch", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -1183,7 +1059,7 @@ func (x *diffServiceRawPatchClient) Recv() (*RawPatchResponse, error) {
 }
 
 func (c *diffServiceClient) DiffStats(ctx context.Context, in *DiffStatsRequest, opts ...grpc.CallOption) (DiffService_DiffStatsClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[5], "/gitaly.DiffService/DiffStats", opts...)
+	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[4], "/gitaly.DiffService/DiffStats", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -1220,7 +1096,6 @@ type DiffServiceServer interface {
 	CommitDiff(*CommitDiffRequest, DiffService_CommitDiffServer) error
 	// Return a stream so we can divide the response in chunks of deltas
 	CommitDelta(*CommitDeltaRequest, DiffService_CommitDeltaServer) error
-	CommitPatch(*CommitPatchRequest, DiffService_CommitPatchServer) error
 	RawDiff(*RawDiffRequest, DiffService_RawDiffServer) error
 	RawPatch(*RawPatchRequest, DiffService_RawPatchServer) error
 	DiffStats(*DiffStatsRequest, DiffService_DiffStatsServer) error
@@ -1236,9 +1111,6 @@ func (*UnimplementedDiffServiceServer) CommitDiff(req *CommitDiffRequest, srv Di
 func (*UnimplementedDiffServiceServer) CommitDelta(req *CommitDeltaRequest, srv DiffService_CommitDeltaServer) error {
 	return status.Errorf(codes.Unimplemented, "method CommitDelta not implemented")
 }
-func (*UnimplementedDiffServiceServer) CommitPatch(req *CommitPatchRequest, srv DiffService_CommitPatchServer) error {
-	return status.Errorf(codes.Unimplemented, "method CommitPatch not implemented")
-}
 func (*UnimplementedDiffServiceServer) RawDiff(req *RawDiffRequest, srv DiffService_RawDiffServer) error {
 	return status.Errorf(codes.Unimplemented, "method RawDiff not implemented")
 }
@@ -1295,27 +1167,6 @@ func (x *diffServiceCommitDeltaServer) Send(m *CommitDeltaResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func _DiffService_CommitPatch_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(CommitPatchRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(DiffServiceServer).CommitPatch(m, &diffServiceCommitPatchServer{stream})
-}
-
-type DiffService_CommitPatchServer interface {
-	Send(*CommitPatchResponse) error
-	grpc.ServerStream
-}
-
-type diffServiceCommitPatchServer struct {
-	grpc.ServerStream
-}
-
-func (x *diffServiceCommitPatchServer) Send(m *CommitPatchResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
 func _DiffService_RawDiff_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(RawDiffRequest)
 	if err := stream.RecvMsg(m); err != nil {
@@ -1395,11 +1246,6 @@ var _DiffService_serviceDesc = grpc.ServiceDesc{
 			ServerStreams: true,
 		},
 		{
-			StreamName:    "CommitPatch",
-			Handler:       _DiffService_CommitPatch_Handler,
-			ServerStreams: true,
-		},
-		{
 			StreamName:    "RawDiff",
 			Handler:       _DiffService_RawDiff_Handler,
 			ServerStreams: true,
diff --git a/ruby/lib/gitaly_server.rb b/ruby/lib/gitaly_server.rb
index 7b72d9318..fccbd41f9 100644
--- a/ruby/lib/gitaly_server.rb
+++ b/ruby/lib/gitaly_server.rb
@@ -7,7 +7,6 @@ require_relative 'gitaly_server/client.rb'
 require_relative 'gitaly_server/utils.rb'
 require_relative 'gitaly_server/blob_service.rb'
 require_relative 'gitaly_server/commit_service.rb'
-require_relative 'gitaly_server/diff_service.rb'
 require_relative 'gitaly_server/ref_service.rb'
 require_relative 'gitaly_server/operations_service.rb'
 require_relative 'gitaly_server/repository_service.rb'
@@ -45,7 +44,6 @@ module GitalyServer
 
   def self.register_handlers(server)
     server.handle(CommitService.new)
-    server.handle(DiffService.new)
     server.handle(RefService.new)
     server.handle(OperationsService.new)
     server.handle(RepositoryService.new)
diff --git a/ruby/lib/gitaly_server/diff_service.rb b/ruby/lib/gitaly_server/diff_service.rb
deleted file mode 100644
index b48e06565..000000000
--- a/ruby/lib/gitaly_server/diff_service.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-module GitalyServer
-  class DiffService < Gitaly::DiffService::Service
-    include Utils
-
-    def commit_patch(request, call)
-      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-      commit = Gitlab::Git::Commit.find(repo, request.revision)
-
-      Enumerator.new do |y|
-        io = StringIO.new(commit.to_diff)
-        while chunk = io.read(Gitlab.config.git.write_buffer_size)
-          y.yield Gitaly::CommitPatchResponse.new(data: chunk)
-        end
-      end
-    end
-  end
-end
diff --git a/ruby/proto/gitaly/diff_pb.rb b/ruby/proto/gitaly/diff_pb.rb
index da3b22071..d72747f68 100644
--- a/ruby/proto/gitaly/diff_pb.rb
+++ b/ruby/proto/gitaly/diff_pb.rb
@@ -52,13 +52,6 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
   add_message "gitaly.CommitDeltaResponse" do
     repeated :deltas, :message, 1, "gitaly.CommitDelta"
   end
-  add_message "gitaly.CommitPatchRequest" do
-    optional :repository, :message, 1, "gitaly.Repository"
-    optional :revision, :bytes, 2
-  end
-  add_message "gitaly.CommitPatchResponse" do
-    optional :data, :bytes, 1
-  end
   add_message "gitaly.RawDiffRequest" do
     optional :repository, :message, 1, "gitaly.Repository"
     optional :left_commit_id, :string, 2
@@ -96,8 +89,6 @@ module Gitaly
   CommitDeltaRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CommitDeltaRequest").msgclass
   CommitDelta = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CommitDelta").msgclass
   CommitDeltaResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CommitDeltaResponse").msgclass
-  CommitPatchRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CommitPatchRequest").msgclass
-  CommitPatchResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CommitPatchResponse").msgclass
   RawDiffRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.RawDiffRequest").msgclass
   RawDiffResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.RawDiffResponse").msgclass
   RawPatchRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.RawPatchRequest").msgclass
diff --git a/ruby/proto/gitaly/diff_services_pb.rb b/ruby/proto/gitaly/diff_services_pb.rb
index bdbc79265..6259adfc2 100644
--- a/ruby/proto/gitaly/diff_services_pb.rb
+++ b/ruby/proto/gitaly/diff_services_pb.rb
@@ -18,7 +18,6 @@ module Gitaly
       rpc :CommitDiff, CommitDiffRequest, stream(CommitDiffResponse)
       # Return a stream so we can divide the response in chunks of deltas
       rpc :CommitDelta, CommitDeltaRequest, stream(CommitDeltaResponse)
-      rpc :CommitPatch, CommitPatchRequest, stream(CommitPatchResponse)
       rpc :RawDiff, RawDiffRequest, stream(RawDiffResponse)
       rpc :RawPatch, RawPatchRequest, stream(RawPatchResponse)
       rpc :DiffStats, DiffStatsRequest, stream(DiffStatsResponse)