2020-04-04 23:20:50 -07:00
|
|
|
// Copyright 2020 The Gitea Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a MIT-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
2016-12-25 18:16:37 -07:00
|
|
|
package models
|
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
2017-12-10 21:37:04 -07:00
|
|
|
|
2021-09-19 04:49:59 -07:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2021-04-08 15:25:57 -07:00
|
|
|
"code.gitea.io/gitea/modules/lfs"
|
2019-08-15 07:46:21 -07:00
|
|
|
"code.gitea.io/gitea/modules/timeutil"
|
2019-10-28 11:31:55 -07:00
|
|
|
|
|
|
|
"xorm.io/builder"
|
2016-12-25 18:16:37 -07:00
|
|
|
)
|
|
|
|
|
|
|
|
// LFSMetaObject stores metadata for LFS tracked files.
|
|
|
|
type LFSMetaObject struct {
|
2021-04-08 15:25:57 -07:00
|
|
|
ID int64 `xorm:"pk autoincr"`
|
|
|
|
lfs.Pointer `xorm:"extends"`
|
2019-08-15 07:46:21 -07:00
|
|
|
RepositoryID int64 `xorm:"UNIQUE(s) INDEX NOT NULL"`
|
|
|
|
Existing bool `xorm:"-"`
|
|
|
|
CreatedUnix timeutil.TimeStamp `xorm:"created"`
|
2016-12-25 18:16:37 -07:00
|
|
|
}
|
|
|
|
|
2021-09-19 04:49:59 -07:00
|
|
|
func init() {
|
|
|
|
db.RegisterModel(new(LFSMetaObject))
|
|
|
|
}
|
|
|
|
|
2016-12-25 18:16:37 -07:00
|
|
|
// LFSTokenResponse defines the JSON structure in which the JWT token is stored.
|
|
|
|
// This structure is fetched via SSH and passed by the Git LFS client to the server
|
|
|
|
// endpoint for authorization.
|
|
|
|
type LFSTokenResponse struct {
|
|
|
|
Header map[string]string `json:"header"`
|
|
|
|
Href string `json:"href"`
|
|
|
|
}
|
|
|
|
|
2021-03-14 11:52:12 -07:00
|
|
|
// ErrLFSObjectNotExist is returned from lfs models functions in order
|
|
|
|
// to differentiate between database and missing object errors.
|
|
|
|
var ErrLFSObjectNotExist = errors.New("LFS Meta object does not exist")
|
2016-12-25 18:16:37 -07:00
|
|
|
|
|
|
|
// NewLFSMetaObject stores a given populated LFSMetaObject structure in the database
|
|
|
|
// if it is not already present.
|
|
|
|
func NewLFSMetaObject(m *LFSMetaObject) (*LFSMetaObject, error) {
|
|
|
|
var err error
|
|
|
|
|
2021-09-19 04:49:59 -07:00
|
|
|
sess := db.DefaultContext().NewSession()
|
2019-01-23 01:56:51 -07:00
|
|
|
defer sess.Close()
|
|
|
|
if err = sess.Begin(); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
has, err := sess.Get(m)
|
2016-12-25 18:16:37 -07:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if has {
|
|
|
|
m.Existing = true
|
2019-01-23 01:56:51 -07:00
|
|
|
return m, sess.Commit()
|
2016-12-25 18:16:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if _, err = sess.Insert(m); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return m, sess.Commit()
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetLFSMetaObjectByOid selects a LFSMetaObject entry from database by its OID.
|
|
|
|
// It may return ErrLFSObjectNotExist or a database error. If the error is nil,
|
|
|
|
// the returned pointer is a valid LFSMetaObject.
|
2017-10-30 05:11:56 -07:00
|
|
|
func (repo *Repository) GetLFSMetaObjectByOid(oid string) (*LFSMetaObject, error) {
|
2016-12-25 18:16:37 -07:00
|
|
|
if len(oid) == 0 {
|
|
|
|
return nil, ErrLFSObjectNotExist
|
|
|
|
}
|
|
|
|
|
2021-04-08 15:25:57 -07:00
|
|
|
m := &LFSMetaObject{Pointer: lfs.Pointer{Oid: oid}, RepositoryID: repo.ID}
|
2021-09-19 04:49:59 -07:00
|
|
|
has, err := db.DefaultContext().Engine().Get(m)
|
2016-12-25 18:16:37 -07:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
|
|
|
return nil, ErrLFSObjectNotExist
|
|
|
|
}
|
|
|
|
return m, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// RemoveLFSMetaObjectByOid removes a LFSMetaObject entry from database by its OID.
|
|
|
|
// It may return ErrLFSObjectNotExist or a database error.
|
2019-10-28 11:31:55 -07:00
|
|
|
func (repo *Repository) RemoveLFSMetaObjectByOid(oid string) (int64, error) {
|
2016-12-25 18:16:37 -07:00
|
|
|
if len(oid) == 0 {
|
2019-10-28 11:31:55 -07:00
|
|
|
return 0, ErrLFSObjectNotExist
|
2016-12-25 18:16:37 -07:00
|
|
|
}
|
|
|
|
|
2021-09-19 04:49:59 -07:00
|
|
|
sess := db.DefaultContext().NewSession()
|
2017-06-20 17:57:05 -07:00
|
|
|
defer sess.Close()
|
2016-12-25 18:16:37 -07:00
|
|
|
if err := sess.Begin(); err != nil {
|
2019-10-28 11:31:55 -07:00
|
|
|
return -1, err
|
2016-12-25 18:16:37 -07:00
|
|
|
}
|
|
|
|
|
2021-04-08 15:25:57 -07:00
|
|
|
m := &LFSMetaObject{Pointer: lfs.Pointer{Oid: oid}, RepositoryID: repo.ID}
|
2016-12-25 18:16:37 -07:00
|
|
|
if _, err := sess.Delete(m); err != nil {
|
2019-10-28 11:31:55 -07:00
|
|
|
return -1, err
|
|
|
|
}
|
|
|
|
|
2021-04-08 15:25:57 -07:00
|
|
|
count, err := sess.Count(&LFSMetaObject{Pointer: lfs.Pointer{Oid: oid}})
|
2019-10-28 11:31:55 -07:00
|
|
|
if err != nil {
|
|
|
|
return count, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return count, sess.Commit()
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetLFSMetaObjects returns all LFSMetaObjects associated with a repository
|
|
|
|
func (repo *Repository) GetLFSMetaObjects(page, pageSize int) ([]*LFSMetaObject, error) {
|
2021-09-19 04:49:59 -07:00
|
|
|
sess := db.DefaultContext().NewSession()
|
2019-10-28 11:31:55 -07:00
|
|
|
defer sess.Close()
|
|
|
|
|
|
|
|
if page >= 0 && pageSize > 0 {
|
|
|
|
start := 0
|
|
|
|
if page > 0 {
|
|
|
|
start = (page - 1) * pageSize
|
|
|
|
}
|
|
|
|
sess.Limit(pageSize, start)
|
|
|
|
}
|
|
|
|
lfsObjects := make([]*LFSMetaObject, 0, pageSize)
|
|
|
|
return lfsObjects, sess.Find(&lfsObjects, &LFSMetaObject{RepositoryID: repo.ID})
|
|
|
|
}
|
|
|
|
|
|
|
|
// CountLFSMetaObjects returns a count of all LFSMetaObjects associated with a repository
|
|
|
|
func (repo *Repository) CountLFSMetaObjects() (int64, error) {
|
2021-09-19 04:49:59 -07:00
|
|
|
return db.DefaultContext().Engine().Count(&LFSMetaObject{RepositoryID: repo.ID})
|
2019-10-28 11:31:55 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// LFSObjectAccessible checks if a provided Oid is accessible to the user
|
|
|
|
func LFSObjectAccessible(user *User, oid string) (bool, error) {
|
|
|
|
if user.IsAdmin {
|
2021-09-19 04:49:59 -07:00
|
|
|
count, err := db.DefaultContext().Engine().Count(&LFSMetaObject{Pointer: lfs.Pointer{Oid: oid}})
|
2021-04-09 00:40:34 -07:00
|
|
|
return count > 0, err
|
2019-10-28 11:31:55 -07:00
|
|
|
}
|
2020-01-13 10:33:46 -07:00
|
|
|
cond := accessibleRepositoryCondition(user)
|
2021-09-19 04:49:59 -07:00
|
|
|
count, err := db.DefaultContext().Engine().Where(cond).Join("INNER", "repository", "`lfs_meta_object`.repository_id = `repository`.id").Count(&LFSMetaObject{Pointer: lfs.Pointer{Oid: oid}})
|
2021-04-09 00:40:34 -07:00
|
|
|
return count > 0, err
|
2019-10-28 11:31:55 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// LFSAutoAssociate auto associates accessible LFSMetaObjects
|
|
|
|
func LFSAutoAssociate(metas []*LFSMetaObject, user *User, repoID int64) error {
|
2021-09-19 04:49:59 -07:00
|
|
|
sess := db.DefaultContext().NewSession()
|
2019-10-28 11:31:55 -07:00
|
|
|
defer sess.Close()
|
|
|
|
if err := sess.Begin(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
oids := make([]interface{}, len(metas))
|
|
|
|
oidMap := make(map[string]*LFSMetaObject, len(metas))
|
|
|
|
for i, meta := range metas {
|
|
|
|
oids[i] = meta.Oid
|
|
|
|
oidMap[meta.Oid] = meta
|
|
|
|
}
|
|
|
|
|
|
|
|
cond := builder.NewCond()
|
|
|
|
if !user.IsAdmin {
|
|
|
|
cond = builder.In("`lfs_meta_object`.repository_id",
|
2020-01-13 10:33:46 -07:00
|
|
|
builder.Select("`repository`.id").From("repository").Where(accessibleRepositoryCondition(user)))
|
2019-10-28 11:31:55 -07:00
|
|
|
}
|
|
|
|
newMetas := make([]*LFSMetaObject, 0, len(metas))
|
|
|
|
if err := sess.Cols("oid").Where(cond).In("oid", oids...).GroupBy("oid").Find(&newMetas); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
for i := range newMetas {
|
|
|
|
newMetas[i].Size = oidMap[newMetas[i].Oid].Size
|
|
|
|
newMetas[i].RepositoryID = repoID
|
|
|
|
}
|
|
|
|
if _, err := sess.InsertMulti(newMetas); err != nil {
|
2016-12-25 18:16:37 -07:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return sess.Commit()
|
|
|
|
}
|
2020-09-08 08:45:10 -07:00
|
|
|
|
|
|
|
// IterateLFS iterates lfs object
|
|
|
|
func IterateLFS(f func(mo *LFSMetaObject) error) error {
|
|
|
|
var start int
|
|
|
|
const batchSize = 100
|
|
|
|
for {
|
2021-03-14 11:52:12 -07:00
|
|
|
mos := make([]*LFSMetaObject, 0, batchSize)
|
2021-09-19 04:49:59 -07:00
|
|
|
if err := db.DefaultContext().Engine().Limit(batchSize, start).Find(&mos); err != nil {
|
2020-09-08 08:45:10 -07:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
if len(mos) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
start += len(mos)
|
|
|
|
|
|
|
|
for _, mo := range mos {
|
|
|
|
if err := f(mo); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|