USEFULL
/
gogs
mirror of https://github.com/gogs/gogs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

all: unwrap `database.LFSStore` interface (#7692)

pull/7695/head
Joe Chen 2024-03-16 20:32:12 -04:00 committed by GitHub
parent b9e41f28c3
commit 3a5132b6f7
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
12 changed files with 635 additions and 662 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
internal/database/database.go
View File

@ -124,7 +124,6 @@ func NewConnection(w logger.Writer) (*gorm.DB, error) {
// Initialize stores, sorted in alphabetical order.
LoginSources = &loginSourcesStore{DB: db, files: sourceFiles}
LFS = &lfsStore{DB: db}
Notices = NewNoticesStore(db)
Orgs = NewOrgsStore(db)
Perms = NewPermsStore(db)
@ -163,3 +162,7 @@ func (db *DB) AccessTokens() *AccessTokensStore {
func (db *DB) Actions() *ActionsStore {
return newActionsStore(db.db)
}
func (db *DB) LFS() *LFSStore {
return newLFSStore(db.db)
}

50
internal/database/lfs.go
View File

@ -6,6 +6,7 @@ package database
import (
"context"
"errors"
"fmt"
"time"
@ -15,20 +16,6 @@ import (
"gogs.io/gogs/internal/lfsutil"
)
// LFSStore is the persistent interface for LFS objects.
type LFSStore interface {
// CreateObject creates a LFS object record in database.
CreateObject(ctx context.Context, repoID int64, oid lfsutil.OID, size int64, storage lfsutil.Storage) error
// GetObjectByOID returns the LFS object with given OID. It returns
// ErrLFSObjectNotExist when not found.
GetObjectByOID(ctx context.Context, repoID int64, oid lfsutil.OID) (*LFSObject, error)
// GetObjectsByOIDs returns LFS objects found within "oids". The returned list
// could have less elements if some oids were not found.
GetObjectsByOIDs(ctx context.Context, repoID int64, oids ...lfsutil.OID) ([]*LFSObject, error)
}
var LFS LFSStore
// LFSObject is the relation between an LFS object and a repository.
type LFSObject struct {
RepoID int64 `gorm:"primaryKey;auto_increment:false"`
@ -38,20 +25,24 @@ type LFSObject struct {
CreatedAt time.Time `gorm:"not null"`
}
var _ LFSStore = (*lfsStore)(nil)
type lfsStore struct {
*gorm.DB
// LFSStore is the storage layer for LFS objects.
type LFSStore struct {
db *gorm.DB
}
func (s *lfsStore) CreateObject(ctx context.Context, repoID int64, oid lfsutil.OID, size int64, storage lfsutil.Storage) error {
func newLFSStore(db *gorm.DB) *LFSStore {
return &LFSStore{db: db}
}
// CreateObject creates an LFS object record in database.
func (s *LFSStore) CreateObject(ctx context.Context, repoID int64, oid lfsutil.OID, size int64, storage lfsutil.Storage) error {
object := &LFSObject{
RepoID: repoID,
OID: oid,
Size: size,
Storage: storage,
}
return s.WithContext(ctx).Create(object).Error
return s.db.WithContext(ctx).Create(object).Error
}
type ErrLFSObjectNotExist struct {
@ -59,8 +50,7 @@ type ErrLFSObjectNotExist struct {
}
func IsErrLFSObjectNotExist(err error) bool {
_, ok := err.(ErrLFSObjectNotExist)
return ok
return errors.As(err, &ErrLFSObjectNotExist{})
}
func (err ErrLFSObjectNotExist) Error() string {
@ -71,11 +61,13 @@ func (ErrLFSObjectNotExist) NotFound() bool {
return true
}
func (s *lfsStore) GetObjectByOID(ctx context.Context, repoID int64, oid lfsutil.OID) (*LFSObject, error) {
// GetObjectByOID returns the LFS object with given OID. It returns
// ErrLFSObjectNotExist when not found.
func (s *LFSStore) GetObjectByOID(ctx context.Context, repoID int64, oid lfsutil.OID) (*LFSObject, error) {
object := new(LFSObject)
err := s.WithContext(ctx).Where("repo_id = ? AND oid = ?", repoID, oid).First(object).Error
err := s.db.WithContext(ctx).Where("repo_id = ? AND oid = ?", repoID, oid).First(object).Error
if err != nil {
if err == gorm.ErrRecordNotFound {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, ErrLFSObjectNotExist{args: errutil.Args{"repoID": repoID, "oid": oid}}
}
return nil, err
@ -83,14 +75,16 @@ func (s *lfsStore) GetObjectByOID(ctx context.Context, repoID int64, oid lfsutil
return object, err
}
func (s *lfsStore) GetObjectsByOIDs(ctx context.Context, repoID int64, oids ...lfsutil.OID) ([]*LFSObject, error) {
// GetObjectsByOIDs returns LFS objects found within "oids". The returned list
// could have fewer elements if some oids were not found.
func (s *LFSStore) GetObjectsByOIDs(ctx context.Context, repoID int64, oids ...lfsutil.OID) ([]*LFSObject, error) {
if len(oids) == 0 {
return []*LFSObject{}, nil
}
objects := make([]*LFSObject, 0, len(oids))
err := s.WithContext(ctx).Where("repo_id = ? AND oid IN (?)", repoID, oids).Find(&objects).Error
if err != nil && err != gorm.ErrRecordNotFound {
err := s.db.WithContext(ctx).Where("repo_id = ? AND oid IN (?)", repoID, oids).Find(&objects).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return nil, err
}
return objects, nil

38
internal/database/lfs_test.go
View File

@ -23,13 +23,13 @@ func TestLFS(t *testing.T) {
t.Parallel()
ctx := context.Background()
db := &lfsStore{
DB: newTestDB(t, "lfsStore"),
s := &LFSStore{
db: newTestDB(t, "LFSStore"),
}
for _, tc := range []struct {
name string
test func(t *testing.T, ctx context.Context, db *lfsStore)
test func(t *testing.T, ctx context.Context, s *LFSStore)
}{
{"CreateObject", lfsCreateObject},
{"GetObjectByOID", lfsGetObjectByOID},
@ -37,10 +37,10 @@ func TestLFS(t *testing.T) {
} {
t.Run(tc.name, func(t *testing.T) {
t.Cleanup(func() {
err := clearTables(t, db.DB)
err := clearTables(t, s.db)
require.NoError(t, err)
})
tc.test(t, ctx, db)
tc.test(t, ctx, s)
})
if t.Failed() {
break
@ -48,52 +48,52 @@ func TestLFS(t *testing.T) {
}
}
func lfsCreateObject(t *testing.T, ctx context.Context, db *lfsStore) {
func lfsCreateObject(t *testing.T, ctx context.Context, s *LFSStore) {
// Create first LFS object
repoID := int64(1)
oid := lfsutil.OID("ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f")
err := db.CreateObject(ctx, repoID, oid, 12, lfsutil.StorageLocal)
err := s.CreateObject(ctx, repoID, oid, 12, lfsutil.StorageLocal)
require.NoError(t, err)
// Get it back and check the CreatedAt field
object, err := db.GetObjectByOID(ctx, repoID, oid)
object, err := s.GetObjectByOID(ctx, repoID, oid)
require.NoError(t, err)
assert.Equal(t, db.NowFunc().Format(time.RFC3339), object.CreatedAt.UTC().Format(time.RFC3339))
assert.Equal(t, s.db.NowFunc().Format(time.RFC3339), object.CreatedAt.UTC().Format(time.RFC3339))
// Try create second LFS object with same oid should fail
err = db.CreateObject(ctx, repoID, oid, 12, lfsutil.StorageLocal)
// Try to create second LFS object with same oid should fail
err = s.CreateObject(ctx, repoID, oid, 12, lfsutil.StorageLocal)
assert.Error(t, err)
}
func lfsGetObjectByOID(t *testing.T, ctx context.Context, db *lfsStore) {
func lfsGetObjectByOID(t *testing.T, ctx context.Context, s *LFSStore) {
// Create a LFS object
repoID := int64(1)
oid := lfsutil.OID("ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f")
err := db.CreateObject(ctx, repoID, oid, 12, lfsutil.StorageLocal)
err := s.CreateObject(ctx, repoID, oid, 12, lfsutil.StorageLocal)
require.NoError(t, err)
// We should be able to get it back
_, err = db.GetObjectByOID(ctx, repoID, oid)
_, err = s.GetObjectByOID(ctx, repoID, oid)
require.NoError(t, err)
// Try to get a non-existent object
_, err = db.GetObjectByOID(ctx, repoID, "bad_oid")
_, err = s.GetObjectByOID(ctx, repoID, "bad_oid")
expErr := ErrLFSObjectNotExist{args: errutil.Args{"repoID": repoID, "oid": lfsutil.OID("bad_oid")}}
assert.Equal(t, expErr, err)
}
func lfsGetObjectsByOIDs(t *testing.T, ctx context.Context, db *lfsStore) {
func lfsGetObjectsByOIDs(t *testing.T, ctx context.Context, s *LFSStore) {
// Create two LFS objects
repoID := int64(1)
oid1 := lfsutil.OID("ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f")
oid2 := lfsutil.OID("ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64g")
err := db.CreateObject(ctx, repoID, oid1, 12, lfsutil.StorageLocal)
err := s.CreateObject(ctx, repoID, oid1, 12, lfsutil.StorageLocal)
require.NoError(t, err)
err = db.CreateObject(ctx, repoID, oid2, 12, lfsutil.StorageLocal)
err = s.CreateObject(ctx, repoID, oid2, 12, lfsutil.StorageLocal)
require.NoError(t, err)
// We should be able to get them back and ignore non-existent ones
objects, err := db.GetObjectsByOIDs(ctx, repoID, oid1, oid2, "bad_oid")
objects, err := s.GetObjectsByOIDs(ctx, repoID, oid1, oid2, "bad_oid")
require.NoError(t, err)
assert.Equal(t, 2, len(objects), "number of objects")

8
internal/database/mocks.go
View File

@ -8,14 +8,6 @@ import (
"testing"
)
func SetMockLFSStore(t *testing.T, mock LFSStore) {
before := LFS
LFS = mock
t.Cleanup(func() {
LFS = before
})
}
func setMockLoginSourcesStore(t *testing.T, mock LoginSourcesStore) {
before := LoginSources
LoginSources = mock

11
internal/route/lfs/basic.go
View File

@ -25,6 +25,7 @@ const (
)
type basicHandler struct {
store Store
// The default storage backend for uploading new objects.
defaultStorage lfsutil.Storage
// The list of available storage backends to access objects.
@ -43,7 +44,7 @@ func (h *basicHandler) Storager(storage lfsutil.Storage) lfsutil.Storager {
// GET /{owner}/{repo}.git/info/lfs/object/basic/{oid}
func (h *basicHandler) serveDownload(c *macaron.Context, repo *database.Repository, oid lfsutil.OID) {
object, err := database.LFS.GetObjectByOID(c.Req.Context(), repo.ID, oid)
object, err := h.store.GetLFSObjectByOID(c.Req.Context(), repo.ID, oid)
if err != nil {
if database.IsErrLFSObjectNotExist(err) {
responseJSON(c.Resp, http.StatusNotFound, responseError{
@ -78,7 +79,7 @@ func (h *basicHandler) serveDownload(c *macaron.Context, repo *database.Reposito
func (h *basicHandler) serveUpload(c *macaron.Context, repo *database.Repository, oid lfsutil.OID) {
// NOTE: LFS client will retry upload the same object if there was a partial failure,
// therefore we would like to skip ones that already exist.
_, err := database.LFS.GetObjectByOID(c.Req.Context(), repo.ID, oid)
_, err := h.store.GetLFSObjectByOID(c.Req.Context(), repo.ID, oid)
if err == nil {
// Object exists, drain the request body and we're good.
_, _ = io.Copy(io.Discard, c.Req.Request.Body)
@ -105,7 +106,7 @@ func (h *basicHandler) serveUpload(c *macaron.Context, repo *database.Repository
return
}
err = database.LFS.CreateObject(c.Req.Context(), repo.ID, oid, written, s.Storage())
err = h.store.CreateLFSObject(c.Req.Context(), repo.ID, oid, written, s.Storage())
if err != nil {
// NOTE: It is OK to leave the file when the whole operation failed
// with a DB error, a retry on client side can safely overwrite the
@ -120,7 +121,7 @@ func (h *basicHandler) serveUpload(c *macaron.Context, repo *database.Repository
}
// POST /{owner}/{repo}.git/info/lfs/object/basic/verify
func (*basicHandler) serveVerify(c *macaron.Context, repo *database.Repository) {
func (h *basicHandler) serveVerify(c *macaron.Context, repo *database.Repository) {
var request basicVerifyRequest
defer func() { _ = c.Req.Request.Body.Close() }()
@ -139,7 +140,7 @@ func (*basicHandler) serveVerify(c *macaron.Context, repo *database.Repository)
return
}
object, err := database.LFS.GetObjectByOID(c.Req.Context(), repo.ID, request.Oid)
object, err := h.store.GetLFSObjectByOID(c.Req.Context(), repo.ID, request.Oid)
if err != nil {
if database.IsErrLFSObjectNotExist(err) {
responseJSON(c.Resp, http.StatusNotFound, responseError{

119
internal/route/lfs/basic_test.go
View File

@ -13,6 +13,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"gopkg.in/macaron.v1"
"gogs.io/gogs/internal/database"
@ -21,7 +22,7 @@ import (
var _ lfsutil.Storager = (*mockStorage)(nil)
// mockStorage is a in-memory storage for LFS objects.
// mockStorage is an in-memory storage for LFS objects.
type mockStorage struct {
buf *bytes.Buffer
}
@ -31,7 +32,7 @@ func (*mockStorage) Storage() lfsutil.Storage {
}
func (s *mockStorage) Upload(_ lfsutil.OID, rc io.ReadCloser) (int64, error) {
defer rc.Close()
defer func() { _ = rc.Close() }()
return io.Copy(s.buf, rc)
}
@ -40,7 +41,7 @@ func (s *mockStorage) Download(_ lfsutil.OID, w io.Writer) error {
return err
}
func Test_basicHandler_serveDownload(t *testing.T) {
func TestBasicHandler_serveDownload(t *testing.T) {
s := &mockStorage{}
basic := &basicHandler{
defaultStorage: s.Storage(),
@ -60,17 +61,17 @@ func Test_basicHandler_serveDownload(t *testing.T) {
tests := []struct {
name string
content string
mockLFSStore func() database.LFSStore
mockStore func() *MockStore
expStatusCode int
expHeader http.Header
expBody string
}{
{
name: "object does not exist",
mockLFSStore: func() database.LFSStore {
mock := NewMockLFSStore()
mock.GetObjectByOIDFunc.SetDefaultReturn(nil, database.ErrLFSObjectNotExist{})
return mock
mockStore: func() *MockStore {
mockStore := NewMockStore()
mockStore.GetLFSObjectByOIDFunc.SetDefaultReturn(nil, database.ErrLFSObjectNotExist{})
return mockStore
},
expStatusCode: http.StatusNotFound,
expHeader: http.Header{
@ -80,10 +81,10 @@ func Test_basicHandler_serveDownload(t *testing.T) {
},
{
name: "storage not found",
mockLFSStore: func() database.LFSStore {
mock := NewMockLFSStore()
mock.GetObjectByOIDFunc.SetDefaultReturn(&database.LFSObject{Storage: "bad_storage"}, nil)
return mock
mockStore: func() *MockStore {
mockStore := NewMockStore()
mockStore.GetLFSObjectByOIDFunc.SetDefaultReturn(&database.LFSObject{Storage: "bad_storage"}, nil)
return mockStore
},
expStatusCode: http.StatusInternalServerError,
expHeader: http.Header{
@ -95,16 +96,16 @@ func Test_basicHandler_serveDownload(t *testing.T) {
{
name: "object exists",
content: "Hello world!",
mockLFSStore: func() database.LFSStore {
mock := NewMockLFSStore()
mock.GetObjectByOIDFunc.SetDefaultReturn(
mockStore: func() *MockStore {
mockStore := NewMockStore()
mockStore.GetLFSObjectByOIDFunc.SetDefaultReturn(
&database.LFSObject{
Size: 12,
Storage: s.Storage(),
},
nil,
)
return mock
return mockStore
},
expStatusCode: http.StatusOK,
expHeader: http.Header{
@ -116,14 +117,12 @@ func Test_basicHandler_serveDownload(t *testing.T) {
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
database.SetMockLFSStore(t, test.mockLFSStore())
basic.store = test.mockStore()
s.buf = bytes.NewBufferString(test.content)
r, err := http.NewRequest("GET", "/", nil)
if err != nil {
t.Fatal(err)
}
r, err := http.NewRequest(http.MethodGet, "/", nil)
require.NoError(t, err)
rr := httptest.NewRecorder()
m.ServeHTTP(rr, r)
@ -133,15 +132,13 @@ func Test_basicHandler_serveDownload(t *testing.T) {
assert.Equal(t, test.expHeader, resp.Header)
body, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
assert.Equal(t, test.expBody, string(body))
})
}
}
func Test_basicHandler_serveUpload(t *testing.T) {
func TestBasicHandler_serveUpload(t *testing.T) {
s := &mockStorage{buf: &bytes.Buffer{}}
basic := &basicHandler{
defaultStorage: s.Storage(),
@ -160,37 +157,35 @@ func Test_basicHandler_serveUpload(t *testing.T) {
tests := []struct {
name string
mockLFSStore func() database.LFSStore
mockStore func() *MockStore
expStatusCode int
expBody string
}{
{
name: "object already exists",
mockLFSStore: func() database.LFSStore {
mock := NewMockLFSStore()
mock.GetObjectByOIDFunc.SetDefaultReturn(&database.LFSObject{}, nil)
return mock
mockStore: func() *MockStore {
mockStore := NewMockStore()
mockStore.GetLFSObjectByOIDFunc.SetDefaultReturn(&database.LFSObject{}, nil)
return mockStore
},
expStatusCode: http.StatusOK,
},
{
name: "new object",
mockLFSStore: func() database.LFSStore {
mock := NewMockLFSStore()
mock.GetObjectByOIDFunc.SetDefaultReturn(nil, database.ErrLFSObjectNotExist{})
return mock
mockStore: func() *MockStore {
mockStore := NewMockStore()
mockStore.GetLFSObjectByOIDFunc.SetDefaultReturn(nil, database.ErrLFSObjectNotExist{})
return mockStore
},
expStatusCode: http.StatusOK,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
database.SetMockLFSStore(t, test.mockLFSStore())
basic.store = test.mockStore()
r, err := http.NewRequest("PUT", "/", strings.NewReader("Hello world!"))
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
rr := httptest.NewRecorder()
m.ServeHTTP(rr, r)
@ -199,26 +194,26 @@ func Test_basicHandler_serveUpload(t *testing.T) {
assert.Equal(t, test.expStatusCode, resp.StatusCode)
body, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
assert.Equal(t, test.expBody, string(body))
})
}
}
func Test_basicHandler_serveVerify(t *testing.T) {
func TestBasicHandler_serveVerify(t *testing.T) {
basic := &basicHandler{}
m := macaron.New()
m.Use(macaron.Renderer())
m.Use(func(c *macaron.Context) {
c.Map(&database.Repository{Name: "repo"})
})
m.Post("/", (&basicHandler{}).serveVerify)
m.Post("/", basic.serveVerify)
tests := []struct {
name string
body string
mockLFSStore func() database.LFSStore
mockStore func() *MockStore
expStatusCode int
expBody string
}{
@ -231,10 +226,10 @@ func Test_basicHandler_serveVerify(t *testing.T) {
{
name: "object does not exist",
body: `{"oid":"ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f"}`,
mockLFSStore: func() database.LFSStore {
mock := NewMockLFSStore()
mock.GetObjectByOIDFunc.SetDefaultReturn(nil, database.ErrLFSObjectNotExist{})
return mock
mockStore: func() *MockStore {
mockStore := NewMockStore()
mockStore.GetLFSObjectByOIDFunc.SetDefaultReturn(nil, database.ErrLFSObjectNotExist{})
return mockStore
},
expStatusCode: http.StatusNotFound,
expBody: `{"message":"Object does not exist"}` + "\n",
@ -242,10 +237,10 @@ func Test_basicHandler_serveVerify(t *testing.T) {
{
name: "object size mismatch",
body: `{"oid":"ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f"}`,
mockLFSStore: func() database.LFSStore {
mock := NewMockLFSStore()
mock.GetObjectByOIDFunc.SetDefaultReturn(&database.LFSObject{Size: 12}, nil)
return mock
mockStore: func() *MockStore {
mockStore := NewMockStore()
mockStore.GetLFSObjectByOIDFunc.SetDefaultReturn(&database.LFSObject{Size: 12}, nil)
return mockStore
},
expStatusCode: http.StatusBadRequest,
expBody: `{"message":"Object size mismatch"}` + "\n",
@ -254,24 +249,22 @@ func Test_basicHandler_serveVerify(t *testing.T) {
{
name: "object exists",
body: `{"oid":"ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f", "size":12}`,
mockLFSStore: func() database.LFSStore {
mock := NewMockLFSStore()
mock.GetObjectByOIDFunc.SetDefaultReturn(&database.LFSObject{Size: 12}, nil)
return mock
mockStore: func() *MockStore {
mockStore := NewMockStore()
mockStore.GetLFSObjectByOIDFunc.SetDefaultReturn(&database.LFSObject{Size: 12}, nil)
return mockStore
},
expStatusCode: http.StatusOK,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.mockLFSStore != nil {
database.SetMockLFSStore(t, test.mockLFSStore())
if test.mockStore != nil {
basic.store = test.mockStore()
}
r, err := http.NewRequest("POST", "/", strings.NewReader(test.body))
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
rr := httptest.NewRecorder()
m.ServeHTTP(rr, r)
@ -280,9 +273,7 @@ func Test_basicHandler_serveVerify(t *testing.T) {
assert.Equal(t, test.expStatusCode, resp.StatusCode)
body, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
assert.Equal(t, test.expBody, string(body))
})
}

182
internal/route/lfs/batch.go
View File

@ -19,111 +19,113 @@ import (
)
// POST /{owner}/{repo}.git/info/lfs/object/batch
func serveBatch(c *macaron.Context, owner *database.User, repo *database.Repository) {
var request batchRequest
defer c.Req.Request.Body.Close()
err := jsoniter.NewDecoder(c.Req.Request.Body).Decode(&request)
if err != nil {
responseJSON(c.Resp, http.StatusBadRequest, responseError{
Message: strutil.ToUpperFirst(err.Error()),
})
return
}
// NOTE: We only support basic transfer as of now.
transfer := transferBasic
// Example: https://try.gogs.io/gogs/gogs.git/info/lfs/object/basic
baseHref := fmt.Sprintf("%s%s/%s.git/info/lfs/objects/basic", conf.Server.ExternalURL, owner.Name, repo.Name)
objects := make([]batchObject, 0, len(request.Objects))
switch request.Operation {
case basicOperationUpload:
for _, obj := range request.Objects {
var actions batchActions
if lfsutil.ValidOID(obj.Oid) {
actions = batchActions{
Upload: &batchAction{
Href: fmt.Sprintf("%s/%s", baseHref, obj.Oid),
Header: map[string]string{
// NOTE: git-lfs v2.5.0 sets the Content-Type based on the uploaded file.
// This ensures that the client always uses the designated value for the header.
"Content-Type": "application/octet-stream",
},
},
Verify: &batchAction{
Href: fmt.Sprintf("%s/verify", baseHref),
},
}
} else {
actions = batchActions{
Error: &batchError{
Code: http.StatusUnprocessableEntity,
Message: "Object has invalid oid",
},
}
}
objects = append(objects, batchObject{
Oid: obj.Oid,
Size: obj.Size,
Actions: actions,
})
}
case basicOperationDownload:
oids := make([]lfsutil.OID, 0, len(request.Objects))
for _, obj := range request.Objects {
oids = append(oids, obj.Oid)
}
stored, err := database.LFS.GetObjectsByOIDs(c.Req.Context(), repo.ID, oids...)
func serveBatch(store Store) macaron.Handler {
return func(c *macaron.Context, owner *database.User, repo *database.Repository) {
var request batchRequest
defer func() { _ = c.Req.Request.Body.Close() }()
err := jsoniter.NewDecoder(c.Req.Request.Body).Decode(&request)
if err != nil {
internalServerError(c.Resp)
log.Error("Failed to get objects [repo_id: %d, oids: %v]: %v", repo.ID, oids, err)
responseJSON(c.Resp, http.StatusBadRequest, responseError{
Message: strutil.ToUpperFirst(err.Error()),
})
return
}
storedSet := make(map[lfsutil.OID]*database.LFSObject, len(stored))
for _, obj := range stored {
storedSet[obj.OID] = obj
}
for _, obj := range request.Objects {
var actions batchActions
if stored := storedSet[obj.Oid]; stored != nil {
if stored.Size != obj.Size {
actions.Error = &batchError{
Code: http.StatusUnprocessableEntity,
Message: "Object size mismatch",
// NOTE: We only support basic transfer as of now.
transfer := transferBasic
// Example: https://try.gogs.io/gogs/gogs.git/info/lfs/object/basic
baseHref := fmt.Sprintf("%s%s/%s.git/info/lfs/objects/basic", conf.Server.ExternalURL, owner.Name, repo.Name)
objects := make([]batchObject, 0, len(request.Objects))
switch request.Operation {
case basicOperationUpload:
for _, obj := range request.Objects {
var actions batchActions
if lfsutil.ValidOID(obj.Oid) {
actions = batchActions{
Upload: &batchAction{
Href: fmt.Sprintf("%s/%s", baseHref, obj.Oid),
Header: map[string]string{
// NOTE: git-lfs v2.5.0 sets the Content-Type based on the uploaded file.
// This ensures that the client always uses the designated value for the header.
"Content-Type": "application/octet-stream",
},
},
Verify: &batchAction{
Href: fmt.Sprintf("%s/verify", baseHref),
},
}
} else {
actions.Download = &batchAction{
Href: fmt.Sprintf("%s/%s", baseHref, obj.Oid),
actions = batchActions{
Error: &batchError{
Code: http.StatusUnprocessableEntity,
Message: "Object has invalid oid",
},
}
}
} else {
actions.Error = &batchError{
Code: http.StatusNotFound,
Message: "Object does not exist",
}
objects = append(objects, batchObject{
Oid: obj.Oid,
Size: obj.Size,
Actions: actions,
})
}
objects = append(objects, batchObject{
Oid: obj.Oid,
Size: obj.Size,
Actions: actions,
case basicOperationDownload:
oids := make([]lfsutil.OID, 0, len(request.Objects))
for _, obj := range request.Objects {
oids = append(oids, obj.Oid)
}
stored, err := store.GetLFSObjectsByOIDs(c.Req.Context(), repo.ID, oids...)
if err != nil {
internalServerError(c.Resp)
log.Error("Failed to get objects [repo_id: %d, oids: %v]: %v", repo.ID, oids, err)
return
}
storedSet := make(map[lfsutil.OID]*database.LFSObject, len(stored))
for _, obj := range stored {
storedSet[obj.OID] = obj
}
for _, obj := range request.Objects {
var actions batchActions
if stored := storedSet[obj.Oid]; stored != nil {
if stored.Size != obj.Size {
actions.Error = &batchError{
Code: http.StatusUnprocessableEntity,
Message: "Object size mismatch",
}
} else {
actions.Download = &batchAction{
Href: fmt.Sprintf("%s/%s", baseHref, obj.Oid),
}
}
} else {
actions.Error = &batchError{
Code: http.StatusNotFound,
Message: "Object does not exist",
}
}
objects = append(objects, batchObject{
Oid: obj.Oid,
Size: obj.Size,
Actions: actions,
})
}
default:
responseJSON(c.Resp, http.StatusBadRequest, responseError{
Message: "Operation not recognized",
})
return
}
default:
responseJSON(c.Resp, http.StatusBadRequest, responseError{
Message: "Operation not recognized",
responseJSON(c.Resp, http.StatusOK, batchResponse{
Transfer: transfer,
Objects: objects,
})
return
}
responseJSON(c.Resp, http.StatusOK, batchResponse{
Transfer: transfer,
Objects: objects,
})
}
// batchRequest defines the request payload for the batch endpoint.

50
internal/route/lfs/batch_test.go
View File

@ -13,28 +13,22 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"gopkg.in/macaron.v1"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/database"
)
func Test_serveBatch(t *testing.T) {
func TestServeBatch(t *testing.T) {
conf.SetMockServer(t, conf.ServerOpts{
ExternalURL: "https://gogs.example.com/",
})
m := macaron.New()
m.Use(func(c *macaron.Context) {
c.Map(&database.User{Name: "owner"})
c.Map(&database.Repository{Name: "repo"})
})
m.Post("/", serveBatch)
tests := []struct {
name string
body string
mockLFSStore func() database.LFSStore
mockStore func() *MockStore
expStatusCode int
expBody string
}{
@ -82,9 +76,9 @@ func Test_serveBatch(t *testing.T) {
{"oid": "ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f", "size": 123},
{"oid": "5cac0a318669fadfee734fb340a5f5b70b428ac57a9f4b109cb6e150b2ba7e57", "size": 456}
]}`,
mockLFSStore: func() database.LFSStore {
mock := NewMockLFSStore()
mock.GetObjectsByOIDsFunc.SetDefaultReturn(
mockStore: func() *MockStore {
mockStore := NewMockStore()
mockStore.GetLFSObjectsByOIDsFunc.SetDefaultReturn(
[]*database.LFSObject{
{
OID: "ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f",
@ -96,7 +90,7 @@ func Test_serveBatch(t *testing.T) {
},
nil,
)
return mock
return mockStore
},
expStatusCode: http.StatusOK,
expBody: `{
@ -123,14 +117,20 @@ func Test_serveBatch(t *testing.T) {
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.mockLFSStore != nil {
database.SetMockLFSStore(t, test.mockLFSStore())
mockStore := NewMockStore()
if test.mockStore != nil {
mockStore = test.mockStore()
}
r, err := http.NewRequest("POST", "/", bytes.NewBufferString(test.body))
if err != nil {
t.Fatal(err)
}
m := macaron.New()
m.Use(func(c *macaron.Context) {
c.Map(&database.User{Name: "owner"})
c.Map(&database.Repository{Name: "repo"})
})
m.Post("/", serveBatch(mockStore))
r, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(test.body))
require.NoError(t, err)
rr := httptest.NewRecorder()
m.ServeHTTP(rr, r)
@ -139,21 +139,15 @@ func Test_serveBatch(t *testing.T) {
assert.Equal(t, test.expStatusCode, resp.StatusCode)
body, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
var expBody bytes.Buffer
err = json.Indent(&expBody, []byte(test.expBody), "", " ")
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
var gotBody bytes.Buffer
err = json.Indent(&gotBody, body, "", " ")
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
assert.Equal(t, expBody.String(), gotBody.String())
})

808
internal/route/lfs/mocks_test.go
View File

@ -14,423 +14,6 @@ import (
lfsutil "gogs.io/gogs/internal/lfsutil"
)
// MockLFSStore is a mock implementation of the LFSStore interface (from the
// package gogs.io/gogs/internal/database) used for unit testing.
type MockLFSStore struct {
// CreateObjectFunc is an instance of a mock function object controlling
// the behavior of the method CreateObject.
CreateObjectFunc *LFSStoreCreateObjectFunc
// GetObjectByOIDFunc is an instance of a mock function object
// controlling the behavior of the method GetObjectByOID.
GetObjectByOIDFunc *LFSStoreGetObjectByOIDFunc
// GetObjectsByOIDsFunc is an instance of a mock function object
// controlling the behavior of the method GetObjectsByOIDs.
GetObjectsByOIDsFunc *LFSStoreGetObjectsByOIDsFunc
}
// NewMockLFSStore creates a new mock of the LFSStore interface. All methods
// return zero values for all results, unless overwritten.
func NewMockLFSStore() *MockLFSStore {
return &MockLFSStore{
CreateObjectFunc: &LFSStoreCreateObjectFunc{
defaultHook: func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) (r0 error) {
return
},
},
GetObjectByOIDFunc: &LFSStoreGetObjectByOIDFunc{
defaultHook: func(context.Context, int64, lfsutil.OID) (r0 *database.LFSObject, r1 error) {
return
},
},
GetObjectsByOIDsFunc: &LFSStoreGetObjectsByOIDsFunc{
defaultHook: func(context.Context, int64, ...lfsutil.OID) (r0 []*database.LFSObject, r1 error) {
return
},
},
}
}
// NewStrictMockLFSStore creates a new mock of the LFSStore interface. All
// methods panic on invocation, unless overwritten.
func NewStrictMockLFSStore() *MockLFSStore {
return &MockLFSStore{
CreateObjectFunc: &LFSStoreCreateObjectFunc{
defaultHook: func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
panic("unexpected invocation of MockLFSStore.CreateObject")
},
},
GetObjectByOIDFunc: &LFSStoreGetObjectByOIDFunc{
defaultHook: func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error) {
panic("unexpected invocation of MockLFSStore.GetObjectByOID")
},
},
GetObjectsByOIDsFunc: &LFSStoreGetObjectsByOIDsFunc{
defaultHook: func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error) {
panic("unexpected invocation of MockLFSStore.GetObjectsByOIDs")
},
},
}
}
// NewMockLFSStoreFrom creates a new mock of the MockLFSStore interface. All
// methods delegate to the given implementation, unless overwritten.
func NewMockLFSStoreFrom(i database.LFSStore) *MockLFSStore {
return &MockLFSStore{
CreateObjectFunc: &LFSStoreCreateObjectFunc{
defaultHook: i.CreateObject,
},
GetObjectByOIDFunc: &LFSStoreGetObjectByOIDFunc{
defaultHook: i.GetObjectByOID,
},
GetObjectsByOIDsFunc: &LFSStoreGetObjectsByOIDsFunc{
defaultHook: i.GetObjectsByOIDs,
},
}
}
// LFSStoreCreateObjectFunc describes the behavior when the CreateObject
// method of the parent MockLFSStore instance is invoked.
type LFSStoreCreateObjectFunc struct {
defaultHook func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error
hooks []func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error
history []LFSStoreCreateObjectFuncCall
mutex sync.Mutex
}
// CreateObject delegates to the next hook function in the queue and stores
// the parameter and result values of this invocation.
func (m *MockLFSStore) CreateObject(v0 context.Context, v1 int64, v2 lfsutil.OID, v3 int64, v4 lfsutil.Storage) error {
r0 := m.CreateObjectFunc.nextHook()(v0, v1, v2, v3, v4)
m.CreateObjectFunc.appendCall(LFSStoreCreateObjectFuncCall{v0, v1, v2, v3, v4, r0})
return r0
}
// SetDefaultHook sets function that is called when the CreateObject method
// of the parent MockLFSStore instance is invoked and the hook queue is
// empty.
func (f *LFSStoreCreateObjectFunc) SetDefaultHook(hook func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error) {
f.defaultHook = hook
}
// PushHook adds a function to the end of hook queue. Each invocation of the
// CreateObject method of the parent MockLFSStore instance invokes the hook
// at the front of the queue and discards it. After the queue is empty, the
// default hook function is invoked for any future action.
func (f *LFSStoreCreateObjectFunc) PushHook(hook func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error) {
f.mutex.Lock()
f.hooks = append(f.hooks, hook)
f.mutex.Unlock()
}
// SetDefaultReturn calls SetDefaultHook with a function that returns the
// given values.
func (f *LFSStoreCreateObjectFunc) SetDefaultReturn(r0 error) {
f.SetDefaultHook(func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
return r0
})
}
// PushReturn calls PushHook with a function that returns the given values.
func (f *LFSStoreCreateObjectFunc) PushReturn(r0 error) {
f.PushHook(func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
return r0
})
}
func (f *LFSStoreCreateObjectFunc) nextHook() func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
f.mutex.Lock()
defer f.mutex.Unlock()
if len(f.hooks) == 0 {
return f.defaultHook
}
hook := f.hooks[0]
f.hooks = f.hooks[1:]
return hook
}
func (f *LFSStoreCreateObjectFunc) appendCall(r0 LFSStoreCreateObjectFuncCall) {
f.mutex.Lock()
f.history = append(f.history, r0)
f.mutex.Unlock()
}
// History returns a sequence of LFSStoreCreateObjectFuncCall objects
// describing the invocations of this function.
func (f *LFSStoreCreateObjectFunc) History() []LFSStoreCreateObjectFuncCall {
f.mutex.Lock()
history := make([]LFSStoreCreateObjectFuncCall, len(f.history))
copy(history, f.history)
f.mutex.Unlock()
return history
}
// LFSStoreCreateObjectFuncCall is an object that describes an invocation of
// method CreateObject on an instance of MockLFSStore.
type LFSStoreCreateObjectFuncCall struct {
// Arg0 is the value of the 1st argument passed to this method
// invocation.
Arg0 context.Context
// Arg1 is the value of the 2nd argument passed to this method
// invocation.
Arg1 int64
// Arg2 is the value of the 3rd argument passed to this method
// invocation.
Arg2 lfsutil.OID
// Arg3 is the value of the 4th argument passed to this method
// invocation.
Arg3 int64
// Arg4 is the value of the 5th argument passed to this method
// invocation.
Arg4 lfsutil.Storage
// Result0 is the value of the 1st result returned from this method
// invocation.
Result0 error
}
// Args returns an interface slice containing the arguments of this
// invocation.
func (c LFSStoreCreateObjectFuncCall) Args() []interface{} {
return []interface{}{c.Arg0, c.Arg1, c.Arg2, c.Arg3, c.Arg4}
}
// Results returns an interface slice containing the results of this
// invocation.
func (c LFSStoreCreateObjectFuncCall) Results() []interface{} {
return []interface{}{c.Result0}
}
// LFSStoreGetObjectByOIDFunc describes the behavior when the GetObjectByOID
// method of the parent MockLFSStore instance is invoked.
type LFSStoreGetObjectByOIDFunc struct {
defaultHook func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error)
hooks []func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error)
history []LFSStoreGetObjectByOIDFuncCall
mutex sync.Mutex
}
// GetObjectByOID delegates to the next hook function in the queue and
// stores the parameter and result values of this invocation.
func (m *MockLFSStore) GetObjectByOID(v0 context.Context, v1 int64, v2 lfsutil.OID) (*database.LFSObject, error) {
r0, r1 := m.GetObjectByOIDFunc.nextHook()(v0, v1, v2)
m.GetObjectByOIDFunc.appendCall(LFSStoreGetObjectByOIDFuncCall{v0, v1, v2, r0, r1})
return r0, r1
}
// SetDefaultHook sets function that is called when the GetObjectByOID
// method of the parent MockLFSStore instance is invoked and the hook queue
// is empty.
func (f *LFSStoreGetObjectByOIDFunc) SetDefaultHook(hook func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error)) {
f.defaultHook = hook
}
// PushHook adds a function to the end of hook queue. Each invocation of the
// GetObjectByOID method of the parent MockLFSStore instance invokes the
// hook at the front of the queue and discards it. After the queue is empty,
// the default hook function is invoked for any future action.
func (f *LFSStoreGetObjectByOIDFunc) PushHook(hook func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error)) {
f.mutex.Lock()
f.hooks = append(f.hooks, hook)
f.mutex.Unlock()
}
// SetDefaultReturn calls SetDefaultHook with a function that returns the
// given values.
func (f *LFSStoreGetObjectByOIDFunc) SetDefaultReturn(r0 *database.LFSObject, r1 error) {
f.SetDefaultHook(func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error) {
return r0, r1
})
}
// PushReturn calls PushHook with a function that returns the given values.
func (f *LFSStoreGetObjectByOIDFunc) PushReturn(r0 *database.LFSObject, r1 error) {
f.PushHook(func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error) {
return r0, r1
})
}
func (f *LFSStoreGetObjectByOIDFunc) nextHook() func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error) {
f.mutex.Lock()
defer f.mutex.Unlock()
if len(f.hooks) == 0 {
return f.defaultHook
}
hook := f.hooks[0]
f.hooks = f.hooks[1:]
return hook
}
func (f *LFSStoreGetObjectByOIDFunc) appendCall(r0 LFSStoreGetObjectByOIDFuncCall) {
f.mutex.Lock()
f.history = append(f.history, r0)
f.mutex.Unlock()
}
// History returns a sequence of LFSStoreGetObjectByOIDFuncCall objects
// describing the invocations of this function.
func (f *LFSStoreGetObjectByOIDFunc) History() []LFSStoreGetObjectByOIDFuncCall {
f.mutex.Lock()
history := make([]LFSStoreGetObjectByOIDFuncCall, len(f.history))
copy(history, f.history)
f.mutex.Unlock()
return history
}
// LFSStoreGetObjectByOIDFuncCall is an object that describes an invocation
// of method GetObjectByOID on an instance of MockLFSStore.
type LFSStoreGetObjectByOIDFuncCall struct {
// Arg0 is the value of the 1st argument passed to this method
// invocation.
Arg0 context.Context
// Arg1 is the value of the 2nd argument passed to this method
// invocation.
Arg1 int64
// Arg2 is the value of the 3rd argument passed to this method
// invocation.
Arg2 lfsutil.OID
// Result0 is the value of the 1st result returned from this method
// invocation.
Result0 *database.LFSObject
// Result1 is the value of the 2nd result returned from this method
// invocation.
Result1 error
}
// Args returns an interface slice containing the arguments of this
// invocation.
func (c LFSStoreGetObjectByOIDFuncCall) Args() []interface{} {
return []interface{}{c.Arg0, c.Arg1, c.Arg2}
}
// Results returns an interface slice containing the results of this
// invocation.
func (c LFSStoreGetObjectByOIDFuncCall) Results() []interface{} {
return []interface{}{c.Result0, c.Result1}
}
// LFSStoreGetObjectsByOIDsFunc describes the behavior when the
// GetObjectsByOIDs method of the parent MockLFSStore instance is invoked.
type LFSStoreGetObjectsByOIDsFunc struct {
defaultHook func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error)
hooks []func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error)
history []LFSStoreGetObjectsByOIDsFuncCall
mutex sync.Mutex
}
// GetObjectsByOIDs delegates to the next hook function in the queue and
// stores the parameter and result values of this invocation.
func (m *MockLFSStore) GetObjectsByOIDs(v0 context.Context, v1 int64, v2 ...lfsutil.OID) ([]*database.LFSObject, error) {
r0, r1 := m.GetObjectsByOIDsFunc.nextHook()(v0, v1, v2...)
m.GetObjectsByOIDsFunc.appendCall(LFSStoreGetObjectsByOIDsFuncCall{v0, v1, v2, r0, r1})
return r0, r1
}
// SetDefaultHook sets function that is called when the GetObjectsByOIDs
// method of the parent MockLFSStore instance is invoked and the hook queue
// is empty.
func (f *LFSStoreGetObjectsByOIDsFunc) SetDefaultHook(hook func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error)) {
f.defaultHook = hook
}
// PushHook adds a function to the end of hook queue. Each invocation of the
// GetObjectsByOIDs method of the parent MockLFSStore instance invokes the
// hook at the front of the queue and discards it. After the queue is empty,
// the default hook function is invoked for any future action.
func (f *LFSStoreGetObjectsByOIDsFunc) PushHook(hook func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error)) {
f.mutex.Lock()
f.hooks = append(f.hooks, hook)
f.mutex.Unlock()
}
// SetDefaultReturn calls SetDefaultHook with a function that returns the
// given values.
func (f *LFSStoreGetObjectsByOIDsFunc) SetDefaultReturn(r0 []*database.LFSObject, r1 error) {
f.SetDefaultHook(func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error) {
return r0, r1
})
}
// PushReturn calls PushHook with a function that returns the given values.
func (f *LFSStoreGetObjectsByOIDsFunc) PushReturn(r0 []*database.LFSObject, r1 error) {
f.PushHook(func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error) {
return r0, r1
})
}
func (f *LFSStoreGetObjectsByOIDsFunc) nextHook() func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error) {
f.mutex.Lock()
defer f.mutex.Unlock()
if len(f.hooks) == 0 {
return f.defaultHook
}
hook := f.hooks[0]
f.hooks = f.hooks[1:]
return hook
}
func (f *LFSStoreGetObjectsByOIDsFunc) appendCall(r0 LFSStoreGetObjectsByOIDsFuncCall) {
f.mutex.Lock()
f.history = append(f.history, r0)
f.mutex.Unlock()
}
// History returns a sequence of LFSStoreGetObjectsByOIDsFuncCall objects
// describing the invocations of this function.
func (f *LFSStoreGetObjectsByOIDsFunc) History() []LFSStoreGetObjectsByOIDsFuncCall {
f.mutex.Lock()
history := make([]LFSStoreGetObjectsByOIDsFuncCall, len(f.history))
copy(history, f.history)
f.mutex.Unlock()
return history
}
// LFSStoreGetObjectsByOIDsFuncCall is an object that describes an
// invocation of method GetObjectsByOIDs on an instance of MockLFSStore.
type LFSStoreGetObjectsByOIDsFuncCall struct {
// Arg0 is the value of the 1st argument passed to this method
// invocation.
Arg0 context.Context
// Arg1 is the value of the 2nd argument passed to this method
// invocation.
Arg1 int64
// Arg2 is a slice containing the values of the variadic arguments
// passed to this method invocation.
Arg2 []lfsutil.OID
// Result0 is the value of the 1st result returned from this method
// invocation.
Result0 []*database.LFSObject
// Result1 is the value of the 2nd result returned from this method
// invocation.
Result1 error
}
// Args returns an interface slice containing the arguments of this
// invocation. The variadic slice argument is flattened in this array such
// that one positional argument and three variadic arguments would result in
// a slice of four, not two.
func (c LFSStoreGetObjectsByOIDsFuncCall) Args() []interface{} {
trailing := []interface{}{}
for _, val := range c.Arg2 {
trailing = append(trailing, val)
}
return append([]interface{}{c.Arg0, c.Arg1}, trailing...)
}
// Results returns an interface slice containing the results of this
// invocation.
func (c LFSStoreGetObjectsByOIDsFuncCall) Results() []interface{} {
return []interface{}{c.Result0, c.Result1}
}
// MockPermsStore is a mock implementation of the PermsStore interface (from
// the package gogs.io/gogs/internal/database) used for unit testing.
type MockPermsStore struct {
@ -6051,9 +5634,18 @@ func (c UsersStoreUseCustomAvatarFuncCall) Results() []interface{} {
// MockStore is a mock implementation of the Store interface (from the
// package gogs.io/gogs/internal/route/lfs) used for unit testing.
type MockStore struct {
// CreateLFSObjectFunc is an instance of a mock function object
// controlling the behavior of the method CreateLFSObject.
CreateLFSObjectFunc *StoreCreateLFSObjectFunc
// GetAccessTokenBySHA1Func is an instance of a mock function object
// controlling the behavior of the method GetAccessTokenBySHA1.
GetAccessTokenBySHA1Func *StoreGetAccessTokenBySHA1Func
// GetLFSObjectByOIDFunc is an instance of a mock function object
// controlling the behavior of the method GetLFSObjectByOID.
GetLFSObjectByOIDFunc *StoreGetLFSObjectByOIDFunc
// GetLFSObjectsByOIDsFunc is an instance of a mock function object
// controlling the behavior of the method GetLFSObjectsByOIDs.
GetLFSObjectsByOIDsFunc *StoreGetLFSObjectsByOIDsFunc
// TouchAccessTokenByIDFunc is an instance of a mock function object
// controlling the behavior of the method TouchAccessTokenByID.
TouchAccessTokenByIDFunc *StoreTouchAccessTokenByIDFunc
@ -6063,11 +5655,26 @@ type MockStore struct {
// return zero values for all results, unless overwritten.
func NewMockStore() *MockStore {
return &MockStore{
CreateLFSObjectFunc: &StoreCreateLFSObjectFunc{
defaultHook: func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) (r0 error) {
return
},
},
GetAccessTokenBySHA1Func: &StoreGetAccessTokenBySHA1Func{
defaultHook: func(context.Context, string) (r0 *database.AccessToken, r1 error) {
return
},
},
GetLFSObjectByOIDFunc: &StoreGetLFSObjectByOIDFunc{
defaultHook: func(context.Context, int64, lfsutil.OID) (r0 *database.LFSObject, r1 error) {
return
},
},
GetLFSObjectsByOIDsFunc: &StoreGetLFSObjectsByOIDsFunc{
defaultHook: func(context.Context, int64, ...lfsutil.OID) (r0 []*database.LFSObject, r1 error) {
return
},
},
TouchAccessTokenByIDFunc: &StoreTouchAccessTokenByIDFunc{
defaultHook: func(context.Context, int64) (r0 error) {
return
@ -6080,11 +5687,26 @@ func NewMockStore() *MockStore {
// panic on invocation, unless overwritten.
func NewStrictMockStore() *MockStore {
return &MockStore{
CreateLFSObjectFunc: &StoreCreateLFSObjectFunc{
defaultHook: func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
panic("unexpected invocation of MockStore.CreateLFSObject")
},
},
GetAccessTokenBySHA1Func: &StoreGetAccessTokenBySHA1Func{
defaultHook: func(context.Context, string) (*database.AccessToken, error) {
panic("unexpected invocation of MockStore.GetAccessTokenBySHA1")
},
},
GetLFSObjectByOIDFunc: &StoreGetLFSObjectByOIDFunc{
defaultHook: func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error) {
panic("unexpected invocation of MockStore.GetLFSObjectByOID")
},
},
GetLFSObjectsByOIDsFunc: &StoreGetLFSObjectsByOIDsFunc{
defaultHook: func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error) {
panic("unexpected invocation of MockStore.GetLFSObjectsByOIDs")
},
},
TouchAccessTokenByIDFunc: &StoreTouchAccessTokenByIDFunc{
defaultHook: func(context.Context, int64) error {
panic("unexpected invocation of MockStore.TouchAccessTokenByID")
@ -6097,15 +5719,138 @@ func NewStrictMockStore() *MockStore {
// methods delegate to the given implementation, unless overwritten.
func NewMockStoreFrom(i Store) *MockStore {
return &MockStore{
CreateLFSObjectFunc: &StoreCreateLFSObjectFunc{
defaultHook: i.CreateLFSObject,
},
GetAccessTokenBySHA1Func: &StoreGetAccessTokenBySHA1Func{
defaultHook: i.GetAccessTokenBySHA1,
},
GetLFSObjectByOIDFunc: &StoreGetLFSObjectByOIDFunc{
defaultHook: i.GetLFSObjectByOID,
},
GetLFSObjectsByOIDsFunc: &StoreGetLFSObjectsByOIDsFunc{
defaultHook: i.GetLFSObjectsByOIDs,
},
TouchAccessTokenByIDFunc: &StoreTouchAccessTokenByIDFunc{
defaultHook: i.TouchAccessTokenByID,
},
}
}
// StoreCreateLFSObjectFunc describes the behavior when the CreateLFSObject
// method of the parent MockStore instance is invoked.
type StoreCreateLFSObjectFunc struct {
defaultHook func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error
hooks []func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error
history []StoreCreateLFSObjectFuncCall
mutex sync.Mutex
}
// CreateLFSObject delegates to the next hook function in the queue and
// stores the parameter and result values of this invocation.
func (m *MockStore) CreateLFSObject(v0 context.Context, v1 int64, v2 lfsutil.OID, v3 int64, v4 lfsutil.Storage) error {
r0 := m.CreateLFSObjectFunc.nextHook()(v0, v1, v2, v3, v4)
m.CreateLFSObjectFunc.appendCall(StoreCreateLFSObjectFuncCall{v0, v1, v2, v3, v4, r0})
return r0
}
// SetDefaultHook sets function that is called when the CreateLFSObject
// method of the parent MockStore instance is invoked and the hook queue is
// empty.
func (f *StoreCreateLFSObjectFunc) SetDefaultHook(hook func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error) {
f.defaultHook = hook
}
// PushHook adds a function to the end of hook queue. Each invocation of the
// CreateLFSObject method of the parent MockStore instance invokes the hook
// at the front of the queue and discards it. After the queue is empty, the
// default hook function is invoked for any future action.
func (f *StoreCreateLFSObjectFunc) PushHook(hook func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error) {
f.mutex.Lock()
f.hooks = append(f.hooks, hook)
f.mutex.Unlock()
}
// SetDefaultReturn calls SetDefaultHook with a function that returns the
// given values.
func (f *StoreCreateLFSObjectFunc) SetDefaultReturn(r0 error) {
f.SetDefaultHook(func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
return r0
})
}
// PushReturn calls PushHook with a function that returns the given values.
func (f *StoreCreateLFSObjectFunc) PushReturn(r0 error) {
f.PushHook(func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
return r0
})
}
func (f *StoreCreateLFSObjectFunc) nextHook() func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
f.mutex.Lock()
defer f.mutex.Unlock()
if len(f.hooks) == 0 {
return f.defaultHook
}
hook := f.hooks[0]
f.hooks = f.hooks[1:]
return hook
}
func (f *StoreCreateLFSObjectFunc) appendCall(r0 StoreCreateLFSObjectFuncCall) {
f.mutex.Lock()
f.history = append(f.history, r0)
f.mutex.Unlock()
}
// History returns a sequence of StoreCreateLFSObjectFuncCall objects
// describing the invocations of this function.
func (f *StoreCreateLFSObjectFunc) History() []StoreCreateLFSObjectFuncCall {
f.mutex.Lock()
history := make([]StoreCreateLFSObjectFuncCall, len(f.history))
copy(history, f.history)
f.mutex.Unlock()
return history
}
// StoreCreateLFSObjectFuncCall is an object that describes an invocation of
// method CreateLFSObject on an instance of MockStore.
type StoreCreateLFSObjectFuncCall struct {
// Arg0 is the value of the 1st argument passed to this method
// invocation.
Arg0 context.Context
// Arg1 is the value of the 2nd argument passed to this method
// invocation.
Arg1 int64
// Arg2 is the value of the 3rd argument passed to this method
// invocation.
Arg2 lfsutil.OID
// Arg3 is the value of the 4th argument passed to this method
// invocation.
Arg3 int64
// Arg4 is the value of the 5th argument passed to this method
// invocation.
Arg4 lfsutil.Storage
// Result0 is the value of the 1st result returned from this method
// invocation.
Result0 error
}
// Args returns an interface slice containing the arguments of this
// invocation.
func (c StoreCreateLFSObjectFuncCall) Args() []interface{} {
return []interface{}{c.Arg0, c.Arg1, c.Arg2, c.Arg3, c.Arg4}
}
// Results returns an interface slice containing the results of this
// invocation.
func (c StoreCreateLFSObjectFuncCall) Results() []interface{} {
return []interface{}{c.Result0}
}
// StoreGetAccessTokenBySHA1Func describes the behavior when the
// GetAccessTokenBySHA1 method of the parent MockStore instance is invoked.
type StoreGetAccessTokenBySHA1Func struct {
@ -6214,6 +5959,235 @@ func (c StoreGetAccessTokenBySHA1FuncCall) Results() []interface{} {
return []interface{}{c.Result0, c.Result1}
}
// StoreGetLFSObjectByOIDFunc describes the behavior when the
// GetLFSObjectByOID method of the parent MockStore instance is invoked.
type StoreGetLFSObjectByOIDFunc struct {
defaultHook func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error)
hooks []func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error)
history []StoreGetLFSObjectByOIDFuncCall
mutex sync.Mutex
}
// GetLFSObjectByOID delegates to the next hook function in the queue and
// stores the parameter and result values of this invocation.
func (m *MockStore) GetLFSObjectByOID(v0 context.Context, v1 int64, v2 lfsutil.OID) (*database.LFSObject, error) {
r0, r1 := m.GetLFSObjectByOIDFunc.nextHook()(v0, v1, v2)
m.GetLFSObjectByOIDFunc.appendCall(StoreGetLFSObjectByOIDFuncCall{v0, v1, v2, r0, r1})
return r0, r1
}
// SetDefaultHook sets function that is called when the GetLFSObjectByOID
// method of the parent MockStore instance is invoked and the hook queue is
// empty.
func (f *StoreGetLFSObjectByOIDFunc) SetDefaultHook(hook func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error)) {
f.defaultHook = hook
}
// PushHook adds a function to the end of hook queue. Each invocation of the
// GetLFSObjectByOID method of the parent MockStore instance invokes the
// hook at the front of the queue and discards it. After the queue is empty,
// the default hook function is invoked for any future action.
func (f *StoreGetLFSObjectByOIDFunc) PushHook(hook func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error)) {
f.mutex.Lock()
f.hooks = append(f.hooks, hook)
f.mutex.Unlock()
}
// SetDefaultReturn calls SetDefaultHook with a function that returns the
// given values.
func (f *StoreGetLFSObjectByOIDFunc) SetDefaultReturn(r0 *database.LFSObject, r1 error) {
f.SetDefaultHook(func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error) {
return r0, r1
})
}
// PushReturn calls PushHook with a function that returns the given values.
func (f *StoreGetLFSObjectByOIDFunc) PushReturn(r0 *database.LFSObject, r1 error) {
f.PushHook(func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error) {
return r0, r1
})
}
func (f *StoreGetLFSObjectByOIDFunc) nextHook() func(context.Context, int64, lfsutil.OID) (*database.LFSObject, error) {
f.mutex.Lock()
defer f.mutex.Unlock()
if len(f.hooks) == 0 {
return f.defaultHook
}
hook := f.hooks[0]
f.hooks = f.hooks[1:]
return hook
}
func (f *StoreGetLFSObjectByOIDFunc) appendCall(r0 StoreGetLFSObjectByOIDFuncCall) {
f.mutex.Lock()
f.history = append(f.history, r0)
f.mutex.Unlock()
}
// History returns a sequence of StoreGetLFSObjectByOIDFuncCall objects
// describing the invocations of this function.
func (f *StoreGetLFSObjectByOIDFunc) History() []StoreGetLFSObjectByOIDFuncCall {
f.mutex.Lock()
history := make([]StoreGetLFSObjectByOIDFuncCall, len(f.history))
copy(history, f.history)
f.mutex.Unlock()
return history
}
// StoreGetLFSObjectByOIDFuncCall is an object that describes an invocation
// of method GetLFSObjectByOID on an instance of MockStore.
type StoreGetLFSObjectByOIDFuncCall struct {
// Arg0 is the value of the 1st argument passed to this method
// invocation.
Arg0 context.Context
// Arg1 is the value of the 2nd argument passed to this method
// invocation.
Arg1 int64
// Arg2 is the value of the 3rd argument passed to this method
// invocation.
Arg2 lfsutil.OID
// Result0 is the value of the 1st result returned from this method
// invocation.
Result0 *database.LFSObject
// Result1 is the value of the 2nd result returned from this method
// invocation.
Result1 error
}
// Args returns an interface slice containing the arguments of this
// invocation.
func (c StoreGetLFSObjectByOIDFuncCall) Args() []interface{} {
return []interface{}{c.Arg0, c.Arg1, c.Arg2}
}
// Results returns an interface slice containing the results of this
// invocation.
func (c StoreGetLFSObjectByOIDFuncCall) Results() []interface{} {
return []interface{}{c.Result0, c.Result1}
}
// StoreGetLFSObjectsByOIDsFunc describes the behavior when the
// GetLFSObjectsByOIDs method of the parent MockStore instance is invoked.
type StoreGetLFSObjectsByOIDsFunc struct {
defaultHook func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error)
hooks []func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error)
history []StoreGetLFSObjectsByOIDsFuncCall
mutex sync.Mutex
}
// GetLFSObjectsByOIDs delegates to the next hook function in the queue and
// stores the parameter and result values of this invocation.
func (m *MockStore) GetLFSObjectsByOIDs(v0 context.Context, v1 int64, v2 ...lfsutil.OID) ([]*database.LFSObject, error) {
r0, r1 := m.GetLFSObjectsByOIDsFunc.nextHook()(v0, v1, v2...)
m.GetLFSObjectsByOIDsFunc.appendCall(StoreGetLFSObjectsByOIDsFuncCall{v0, v1, v2, r0, r1})
return r0, r1
}
// SetDefaultHook sets function that is called when the GetLFSObjectsByOIDs
// method of the parent MockStore instance is invoked and the hook queue is
// empty.
func (f *StoreGetLFSObjectsByOIDsFunc) SetDefaultHook(hook func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error)) {
f.defaultHook = hook
}
// PushHook adds a function to the end of hook queue. Each invocation of the
// GetLFSObjectsByOIDs method of the parent MockStore instance invokes the
// hook at the front of the queue and discards it. After the queue is empty,
// the default hook function is invoked for any future action.
func (f *StoreGetLFSObjectsByOIDsFunc) PushHook(hook func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error)) {
f.mutex.Lock()
f.hooks = append(f.hooks, hook)
f.mutex.Unlock()
}
// SetDefaultReturn calls SetDefaultHook with a function that returns the
// given values.
func (f *StoreGetLFSObjectsByOIDsFunc) SetDefaultReturn(r0 []*database.LFSObject, r1 error) {
f.SetDefaultHook(func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error) {
return r0, r1
})
}
// PushReturn calls PushHook with a function that returns the given values.
func (f *StoreGetLFSObjectsByOIDsFunc) PushReturn(r0 []*database.LFSObject, r1 error) {
f.PushHook(func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error) {
return r0, r1
})
}
func (f *StoreGetLFSObjectsByOIDsFunc) nextHook() func(context.Context, int64, ...lfsutil.OID) ([]*database.LFSObject, error) {
f.mutex.Lock()
defer f.mutex.Unlock()
if len(f.hooks) == 0 {
return f.defaultHook
}
hook := f.hooks[0]
f.hooks = f.hooks[1:]
return hook
}
func (f *StoreGetLFSObjectsByOIDsFunc) appendCall(r0 StoreGetLFSObjectsByOIDsFuncCall) {
f.mutex.Lock()
f.history = append(f.history, r0)
f.mutex.Unlock()
}
// History returns a sequence of StoreGetLFSObjectsByOIDsFuncCall objects
// describing the invocations of this function.
func (f *StoreGetLFSObjectsByOIDsFunc) History() []StoreGetLFSObjectsByOIDsFuncCall {
f.mutex.Lock()
history := make([]StoreGetLFSObjectsByOIDsFuncCall, len(f.history))
copy(history, f.history)
f.mutex.Unlock()
return history
}
// StoreGetLFSObjectsByOIDsFuncCall is an object that describes an
// invocation of method GetLFSObjectsByOIDs on an instance of MockStore.
type StoreGetLFSObjectsByOIDsFuncCall struct {
// Arg0 is the value of the 1st argument passed to this method
// invocation.
Arg0 context.Context
// Arg1 is the value of the 2nd argument passed to this method
// invocation.
Arg1 int64
// Arg2 is a slice containing the values of the variadic arguments
// passed to this method invocation.
Arg2 []lfsutil.OID
// Result0 is the value of the 1st result returned from this method
// invocation.
Result0 []*database.LFSObject
// Result1 is the value of the 2nd result returned from this method
// invocation.
Result1 error
}
// Args returns an interface slice containing the arguments of this
// invocation. The variadic slice argument is flattened in this array such
// that one positional argument and three variadic arguments would result in
// a slice of four, not two.
func (c StoreGetLFSObjectsByOIDsFuncCall) Args() []interface{} {
trailing := []interface{}{}
for _, val := range c.Arg2 {
trailing = append(trailing, val)
}
return append([]interface{}{c.Arg0, c.Arg1}, trailing...)
}
// Results returns an interface slice containing the results of this
// invocation.
func (c StoreGetLFSObjectsByOIDsFuncCall) Results() []interface{} {
return []interface{}{c.Result0, c.Result1}
}
// StoreTouchAccessTokenByIDFunc describes the behavior when the
// TouchAccessTokenByID method of the parent MockStore instance is invoked.
type StoreTouchAccessTokenByIDFunc struct {

3
internal/route/lfs/route.go
View File

@ -28,9 +28,10 @@ func RegisterRoutes(r *macaron.Router) {
store := NewStore()
r.Group("", func() {
r.Post("/objects/batch", authorize(database.AccessModeRead), verifyAccept, verifyContentTypeJSON, serveBatch)
r.Post("/objects/batch", authorize(database.AccessModeRead), verifyAccept, verifyContentTypeJSON, serveBatch(store))
r.Group("/objects/basic", func() {
basic := &basicHandler{
store: store,
defaultStorage: lfsutil.Storage(conf.LFS.Storage),
storagers: map[lfsutil.Storage]lfsutil.Storager{
lfsutil.StorageLocal: &lfsutil.LocalStorage{Root: conf.LFS.ObjectsPath},

22
internal/route/lfs/store.go
View File

@ -4,6 +4,7 @@ import (
"context"
"gogs.io/gogs/internal/database"
"gogs.io/gogs/internal/lfsutil"
)
// Store is the data layer carrier for LFS endpoints. This interface is meant to
@ -16,6 +17,15 @@ type Store interface {
// TouchAccessTokenByID updates the updated time of the given access token to
// the current time.
TouchAccessTokenByID(ctx context.Context, id int64) error
// CreateLFSObject creates an LFS object record in database.
CreateLFSObject(ctx context.Context, repoID int64, oid lfsutil.OID, size int64, storage lfsutil.Storage) error
// GetLFSObjectByOID returns the LFS object with given OID. It returns
// database.ErrLFSObjectNotExist when not found.
GetLFSObjectByOID(ctx context.Context, repoID int64, oid lfsutil.OID) (*database.LFSObject, error)
// GetLFSObjectsByOIDs returns LFS objects found within "oids". The returned
// list could have fewer elements if some oids were not found.
GetLFSObjectsByOIDs(ctx context.Context, repoID int64, oids ...lfsutil.OID) ([]*database.LFSObject, error)
}
type store struct{}
@ -32,3 +42,15 @@ func (*store) GetAccessTokenBySHA1(ctx context.Context, sha1 string) (*database.
func (*store) TouchAccessTokenByID(ctx context.Context, id int64) error {
return database.Handle.AccessTokens().Touch(ctx, id)
}
func (*store) CreateLFSObject(ctx context.Context, repoID int64, oid lfsutil.OID, size int64, storage lfsutil.Storage) error {
return database.Handle.LFS().CreateObject(ctx, repoID, oid, size, storage)
}
func (*store) GetLFSObjectByOID(ctx context.Context, repoID int64, oid lfsutil.OID) (*database.LFSObject, error) {
return database.Handle.LFS().GetObjectByOID(ctx, repoID, oid)
}
func (*store) GetLFSObjectsByOIDs(ctx context.Context, repoID int64, oids ...lfsutil.OID) ([]*database.LFSObject, error) {
return database.Handle.LFS().GetObjectsByOIDs(ctx, repoID, oids...)
}

1
mockgen.yaml
View File

@ -36,7 +36,6 @@ mocks:
sources:
- path: gogs.io/gogs/internal/database
interfaces:
- LFSStore
- UsersStore
- TwoFactorsStore
- ReposStore