2014-02-15 03:16:54 +04:00
// Copyright 2014 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
2014-02-14 18:20:57 +04:00
package models
import (
2014-03-10 04:06:29 +04:00
"errors"
2014-03-11 04:48:58 +04:00
"fmt"
2014-07-22 21:52:37 +04:00
"html/template"
2014-07-23 15:48:06 +04:00
"io/ioutil"
2014-02-14 18:20:57 +04:00
"os"
2014-07-27 02:37:18 +04:00
"os/exec"
2014-03-30 06:18:36 +04:00
"path"
2014-02-14 18:20:57 +04:00
"path/filepath"
2014-07-22 21:52:37 +04:00
"regexp"
2014-06-03 07:17:21 +04:00
"sort"
2014-02-14 18:20:57 +04:00
"strings"
"time"
2014-03-11 08:53:53 +04:00
"unicode/utf8"
2014-02-14 18:20:57 +04:00
2014-03-17 19:56:50 +04:00
"github.com/Unknwon/cae/zip"
2014-03-11 09:32:36 +04:00
"github.com/Unknwon/com"
2014-03-17 19:56:50 +04:00
2014-10-05 01:15:22 +04:00
"github.com/gogits/gogs/modules/base"
2014-07-26 08:24:27 +04:00
"github.com/gogits/gogs/modules/git"
2014-03-08 02:22:15 +04:00
"github.com/gogits/gogs/modules/log"
2014-06-19 09:08:03 +04:00
"github.com/gogits/gogs/modules/process"
2014-05-26 04:11:25 +04:00
"github.com/gogits/gogs/modules/setting"
2014-02-14 18:20:57 +04:00
)
2014-06-11 03:11:53 +04:00
const (
2015-02-09 13:27:15 +03:00
_TPL_UPDATE_HOOK = "#!/usr/bin/env %s\n%s update $1 $2 $3 --config='%s'\n"
2014-06-11 03:11:53 +04:00
)
2014-03-11 09:32:36 +04:00
var (
2014-03-21 00:04:56 +04:00
ErrRepoAlreadyExist = errors . New ( "Repository already exist" )
ErrRepoNotExist = errors . New ( "Repository does not exist" )
2014-06-02 05:47:48 +04:00
ErrRepoFileNotExist = errors . New ( "Repository file does not exist" )
2014-03-21 00:04:56 +04:00
ErrRepoNameIllegal = errors . New ( "Repository name contains illegal characters" )
2014-06-02 05:47:48 +04:00
ErrRepoFileNotLoaded = errors . New ( "Repository file not loaded" )
2014-04-13 06:30:00 +04:00
ErrMirrorNotExist = errors . New ( "Mirror does not exist" )
2014-07-23 15:48:06 +04:00
ErrInvalidReference = errors . New ( "Invalid reference specified" )
2014-03-11 09:32:36 +04:00
)
2014-03-10 04:06:29 +04:00
var (
2014-07-26 08:24:27 +04:00
Gitignores , Licenses [ ] string
2014-03-10 04:06:29 +04:00
)
2014-07-22 21:52:37 +04:00
var (
2014-10-05 01:15:22 +04:00
DescPattern = regexp . MustCompile ( ` https?://\S+ ` )
2014-07-22 21:52:37 +04:00
)
2014-05-26 04:11:25 +04:00
func LoadRepoConfig ( ) {
2014-05-11 22:03:51 +04:00
// Load .gitignore and license files.
types := [ ] string { "gitignore" , "license" }
typeFiles := make ( [ ] [ ] string , 2 )
for i , t := range types {
2014-07-26 08:24:27 +04:00
files , err := com . StatDir ( path . Join ( "conf" , t ) )
if err != nil {
log . Fatal ( 4 , "Fail to get %s files: %v" , t , err )
}
2014-05-26 04:11:25 +04:00
customPath := path . Join ( setting . CustomPath , "conf" , t )
if com . IsDir ( customPath ) {
customFiles , err := com . StatDir ( customPath )
2014-05-11 22:03:51 +04:00
if err != nil {
2014-07-26 08:24:27 +04:00
log . Fatal ( 4 , "Fail to get custom %s files: %v" , t , err )
2014-05-11 22:03:51 +04:00
}
for _ , f := range customFiles {
if ! com . IsSliceContainsStr ( files , f ) {
files = append ( files , f )
}
}
}
typeFiles [ i ] = files
}
2014-07-26 08:24:27 +04:00
Gitignores = typeFiles [ 0 ]
2014-05-11 22:03:51 +04:00
Licenses = typeFiles [ 1 ]
2014-07-26 08:24:27 +04:00
sort . Strings ( Gitignores )
2014-06-03 07:17:21 +04:00
sort . Strings ( Licenses )
2014-03-21 09:48:10 +04:00
}
2014-03-17 19:56:50 +04:00
2014-03-21 09:48:10 +04:00
func NewRepoContext ( ) {
2014-03-17 19:56:50 +04:00
zip . Verbose = false
2014-03-17 23:58:32 +04:00
2014-07-27 02:37:18 +04:00
// Check Git installation.
if _ , err := exec . LookPath ( "git" ) ; err != nil {
log . Fatal ( 4 , "Fail to test 'git' command: %v (forgotten install?)" , err )
}
2014-07-26 08:24:27 +04:00
// Check Git version.
ver , err := git . GetVersion ( )
if err != nil {
log . Fatal ( 4 , "Fail to get Git version: %v" , err )
}
2014-09-16 18:10:33 +04:00
reqVer , err := git . ParseVersion ( "1.7.1" )
if err != nil {
log . Fatal ( 4 , "Fail to parse required Git version: %v" , err )
}
2014-09-16 19:29:53 +04:00
if ver . LessThan ( reqVer ) {
2014-09-16 18:10:33 +04:00
log . Fatal ( 4 , "Gogs requires Git version greater or equal to 1.7.1" )
2014-07-26 08:24:27 +04:00
}
2014-12-28 06:07:54 +03:00
// Check if server has user.email and user.name set correctly and set if they're not.
for configKey , defaultValue := range map [ string ] string { "user.name" : "Gogs" , "user.email" : "gogitservice@gmail.com" } {
if stdout , stderr , err := process . Exec ( "NewRepoContext(get setting)" , "git" , "config" , "--get" , configKey ) ; err != nil || strings . TrimSpace ( stdout ) == "" {
// ExitError indicates this config is not set
if _ , ok := err . ( * exec . ExitError ) ; ok || strings . TrimSpace ( stdout ) == "" {
if _ , stderr , gerr := process . Exec ( "NewRepoContext(set " + configKey + ")" , "git" , "config" , "--global" , configKey , defaultValue ) ; gerr != nil {
log . Fatal ( 4 , "Fail to set git %s(%s): %s" , configKey , gerr , stderr )
}
log . Info ( "Git config %s set to %s" , configKey , defaultValue )
} else {
log . Fatal ( 4 , "Fail to get git %s(%s): %s" , configKey , err , stderr )
2014-09-04 14:03:29 +04:00
}
2014-03-17 23:58:32 +04:00
}
}
2014-08-23 19:58:56 +04:00
// Set git some configurations.
2014-09-04 14:03:29 +04:00
if _ , stderr , err := process . Exec ( "NewRepoContext(git config --global core.quotepath false)" ,
2014-08-23 19:58:56 +04:00
"git" , "config" , "--global" , "core.quotepath" , "false" ) ; err != nil {
log . Fatal ( 4 , "Fail to execute 'git config --global core.quotepath false': %s" , stderr )
}
2014-03-11 09:32:36 +04:00
}
2014-03-21 00:04:56 +04:00
// Repository represents a git repository.
type Repository struct {
2014-10-19 09:35:24 +04:00
Id int64
OwnerId int64 ` xorm:"UNIQUE(s)" `
Owner * User ` xorm:"-" `
LowerName string ` xorm:"UNIQUE(s) INDEX NOT NULL" `
Name string ` xorm:"INDEX NOT NULL" `
Description string
Website string
DefaultBranch string
2014-05-12 22:06:42 +04:00
NumWatches int
NumStars int
NumForks int
NumIssues int
NumClosedIssues int
NumOpenIssues int ` xorm:"-" `
2014-07-26 08:24:27 +04:00
NumPulls int
NumClosedPulls int
NumOpenPulls int ` xorm:"-" `
2014-05-12 22:06:42 +04:00
NumMilestones int ` xorm:"NOT NULL DEFAULT 0" `
NumClosedMilestones int ` xorm:"NOT NULL DEFAULT 0" `
NumOpenMilestones int ` xorm:"-" `
NumTags int ` xorm:"-" `
2014-10-19 09:35:24 +04:00
IsPrivate bool
IsBare bool
IsMirror bool
* Mirror ` xorm:"-" `
IsFork bool ` xorm:"NOT NULL DEFAULT false" `
ForkId int64
ForkRepo * Repository ` xorm:"-" `
Created time . Time ` xorm:"CREATED" `
Updated time . Time ` xorm:"UPDATED" `
2014-03-21 00:04:56 +04:00
}
2015-02-13 08:58:46 +03:00
func ( repo * Repository ) getOwner ( e Engine ) ( err error ) {
2014-10-10 03:01:22 +04:00
if repo . Owner == nil {
2015-02-13 08:58:46 +03:00
repo . Owner , err = getUserById ( e , repo . OwnerId )
2014-10-10 03:01:22 +04:00
}
2014-05-08 16:18:03 +04:00
return err
}
2015-02-13 08:58:46 +03:00
func ( repo * Repository ) GetOwner ( ) ( err error ) {
return repo . getOwner ( x )
}
2014-08-11 07:11:18 +04:00
func ( repo * Repository ) GetMirror ( ) ( err error ) {
repo . Mirror , err = GetMirror ( repo . Id )
return err
}
2014-10-19 09:35:24 +04:00
func ( repo * Repository ) GetForkRepo ( ) ( err error ) {
if ! repo . IsFork {
return nil
}
repo . ForkRepo , err = GetRepositoryById ( repo . ForkId )
return err
}
func ( repo * Repository ) RepoPath ( ) ( string , error ) {
if err := repo . GetOwner ( ) ; err != nil {
return "" , err
}
return RepoPath ( repo . Owner . Name , repo . Name ) , nil
}
func ( repo * Repository ) RepoLink ( ) ( string , error ) {
if err := repo . GetOwner ( ) ; err != nil {
return "" , err
}
return setting . AppSubUrl + "/" + repo . Owner . Name + "/" + repo . Name , nil
2014-10-04 21:19:14 +04:00
}
2015-02-13 10:14:57 +03:00
func ( repo * Repository ) HasAccess ( u * User ) bool {
has , _ := HasAccess ( u , repo , ACCESS_MODE_READ )
return has
}
2014-10-13 23:23:30 +04:00
func ( repo * Repository ) IsOwnedBy ( u * User ) bool {
2014-10-19 09:35:24 +04:00
return repo . OwnerId == u . Id
2014-10-13 23:23:30 +04:00
}
2014-07-26 08:24:27 +04:00
// DescriptionHtml does special handles to description and return HTML string.
2014-07-22 21:52:37 +04:00
func ( repo * Repository ) DescriptionHtml ( ) template . HTML {
2014-07-22 22:08:04 +04:00
sanitize := func ( s string ) string {
2015-01-31 02:12:30 +03:00
return fmt . Sprintf ( ` <a href="%[1]s" target="_blank">%[1]s</a> ` , s )
2014-07-22 22:08:04 +04:00
}
2015-01-31 02:12:30 +03:00
return template . HTML ( DescPattern . ReplaceAllStringFunc ( base . Sanitizer . Sanitize ( repo . Description ) , sanitize ) )
2014-07-22 21:52:37 +04:00
}
2014-03-17 22:03:58 +04:00
// IsRepositoryExist returns true if the repository with given name under user has already existed.
2014-05-16 21:41:08 +04:00
func IsRepositoryExist ( u * User , repoName string ) ( bool , error ) {
repo := Repository { OwnerId : u . Id }
2014-06-21 08:51:41 +04:00
has , err := x . Where ( "lower_name = ?" , strings . ToLower ( repoName ) ) . Get ( & repo )
2014-02-19 13:50:53 +04:00
if err != nil {
return has , err
2014-03-27 23:24:11 +04:00
} else if ! has {
return false , nil
2014-02-19 13:50:53 +04:00
}
2014-03-27 23:24:11 +04:00
2014-05-16 21:41:08 +04:00
return com . IsDir ( RepoPath ( u . Name , repoName ) ) , nil
2014-02-14 18:20:57 +04:00
}
2014-12-14 00:46:00 +03:00
// CloneLink represents different types of clone URLs of repository.
type CloneLink struct {
SSH string
HTTPS string
Git string
}
// CloneLink returns clone URLs of repository.
func ( repo * Repository ) CloneLink ( ) ( cl CloneLink , err error ) {
if err = repo . GetOwner ( ) ; err != nil {
return cl , err
}
2015-02-07 18:46:57 +03:00
if setting . SSHPort != 22 {
cl . SSH = fmt . Sprintf ( "ssh://%s@%s:%d/%s/%s.git" , setting . RunUser , setting . Domain , setting . SSHPort , repo . Owner . LowerName , repo . LowerName )
2014-12-14 00:46:00 +03:00
} else {
cl . SSH = fmt . Sprintf ( "%s@%s:%s/%s.git" , setting . RunUser , setting . Domain , repo . Owner . LowerName , repo . LowerName )
}
cl . HTTPS = fmt . Sprintf ( "%s%s/%s.git" , setting . AppUrl , repo . Owner . LowerName , repo . LowerName )
return cl , nil
}
2014-03-20 19:41:24 +04:00
var (
2014-07-04 13:41:43 +04:00
illegalEquals = [ ] string { "debug" , "raw" , "install" , "api" , "avatar" , "user" , "org" , "help" , "stars" , "issues" , "pulls" , "commits" , "repo" , "template" , "admin" , "new" }
2014-11-23 10:33:47 +03:00
illegalSuffixs = [ ] string { ".git" , ".keys" }
2014-03-20 19:41:24 +04:00
)
// IsLegalName returns false if name contains illegal characters.
func IsLegalName ( repoName string ) bool {
2014-03-30 01:50:51 +04:00
repoName = strings . ToLower ( repoName )
for _ , char := range illegalEquals {
if repoName == char {
return false
}
}
for _ , char := range illegalSuffixs {
if strings . HasSuffix ( repoName , char ) {
2014-03-20 19:41:24 +04:00
return false
}
}
return true
}
2014-04-13 04:35:35 +04:00
// Mirror represents a mirror information of repository.
type Mirror struct {
Id int64
RepoId int64
RepoName string // <user name>/<repo name>
Interval int // Hour.
Updated time . Time ` xorm:"UPDATED" `
NextUpdate time . Time
}
2014-07-27 07:53:16 +04:00
func GetMirror ( repoId int64 ) ( * Mirror , error ) {
m := & Mirror { RepoId : repoId }
has , err := x . Get ( m )
if err != nil {
return nil , err
} else if ! has {
return nil , ErrMirrorNotExist
}
return m , nil
}
func UpdateMirror ( m * Mirror ) error {
_ , err := x . Id ( m . Id ) . Update ( m )
return err
}
2014-06-09 01:53:53 +04:00
// MirrorRepository creates a mirror repository from source.
func MirrorRepository ( repoId int64 , userName , repoName , repoPath , url string ) error {
2014-07-07 01:32:36 +04:00
_ , stderr , err := process . ExecTimeout ( 10 * time . Minute ,
fmt . Sprintf ( "MirrorRepository: %s/%s" , userName , repoName ) ,
2014-06-19 09:08:03 +04:00
"git" , "clone" , "--mirror" , url , repoPath )
2014-06-09 01:53:53 +04:00
if err != nil {
return errors . New ( "git clone --mirror: " + stderr )
}
2014-06-21 08:51:41 +04:00
if _ , err = x . InsertOne ( & Mirror {
2014-06-09 01:53:53 +04:00
RepoId : repoId ,
RepoName : strings . ToLower ( userName + "/" + repoName ) ,
Interval : 24 ,
NextUpdate : time . Now ( ) . Add ( 24 * time . Hour ) ,
} ) ; err != nil {
return err
}
2014-07-26 08:24:27 +04:00
return nil
2014-06-09 01:53:53 +04:00
}
2014-04-13 04:35:35 +04:00
// MigrateRepository migrates a existing repository from other project hosting.
2014-06-25 13:35:23 +04:00
func MigrateRepository ( u * User , name , desc string , private , mirror bool , url string ) ( * Repository , error ) {
2014-09-02 15:11:39 +04:00
repo , err := CreateRepository ( u , name , desc , "" , "" , private , mirror , false )
2014-04-13 04:35:35 +04:00
if err != nil {
return nil , err
}
// Clone to temprory path and do the init commit.
tmpDir := filepath . Join ( os . TempDir ( ) , fmt . Sprintf ( "%d" , time . Now ( ) . Nanosecond ( ) ) )
os . MkdirAll ( tmpDir , os . ModePerm )
2014-06-25 13:35:23 +04:00
repoPath := RepoPath ( u . Name , name )
2014-04-13 04:35:35 +04:00
2014-08-27 12:39:36 +04:00
if u . IsOrganization ( ) {
t , err := u . GetOwnerTeam ( )
if err != nil {
return nil , err
}
repo . NumWatches = t . NumMembers
} else {
repo . NumWatches = 1
}
2014-04-13 04:35:35 +04:00
repo . IsBare = false
if mirror {
2014-06-25 13:35:23 +04:00
if err = MirrorRepository ( repo . Id , u . Name , repo . Name , repoPath , url ) ; err != nil {
2014-04-13 04:35:35 +04:00
return repo , err
}
repo . IsMirror = true
return repo , UpdateRepository ( repo )
2014-09-02 15:11:39 +04:00
} else {
os . RemoveAll ( repoPath )
2014-04-13 04:35:35 +04:00
}
2015-02-09 20:42:53 +03:00
// FIXME: this command could for both migrate and mirror
2014-07-07 01:32:36 +04:00
_ , stderr , err := process . ExecTimeout ( 10 * time . Minute ,
2014-09-02 07:57:06 +04:00
fmt . Sprintf ( "MigrateRepository: %s" , repoPath ) ,
"git" , "clone" , "--mirror" , "--bare" , url , repoPath )
if err != nil {
2015-02-09 20:42:53 +03:00
return repo , fmt . Errorf ( "git clone --mirror --bare: %v" , stderr )
} else if err = createUpdateHook ( repoPath ) ; err != nil {
return repo , fmt . Errorf ( "create update hook: %v" , err )
2014-09-02 07:57:06 +04:00
}
2015-02-09 20:42:53 +03:00
2014-04-13 04:35:35 +04:00
return repo , UpdateRepository ( repo )
}
2014-03-17 19:56:50 +04:00
// extractGitBareZip extracts git-bare.zip to repository path.
func extractGitBareZip ( repoPath string ) error {
2014-07-26 08:24:27 +04:00
z , err := zip . Open ( path . Join ( setting . ConfRootPath , "content/git-bare.zip" ) )
2014-03-17 19:56:50 +04:00
if err != nil {
return err
}
defer z . Close ( )
return z . ExtractTo ( repoPath )
}
// initRepoCommit temporarily changes with work directory.
2014-03-26 07:53:01 +04:00
func initRepoCommit ( tmpPath string , sig * git . Signature ) ( err error ) {
2014-03-17 23:58:32 +04:00
var stderr string
2014-07-07 01:32:36 +04:00
if _ , stderr , err = process . ExecDir ( - 1 ,
2014-06-19 09:08:03 +04:00
tmpPath , fmt . Sprintf ( "initRepoCommit(git add): %s" , tmpPath ) ,
"git" , "add" , "--all" ) ; err != nil {
2014-04-14 12:11:33 +04:00
return errors . New ( "git add: " + stderr )
2014-03-27 23:24:11 +04:00
}
2014-06-19 09:08:03 +04:00
2014-07-07 01:32:36 +04:00
if _ , stderr , err = process . ExecDir ( - 1 ,
2014-06-19 09:08:03 +04:00
tmpPath , fmt . Sprintf ( "initRepoCommit(git commit): %s" , tmpPath ) ,
"git" , "commit" , fmt . Sprintf ( "--author='%s <%s>'" , sig . Name , sig . Email ) ,
2014-03-17 19:56:50 +04:00
"-m" , "Init commit" ) ; err != nil {
2014-04-14 12:11:33 +04:00
return errors . New ( "git commit: " + stderr )
2014-03-27 23:24:11 +04:00
}
2014-07-07 01:32:36 +04:00
if _ , stderr , err = process . ExecDir ( - 1 ,
2014-06-19 09:08:03 +04:00
tmpPath , fmt . Sprintf ( "initRepoCommit(git push): %s" , tmpPath ) ,
"git" , "push" , "origin" , "master" ) ; err != nil {
2014-04-14 12:11:33 +04:00
return errors . New ( "git push: " + stderr )
2014-03-27 23:24:11 +04:00
}
2014-03-17 19:56:50 +04:00
return nil
2014-02-14 18:20:57 +04:00
}
2015-02-09 20:42:53 +03:00
func createUpdateHook ( repoPath string ) error {
2015-02-09 05:26:14 +03:00
return ioutil . WriteFile ( path . Join ( repoPath , "hooks/update" ) ,
[ ] byte ( fmt . Sprintf ( _TPL_UPDATE_HOOK , setting . ScriptType , "\"" + appPath + "\"" , setting . CustomConf ) ) , 0777 )
2014-03-26 17:40:02 +04:00
}
2014-03-11 04:48:58 +04:00
// InitRepository initializes README and .gitignore if needed.
2015-02-13 08:58:46 +03:00
func initRepository ( e Engine , f string , u * User , repo * Repository , initReadme bool , repoLang , license string ) error {
2014-07-26 08:24:27 +04:00
repoPath := RepoPath ( u . Name , repo . Name )
2014-03-11 14:10:19 +04:00
2014-03-17 19:56:50 +04:00
// Create bare new repository.
if err := extractGitBareZip ( repoPath ) ; err != nil {
return err
}
2015-02-09 20:42:53 +03:00
if err := createUpdateHook ( repoPath ) ; err != nil {
2014-03-18 01:00:35 +04:00
return err
}
2014-03-17 19:56:50 +04:00
// Initialize repository according to user's choice.
fileName := map [ string ] string { }
2014-03-11 14:10:19 +04:00
if initReadme {
fileName [ "readme" ] = "README.md"
}
if repoLang != "" {
fileName [ "gitign" ] = ".gitignore"
2014-03-11 08:53:53 +04:00
}
2014-03-11 14:10:19 +04:00
if license != "" {
fileName [ "license" ] = "LICENSE"
}
2014-03-17 19:56:50 +04:00
// Clone to temprory path and do the init commit.
2014-07-26 08:24:27 +04:00
tmpDir := filepath . Join ( os . TempDir ( ) , com . ToStr ( time . Now ( ) . Nanosecond ( ) ) )
2014-03-17 19:56:50 +04:00
os . MkdirAll ( tmpDir , os . ModePerm )
2014-03-11 08:18:44 +04:00
2014-06-19 09:08:03 +04:00
_ , stderr , err := process . Exec (
fmt . Sprintf ( "initRepository(git clone): %s" , repoPath ) ,
"git" , "clone" , repoPath , tmpDir )
2014-04-13 04:35:35 +04:00
if err != nil {
2014-06-19 09:08:03 +04:00
return errors . New ( "initRepository(git clone): " + stderr )
2014-04-13 04:35:35 +04:00
}
2014-03-11 08:18:44 +04:00
// README
2014-03-11 14:10:19 +04:00
if initReadme {
defaultReadme := repo . Name + "\n" + strings . Repeat ( "=" ,
utf8 . RuneCountInString ( repo . Name ) ) + "\n\n" + repo . Description
2014-03-17 19:56:50 +04:00
if err := ioutil . WriteFile ( filepath . Join ( tmpDir , fileName [ "readme" ] ) ,
2014-03-11 14:10:19 +04:00
[ ] byte ( defaultReadme ) , 0644 ) ; err != nil {
return err
}
2014-03-11 08:18:44 +04:00
}
2014-03-11 04:48:58 +04:00
2014-03-17 19:56:50 +04:00
// .gitignore
2014-07-26 08:24:27 +04:00
filePath := "conf/gitignore/" + repoLang
if com . IsFile ( filePath ) {
2014-06-04 05:51:25 +04:00
targetPath := path . Join ( tmpDir , fileName [ "gitign" ] )
2014-07-26 08:24:27 +04:00
if com . IsFile ( filePath ) {
if err = com . Copy ( filePath , targetPath ) ; err != nil {
2014-03-11 14:10:19 +04:00
return err
}
2014-06-04 05:51:25 +04:00
} else {
// Check custom files.
filePath = path . Join ( setting . CustomPath , "conf/gitignore" , repoLang )
if com . IsFile ( filePath ) {
if err := com . Copy ( filePath , targetPath ) ; err != nil {
return err
}
}
2014-03-11 09:32:36 +04:00
}
2014-07-26 08:24:27 +04:00
} else {
delete ( fileName , "gitign" )
2014-03-11 09:32:36 +04:00
}
2014-03-11 08:53:53 +04:00
2014-03-17 19:56:50 +04:00
// LICENSE
2014-07-26 08:24:27 +04:00
filePath = "conf/license/" + license
if com . IsFile ( filePath ) {
2014-06-04 05:51:25 +04:00
targetPath := path . Join ( tmpDir , fileName [ "license" ] )
2014-07-26 08:24:27 +04:00
if com . IsFile ( filePath ) {
if err = com . Copy ( filePath , targetPath ) ; err != nil {
2014-03-11 14:10:19 +04:00
return err
}
2014-06-04 05:51:25 +04:00
} else {
// Check custom files.
filePath = path . Join ( setting . CustomPath , "conf/license" , license )
if com . IsFile ( filePath ) {
if err := com . Copy ( filePath , targetPath ) ; err != nil {
return err
}
}
2014-03-11 09:32:36 +04:00
}
2014-07-26 08:24:27 +04:00
} else {
delete ( fileName , "license" )
2014-03-11 09:32:36 +04:00
}
2014-03-11 08:18:44 +04:00
2014-03-18 01:00:35 +04:00
if len ( fileName ) == 0 {
2015-02-03 07:42:53 +03:00
// Re-fetch the repository from database before updating it (else it would
2015-01-02 12:15:42 +03:00
// override changes that were done earlier with sql)
2015-02-13 08:58:46 +03:00
if repo , err = getRepositoryById ( e , repo . Id ) ; err != nil {
2015-01-02 12:15:42 +03:00
return err
}
2014-08-06 03:40:01 +04:00
repo . IsBare = true
repo . DefaultBranch = "master"
2015-02-13 08:58:46 +03:00
return updateRepository ( e , repo )
2014-03-18 01:00:35 +04:00
}
2014-03-17 19:56:50 +04:00
// Apply changes and commit.
2014-07-26 08:24:27 +04:00
return initRepoCommit ( tmpDir , u . NewGitSig ( ) )
2014-03-11 04:48:58 +04:00
}
2014-06-25 13:14:36 +04:00
// CreateRepository creates a repository for given user or organization.
func CreateRepository ( u * User , name , desc , lang , license string , private , mirror , initReadme bool ) ( * Repository , error ) {
2014-06-19 09:08:03 +04:00
if ! IsLegalName ( name ) {
return nil , ErrRepoNameIllegal
}
2014-06-25 13:14:36 +04:00
isExist , err := IsRepositoryExist ( u , name )
2014-06-19 09:08:03 +04:00
if err != nil {
return nil , err
} else if isExist {
return nil , ErrRepoAlreadyExist
}
repo := & Repository {
2014-06-25 13:14:36 +04:00
OwnerId : u . Id ,
2014-06-25 13:27:17 +04:00
Owner : u ,
2014-06-19 09:08:03 +04:00
Name : name ,
LowerName : strings . ToLower ( name ) ,
Description : desc ,
IsPrivate : private ,
}
2015-02-13 08:58:46 +03:00
sess := x . NewSession ( )
defer sessionRelease ( sess )
if err = sess . Begin ( ) ; err != nil {
return nil , err
}
2014-06-19 09:08:03 +04:00
if _ , err = sess . Insert ( repo ) ; err != nil {
return nil , err
2015-02-13 10:14:57 +03:00
} else if _ , err = sess . Exec ( "UPDATE `user` SET num_repos = num_repos + 1 WHERE id = ?" , u . Id ) ; err != nil {
return nil , err
2014-06-19 09:08:03 +04:00
}
2015-02-05 16:29:08 +03:00
// TODO fix code for mirrors?
2014-06-25 13:14:36 +04:00
// Give access to all members in owner team.
if u . IsOrganization ( ) {
2015-02-13 08:58:46 +03:00
if err = repo . recalculateAccesses ( sess ) ; err != nil {
2014-06-25 13:14:36 +04:00
return nil , err
2014-06-19 09:08:03 +04:00
}
2014-06-25 13:14:36 +04:00
2015-02-13 10:14:57 +03:00
// Update owner team info and count.
2015-02-13 08:58:46 +03:00
t , err := u . getOwnerTeam ( sess )
2014-06-25 13:14:36 +04:00
if err != nil {
2015-02-13 08:58:46 +03:00
return nil , fmt . Errorf ( "get owner team: %v" , err )
} else if err = t . getMembers ( sess ) ; err != nil {
return nil , fmt . Errorf ( "get team members: %v" , err )
}
for _ , u := range t . Members {
if err = watchRepo ( sess , u . Id , repo . Id , true ) ; err != nil {
return nil , fmt . Errorf ( "watch repository: %v" , err )
2014-06-25 13:14:36 +04:00
}
}
2015-02-13 10:14:57 +03:00
t . RepoIds += "$" + com . ToStr ( repo . Id ) + "|"
t . NumRepos ++
if _ , err = sess . Id ( t . Id ) . AllCols ( ) . Update ( t ) ; err != nil {
return nil , err
}
2014-08-27 12:39:36 +04:00
} else {
2015-02-13 08:58:46 +03:00
if err = watchRepo ( sess , u . Id , repo . Id , true ) ; err != nil {
return nil , fmt . Errorf ( "watch repository 2: %v" , err )
2014-08-27 12:39:36 +04:00
}
2014-06-19 09:08:03 +04:00
}
2015-02-13 08:58:46 +03:00
if err = newRepoAction ( sess , u , repo ) ; err != nil {
return nil , fmt . Errorf ( "new repository action: %v" , err )
2014-06-19 09:08:03 +04:00
}
2014-07-26 08:24:27 +04:00
// No need for init mirror.
2015-02-13 08:58:46 +03:00
if ! mirror {
repoPath := RepoPath ( u . Name , repo . Name )
if err = initRepository ( sess , repoPath , u , repo , initReadme , lang , license ) ; err != nil {
if err2 := os . RemoveAll ( repoPath ) ; err2 != nil {
log . Error ( 4 , "initRepository: %v" , err )
return nil , fmt . Errorf (
"delete repo directory %s/%s failed(2): %v" , u . Name , repo . Name , err2 )
}
return nil , fmt . Errorf ( "initRepository: %v" , err )
2014-06-25 13:14:36 +04:00
}
2014-06-19 09:08:03 +04:00
2015-02-13 08:58:46 +03:00
_ , stderr , err := process . ExecDir ( - 1 ,
repoPath , fmt . Sprintf ( "CreateRepository(git update-server-info): %s" , repoPath ) ,
"git" , "update-server-info" )
if err != nil {
return nil , errors . New ( "CreateRepository(git update-server-info): " + stderr )
}
2014-06-19 09:08:03 +04:00
}
2015-02-13 08:58:46 +03:00
return repo , sess . Commit ( )
2014-06-19 09:08:03 +04:00
}
2014-07-07 12:15:08 +04:00
// CountRepositories returns number of repositories.
func CountRepositories ( ) int64 {
count , _ := x . Count ( new ( Repository ) )
return count
}
2014-05-08 00:51:14 +04:00
// GetRepositoriesWithUsers returns given number of repository objects with offset.
// It also auto-gets corresponding users.
func GetRepositoriesWithUsers ( num , offset int ) ( [ ] * Repository , error ) {
repos := make ( [ ] * Repository , 0 , num )
2014-06-21 08:51:41 +04:00
if err := x . Limit ( num , offset ) . Asc ( "id" ) . Find ( & repos ) ; err != nil {
2014-03-21 09:09:22 +04:00
return nil , err
}
2014-05-08 00:51:14 +04:00
for _ , repo := range repos {
repo . Owner = & User { Id : repo . OwnerId }
2014-06-21 08:51:41 +04:00
has , err := x . Get ( repo . Owner )
2014-03-21 09:09:22 +04:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrUserNotExist
}
}
2014-05-08 00:51:14 +04:00
return repos , nil
2014-03-21 00:04:56 +04:00
}
2014-04-13 04:35:35 +04:00
// RepoPath returns repository path by given user and repository name.
2014-03-21 00:04:56 +04:00
func RepoPath ( userName , repoName string ) string {
2014-03-30 06:13:02 +04:00
return filepath . Join ( UserPath ( userName ) , strings . ToLower ( repoName ) + ".git" )
2014-03-21 00:04:56 +04:00
}
2014-04-05 02:31:09 +04:00
// TransferOwnership transfers all corresponding setting from old user to new one.
2014-09-13 02:29:58 +04:00
func TransferOwnership ( u * User , newOwner string , repo * Repository ) error {
2014-04-05 02:31:09 +04:00
newUser , err := GetUserByName ( newOwner )
if err != nil {
2014-10-12 02:02:48 +04:00
return fmt . Errorf ( "fail to get new owner(%s): %v" , newOwner , err )
2014-04-05 02:31:09 +04:00
}
2014-09-13 02:29:58 +04:00
// Check if new owner has repository with same name.
2014-09-17 22:22:51 +04:00
has , err := IsRepositoryExist ( newUser , repo . Name )
2014-09-13 02:29:58 +04:00
if err != nil {
return err
} else if has {
return ErrRepoAlreadyExist
}
2014-06-21 08:51:41 +04:00
sess := x . NewSession ( )
2015-02-13 08:58:46 +03:00
defer sessionRelease ( sess )
2014-04-05 02:55:17 +04:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2014-09-26 06:36:07 +04:00
owner := repo . Owner
2014-04-05 02:31:09 +04:00
// Update repository.
repo . OwnerId = newUser . Id
2015-02-05 16:29:08 +03:00
repo . Owner = newUser
2014-04-05 02:55:17 +04:00
if _ , err := sess . Id ( repo . Id ) . Update ( repo ) ; err != nil {
2014-04-05 02:31:09 +04:00
return err
}
// Update user repository number.
2014-08-27 12:39:36 +04:00
if _ , err = sess . Exec ( "UPDATE `user` SET num_repos = num_repos + 1 WHERE id = ?" , newUser . Id ) ; err != nil {
2014-04-05 02:31:09 +04:00
return err
2015-02-13 08:58:46 +03:00
} else if _ , err = sess . Exec ( "UPDATE `user` SET num_repos = num_repos - 1 WHERE id = ?" , owner . Id ) ; err != nil {
2014-04-05 02:31:09 +04:00
return err
2015-02-13 08:58:46 +03:00
} else if err = repo . recalculateAccesses ( sess ) ; err != nil {
2015-02-05 16:29:08 +03:00
return err
2015-02-13 08:58:46 +03:00
} else if err = watchRepo ( sess , newUser . Id , repo . Id , true ) ; err != nil {
2014-07-05 06:43:39 +04:00
return err
2015-02-13 08:58:46 +03:00
} else if err = transferRepoAction ( sess , u , newUser , repo ) ; err != nil {
2014-07-05 06:43:39 +04:00
return err
}
2015-02-13 08:58:46 +03:00
// Change repository directory name.
if err = os . Rename ( RepoPath ( owner . Name , repo . Name ) , RepoPath ( newUser . Name , repo . Name ) ) ; err != nil {
2014-04-05 02:55:17 +04:00
return err
}
2015-02-13 08:58:46 +03:00
return sess . Commit ( )
2014-04-05 02:31:09 +04:00
}
2014-04-03 23:50:55 +04:00
// ChangeRepositoryName changes all corresponding setting from old repository name to new one.
func ChangeRepositoryName ( userName , oldRepoName , newRepoName string ) ( err error ) {
2015-01-02 07:47:33 +03:00
userName = strings . ToLower ( userName )
oldRepoName = strings . ToLower ( oldRepoName )
2014-12-12 09:29:36 +03:00
newRepoName = strings . ToLower ( newRepoName )
2014-08-24 17:09:05 +04:00
if ! IsLegalName ( newRepoName ) {
return ErrRepoNameIllegal
}
2014-04-03 23:50:55 +04:00
// Change repository directory name.
2015-02-05 16:29:08 +03:00
return os . Rename ( RepoPath ( userName , oldRepoName ) , RepoPath ( userName , newRepoName ) )
2014-04-03 23:50:55 +04:00
}
2015-02-13 08:58:46 +03:00
func updateRepository ( e Engine , repo * Repository ) error {
2014-04-03 23:50:55 +04:00
repo . LowerName = strings . ToLower ( repo . Name )
2014-03-23 00:00:46 +04:00
if len ( repo . Description ) > 255 {
repo . Description = repo . Description [ : 255 ]
}
if len ( repo . Website ) > 255 {
repo . Website = repo . Website [ : 255 ]
}
2015-02-13 08:58:46 +03:00
_ , err := e . Id ( repo . Id ) . AllCols ( ) . Update ( repo )
2014-03-22 12:44:57 +04:00
return err
}
2015-02-13 08:58:46 +03:00
func UpdateRepository ( repo * Repository ) error {
return updateRepository ( x , repo )
}
2014-12-07 04:22:48 +03:00
// DeleteRepository deletes a repository for a user or organization.
2014-08-27 12:39:36 +04:00
func DeleteRepository ( uid , repoId int64 , userName string ) error {
repo := & Repository { Id : repoId , OwnerId : uid }
2014-06-21 08:51:41 +04:00
has , err := x . Get ( repo )
2014-03-21 00:04:56 +04:00
if err != nil {
return err
} else if ! has {
return ErrRepoNotExist
}
2014-08-27 12:39:36 +04:00
// In case is a organization.
org , err := GetUserById ( uid )
if err != nil {
return err
}
if org . IsOrganization ( ) {
if err = org . GetTeams ( ) ; err != nil {
return err
}
}
2014-06-21 08:51:41 +04:00
sess := x . NewSession ( )
2015-02-13 10:14:57 +03:00
defer sessionRelease ( sess )
2014-04-05 02:31:09 +04:00
if err = sess . Begin ( ) ; err != nil {
2014-03-21 00:04:56 +04:00
return err
}
2014-06-28 08:40:07 +04:00
2014-08-27 12:39:36 +04:00
if org . IsOrganization ( ) {
idStr := "$" + com . ToStr ( repoId ) + "|"
for _ , t := range org . Teams {
if ! strings . Contains ( t . RepoIds , idStr ) {
continue
}
t . NumRepos --
t . RepoIds = strings . Replace ( t . RepoIds , idStr , "" , 1 )
if _ , err = sess . Id ( t . Id ) . AllCols ( ) . Update ( t ) ; err != nil {
return err
}
}
}
2015-02-13 10:14:57 +03:00
if _ , err = sess . Delete ( & Repository { Id : repoId } ) ; err != nil {
2014-03-21 00:04:56 +04:00
return err
2015-02-13 10:14:57 +03:00
} else if _ , err := sess . Delete ( & Access { RepoID : repo . Id } ) ; err != nil {
2014-03-21 00:04:56 +04:00
return err
2015-02-13 10:14:57 +03:00
} else if _ , err := sess . Delete ( & Action { RepoId : repo . Id } ) ; err != nil {
2014-04-13 06:30:00 +04:00
return err
2015-02-13 10:14:57 +03:00
} else if _ , err = sess . Delete ( & Watch { RepoId : repoId } ) ; err != nil {
2014-05-14 16:51:04 +04:00
return err
2015-02-13 10:14:57 +03:00
} else if _ , err = sess . Delete ( & Mirror { RepoId : repoId } ) ; err != nil {
2014-05-14 16:51:04 +04:00
return err
2015-02-13 10:14:57 +03:00
} else if _ , err = sess . Delete ( & IssueUser { RepoId : repoId } ) ; err != nil {
return err
} else if _ , err = sess . Delete ( & Milestone { RepoId : repoId } ) ; err != nil {
return err
} else if _ , err = sess . Delete ( & Release { RepoId : repoId } ) ; err != nil {
2014-05-14 21:04:57 +04:00
return err
}
// Delete comments.
2014-06-21 08:51:41 +04:00
if err = x . Iterate ( & Issue { RepoId : repoId } , func ( idx int , bean interface { } ) error {
2014-05-14 21:04:57 +04:00
issue := bean . ( * Issue )
if _ , err = sess . Delete ( & Comment { IssueId : issue . Id } ) ; err != nil {
return err
}
return nil
} ) ; err != nil {
return err
}
if _ , err = sess . Delete ( & Issue { RepoId : repoId } ) ; err != nil {
2014-05-14 17:23:33 +04:00
return err
}
2014-10-19 09:35:24 +04:00
2014-10-13 23:23:30 +04:00
if repo . IsFork {
2014-10-19 09:35:24 +04:00
if _ , err = sess . Exec ( "UPDATE `repository` SET num_forks = num_forks - 1 WHERE id = ?" , repo . ForkId ) ; err != nil {
return err
}
2014-10-13 23:23:30 +04:00
}
2014-04-13 04:35:35 +04:00
2014-08-27 12:39:36 +04:00
if _ , err = sess . Exec ( "UPDATE `user` SET num_repos = num_repos - 1 WHERE id = ?" , uid ) ; err != nil {
2014-04-13 04:35:35 +04:00
return err
}
2014-10-09 02:29:18 +04:00
// Remove repository files.
2014-03-21 00:04:56 +04:00
if err = os . RemoveAll ( RepoPath ( userName , repo . Name ) ) ; err != nil {
2014-10-09 02:29:18 +04:00
desc := fmt . Sprintf ( "Fail to delete repository files(%s/%s): %v" , userName , repo . Name , err )
log . Warn ( desc )
if err = CreateRepositoryNotice ( desc ) ; err != nil {
log . Error ( 4 , "Fail to add notice: %v" , err )
}
2014-03-21 00:04:56 +04:00
}
2015-02-13 10:14:57 +03:00
2014-06-09 01:53:53 +04:00
return sess . Commit ( )
2014-03-21 00:04:56 +04:00
}
2014-07-23 15:48:06 +04:00
// GetRepositoryByRef returns a Repository specified by a GFM reference.
// See https://help.github.com/articles/writing-on-github#references for more information on the syntax.
func GetRepositoryByRef ( ref string ) ( * Repository , error ) {
n := strings . IndexByte ( ref , byte ( '/' ) )
if n < 2 {
return nil , ErrInvalidReference
}
userName , repoName := ref [ : n ] , ref [ n + 1 : ]
user , err := GetUserByName ( userName )
if err != nil {
return nil , err
}
return GetRepositoryByName ( user . Id , repoName )
}
2014-03-17 22:03:58 +04:00
// GetRepositoryByName returns the repository by given name under user if exists.
2014-09-13 02:29:58 +04:00
func GetRepositoryByName ( uid int64 , repoName string ) ( * Repository , error ) {
2014-03-13 06:27:11 +04:00
repo := & Repository {
2014-09-13 02:29:58 +04:00
OwnerId : uid ,
2014-03-13 06:27:11 +04:00
LowerName : strings . ToLower ( repoName ) ,
}
2014-06-21 08:51:41 +04:00
has , err := x . Get ( repo )
2014-03-13 06:27:11 +04:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrRepoNotExist
}
return repo , err
}
2015-02-13 08:58:46 +03:00
func getRepositoryById ( e Engine , id int64 ) ( * Repository , error ) {
2014-03-28 03:42:10 +04:00
repo := & Repository { }
2015-02-13 08:58:46 +03:00
has , err := e . Id ( id ) . Get ( repo )
2014-03-13 06:27:11 +04:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrRepoNotExist
}
2014-05-06 05:36:08 +04:00
return repo , nil
2014-03-13 06:27:11 +04:00
}
2015-02-13 08:58:46 +03:00
// GetRepositoryById returns the repository by given id if exists.
func GetRepositoryById ( id int64 ) ( * Repository , error ) {
return getRepositoryById ( x , id )
}
2014-05-12 23:14:22 +04:00
// GetRepositories returns a list of repositories of given user.
2014-05-24 23:28:31 +04:00
func GetRepositories ( uid int64 , private bool ) ( [ ] * Repository , error ) {
2014-05-07 20:09:30 +04:00
repos := make ( [ ] * Repository , 0 , 10 )
2014-06-21 08:51:41 +04:00
sess := x . Desc ( "updated" )
2014-04-14 02:12:07 +04:00
if ! private {
sess . Where ( "is_private=?" , false )
}
2014-05-24 23:28:31 +04:00
err := sess . Find ( & repos , & Repository { OwnerId : uid } )
2014-02-14 18:20:57 +04:00
return repos , err
}
2014-04-14 12:11:33 +04:00
// GetRecentUpdatedRepositories returns the list of repositories that are recently updated.
2014-09-06 01:28:09 +04:00
func GetRecentUpdatedRepositories ( num int ) ( repos [ ] * Repository , err error ) {
err = x . Where ( "is_private=?" , false ) . Limit ( num ) . Desc ( "updated" ) . Find ( & repos )
2014-04-14 12:11:33 +04:00
return repos , err
}
// GetRepositoryCount returns the total number of repositories of user.
2014-03-11 10:17:05 +04:00
func GetRepositoryCount ( user * User ) ( int64 , error ) {
2014-06-21 08:51:41 +04:00
return x . Count ( & Repository { OwnerId : user . Id } )
2014-03-11 10:17:05 +04:00
}
2014-08-26 14:11:15 +04:00
type SearchOption struct {
Keyword string
Uid int64
Limit int
2014-10-25 15:50:19 +04:00
Private bool
}
2014-08-26 14:11:15 +04:00
// SearchRepositoryByName returns given number of repositories whose name contains keyword.
func SearchRepositoryByName ( opt SearchOption ) ( repos [ ] * Repository , err error ) {
if len ( opt . Keyword ) == 0 {
return repos , nil
}
opt . Keyword = strings . ToLower ( opt . Keyword )
repos = make ( [ ] * Repository , 0 , opt . Limit )
// Append conditions.
sess := x . Limit ( opt . Limit )
if opt . Uid > 0 {
sess . Where ( "owner_id=?" , opt . Uid )
}
2014-10-25 15:50:19 +04:00
if ! opt . Private {
sess . And ( "is_private=false" )
}
2014-11-04 19:37:15 +03:00
sess . And ( "lower_name like ?" , "%" + opt . Keyword + "%" ) . Find ( & repos )
2014-08-26 14:11:15 +04:00
return repos , err
}
2014-11-19 03:05:33 +03:00
// DeleteRepositoryArchives deletes all repositories' archives.
func DeleteRepositoryArchives ( ) error {
return x . Where ( "id > 0" ) . Iterate ( new ( Repository ) ,
func ( idx int , bean interface { } ) error {
repo := bean . ( * Repository )
if err := repo . GetOwner ( ) ; err != nil {
return err
}
return os . RemoveAll ( filepath . Join ( RepoPath ( repo . Owner . Name , repo . Name ) , "archives" ) )
} )
}
2015-02-09 05:26:14 +03:00
// RewriteRepositoryUpdateHook rewrites all repositories' update hook.
func RewriteRepositoryUpdateHook ( ) error {
return x . Where ( "id > 0" ) . Iterate ( new ( Repository ) ,
func ( idx int , bean interface { } ) error {
repo := bean . ( * Repository )
if err := repo . GetOwner ( ) ; err != nil {
return err
}
2015-02-09 20:42:53 +03:00
return createUpdateHook ( RepoPath ( repo . Owner . Name , repo . Name ) )
2015-02-09 05:26:14 +03:00
} )
}
2014-12-05 07:07:51 +03:00
var (
// Prevent duplicate tasks.
isMirrorUpdating = false
isGitFscking = false
)
// MirrorUpdate checks and updates mirror repositories.
func MirrorUpdate ( ) {
if isMirrorUpdating {
return
}
isMirrorUpdating = true
defer func ( ) { isMirrorUpdating = false } ( )
2015-01-02 08:30:45 +03:00
mirrors := make ( [ ] * Mirror , 0 , 10 )
2014-12-05 07:07:51 +03:00
if err := x . Iterate ( new ( Mirror ) , func ( idx int , bean interface { } ) error {
m := bean . ( * Mirror )
if m . NextUpdate . After ( time . Now ( ) ) {
return nil
}
repoPath := filepath . Join ( setting . RepoRootPath , m . RepoName + ".git" )
if _ , stderr , err := process . ExecDir ( 10 * time . Minute ,
repoPath , fmt . Sprintf ( "MirrorUpdate: %s" , repoPath ) ,
"git" , "remote" , "update" ) ; err != nil {
2015-01-02 08:30:45 +03:00
desc := fmt . Sprintf ( "Fail to update mirror repository(%s): %s" , repoPath , stderr )
log . Error ( 4 , desc )
if err = CreateRepositoryNotice ( desc ) ; err != nil {
log . Error ( 4 , "Fail to add notice: %v" , err )
}
return nil
2014-12-05 07:07:51 +03:00
}
m . NextUpdate = time . Now ( ) . Add ( time . Duration ( m . Interval ) * time . Hour )
2015-01-02 08:30:45 +03:00
mirrors = append ( mirrors , m )
return nil
2014-12-05 07:07:51 +03:00
} ) ; err != nil {
2015-01-02 08:30:45 +03:00
log . Error ( 4 , "MirrorUpdate: %v" , err )
}
for i := range mirrors {
if err := UpdateMirror ( mirrors [ i ] ) ; err != nil {
log . Error ( 4 , "UpdateMirror" , fmt . Sprintf ( "%s: %v" , mirrors [ i ] . RepoName , err ) )
}
2014-12-05 07:07:51 +03:00
}
}
2014-11-30 10:26:29 +03:00
// GitFsck calls 'git fsck' to check repository health.
func GitFsck ( ) {
2014-12-05 07:07:51 +03:00
if isGitFscking {
return
}
isGitFscking = true
defer func ( ) { isGitFscking = false } ( )
2015-01-02 15:14:43 +03:00
args := append ( [ ] string { "fsck" } , setting . Git . Fsck . Args ... )
2014-11-30 10:26:29 +03:00
if err := x . Where ( "id > 0" ) . Iterate ( new ( Repository ) ,
func ( idx int , bean interface { } ) error {
repo := bean . ( * Repository )
if err := repo . GetOwner ( ) ; err != nil {
return err
}
repoPath := RepoPath ( repo . Owner . Name , repo . Name )
_ , _ , err := process . ExecDir ( - 1 , repoPath , "Repository health check" , "git" , args ... )
if err != nil {
desc := fmt . Sprintf ( "Fail to health check repository(%s)" , repoPath )
log . Warn ( desc )
if err = CreateRepositoryNotice ( desc ) ; err != nil {
log . Error ( 4 , "Fail to add notice: %v" , err )
}
}
return nil
} ) ; err != nil {
log . Error ( 4 , "repo.Fsck: %v" , err )
}
}
func GitGcRepos ( ) error {
2015-01-02 15:14:43 +03:00
args := append ( [ ] string { "gc" } , setting . Git . GcArgs ... )
2014-11-30 10:26:29 +03:00
return x . Where ( "id > 0" ) . Iterate ( new ( Repository ) ,
func ( idx int , bean interface { } ) error {
repo := bean . ( * Repository )
if err := repo . GetOwner ( ) ; err != nil {
return err
}
_ , stderr , err := process . ExecDir ( - 1 , RepoPath ( repo . Owner . Name , repo . Name ) , "Repository garbage collection" , "git" , args ... )
if err != nil {
return fmt . Errorf ( "%v: %v" , err , stderr )
}
return nil
} )
}
2015-02-12 05:58:37 +03:00
// _________ .__ .__ ___. __ .__
// \_ ___ \ ____ | | | | _____ \_ |__ ________________ _/ |_|__| ____ ____
// / \ \/ / _ \| | | | \__ \ | __ \ / _ \_ __ \__ \\ __\ |/ _ \ / \
// \ \___( <_> ) |_| |__/ __ \| \_\ ( <_> ) | \// __ \| | | ( <_> ) | \
// \______ /\____/|____/____(____ /___ /\____/|__| (____ /__| |__|\____/|___| /
// \/ \/ \/ \/ \/
// A Collaboration is a relation between an individual and a repository
type Collaboration struct {
ID int64 ` xorm:"pk autoincr" `
RepoID int64 ` xorm:"UNIQUE(s) INDEX NOT NULL" `
UserID int64 ` xorm:"UNIQUE(s) INDEX NOT NULL" `
Created time . Time ` xorm:"CREATED" `
}
// Add collaborator and accompanying access
2015-02-13 08:58:46 +03:00
func ( repo * Repository ) AddCollaborator ( u * User ) error {
collaboration := & Collaboration {
RepoID : repo . Id ,
UserID : u . Id ,
}
2015-02-05 16:29:08 +03:00
2015-02-12 05:58:37 +03:00
has , err := x . Get ( collaboration )
if err != nil {
return err
2015-02-13 08:58:46 +03:00
} else if has {
2015-02-05 16:29:08 +03:00
return nil
2015-02-12 05:58:37 +03:00
}
2015-02-13 08:58:46 +03:00
sess := x . NewSession ( )
defer sessionRelease ( sess )
if err = sess . Begin ( ) ; err != nil {
2015-02-12 05:58:37 +03:00
return err
}
2015-02-13 08:58:46 +03:00
if _ , err = sess . InsertOne ( collaboration ) ; err != nil {
return err
} else if err = repo . recalculateAccesses ( sess ) ; err != nil {
2015-02-12 05:58:37 +03:00
return err
}
2015-02-13 08:58:46 +03:00
return sess . Commit ( )
2015-02-12 05:58:37 +03:00
}
2015-02-13 08:58:46 +03:00
func ( repo * Repository ) getCollaborators ( e Engine ) ( [ ] * User , error ) {
2015-02-05 16:29:08 +03:00
collaborations := make ( [ ] * Collaboration , 0 )
2015-02-13 08:58:46 +03:00
if err := e . Find ( & collaborations , & Collaboration { RepoID : repo . Id } ) ; err != nil {
2015-02-12 05:58:37 +03:00
return nil , err
}
users := make ( [ ] * User , len ( collaborations ) )
for i , c := range collaborations {
2015-02-13 08:58:46 +03:00
user , err := getUserById ( e , c . UserID )
2015-02-12 05:58:37 +03:00
if err != nil {
return nil , err
}
users [ i ] = user
}
return users , nil
}
2015-02-13 08:58:46 +03:00
// GetCollaborators returns the collaborators for a repository
func ( repo * Repository ) GetCollaborators ( ) ( [ ] * User , error ) {
return repo . getCollaborators ( x )
}
2015-02-12 05:58:37 +03:00
// Delete collaborator and accompanying access
2015-02-13 08:58:46 +03:00
func ( repo * Repository ) DeleteCollaborator ( u * User ) ( err error ) {
collaboration := & Collaboration {
RepoID : repo . Id ,
UserID : u . Id ,
}
sess := x . NewSession ( )
defer sessionRelease ( sess )
if err = sess . Begin ( ) ; err != nil {
return err
}
2015-02-12 05:58:37 +03:00
2015-02-13 08:58:46 +03:00
if has , err := sess . Delete ( collaboration ) ; err != nil || has == 0 {
return err
} else if err = repo . recalculateAccesses ( sess ) ; err != nil {
2015-02-12 05:58:37 +03:00
return err
}
2015-02-13 08:58:46 +03:00
return sess . Commit ( )
2015-02-12 05:58:37 +03:00
}
2014-09-23 23:30:04 +04:00
// __ __ __ .__
// / \ / \_____ _/ |_ ____ | |__
// \ \/\/ /\__ \\ __\/ ___\| | \
// \ / / __ \| | \ \___| Y \
// \__/\ / (____ /__| \___ >___| /
// \/ \/ \/ \/
2014-12-07 04:22:48 +03:00
// Watch is connection request for receiving repository notification.
2014-03-21 00:04:56 +04:00
type Watch struct {
Id int64
2014-05-08 01:38:03 +04:00
UserId int64 ` xorm:"UNIQUE(watch)" `
RepoId int64 ` xorm:"UNIQUE(watch)" `
2014-03-21 00:04:56 +04:00
}
2014-10-19 09:35:24 +04:00
// IsWatching checks if user has watched given repository.
func IsWatching ( uid , repoId int64 ) bool {
has , _ := x . Get ( & Watch { 0 , uid , repoId } )
return has
}
2015-02-11 07:44:16 +03:00
func watchRepo ( e Engine , uid , repoId int64 , watch bool ) ( err error ) {
2014-03-21 00:04:56 +04:00
if watch {
2014-08-11 07:11:18 +04:00
if IsWatching ( uid , repoId ) {
return nil
}
2014-10-19 09:35:24 +04:00
if _ , err = e . Insert ( & Watch { RepoId : repoId , UserId : uid } ) ; err != nil {
2014-03-21 00:14:50 +04:00
return err
}
2014-10-19 09:35:24 +04:00
_ , err = e . Exec ( "UPDATE `repository` SET num_watches = num_watches + 1 WHERE id = ?" , repoId )
2014-03-21 00:04:56 +04:00
} else {
2014-08-11 07:11:18 +04:00
if ! IsWatching ( uid , repoId ) {
return nil
}
2014-10-19 09:35:24 +04:00
if _ , err = e . Delete ( & Watch { 0 , uid , repoId } ) ; err != nil {
2014-03-21 00:14:50 +04:00
return err
}
2014-10-19 09:35:24 +04:00
_ , err = e . Exec ( "UPDATE `repository` SET num_watches = num_watches - 1 WHERE id = ?" , repoId )
2014-03-21 00:04:56 +04:00
}
return err
}
2014-10-19 09:35:24 +04:00
// Watch or unwatch repository.
func WatchRepo ( uid , repoId int64 , watch bool ) ( err error ) {
2015-02-11 07:44:16 +03:00
return watchRepo ( x , uid , repoId , watch )
2014-08-11 07:11:18 +04:00
}
2015-02-13 08:58:46 +03:00
func getWatchers ( e Engine , rid int64 ) ( [ ] * Watch , error ) {
2014-05-08 00:51:14 +04:00
watches := make ( [ ] * Watch , 0 , 10 )
2015-02-13 08:58:46 +03:00
err := e . Find ( & watches , & Watch { RepoId : rid } )
2014-03-21 00:04:56 +04:00
return watches , err
}
2015-02-13 08:58:46 +03:00
// GetWatchers returns all watchers of given repository.
func GetWatchers ( rid int64 ) ( [ ] * Watch , error ) {
return getWatchers ( x , rid )
}
func notifyWatchers ( e Engine , act * Action ) error {
2014-03-25 22:04:57 +04:00
// Add feeds for user self and all watchers.
2015-02-13 08:58:46 +03:00
watches , err := getWatchers ( e , act . RepoId )
2014-03-20 09:31:24 +04:00
if err != nil {
2015-02-13 08:58:46 +03:00
return fmt . Errorf ( "get watchers: %v" , err )
2014-03-20 09:31:24 +04:00
}
2014-03-27 20:48:29 +04:00
// Add feed for actioner.
act . UserId = act . ActUserId
2015-02-13 08:58:46 +03:00
if _ , err = e . InsertOne ( act ) ; err != nil {
return fmt . Errorf ( "insert new actioner: %v" , err )
2014-03-27 20:48:29 +04:00
}
2014-03-20 09:31:24 +04:00
2014-03-25 22:04:57 +04:00
for i := range watches {
2014-05-08 01:23:02 +04:00
if act . ActUserId == watches [ i ] . UserId {
2014-03-27 20:48:29 +04:00
continue
2014-03-20 09:31:24 +04:00
}
2014-04-02 18:38:30 +04:00
act . Id = 0
2014-05-08 01:23:02 +04:00
act . UserId = watches [ i ] . UserId
2015-02-13 08:58:46 +03:00
if _ , err = e . InsertOne ( act ) ; err != nil {
return fmt . Errorf ( "insert new action: %v" , err )
2014-03-25 22:04:57 +04:00
}
2014-03-20 09:31:24 +04:00
}
2014-03-25 22:04:57 +04:00
return nil
2014-03-20 09:31:24 +04:00
}
2015-02-13 08:58:46 +03:00
// NotifyWatchers creates batch of actions for every watcher.
func NotifyWatchers ( act * Action ) error {
return notifyWatchers ( x , act )
}
2014-09-23 23:30:04 +04:00
// _________ __
// / _____// |______ _______
// \_____ \\ __\__ \\_ __ \
// / \| | / __ \| | \/
// /_______ /|__| (____ /__|
// \/ \/
2014-08-11 07:11:18 +04:00
type Star struct {
Id int64
Uid int64 ` xorm:"UNIQUE(s)" `
RepoId int64 ` xorm:"UNIQUE(s)" `
}
// Star or unstar repository.
func StarRepo ( uid , repoId int64 , star bool ) ( err error ) {
if star {
if IsStaring ( uid , repoId ) {
return nil
}
if _ , err = x . Insert ( & Star { Uid : uid , RepoId : repoId } ) ; err != nil {
return err
2014-09-26 03:33:39 +04:00
} else if _ , err = x . Exec ( "UPDATE `repository` SET num_stars = num_stars + 1 WHERE id = ?" , repoId ) ; err != nil {
return err
2014-08-11 07:11:18 +04:00
}
2014-09-26 03:33:39 +04:00
_ , err = x . Exec ( "UPDATE `user` SET num_stars = num_stars + 1 WHERE id = ?" , uid )
2014-08-11 07:11:18 +04:00
} else {
if ! IsStaring ( uid , repoId ) {
return nil
}
if _ , err = x . Delete ( & Star { 0 , uid , repoId } ) ; err != nil {
return err
2014-09-26 03:33:39 +04:00
} else if _ , err = x . Exec ( "UPDATE `repository` SET num_stars = num_stars - 1 WHERE id = ?" , repoId ) ; err != nil {
return err
2014-08-11 07:11:18 +04:00
}
2014-09-26 03:33:39 +04:00
_ , err = x . Exec ( "UPDATE `user` SET num_stars = num_stars - 1 WHERE id = ?" , uid )
2014-08-11 07:11:18 +04:00
}
return err
}
// IsStaring checks if user has starred given repository.
func IsStaring ( uid , repoId int64 ) bool {
has , _ := x . Get ( & Star { 0 , uid , repoId } )
2014-03-21 00:04:56 +04:00
return has
2014-03-17 22:03:58 +04:00
}
2014-10-19 09:35:24 +04:00
// ___________ __
// \_ _____/__________| | __
// | __)/ _ \_ __ \ |/ /
// | \( <_> ) | \/ <
// \___ / \____/|__| |__|_ \
// \/ \/
2014-11-06 07:30:04 +03:00
func ForkRepository ( u * User , oldRepo * Repository , name , desc string ) ( * Repository , error ) {
isExist , err := IsRepositoryExist ( u , name )
2014-10-19 09:35:24 +04:00
if err != nil {
return nil , err
} else if isExist {
return nil , ErrRepoAlreadyExist
}
// In case the old repository is a fork.
if oldRepo . IsFork {
oldRepo , err = GetRepositoryById ( oldRepo . ForkId )
if err != nil {
return nil , err
}
}
repo := & Repository {
OwnerId : u . Id ,
Owner : u ,
2014-11-06 07:30:04 +03:00
Name : name ,
LowerName : strings . ToLower ( name ) ,
Description : desc ,
2014-10-19 09:35:24 +04:00
IsPrivate : oldRepo . IsPrivate ,
IsFork : true ,
ForkId : oldRepo . Id ,
}
2015-02-13 08:58:46 +03:00
sess := x . NewSession ( )
defer sessionRelease ( sess )
if err = sess . Begin ( ) ; err != nil {
return nil , err
}
2014-10-19 09:35:24 +04:00
if _ , err = sess . Insert ( repo ) ; err != nil {
return nil , err
}
2014-03-18 07:22:19 +04:00
2015-02-13 08:58:46 +03:00
if err = repo . recalculateAccesses ( sess ) ; err != nil {
2015-02-05 16:29:08 +03:00
return nil , err
2015-02-13 10:14:57 +03:00
} else if _ , err = sess . Exec ( "UPDATE `user` SET num_repos = num_repos + 1 WHERE id = ?" , u . Id ) ; err != nil {
2014-10-19 09:35:24 +04:00
return nil , err
}
if u . IsOrganization ( ) {
2015-02-13 10:14:57 +03:00
// Update owner team info and count.
2015-02-13 08:58:46 +03:00
t , err := u . getOwnerTeam ( sess )
2014-10-19 09:35:24 +04:00
if err != nil {
2015-02-13 08:58:46 +03:00
return nil , fmt . Errorf ( "get owner team: %v" , err )
2015-02-13 10:14:57 +03:00
} else if err = t . getMembers ( sess ) ; err != nil {
return nil , fmt . Errorf ( "get team members: %v" , err )
}
for _ , u := range t . Members {
if err = watchRepo ( sess , u . Id , repo . Id , true ) ; err != nil {
return nil , fmt . Errorf ( "watch repository: %v" , err )
2014-10-19 09:35:24 +04:00
}
}
2015-02-13 10:14:57 +03:00
t . RepoIds += "$" + com . ToStr ( repo . Id ) + "|"
t . NumRepos ++
if _ , err = sess . Id ( t . Id ) . AllCols ( ) . Update ( t ) ; err != nil {
return nil , err
}
2014-10-19 09:35:24 +04:00
} else {
2015-02-11 07:44:16 +03:00
if err = watchRepo ( sess , u . Id , repo . Id , true ) ; err != nil {
2015-02-13 08:58:46 +03:00
return nil , fmt . Errorf ( "watch repository 2: %v" , err )
2014-10-19 09:35:24 +04:00
}
}
2015-02-13 08:58:46 +03:00
if err = newRepoAction ( sess , u , repo ) ; err != nil {
return nil , fmt . Errorf ( "new repository action: %v" , err )
2014-10-19 09:35:24 +04:00
}
2015-02-13 08:58:46 +03:00
if _ , err = sess . Exec ( "UPDATE `repository` SET num_forks = num_forks + 1 WHERE id = ?" , oldRepo . Id ) ; err != nil {
2014-10-19 09:35:24 +04:00
return nil , err
}
oldRepoPath , err := oldRepo . RepoPath ( )
if err != nil {
2015-02-13 08:58:46 +03:00
return nil , fmt . Errorf ( "get old repository path: %v" , err )
2014-10-19 09:35:24 +04:00
}
repoPath := RepoPath ( u . Name , repo . Name )
_ , stderr , err := process . ExecTimeout ( 10 * time . Minute ,
fmt . Sprintf ( "ForkRepository(git clone): %s/%s" , u . Name , repo . Name ) ,
2014-10-25 02:43:17 +04:00
"git" , "clone" , "--bare" , oldRepoPath , repoPath )
2014-10-19 09:35:24 +04:00
if err != nil {
2015-02-13 08:58:46 +03:00
return nil , fmt . Errorf ( "git clone: %v" , stderr )
2014-10-19 09:35:24 +04:00
}
_ , stderr , err = process . ExecDir ( - 1 ,
repoPath , fmt . Sprintf ( "ForkRepository(git update-server-info): %s" , repoPath ) ,
"git" , "update-server-info" )
if err != nil {
2015-02-13 08:58:46 +03:00
return nil , fmt . Errorf ( "git update-server-info: %v" , err )
2014-10-19 09:35:24 +04:00
}
2015-02-13 08:58:46 +03:00
return repo , sess . Commit ( )
2014-07-23 15:48:06 +04:00
}