refactor,fix: add rename lfs objects migration

README.md

@@ -208,7 +208,7 @@ lfs:
   # Enable Git LFS.
   enabled: true
   # Enable Git SSH transfer.
-  ssh_enabled: true
+  ssh_enabled: false
 
 # Cron job configuration
 jobs:
@@ -268,6 +268,8 @@ Soft Serve supports both Git LFS [HTTP](https://github.com/git-lfs/git-lfs/blob/
 
 Use the `lfs` config section to customize your Git LFS server.
 
+> **Note**: The pure-SSH transfer is disabled by default.
+
 ## Server Access
 
 Soft Serve at its core manages your server authentication and authorization. Authentication verifies the identity of a user, while authorization determines their access rights to a repository.

go.mod

@@ -2,7 +2,7 @@
 
 go 1.20
 
 replace github.com/gogs/git-module => github.com/aymanbagabas/git-module v1.4.1-0.20231025145308-5e8facf7a213
 
 require (
 	github.com/alecthomas/chroma v0.10.0
@@ -23,7 +23,7 @@
 	github.com/caarlos0/duration v0.0.0-20220103233809-8df7c22fe305
 	github.com/caarlos0/env/v8 v8.0.0
 	github.com/caarlos0/tablewriter v0.1.0
-	github.com/charmbracelet/git-lfs-transfer v0.1.1-0.20230725143853-5dd0632f9245
+	github.com/charmbracelet/git-lfs-transfer v0.1.1-0.20231027181609-f7ff6baf2ed0
 	github.com/charmbracelet/keygen v0.5.0
 	github.com/charmbracelet/log v0.2.5
 	github.com/charmbracelet/ssh v0.0.0-20230822194956-1a051f898e09

go.sum

@@ -25,8 +25,8 @@ github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5
 github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc=
 github.com/charmbracelet/bubbletea v0.24.2 h1:uaQIKx9Ai6Gdh5zpTbGiWpytMU+CfsPp06RaW2cx/SY=
 github.com/charmbracelet/bubbletea v0.24.2/go.mod h1:XdrNrV4J8GiyshTtx3DNuYkR1FDaJmO3l2nejekbsgg=
-github.com/charmbracelet/git-lfs-transfer v0.1.1-0.20230725143853-5dd0632f9245 h1:PeGKqKX84IAFhFSWjTyPGiLzzEPcv94C9qKsYBk2nbQ=
-github.com/charmbracelet/git-lfs-transfer v0.1.1-0.20230725143853-5dd0632f9245/go.mod h1:eXJuVicxnjRgRMokmutZdistxoMRjBjjfqvrYq7bCIU=
+github.com/charmbracelet/git-lfs-transfer v0.1.1-0.20231027181609-f7ff6baf2ed0 h1:Wi80d2xNAqvi6r8Udlc9UgPMdrJ+ld5ylKH7d8SQ7gE=
+github.com/charmbracelet/git-lfs-transfer v0.1.1-0.20231027181609-f7ff6baf2ed0/go.mod h1:AHLgIZ2TXQCgt3pDNXR6FgmpGHLH1wPM9cEJPHSVaYg=
 github.com/charmbracelet/glamour v0.6.0 h1:wi8fse3Y7nfcabbbDuwolqTqMQPMnVPeZhDM273bISc=
 github.com/charmbracelet/glamour v0.6.0/go.mod h1:taqWV4swIMMbWALc0m7AfE9JkPSU8om2538k9ITBxOc=
 github.com/charmbracelet/keygen v0.5.0 h1:XY0fsoYiCSM9axkrU+2ziE6u6YjJulo/b9Dghnw6MZc=

pkg/config/config.go

@@ -339,7 +339,7 @@ func DefaultConfig() *Config {
 		},
 		LFS: LFSConfig{
 			Enabled:    true,
-			SSHEnabled: true,
+			SSHEnabled: false,
 		},
 	}
 }

pkg/db/migrate/0003_migrate_lfs_objects.go

