modules/lfs_ssh: add a backend and runner

Author: ConcurrentCrab

cmd/serv.go

@@ -22,6 +22,7 @@ import (
 	"code.gitea.io/gitea/models/perm"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/json"
+	"code.gitea.io/gitea/modules/lfs_ssh"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/pprof"
 	"code.gitea.io/gitea/modules/private"
@@ -279,6 +280,11 @@ func runServ(c *cli.Context) error {
 		return fail(ctx, extra.UserMsg, "ServCommand failed: %s", extra.Error)
 	}
 
+	// LFS SSH protocol
+	if verb == verbLfsTransfer {
+		return lfs_ssh.Main(repoPath, lfsVerb)
+	}
+
 	// LFS token authentication
 	if verb == verbLfsAuthenticate {
 		url := fmt.Sprintf("%s%s/%s.git/info/lfs", setting.AppURL, url.PathEscape(results.OwnerName), url.PathEscape(results.RepoName))

modules/lfs_ssh/backend/backend.go

@@ -0,0 +1,87 @@
+package backend
+
+import (
+	"fmt"
+	"io"
+
+	"code.gitea.io/gitea/modules/lfs"
+	"code.gitea.io/gitea/modules/lfs_ssh/transfer"
+)
+
+// Version is the git-lfs-transfer protocol version number.
+const Version = "1"
+
+// Capabilities is a list of Git LFS capabilities supported by this package.
+var Capabilities = []string{
+	"version=" + Version,
+	// "locking", // no support yet in gitea backend
+}
+
+// GiteaBackend is an adapter between git-lfs-transfer library and Gitea's internal LFS API
+type GiteaBackend struct {
+	store *lfs.ContentStore
+}
+
+var _ transfer.Backend = &GiteaBackend{}
+
+// Batch implements transfer.Backend
+func (g *GiteaBackend) Batch(_ string, pointers []transfer.BatchItem, _ transfer.Args) ([]transfer.BatchItem, error) {
+	for i := range pointers {
+		pointers[i].Present = false
+		pointer := lfs.Pointer{Oid: pointers[i].Oid, Size: pointers[i].Size}
+		exists, err := g.store.Verify(pointer)
+		if err == nil && exists {
+			pointers[i].Present = true
+		}
+	}
+	return pointers, nil
+}
+
+// Download implements main.Backend. The returned reader must be closed by the
+// caller.
+func (g *GiteaBackend) Download(oid string, _ transfer.Args) (io.ReadCloser, int64, error) {
+	pointer := lfs.Pointer{Oid: oid}
+	pointer, err := g.store.GetMeta(pointer)
+	if err != nil {
+		return nil, 0, err
+	}
+	obj, err := g.store.Get(pointer)
+	if err != nil {
+		return nil, 0, err
+	}
+	return obj, pointer.Size, nil
+}
+
+// StartUpload implements main.Backend. The returned temp file should be closed.
+func (g *GiteaBackend) Upload(oid string, size int64, r io.Reader, _ transfer.Args) error {
+	if r == nil {
+		return fmt.Errorf("%w: received null data", transfer.ErrMissingData)
+	}
+	pointer := lfs.Pointer{Oid: oid, Size: size}
+	err := g.store.Put(pointer, r)
+	return err
+}
+
+// Verify implements main.Backend.
+func (g *GiteaBackend) Verify(oid string, size int64, args transfer.Args) (transfer.Status, error) {
+	pointer := lfs.Pointer{Oid: oid, Size: size}
+	exists, err := g.store.Exists(pointer)
+	if err != nil {
+		return transfer.NewStatus(transfer.StatusNotFound, err.Error()), err
+	}
+	if !exists {
+		return transfer.NewStatus(transfer.StatusNotFound, "not found"), nil
+	}
+	return transfer.SuccessStatus(), nil
+}
+
+// LockBackend implements main.Backend.
+func (g *GiteaBackend) LockBackend(_ transfer.Args) transfer.LockBackend {
+	// Gitea doesn't support the locking API
+	// this should never be called as we don't advertise the capability
+	return (transfer.LockBackend)(nil)
+}
+
+func New() transfer.Backend {
+	return &GiteaBackend{lfs.NewContentStore()}
+}

modules/lfs_ssh/main.go

@@ -0,0 +1,36 @@
+package lfs_ssh
+
+import (
+	"fmt"
+	"os"
+
+	"code.gitea.io/gitea/modules/lfs_ssh/backend"
+	"code.gitea.io/gitea/modules/lfs_ssh/transfer"
+	"code.gitea.io/gitea/modules/log"
+)
+
+func Main(repo string, verb string) error {
+	//TODO
+	var logger transfer.Logger = nil
+
+	pktline := transfer.NewPktline(os.Stdin, os.Stdout, logger)
+	giteaBackend := backend.New()
+	for _, cap := range backend.Capabilities {
+		if err := pktline.WritePacketText(cap); err != nil {
+			log.Error("error sending capability [%v] due to error: %v", cap, err)
+		}
+	}
+	if err := pktline.WriteFlush(); err != nil {
+		log.Error("error flushing capabilities: %v", err)
+	}
+	p := transfer.NewProcessor(pktline, giteaBackend, logger)
+	defer log.Info("done processing commands")
+	switch verb {
+	case "upload":
+		return p.ProcessCommands(transfer.UploadOperation)
+	case "download":
+		return p.ProcessCommands(transfer.DownloadOperation)
+	default:
+		return fmt.Errorf("unknown operation %q", verb)
+	}
+}