mirror of
https://github.com/go-gitea/gitea.git
synced 2024-08-26 21:54:19 -04:00
* Panic don't fatal on create new logger Fixes #5854 Signed-off-by: Andrew Thornton <art27@cantab.net> * partial broken * Update the logging infrastrcture Signed-off-by: Andrew Thornton <art27@cantab.net> * Reset the skip levels for Fatal and Error Signed-off-by: Andrew Thornton <art27@cantab.net> * broken ncsa * More log.Error fixes Signed-off-by: Andrew Thornton <art27@cantab.net> * Remove nal * set log-levels to lowercase * Make console_test test all levels * switch to lowercased levels * OK now working * Fix vetting issues * Fix lint * Fix tests * change default logging to match current gitea * Improve log testing Signed-off-by: Andrew Thornton <art27@cantab.net> * reset error skip levels to 0 * Update documentation and access logger configuration * Redirect the router log back to gitea if redirect macaron log but also allow setting the log level - i.e. TRACE * Fix broken level caching * Refactor the router log * Add Router logger * Add colorizing options * Adjust router colors * Only create logger if they will be used * update app.ini.sample * rename Attribute ColorAttribute * Change from white to green for function * Set fatal/error levels * Restore initial trace logger * Fix Trace arguments in modules/auth/auth.go * Properly handle XORMLogger * Improve admin/config page * fix fmt * Add auto-compression of old logs * Update error log levels * Remove the unnecessary skip argument from Error, Fatal and Critical * Add stacktrace support * Fix tests * Remove x/sync from vendors? * Add stderr option to console logger * Use filepath.ToSlash to protect against Windows in tests * Remove prefixed underscores from names in colors.go * Remove not implemented database logger This was removed from Gogs on 4 Mar 2016 but left in the configuration since then. * Ensure that log paths are relative to ROOT_PATH * use path.Join * rename jsonConfig to logConfig * Rename "config" to "jsonConfig" to make it clearer * Requested changes * Requested changes: XormLogger * Try to color the windows terminal If successful default to colorizing the console logs * fixup * Colorize initially too * update vendor * Colorize logs on default and remove if this is not a colorizing logger * Fix documentation * fix test * Use go-isatty to detect if on windows we are on msys or cygwin * Fix spelling mistake * Add missing vendors * More changes * Rationalise the ANSI writer protection * Adjust colors on advice from @0x5c * Make Flags a comma separated list * Move to use the windows constant for ENABLE_VIRTUAL_TERMINAL_PROCESSING * Ensure matching is done on the non-colored message - to simpify EXPRESSION
151 lines
3.7 KiB
Go
151 lines
3.7 KiB
Go
// Copyright 2017 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.
|
|
|
|
package models
|
|
|
|
import (
|
|
"fmt"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"code.gitea.io/gitea/modules/log"
|
|
api "code.gitea.io/sdk/gitea"
|
|
"github.com/go-xorm/xorm"
|
|
)
|
|
|
|
// LFSLock represents a git lfs lock of repository.
|
|
type LFSLock struct {
|
|
ID int64 `xorm:"pk autoincr"`
|
|
Repo *Repository `xorm:"-"`
|
|
RepoID int64 `xorm:"INDEX NOT NULL"`
|
|
Owner *User `xorm:"-"`
|
|
OwnerID int64 `xorm:"INDEX NOT NULL"`
|
|
Path string `xorm:"TEXT"`
|
|
Created time.Time `xorm:"created"`
|
|
}
|
|
|
|
// BeforeInsert is invoked from XORM before inserting an object of this type.
|
|
func (l *LFSLock) BeforeInsert() {
|
|
l.OwnerID = l.Owner.ID
|
|
l.RepoID = l.Repo.ID
|
|
l.Path = cleanPath(l.Path)
|
|
}
|
|
|
|
// AfterLoad is invoked from XORM after setting the values of all fields of this object.
|
|
func (l *LFSLock) AfterLoad(session *xorm.Session) {
|
|
var err error
|
|
l.Owner, err = getUserByID(session, l.OwnerID)
|
|
if err != nil {
|
|
log.Error("LFS lock AfterLoad failed OwnerId[%d] not found: %v", l.OwnerID, err)
|
|
}
|
|
l.Repo, err = getRepositoryByID(session, l.RepoID)
|
|
if err != nil {
|
|
log.Error("LFS lock AfterLoad failed RepoId[%d] not found: %v", l.RepoID, err)
|
|
}
|
|
}
|
|
|
|
func cleanPath(p string) string {
|
|
return path.Clean(p)
|
|
}
|
|
|
|
// APIFormat convert a Release to lfs.LFSLock
|
|
func (l *LFSLock) APIFormat() *api.LFSLock {
|
|
return &api.LFSLock{
|
|
ID: strconv.FormatInt(l.ID, 10),
|
|
Path: l.Path,
|
|
LockedAt: l.Created,
|
|
Owner: &api.LFSLockOwner{
|
|
Name: l.Owner.DisplayName(),
|
|
},
|
|
}
|
|
}
|
|
|
|
// CreateLFSLock creates a new lock.
|
|
func CreateLFSLock(lock *LFSLock) (*LFSLock, error) {
|
|
err := CheckLFSAccessForRepo(lock.Owner, lock.Repo, AccessModeWrite)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
l, err := GetLFSLock(lock.Repo, lock.Path)
|
|
if err == nil {
|
|
return l, ErrLFSLockAlreadyExist{lock.RepoID, lock.Path}
|
|
}
|
|
if !IsErrLFSLockNotExist(err) {
|
|
return nil, err
|
|
}
|
|
|
|
_, err = x.InsertOne(lock)
|
|
return lock, err
|
|
}
|
|
|
|
// GetLFSLock returns release by given path.
|
|
func GetLFSLock(repo *Repository, path string) (*LFSLock, error) {
|
|
path = cleanPath(path)
|
|
rel := &LFSLock{RepoID: repo.ID}
|
|
has, err := x.Where("lower(path) = ?", strings.ToLower(path)).Get(rel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !has {
|
|
return nil, ErrLFSLockNotExist{0, repo.ID, path}
|
|
}
|
|
return rel, nil
|
|
}
|
|
|
|
// GetLFSLockByID returns release by given id.
|
|
func GetLFSLockByID(id int64) (*LFSLock, error) {
|
|
lock := new(LFSLock)
|
|
has, err := x.ID(id).Get(lock)
|
|
if err != nil {
|
|
return nil, err
|
|
} else if !has {
|
|
return nil, ErrLFSLockNotExist{id, 0, ""}
|
|
}
|
|
return lock, nil
|
|
}
|
|
|
|
// GetLFSLockByRepoID returns a list of locks of repository.
|
|
func GetLFSLockByRepoID(repoID int64) (locks []*LFSLock, err error) {
|
|
err = x.Where("repo_id = ?", repoID).Find(&locks)
|
|
return
|
|
}
|
|
|
|
// DeleteLFSLockByID deletes a lock by given ID.
|
|
func DeleteLFSLockByID(id int64, u *User, force bool) (*LFSLock, error) {
|
|
lock, err := GetLFSLockByID(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = CheckLFSAccessForRepo(u, lock.Repo, AccessModeWrite)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !force && u.ID != lock.OwnerID {
|
|
return nil, fmt.Errorf("user doesn't own lock and force flag is not set")
|
|
}
|
|
|
|
_, err = x.ID(id).Delete(new(LFSLock))
|
|
return lock, err
|
|
}
|
|
|
|
//CheckLFSAccessForRepo check needed access mode base on action
|
|
func CheckLFSAccessForRepo(u *User, repo *Repository, mode AccessMode) error {
|
|
if u == nil {
|
|
return ErrLFSUnauthorizedAction{repo.ID, "undefined", mode}
|
|
}
|
|
perm, err := GetUserRepoPermission(repo, u)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !perm.CanAccess(mode, UnitTypeCode) {
|
|
return ErrLFSUnauthorizedAction{repo.ID, u.DisplayName(), mode}
|
|
}
|
|
return nil
|
|
}
|