@@ -0,0 +1,70 @@
+package migrate
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"github.com/charmbracelet/log"
+	"github.com/charmbracelet/soft-serve/pkg/config"
+	"github.com/charmbracelet/soft-serve/pkg/db"
+	"github.com/charmbracelet/soft-serve/pkg/db/models"
+)
+
+const (
+	migrateLfsObjectsName    = "migrate_lfs_objects"
+	migrateLfsObjectsVersion = 3
+)
+
+// Correct LFS objects relative path.
+// From OID[:2]/OID[2:4]/OID[4:] to OID[:2]/OID[2:4]/OID
+// See: https://github.com/git-lfs/git-lfs/blob/main/docs/spec.md#intercepting-git
+var migrateLfsObjects = Migration{
+	Name:    migrateLfsObjectsName,
+	Version: migrateLfsObjectsVersion,
+	Migrate: func(ctx context.Context, tx *db.Tx) error {
+		cfg := config.FromContext(ctx)
+		logger := log.FromContext(ctx).WithPrefix("migrate_lfs_objects")
+
+		var repoIds []int64
+		if err := tx.Select(&repoIds, "SELECT id FROM repos"); err != nil {
+			return err
+		}
+		for _, r := range repoIds {
+			var objs []models.LFSObject
+			if err := tx.Select(&objs, "SELECT * FROM lfs_objects WHERE repo_id = ?", r); err != nil {
+				return err
+			}
+			objsp := filepath.Join(cfg.DataPath, "lfs", strconv.FormatInt(r, 10), "objects")
+			for _, obj := range objs {
+				oldpath := filepath.Join(objsp, badRelativePath(obj.Oid))
+				newpath := filepath.Join(objsp, goodRelativePath(obj.Oid))
+				if _, err := os.Stat(oldpath); err == nil {
+					if err := os.Rename(oldpath, newpath); err != nil {
+						logger.Error("rename lfs object", "oldpath", oldpath, "newpath", newpath, "err", err)
+						continue
+					}
+				}
+			}
+		}
+		return nil
+	},
+	Rollback: func(ctx context.Context, tx *db.Tx) error {
+		return nil
+	},
+}
+
+func goodRelativePath(oid string) string {
+	if len(oid) < 5 {
+		return oid
+	}
+	return filepath.Join(oid[:2], oid[2:4], oid)
+}
+
+func badRelativePath(oid string) string {
+	if len(oid) < 5 {
+		return oid
+	}
+	return filepath.Join(oid[:2], oid[2:4], oid[4:])
+}

pkg/db/migrate/migrations.go

@@ -17,6 +17,7 @@ var sqls embed.FS
 var migrations = []Migration{
 	createTables,
 	webhooks,
+	migrateLfsObjects,
 }
 
 func execMigration(ctx context.Context, tx *db.Tx, version int, name string, down bool) error {

pkg/git/lfs.go

@@ -10,7 +10,6 @@
 	"path"
 	"path/filepath"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/charmbracelet/git-lfs-transfer/transfer"
@@ -51,92 +50,85 @@
 // *config.Config, *db.DB, and store.Store.
 // The first arg in cmd.Args should be the repo path.
 // The second arg in cmd.Args should be the LFS operation (download or upload).
 func LFSTransfer(ctx context.Context, cmd ServiceCommand) error {
 	if len(cmd.Args) < 2 {
 		return errors.New("missing args")
 	}
 
 	op := cmd.Args[1]
 	if op != lfs.OperationDownload && op != lfs.OperationUpload {
 		return errors.New("invalid operation")
 	}
 
 	logger := log.FromContext(ctx).WithPrefix("lfs-transfer")
-	handler := transfer.NewPktline(cmd.Stdin, cmd.Stdout)
+	handler := transfer.NewPktline(cmd.Stdin, cmd.Stdout, &lfsLogger{logger})
 	repo := proto.RepositoryFromContext(ctx)
 	if repo == nil {
 		logger.Error("no repository in context")
 		return proto.ErrRepoNotFound
 	}
 
 	// Advertise capabilities.
 	for _, cap := range []string{
 		"version=1",
 		"locking",
 	} {
 		if err := handler.WritePacketText(cap); err != nil {
 			logger.Errorf("error sending capability: %s: %v", cap, err)
 			return err
 		}
 	}
 
 	if err := handler.WriteFlush(); err != nil {
 		logger.Error("error sending flush", "err", err)
 		return err
 	}
 
 	repoID := strconv.FormatInt(repo.ID(), 10)
 	cfg := config.FromContext(ctx)
 	processor := transfer.NewProcessor(handler, &lfsTransfer{
 		ctx:     ctx,
 		cfg:     cfg,
 		dbx:     db.FromContext(ctx),
 		store:   store.FromContext(ctx),
 		logger:  logger,
 		storage: storage.NewLocalStorage(filepath.Join(cfg.DataPath, "lfs", repoID)),
 		repo:    repo,
-	})
+	}, &lfsLogger{logger})
 
 	return processor.ProcessCommands(op)
 }
 
 // Batch implements transfer.Backend.
