2017-02-21 18:02:10 +03:00
// Copyright 2016 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 (
2019-12-15 12:51:28 +03:00
"context"
2017-02-21 18:02:10 +03:00
"fmt"
2020-03-27 01:26:34 +03:00
"strings"
2017-02-21 18:02:10 +03:00
"time"
2017-09-14 11:16:22 +03:00
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/log"
2019-08-15 17:46:21 +03:00
"code.gitea.io/gitea/modules/timeutil"
2017-09-14 11:16:22 +03:00
"code.gitea.io/gitea/modules/util"
2020-03-27 01:26:34 +03:00
"github.com/gobwas/glob"
2019-08-23 19:40:30 +03:00
"github.com/unknwon/com"
2017-02-21 18:02:10 +03:00
)
// ProtectedBranch struct
type ProtectedBranch struct {
2018-12-11 14:28:37 +03:00
ID int64 ` xorm:"pk autoincr" `
RepoID int64 ` xorm:"UNIQUE(s)" `
BranchName string ` xorm:"UNIQUE(s)" `
CanPush bool ` xorm:"NOT NULL DEFAULT false" `
EnableWhitelist bool
2020-01-09 04:47:45 +03:00
WhitelistUserIDs [ ] int64 ` xorm:"JSON TEXT" `
WhitelistTeamIDs [ ] int64 ` xorm:"JSON TEXT" `
EnableMergeWhitelist bool ` xorm:"NOT NULL DEFAULT false" `
WhitelistDeployKeys bool ` xorm:"NOT NULL DEFAULT false" `
MergeWhitelistUserIDs [ ] int64 ` xorm:"JSON TEXT" `
MergeWhitelistTeamIDs [ ] int64 ` xorm:"JSON TEXT" `
EnableStatusCheck bool ` xorm:"NOT NULL DEFAULT false" `
StatusCheckContexts [ ] string ` xorm:"JSON TEXT" `
EnableApprovalsWhitelist bool ` xorm:"NOT NULL DEFAULT false" `
ApprovalsWhitelistUserIDs [ ] int64 ` xorm:"JSON TEXT" `
ApprovalsWhitelistTeamIDs [ ] int64 ` xorm:"JSON TEXT" `
RequiredApprovals int64 ` xorm:"NOT NULL DEFAULT 0" `
BlockOnRejectedReviews bool ` xorm:"NOT NULL DEFAULT false" `
2020-04-17 04:00:36 +03:00
BlockOnOutdatedBranch bool ` xorm:"NOT NULL DEFAULT false" `
2020-01-09 04:47:45 +03:00
DismissStaleApprovals bool ` xorm:"NOT NULL DEFAULT false" `
2020-01-15 11:32:57 +03:00
RequireSignedCommits bool ` xorm:"NOT NULL DEFAULT false" `
2020-03-27 01:26:34 +03:00
ProtectedFilePatterns string ` xorm:"TEXT" `
2020-01-09 04:47:45 +03:00
CreatedUnix timeutil . TimeStamp ` xorm:"created" `
UpdatedUnix timeutil . TimeStamp ` xorm:"updated" `
2017-09-14 11:16:22 +03:00
}
// IsProtected returns if the branch is protected
func ( protectBranch * ProtectedBranch ) IsProtected ( ) bool {
return protectBranch . ID > 0
}
// CanUserPush returns if some user could push to this protected branch
func ( protectBranch * ProtectedBranch ) CanUserPush ( userID int64 ) bool {
2019-12-04 04:08:56 +03:00
if ! protectBranch . CanPush {
2017-09-14 11:16:22 +03:00
return false
}
2019-12-04 04:08:56 +03:00
if ! protectBranch . EnableWhitelist {
if user , err := GetUserByID ( userID ) ; err != nil {
log . Error ( "GetUserByID: %v" , err )
return false
} else if repo , err := GetRepositoryByID ( protectBranch . RepoID ) ; err != nil {
log . Error ( "GetRepositoryByID: %v" , err )
return false
} else if writeAccess , err := HasAccessUnit ( user , repo , UnitTypeCode , AccessModeWrite ) ; err != nil {
log . Error ( "HasAccessUnit: %v" , err )
return false
} else {
return writeAccess
}
}
2017-09-14 11:16:22 +03:00
if base . Int64sContains ( protectBranch . WhitelistUserIDs , userID ) {
return true
}
if len ( protectBranch . WhitelistTeamIDs ) == 0 {
return false
}
in , err := IsUserInTeams ( userID , protectBranch . WhitelistTeamIDs )
if err != nil {
2019-04-02 10:48:31 +03:00
log . Error ( "IsUserInTeams: %v" , err )
2017-09-14 11:16:22 +03:00
return false
}
return in
2017-02-21 18:02:10 +03:00
}
2020-01-11 10:29:34 +03:00
// IsUserMergeWhitelisted checks if some user is whitelisted to merge to this branch
2020-08-20 10:48:40 +03:00
func ( protectBranch * ProtectedBranch ) IsUserMergeWhitelisted ( userID int64 , permissionInRepo Permission ) bool {
2018-03-25 13:01:32 +03:00
if ! protectBranch . EnableMergeWhitelist {
2020-08-20 10:48:40 +03:00
// Then we need to fall back on whether the user has write permission
return permissionInRepo . CanWrite ( UnitTypeCode )
2018-03-25 13:01:32 +03:00
}
if base . Int64sContains ( protectBranch . MergeWhitelistUserIDs , userID ) {
return true
}
2018-07-27 22:11:24 +03:00
if len ( protectBranch . MergeWhitelistTeamIDs ) == 0 {
2018-03-25 13:01:32 +03:00
return false
}
in , err := IsUserInTeams ( userID , protectBranch . MergeWhitelistTeamIDs )
if err != nil {
2019-04-02 10:48:31 +03:00
log . Error ( "IsUserInTeams: %v" , err )
2018-03-25 13:01:32 +03:00
return false
}
return in
}
2019-12-04 04:08:56 +03:00
// IsUserOfficialReviewer check if user is official reviewer for the branch (counts towards required approvals)
func ( protectBranch * ProtectedBranch ) IsUserOfficialReviewer ( user * User ) ( bool , error ) {
return protectBranch . isUserOfficialReviewer ( x , user )
}
func ( protectBranch * ProtectedBranch ) isUserOfficialReviewer ( e Engine , user * User ) ( bool , error ) {
repo , err := getRepositoryByID ( e , protectBranch . RepoID )
if err != nil {
return false , err
}
if ! protectBranch . EnableApprovalsWhitelist {
// Anyone with write access is considered official reviewer
writeAccess , err := hasAccessUnit ( e , user , repo , UnitTypeCode , AccessModeWrite )
if err != nil {
return false , err
}
return writeAccess , nil
}
if base . Int64sContains ( protectBranch . ApprovalsWhitelistUserIDs , user . ID ) {
return true , nil
}
inTeam , err := isUserInTeams ( e , user . ID , protectBranch . ApprovalsWhitelistTeamIDs )
if err != nil {
return false , err
}
return inTeam , nil
}
2018-12-11 14:28:37 +03:00
// HasEnoughApprovals returns true if pr has enough granted approvals.
func ( protectBranch * ProtectedBranch ) HasEnoughApprovals ( pr * PullRequest ) bool {
if protectBranch . RequiredApprovals == 0 {
return true
}
return protectBranch . GetGrantedApprovalsCount ( pr ) >= protectBranch . RequiredApprovals
}
// GetGrantedApprovalsCount returns the number of granted approvals for pr. A granted approval must be authored by a user in an approval whitelist.
func ( protectBranch * ProtectedBranch ) GetGrantedApprovalsCount ( pr * PullRequest ) int64 {
2020-01-09 04:47:45 +03:00
sess := x . Where ( "issue_id = ?" , pr . IssueID ) .
2019-12-04 04:08:56 +03:00
And ( "type = ?" , ReviewTypeApprove ) .
2020-01-09 04:47:45 +03:00
And ( "official = ?" , true )
if protectBranch . DismissStaleApprovals {
sess = sess . And ( "stale = ?" , false )
}
approvals , err := sess . Count ( new ( Review ) )
2018-12-11 14:28:37 +03:00
if err != nil {
2019-12-04 04:08:56 +03:00
log . Error ( "GetGrantedApprovalsCount: %v" , err )
2018-12-11 14:28:37 +03:00
return 0
}
2018-12-12 02:49:33 +03:00
2019-12-04 04:08:56 +03:00
return approvals
2018-12-11 14:28:37 +03:00
}
2020-01-03 20:47:10 +03:00
// MergeBlockedByRejectedReview returns true if merge is blocked by rejected reviews
2020-04-06 19:33:34 +03:00
// An official ReviewRequest should also block Merge like Reject
2020-01-03 20:47:10 +03:00
func ( protectBranch * ProtectedBranch ) MergeBlockedByRejectedReview ( pr * PullRequest ) bool {
if ! protectBranch . BlockOnRejectedReviews {
return false
}
rejectExist , err := x . Where ( "issue_id = ?" , pr . IssueID ) .
2020-04-06 19:33:34 +03:00
And ( "type in ( ?, ?)" , ReviewTypeReject , ReviewTypeRequest ) .
2020-01-03 20:47:10 +03:00
And ( "official = ?" , true ) .
Exist ( new ( Review ) )
if err != nil {
log . Error ( "MergeBlockedByRejectedReview: %v" , err )
return true
}
return rejectExist
}
2020-04-17 04:00:36 +03:00
// MergeBlockedByOutdatedBranch returns true if merge is blocked by an outdated head branch
func ( protectBranch * ProtectedBranch ) MergeBlockedByOutdatedBranch ( pr * PullRequest ) bool {
return protectBranch . BlockOnOutdatedBranch && pr . CommitsBehind > 0
}
2020-03-27 01:26:34 +03:00
// GetProtectedFilePatterns parses a semicolon separated list of protected file patterns and returns a glob.Glob slice
func ( protectBranch * ProtectedBranch ) GetProtectedFilePatterns ( ) [ ] glob . Glob {
extarr := make ( [ ] glob . Glob , 0 , 10 )
for _ , expr := range strings . Split ( strings . ToLower ( protectBranch . ProtectedFilePatterns ) , ";" ) {
expr = strings . TrimSpace ( expr )
if expr != "" {
if g , err := glob . Compile ( expr , '.' , '/' ) ; err != nil {
log . Info ( "Invalid glob expresion '%s' (skipped): %v" , expr , err )
} else {
extarr = append ( extarr , g )
}
}
}
return extarr
}
2017-02-21 18:02:10 +03:00
// GetProtectedBranchByRepoID getting protected branch by repo ID
2019-06-12 22:41:28 +03:00
func GetProtectedBranchByRepoID ( repoID int64 ) ( [ ] * ProtectedBranch , error ) {
2017-02-21 18:02:10 +03:00
protectedBranches := make ( [ ] * ProtectedBranch , 0 )
2019-06-12 22:41:28 +03:00
return protectedBranches , x . Where ( "repo_id = ?" , repoID ) . Desc ( "updated_unix" ) . Find ( & protectedBranches )
2017-02-21 18:02:10 +03:00
}
// GetProtectedBranchBy getting protected branch by ID/Name
2019-06-12 22:41:28 +03:00
func GetProtectedBranchBy ( repoID int64 , branchName string ) ( * ProtectedBranch , error ) {
2019-12-04 04:08:56 +03:00
return getProtectedBranchBy ( x , repoID , branchName )
}
func getProtectedBranchBy ( e Engine , repoID int64 , branchName string ) ( * ProtectedBranch , error ) {
2019-06-12 22:41:28 +03:00
rel := & ProtectedBranch { RepoID : repoID , BranchName : branchName }
2019-12-04 04:08:56 +03:00
has , err := e . Get ( rel )
2017-02-21 18:02:10 +03:00
if err != nil {
return nil , err
}
if ! has {
return nil , nil
}
return rel , nil
}
2017-09-14 11:16:22 +03:00
// GetProtectedBranchByID getting protected branch by ID
func GetProtectedBranchByID ( id int64 ) ( * ProtectedBranch , error ) {
2020-06-17 20:50:11 +03:00
rel := & ProtectedBranch { }
has , err := x . ID ( id ) . Get ( rel )
2017-09-14 11:16:22 +03:00
if err != nil {
return nil , err
}
if ! has {
return nil , nil
}
return rel , nil
}
2018-12-11 14:28:37 +03:00
// WhitelistOptions represent all sorts of whitelists used for protected branches
type WhitelistOptions struct {
UserIDs [ ] int64
TeamIDs [ ] int64
MergeUserIDs [ ] int64
MergeTeamIDs [ ] int64
ApprovalsUserIDs [ ] int64
ApprovalsTeamIDs [ ] int64
}
2017-09-14 11:16:22 +03:00
// UpdateProtectBranch saves branch protection options of repository.
// If ID is 0, it creates a new record. Otherwise, updates existing record.
// This function also performs check if whitelist user and team's IDs have been changed
// to avoid unnecessary whitelist delete and regenerate.
2018-12-11 14:28:37 +03:00
func UpdateProtectBranch ( repo * Repository , protectBranch * ProtectedBranch , opts WhitelistOptions ) ( err error ) {
2017-09-14 11:16:22 +03:00
if err = repo . GetOwner ( ) ; err != nil {
return fmt . Errorf ( "GetOwner: %v" , err )
}
2018-12-11 14:28:37 +03:00
whitelist , err := updateUserWhitelist ( repo , protectBranch . WhitelistUserIDs , opts . UserIDs )
2018-03-25 13:01:32 +03:00
if err != nil {
return err
}
protectBranch . WhitelistUserIDs = whitelist
2017-09-14 11:16:22 +03:00
2018-12-11 14:28:37 +03:00
whitelist , err = updateUserWhitelist ( repo , protectBranch . MergeWhitelistUserIDs , opts . MergeUserIDs )
2018-03-25 13:01:32 +03:00
if err != nil {
return err
2017-09-14 11:16:22 +03:00
}
2018-03-25 13:01:32 +03:00
protectBranch . MergeWhitelistUserIDs = whitelist
2017-09-14 11:16:22 +03:00
2019-10-08 22:18:17 +03:00
whitelist , err = updateApprovalWhitelist ( repo , protectBranch . ApprovalsWhitelistUserIDs , opts . ApprovalsUserIDs )
2018-12-11 14:28:37 +03:00
if err != nil {
return err
}
protectBranch . ApprovalsWhitelistUserIDs = whitelist
2018-03-25 13:01:32 +03:00
// if the repo is in an organization
2018-12-11 14:28:37 +03:00
whitelist , err = updateTeamWhitelist ( repo , protectBranch . WhitelistTeamIDs , opts . TeamIDs )
2018-03-25 13:01:32 +03:00
if err != nil {
return err
2017-09-14 11:16:22 +03:00
}
2018-03-25 13:01:32 +03:00
protectBranch . WhitelistTeamIDs = whitelist
2018-12-11 14:28:37 +03:00
whitelist , err = updateTeamWhitelist ( repo , protectBranch . MergeWhitelistTeamIDs , opts . MergeTeamIDs )
2018-03-25 13:01:32 +03:00
if err != nil {
return err
}
protectBranch . MergeWhitelistTeamIDs = whitelist
2017-09-14 11:16:22 +03:00
2018-12-11 14:28:37 +03:00
whitelist , err = updateTeamWhitelist ( repo , protectBranch . ApprovalsWhitelistTeamIDs , opts . ApprovalsTeamIDs )
if err != nil {
return err
}
protectBranch . ApprovalsWhitelistTeamIDs = whitelist
2017-09-14 11:16:22 +03:00
// Make sure protectBranch.ID is not 0 for whitelists
if protectBranch . ID == 0 {
if _ , err = x . Insert ( protectBranch ) ; err != nil {
return fmt . Errorf ( "Insert: %v" , err )
}
return nil
}
2017-10-05 07:43:04 +03:00
if _ , err = x . ID ( protectBranch . ID ) . AllCols ( ) . Update ( protectBranch ) ; err != nil {
2017-09-14 11:16:22 +03:00
return fmt . Errorf ( "Update: %v" , err )
}
return nil
}
2017-03-15 03:52:01 +03:00
// GetProtectedBranches get all protected branches
2017-02-21 18:02:10 +03:00
func ( repo * Repository ) GetProtectedBranches ( ) ( [ ] * ProtectedBranch , error ) {
protectedBranches := make ( [ ] * ProtectedBranch , 0 )
return protectedBranches , x . Find ( & protectedBranches , & ProtectedBranch { RepoID : repo . ID } )
}
2019-11-16 22:39:18 +03:00
// GetBranchProtection get the branch protection of a branch
func ( repo * Repository ) GetBranchProtection ( branchName string ) ( * ProtectedBranch , error ) {
return GetProtectedBranchBy ( repo . ID , branchName )
}
2017-05-02 03:49:55 +03:00
// IsProtectedBranch checks if branch is protected
2017-09-14 11:16:22 +03:00
func ( repo * Repository ) IsProtectedBranch ( branchName string , doer * User ) ( bool , error ) {
2018-02-23 13:10:03 +03:00
if doer == nil {
return true , nil
}
2017-05-02 03:49:55 +03:00
protectedBranch := & ProtectedBranch {
RepoID : repo . ID ,
BranchName : branchName ,
}
2018-08-08 06:17:11 +03:00
has , err := x . Exist ( protectedBranch )
if err != nil {
return true , err
}
return has , nil
}
// IsProtectedBranchForPush checks if branch is protected for push
func ( repo * Repository ) IsProtectedBranchForPush ( branchName string , doer * User ) ( bool , error ) {
if doer == nil {
return true , nil
}
protectedBranch := & ProtectedBranch {
RepoID : repo . ID ,
BranchName : branchName ,
}
2017-05-02 03:49:55 +03:00
has , err := x . Get ( protectedBranch )
if err != nil {
return true , err
} else if has {
2017-09-14 11:16:22 +03:00
return ! protectedBranch . CanUserPush ( doer . ID ) , nil
2017-05-02 03:49:55 +03:00
}
return false , nil
}
2019-10-08 22:18:17 +03:00
// updateApprovalWhitelist checks whether the user whitelist changed and returns a whitelist with
// the users from newWhitelist which have explicit read or write access to the repo.
func updateApprovalWhitelist ( repo * Repository , currentWhitelist , newWhitelist [ ] int64 ) ( whitelist [ ] int64 , err error ) {
hasUsersChanged := ! util . IsSliceInt64Eq ( currentWhitelist , newWhitelist )
if ! hasUsersChanged {
return currentWhitelist , nil
}
whitelist = make ( [ ] int64 , 0 , len ( newWhitelist ) )
for _ , userID := range newWhitelist {
if reader , err := repo . IsReader ( userID ) ; err != nil {
return nil , err
} else if ! reader {
continue
}
whitelist = append ( whitelist , userID )
}
return
}
2018-03-25 13:01:32 +03:00
// updateUserWhitelist checks whether the user whitelist changed and returns a whitelist with
// the users from newWhitelist which have write access to the repo.
func updateUserWhitelist ( repo * Repository , currentWhitelist , newWhitelist [ ] int64 ) ( whitelist [ ] int64 , err error ) {
hasUsersChanged := ! util . IsSliceInt64Eq ( currentWhitelist , newWhitelist )
if ! hasUsersChanged {
return currentWhitelist , nil
}
whitelist = make ( [ ] int64 , 0 , len ( newWhitelist ) )
for _ , userID := range newWhitelist {
2018-11-28 14:26:14 +03:00
user , err := GetUserByID ( userID )
2018-03-25 13:01:32 +03:00
if err != nil {
2018-11-28 14:26:14 +03:00
return nil , fmt . Errorf ( "GetUserByID [user_id: %d, repo_id: %d]: %v" , userID , repo . ID , err )
}
perm , err := GetUserRepoPermission ( repo , user )
if err != nil {
return nil , fmt . Errorf ( "GetUserRepoPermission [user_id: %d, repo_id: %d]: %v" , userID , repo . ID , err )
}
if ! perm . CanWrite ( UnitTypeCode ) {
2018-03-25 13:01:32 +03:00
continue // Drop invalid user ID
}
whitelist = append ( whitelist , userID )
}
return
}
// updateTeamWhitelist checks whether the team whitelist changed and returns a whitelist with
// the teams from newWhitelist which have write access to the repo.
func updateTeamWhitelist ( repo * Repository , currentWhitelist , newWhitelist [ ] int64 ) ( whitelist [ ] int64 , err error ) {
hasTeamsChanged := ! util . IsSliceInt64Eq ( currentWhitelist , newWhitelist )
if ! hasTeamsChanged {
return currentWhitelist , nil
}
2018-12-11 14:28:37 +03:00
teams , err := GetTeamsWithAccessToRepo ( repo . OwnerID , repo . ID , AccessModeRead )
2018-03-25 13:01:32 +03:00
if err != nil {
return nil , fmt . Errorf ( "GetTeamsWithAccessToRepo [org_id: %d, repo_id: %d]: %v" , repo . OwnerID , repo . ID , err )
}
whitelist = make ( [ ] int64 , 0 , len ( teams ) )
for i := range teams {
2018-12-11 14:28:37 +03:00
if com . IsSliceContainsInt64 ( newWhitelist , teams [ i ] . ID ) {
2018-03-25 13:01:32 +03:00
whitelist = append ( whitelist , teams [ i ] . ID )
}
}
return
}
2017-02-21 18:02:10 +03:00
// DeleteProtectedBranch removes ProtectedBranch relation between the user and repository.
func ( repo * Repository ) DeleteProtectedBranch ( id int64 ) ( err error ) {
protectedBranch := & ProtectedBranch {
RepoID : repo . ID ,
ID : id ,
}
sess := x . NewSession ( )
2017-06-21 03:57:05 +03:00
defer sess . Close ( )
2017-02-21 18:02:10 +03:00
if err = sess . Begin ( ) ; err != nil {
return err
}
if affected , err := sess . Delete ( protectedBranch ) ; err != nil {
return err
} else if affected != 1 {
return fmt . Errorf ( "delete protected branch ID(%v) failed" , id )
}
return sess . Commit ( )
}
2017-10-26 03:49:16 +03:00
// DeletedBranch struct
type DeletedBranch struct {
2019-08-15 17:46:21 +03:00
ID int64 ` xorm:"pk autoincr" `
RepoID int64 ` xorm:"UNIQUE(s) INDEX NOT NULL" `
Name string ` xorm:"UNIQUE(s) NOT NULL" `
Commit string ` xorm:"UNIQUE(s) NOT NULL" `
DeletedByID int64 ` xorm:"INDEX" `
DeletedBy * User ` xorm:"-" `
DeletedUnix timeutil . TimeStamp ` xorm:"INDEX created" `
2017-10-26 03:49:16 +03:00
}
// AddDeletedBranch adds a deleted branch to the database
func ( repo * Repository ) AddDeletedBranch ( branchName , commit string , deletedByID int64 ) error {
deletedBranch := & DeletedBranch {
RepoID : repo . ID ,
Name : branchName ,
Commit : commit ,
DeletedByID : deletedByID ,
}
sess := x . NewSession ( )
defer sess . Close ( )
if err := sess . Begin ( ) ; err != nil {
return err
}
if _ , err := sess . InsertOne ( deletedBranch ) ; err != nil {
return err
}
return sess . Commit ( )
}
// GetDeletedBranches returns all the deleted branches
func ( repo * Repository ) GetDeletedBranches ( ) ( [ ] * DeletedBranch , error ) {
deletedBranches := make ( [ ] * DeletedBranch , 0 )
return deletedBranches , x . Where ( "repo_id = ?" , repo . ID ) . Desc ( "deleted_unix" ) . Find ( & deletedBranches )
}
// GetDeletedBranchByID get a deleted branch by its ID
2020-06-17 20:50:11 +03:00
func ( repo * Repository ) GetDeletedBranchByID ( id int64 ) ( * DeletedBranch , error ) {
deletedBranch := & DeletedBranch { }
has , err := x . ID ( id ) . Get ( deletedBranch )
2017-10-26 03:49:16 +03:00
if err != nil {
return nil , err
}
if ! has {
return nil , nil
}
return deletedBranch , nil
}
// RemoveDeletedBranch removes a deleted branch from the database
func ( repo * Repository ) RemoveDeletedBranch ( id int64 ) ( err error ) {
deletedBranch := & DeletedBranch {
RepoID : repo . ID ,
ID : id ,
}
sess := x . NewSession ( )
defer sess . Close ( )
if err = sess . Begin ( ) ; err != nil {
return err
}
if affected , err := sess . Delete ( deletedBranch ) ; err != nil {
return err
} else if affected != 1 {
return fmt . Errorf ( "remove deleted branch ID(%v) failed" , id )
}
return sess . Commit ( )
}
// LoadUser loads the user that deleted the branch
// When there's no user found it returns a NewGhostUser
func ( deletedBranch * DeletedBranch ) LoadUser ( ) {
user , err := GetUserByID ( deletedBranch . DeletedByID )
if err != nil {
user = NewGhostUser ( )
}
deletedBranch . DeletedBy = user
}
2019-12-27 22:17:37 +03:00
// RemoveDeletedBranch removes all deleted branches
func RemoveDeletedBranch ( repoID int64 , branch string ) error {
_ , err := x . Where ( "repo_id=? AND name=?" , repoID , branch ) . Delete ( new ( DeletedBranch ) )
return err
}
2017-10-26 03:49:16 +03:00
// RemoveOldDeletedBranches removes old deleted branches
2020-05-17 02:31:38 +03:00
func RemoveOldDeletedBranches ( ctx context . Context , olderThan time . Duration ) {
2019-12-15 12:51:28 +03:00
// Nothing to do for shutdown or terminate
2017-10-26 03:49:16 +03:00
log . Trace ( "Doing: DeletedBranchesCleanup" )
2020-05-17 02:31:38 +03:00
deleteBefore := time . Now ( ) . Add ( - olderThan )
2017-10-26 03:49:16 +03:00
_ , err := x . Where ( "deleted_unix < ?" , deleteBefore . Unix ( ) ) . Delete ( new ( DeletedBranch ) )
if err != nil {
2019-04-02 10:48:31 +03:00
log . Error ( "DeletedBranchesCleanup: %v" , err )
2017-10-26 03:49:16 +03:00
}
}