-func (t *lfsTransfer) Batch(_ string, pointers []transfer.Pointer, _ map[string]string) ([]transfer.BatchItem, error) {
-	items := make([]transfer.BatchItem, 0)
-	for _, p := range pointers {
-		obj, err := t.store.GetLFSObjectByOid(t.ctx, t.dbx, t.repo.ID(), p.Oid)
+func (t *lfsTransfer) Batch(_ string, pointers []transfer.BatchItem, _ transfer.Args) ([]transfer.BatchItem, error) {
+	for i := range pointers {
+		obj, err := t.store.GetLFSObjectByOid(t.ctx, t.dbx, t.repo.ID(), pointers[i].Oid)
 		if err != nil && !errors.Is(err, db.ErrRecordNotFound) {
-			return items, db.WrapError(err)
+			return pointers, db.WrapError(err)
 		}
 
-		exist, err := t.storage.Exists(path.Join("objects", p.RelativePath()))
+		pointers[i].Present, err = t.storage.Exists(path.Join("objects", pointers[i].RelativePath()))
 		if err != nil {
-			return items, err
+			return pointers, err
 		}
 
-		if exist && obj.ID == 0 {
-			if err := t.store.CreateLFSObject(t.ctx, t.dbx, t.repo.ID(), p.Oid, p.Size); err != nil {
-				return items, db.WrapError(err)
+		if pointers[i].Present && obj.ID == 0 {
+			if err := t.store.CreateLFSObject(t.ctx, t.dbx, t.repo.ID(), pointers[i].Oid, pointers[i].Size); err != nil {
+				return pointers, db.WrapError(err)
 			}
 		}
-
-		item := transfer.BatchItem{
-			Pointer: p,
-			Present: exist,
-		}
-		items = append(items, item)
 	}
 
-	return items, nil
+	return pointers, nil
 }
 
 // Download implements transfer.Backend.
-func (t *lfsTransfer) Download(oid string, _ map[string]string) (fs.File, error) {
+func (t *lfsTransfer) Download(oid string, _ transfer.Args) (fs.File, error) {
 	cfg := config.FromContext(t.ctx)
 	repoID := strconv.FormatInt(t.repo.ID(), 10)
 	strg := storage.NewLocalStorage(filepath.Join(cfg.DataPath, "lfs", repoID))
 	pointer := transfer.Pointer{Oid: oid}
 	return strg.Open(path.Join("objects", pointer.RelativePath()))
 }
 
 type uploadObject struct {
@@ -145,110 +137,99 @@
 	object storage.Object
 }
 
+func (u *uploadObject) Close() error {
+	return u.object.Close()
+}
+
 // StartUpload implements transfer.Backend.
-func (t *lfsTransfer) StartUpload(oid string, r io.Reader, _ map[string]string) (interface{}, error) {
+func (t *lfsTransfer) StartUpload(oid string, r io.Reader, _ transfer.Args) (io.Closer, error) {
 	if r == nil {
 		return nil, fmt.Errorf("no reader: %w", transfer.ErrMissingData)
 	}
 
 	tempDir := "incomplete"
 	randBytes := make([]byte, 12)
 	if _, err := rand.Read(randBytes); err != nil {
 		return nil, err
 	}
 
 	tempName := fmt.Sprintf("%s%x", oid, randBytes)
 	tempName = path.Join(tempDir, tempName)
 
 	written, err := t.storage.Put(tempName, r)
 	if err != nil {
 		t.logger.Errorf("error putting object: %v", err)
 		return nil, err
 	}
 
 	obj, err := t.storage.Open(tempName)
 	if err != nil {
 		t.logger.Errorf("error opening object: %v", err)
 		return nil, err
 	}
 
 	t.logger.Infof("Object name: %s", obj.Name())
 
-	return uploadObject{
+	return &uploadObject{
 		oid:    oid,
 		size:   written,
 		object: obj,
 	}, nil
 }
 
 // FinishUpload implements transfer.Backend.
-func (t *lfsTransfer) FinishUpload(state interface{}, args map[string]string) error {
-	upl, ok := state.(uploadObject)
+func (t *lfsTransfer) FinishUpload(state io.Closer, args transfer.Args) error {
+	upl, ok := state.(*uploadObject)
 	if !ok {
 		return errors.New("invalid state")
 	}
 
-	var size int64
-	for _, arg := range args {
-		if strings.HasPrefix(arg, "size=") {
-			size, _ = strconv.ParseInt(strings.TrimPrefix(arg, "size="), 10, 64)
-			break
-		}
-	}
-
+	size, _ := transfer.SizeFromArgs(args)
 	pointer := transfer.Pointer{
 		Oid: upl.oid,
 	}
 	if size > 0 {
 		pointer.Size = size
 	} else {
 		pointer.Size = upl.size
 	}
 
 	if err := t.store.CreateLFSObject(t.ctx, t.dbx, t.repo.ID(), pointer.Oid, pointer.Size); err != nil {
 		return db.WrapError(err)
 	}
 
 	expectedPath := path.Join("objects", pointer.RelativePath())
 	if err := t.storage.Rename(upl.object.Name(), expectedPath); err != nil {
 		t.logger.Errorf("error renaming object: %v", err)
 		_ = t.store.DeleteLFSObjectByOid(t.ctx, t.dbx, t.repo.ID(), pointer.Oid)
 		return err
 	}
 
 	return nil
 }
 
 // Verify implements transfer.Backend.
-func (t *lfsTransfer) Verify(oid string, args map[string]string) (transfer.Status, error) {
-	var expectedSize int64
-	var err error
-	size, ok := args[transfer.SizeKey]
-	if !ok {
-		return transfer.NewFailureStatus(transfer.StatusBadRequest, "missing size"), nil
-	}
-
-	expectedSize, err = strconv.ParseInt(size, 10, 64)
+func (t *lfsTransfer) Verify(oid string, args transfer.Args) (transfer.Status, error) {
+	expectedSize, err := transfer.SizeFromArgs(args)
 	if err != nil {
-		t.logger.Errorf("invalid size argument: %v", err)
-		return transfer.NewFailureStatus(transfer.StatusBadRequest, "invalid size argument"), nil
+		return transfer.NewStatus(transfer.StatusBadRequest, "missing size"), nil // nolint: nilerr
 	}
 
 	obj, err := t.store.GetLFSObjectByOid(t.ctx, t.dbx, t.repo.ID(), oid)
 	if err != nil {
 		if errors.Is(err, db.ErrRecordNotFound) {
-			return transfer.NewFailureStatus(transfer.StatusNotFound, "object not found"), nil
+			return transfer.NewStatus(transfer.StatusNotFound, "object not found"), nil
 		}
 		t.logger.Errorf("error getting object: %v", err)
 		return nil, err
 	}
 
 	if obj.Size != expectedSize {
 		t.logger.Errorf("size mismatch: %d != %d", obj.Size, expectedSize)
-		return transfer.NewFailureStatus(transfer.StatusConflict, "size mismatch"), nil
+		return transfer.NewStatus(transfer.StatusConflict, "size mismatch"), nil
 	}
 
 	return transfer.SuccessStatus(), nil
 }
 
 type lfsLockBackend struct {
@@ -260,179 +241,179 @@
 var _ transfer.LockBackend = (*lfsLockBackend)(nil)
 
 // LockBackend implements transfer.Backend.
-func (t *lfsTransfer) LockBackend(args map[string]string) transfer.LockBackend {
+func (t *lfsTransfer) LockBackend(args transfer.Args) transfer.LockBackend {
 	user := proto.UserFromContext(t.ctx)
 	if user == nil {
 		t.logger.Errorf("no user in context while creating lock backend, repo %s", t.repo.Name())
 		return nil
 	}
 
 	return &lfsLockBackend{t, args, user}
 }
 
 // Create implements transfer.LockBackend.
 func (l *lfsLockBackend) Create(path string, refname string) (transfer.Lock, error) {
 	var lock LFSLock
 	if err := l.dbx.TransactionContext(l.ctx, func(tx *db.Tx) error {
 		if err := l.store.CreateLFSLockForUser(l.ctx, tx, l.repo.ID(), l.user.ID(), path, refname); err != nil {
 			return db.WrapError(err)
 		}
 
 		var err error
 		lock.lock, err = l.store.GetLFSLockForUserPath(l.ctx, tx, l.repo.ID(), l.user.ID(), path)
 		if err != nil {
 			return db.WrapError(err)
 		}
 
 		lock.owner, err = l.store.GetUserByID(l.ctx, tx, lock.lock.UserID)
 		return db.WrapError(err)
 	}); err != nil {
 		// Return conflict (409) if the lock already exists.
 		if errors.Is(err, db.ErrDuplicateKey) {
 			return nil, transfer.ErrConflict
 		}
 		l.logger.Errorf("error creating lock: %v", err)
 		return nil, err
 	}
 
 	lock.backend = l
 
 	return &lock, nil
 }
 
 // FromID implements transfer.LockBackend.
 func (l *lfsLockBackend) FromID(id string) (transfer.Lock, error) {
 	var lock LFSLock
 	iid, err := strconv.ParseInt(id, 10, 64)
 	if err != nil {
 		return nil, err
 	}
 
 	if err := l.dbx.TransactionContext(l.ctx, func(tx *db.Tx) error {
 		var err error
 		lock.lock, err = l.store.GetLFSLockForUserByID(l.ctx, tx, l.repo.ID(), l.user.ID(), iid)
 		if err != nil {
 			return db.WrapError(err)
 		}
 
 		lock.owner, err = l.store.GetUserByID(l.ctx, tx, lock.lock.UserID)
 		return db.WrapError(err)
 	}); err != nil {
 		if errors.Is(err, db.ErrRecordNotFound) {
 			return nil, transfer.ErrNotFound
 		}
 		l.logger.Errorf("error getting lock: %v", err)
 		return nil, err
 	}
 
 	lock.backend = l
 
 	return &lock, nil
 }
 
 // FromPath implements transfer.LockBackend.
 func (l *lfsLockBackend) FromPath(path string) (transfer.Lock, error) {
 	var lock LFSLock
 
 	if err := l.dbx.TransactionContext(l.ctx, func(tx *db.Tx) error {
 		var err error
 		lock.lock, err = l.store.GetLFSLockForUserPath(l.ctx, tx, l.repo.ID(), l.user.ID(), path)
 		if err != nil {
 			return db.WrapError(err)
 		}
 
 		lock.owner, err = l.store.GetUserByID(l.ctx, tx, lock.lock.UserID)
 		return db.WrapError(err)
 	}); err != nil {
 		if errors.Is(err, db.ErrRecordNotFound) {
 			return nil, transfer.ErrNotFound
 		}
 		l.logger.Errorf("error getting lock: %v", err)
 		return nil, err
 	}
 
 	lock.backend = l
 
 	return &lock, nil
 }
 
 // Range implements transfer.LockBackend.
 func (l *lfsLockBackend) Range(cursor string, limit int, fn func(transfer.Lock) error) (string, error) {
 	var nextCursor string
 	var locks []*LFSLock
 
 	page, _ := strconv.Atoi(cursor)
 	if page <= 0 {
 		page = 1
 	}
 
 	if limit <= 0 {
 		limit = lfs.DefaultLocksLimit
 	} else if limit > 100 {
 		limit = 100
 	}
 
 	if err := l.dbx.TransactionContext(l.ctx, func(tx *db.Tx) error {
 		l.logger.Debug("getting locks", "limit", limit, "page", page)
 		mlocks, err := l.store.GetLFSLocks(l.ctx, tx, l.repo.ID(), page, limit)
 		if err != nil {
 			return db.WrapError(err)
 		}
 
 		if len(mlocks) == limit {
 			nextCursor = strconv.Itoa(page + 1)
 		}
 
 		users := make(map[int64]models.User, 0)
 		for _, mlock := range mlocks {
 			owner, ok := users[mlock.UserID]
 			if !ok {
 				owner, err = l.store.GetUserByID(l.ctx, tx, mlock.UserID)
 				if err != nil {
 					return db.WrapError(err)
 				}
 
 				users[mlock.UserID] = owner
 			}
 
 			locks = append(locks, &LFSLock{lock: mlock, owner: owner, backend: l})
 		}
 
 		return nil
 	}); err != nil {
 		return "", err
 	}
 
 	for _, lock := range locks {
 		if err := fn(lock); err != nil {
 			return "", err
 		}
 	}
 
 	return nextCursor, nil
 }
 
 // Unlock implements transfer.LockBackend.
 func (l *lfsLockBackend) Unlock(lock transfer.Lock) error {
 	id, err := strconv.ParseInt(lock.ID(), 10, 64)
 	if err != nil {
 		return err
 	}
 
 	err = l.dbx.TransactionContext(l.ctx, func(tx *db.Tx) error {
 		return db.WrapError(
 			l.store.DeleteLFSLockForUserByID(l.ctx, tx, l.repo.ID(), l.user.ID(), id),
 		)
 	})
 	if err != nil {
 		if errors.Is(err, db.ErrRecordNotFound) {
 			return transfer.ErrNotFound
 		}
 		l.logger.Error("error unlocking lock", "err", err)
 		return err
 	}
 
 	return nil
 }
 
 // LFSLock is a Git LFS lock object.
@@ -446,58 +427,58 @@
 var _ transfer.Lock = (*LFSLock)(nil)
 
 // AsArguments implements transfer.Lock.
 func (l *LFSLock) AsArguments() []string {
 	return []string{
 		fmt.Sprintf("id=%s", l.ID()),
 		fmt.Sprintf("path=%s", l.Path()),
 		fmt.Sprintf("locked-at=%s", l.FormattedTimestamp()),
 		fmt.Sprintf("ownername=%s", l.OwnerName()),
 	}
 }
 
 // AsLockSpec implements transfer.Lock.
 func (l *LFSLock) AsLockSpec(ownerID bool) ([]string, error) {
 	id := l.ID()
 	spec := []string{
 		fmt.Sprintf("lock %s", id),
 		fmt.Sprintf("path %s %s", id, l.Path()),
 		fmt.Sprintf("locked-at %s %s", id, l.FormattedTimestamp()),
 		fmt.Sprintf("ownername %s %s", id, l.OwnerName()),
 	}
 
 	if ownerID {
 		who := "theirs"
 		if l.lock.UserID == l.owner.ID {
 			who = "ours"
 		}
 
 		spec = append(spec, fmt.Sprintf("owner %s %s", id, who))
 	}
 
 	return spec, nil
 }
 
 // FormattedTimestamp implements transfer.Lock.
 func (l *LFSLock) FormattedTimestamp() string {
 	return l.lock.CreatedAt.Format(time.RFC3339)
 }
 
 // ID implements transfer.Lock.
 func (l *LFSLock) ID() string {
 	return strconv.FormatInt(l.lock.ID, 10)
 }
 
 // OwnerName implements transfer.Lock.
 func (l *LFSLock) OwnerName() string {
 	return l.owner.Username
 }
 
 // Path implements transfer.Lock.
 func (l *LFSLock) Path() string {
 	return l.lock.Path
 }
 
 // Unlock implements transfer.Lock.
 func (l *LFSLock) Unlock() error {
 	return l.backend.Unlock(l)
 }

pkg/git/lfs_log.go

@@ -0,0 +1,17 @@
+package git
+
+import (
+	"github.com/charmbracelet/git-lfs-transfer/transfer"
+	"github.com/charmbracelet/log"
+)
+
+type lfsLogger struct {
+	l *log.Logger
+}
+
+var _ transfer.Logger = &lfsLogger{}
+
+// Log implements transfer.Logger.
+func (l *lfsLogger) Log(msg string, kv ...interface{}) {
+	l.l.Debug(msg, kv...)
+}

pkg/lfs/pointer.go

@@ -38,15 +38,15 @@
 )
 
 // ReadPointer tries to read LFS pointer data from the reader
 func ReadPointer(reader io.Reader) (Pointer, error) {
 	buf := make([]byte, blobSizeCutoff)
 	n, err := io.ReadFull(reader, buf)
 	if err != nil && err != io.ErrUnexpectedEOF {
 		return Pointer{}, err
 	}
 	buf = buf[:n]
 
 	return ReadPointerFromBuffer(buf)
 }
 
 var oidPattern = regexp.MustCompile(`^[a-f\d]{64}$`)
@@ -87,36 +87,37 @@
 		return false
 	}
 	if !oidPattern.MatchString(p.Oid) {
 		return false
 	}
 	if p.Size < 0 {
 		return false
 	}
 	return true
 }
 
 // String returns the string representation of the pointer
 // https://github.com/git-lfs/git-lfs/blob/main/docs/spec.md#the-pointer
 func (p Pointer) String() string {
 	return fmt.Sprintf("%s\n%s%s\nsize %d\n", MetaFileIdentifier, MetaFileOidPrefix, p.Oid, p.Size)
 }
 
 // RelativePath returns the relative storage path of the pointer
+// https://github.com/git-lfs/git-lfs/blob/main/docs/spec.md#intercepting-git
 func (p Pointer) RelativePath() string {
 	if len(p.Oid) < 5 {
 		return p.Oid
 	}
 
-	return path.Join(p.Oid[0:2], p.Oid[2:4], p.Oid[4:])
+	return path.Join(p.Oid[0:2], p.Oid[2:4], p.Oid)
 }
 
 // GeneratePointer generates a pointer for arbitrary content
 func GeneratePointer(content io.Reader) (Pointer, error) {
 	h := sha256.New()
 	c, err := io.Copy(h, content)
 	if err != nil {
 		return Pointer{}, err
 	}
 	sum := h.Sum(nil)
 	return Pointer{Oid: hex.EncodeToString(sum), Size: c}, nil
 }

pkg/lfs/pointer_test.go

@@ -2,8 +2,8 @@ package lfs
 
 import (
 	"errors"
+	"path"
 	"strconv"
-	"strings"
 	"testing"
 )
 
@@ -78,8 +78,8 @@ size abc
 					t.Errorf("Expected a valid pointer")
 					return
 				}
-				if p.Oid != strings.ReplaceAll(p.RelativePath(), "/", "") {
-					t.Errorf("Expected oid to be the relative path without slashes")
+				if path.Join(p.Oid[:2], p.Oid[2:4], p.Oid) != p.RelativePath() {
+					t.Errorf("Expected a valid relative path")
 					return
 				}
 			}