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-03-11 08:18:44 +04:00
"io/ioutil"
2014-02-14 18:20:57 +04:00
"os"
2014-03-30 06:18:36 +04:00
"path"
2014-02-14 18:20:57 +04:00
"path/filepath"
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
"github.com/gogits/git"
2014-03-08 02:22:15 +04:00
2014-03-11 09:32:36 +04:00
"github.com/gogits/gogs/modules/base"
2014-05-26 04:11:25 +04:00
"github.com/gogits/gogs/modules/bin"
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 (
TPL_UPDATE_HOOK = "#!/usr/bin/env %s\n%s update $1 $2 $3\n"
)
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-03-11 09:32:36 +04:00
)
2014-03-10 04:06:29 +04:00
var (
2014-03-21 00:04:56 +04:00
LanguageIgns , Licenses [ ] string
2014-03-10 04:06:29 +04:00
)
2014-05-26 04:11:25 +04:00
// getAssetList returns corresponding asset list in 'conf'.
func getAssetList ( prefix string ) [ ] string {
assets := make ( [ ] string , 0 , 15 )
for _ , name := range bin . AssetNames ( ) {
if strings . HasPrefix ( name , prefix ) {
2014-06-02 05:47:48 +04:00
assets = append ( assets , strings . TrimPrefix ( name , prefix + "/" ) )
2014-05-26 04:11:25 +04:00
}
2014-05-11 22:03:51 +04:00
}
2014-05-26 04:11:25 +04:00
return assets
}
2014-05-11 22:03:51 +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-05-26 04:11:25 +04:00
files := getAssetList ( path . Join ( "conf" , t ) )
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-05-26 04:11:25 +04:00
log . Fatal ( "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
}
LanguageIgns = typeFiles [ 0 ]
Licenses = typeFiles [ 1 ]
2014-06-03 07:17:21 +04:00
sort . Strings ( LanguageIgns )
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
// Check if server has basic git setting.
2014-06-19 09:08:03 +04:00
stdout , stderr , err := process . Exec ( "NewRepoContext(get setting)" , "git" , "config" , "--get" , "user.name" )
2014-04-23 06:34:49 +04:00
if strings . Contains ( stderr , "fatal:" ) {
2014-06-01 18:53:57 +04:00
log . Fatal ( "repo.NewRepoContext(fail to get git user.name): %s" , stderr )
2014-04-23 06:34:49 +04:00
} else if err != nil || len ( strings . TrimSpace ( stdout ) ) == 0 {
2014-06-19 09:08:03 +04:00
if _ , stderr , err = process . Exec ( "NewRepoContext(set email)" , "git" , "config" , "--global" , "user.email" , "gogitservice@gmail.com" ) ; err != nil {
2014-06-01 18:53:57 +04:00
log . Fatal ( "repo.NewRepoContext(fail to set git user.email): %s" , stderr )
2014-06-19 09:08:03 +04:00
} else if _ , stderr , err = process . Exec ( "NewRepoContext(set name)" , "git" , "config" , "--global" , "user.name" , "Gogs" ) ; err != nil {
2014-06-01 18:53:57 +04:00
log . Fatal ( "repo.NewRepoContext(fail to set git user.name): %s" , stderr )
}
}
barePath := path . Join ( setting . RepoRootPath , "git-bare.zip" )
if ! com . IsExist ( barePath ) {
data , err := bin . Asset ( "conf/content/git-bare.zip" )
if err != nil {
log . Fatal ( "Fail to get asset 'git-bare.zip': %v" , err )
} else if err := ioutil . WriteFile ( barePath , data , os . ModePerm ) ; err != nil {
log . Fatal ( "Fail to write asset 'git-bare.zip': %v" , err )
2014-03-17 23:58:32 +04:00
}
}
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-05-12 22:06:42 +04:00
Id int64
2014-06-09 01:53:53 +04:00
OwnerId int64 ` xorm:"UNIQUE(s)" `
2014-05-12 22:06:42 +04:00
Owner * User ` xorm:"-" `
ForkId int64
2014-06-09 01:53:53 +04:00
LowerName string ` xorm:"UNIQUE(s) INDEX NOT NULL" `
Name string ` xorm:"INDEX NOT NULL" `
2014-05-12 22:06:42 +04:00
Description string
Website string
NumWatches int
NumStars int
NumForks int
NumIssues int
NumClosedIssues int
NumOpenIssues int ` xorm:"-" `
NumMilestones int ` xorm:"NOT NULL DEFAULT 0" `
NumClosedMilestones int ` xorm:"NOT NULL DEFAULT 0" `
NumOpenMilestones int ` xorm:"-" `
NumTags int ` xorm:"-" `
IsPrivate bool
IsMirror bool
IsBare bool
IsGoget bool
DefaultBranch string
2014-06-09 01:53:53 +04:00
Created time . Time ` xorm:"CREATED" `
Updated time . Time ` xorm:"UPDATED" `
2014-03-21 00:04:56 +04:00
}
2014-05-08 16:18:03 +04:00
func ( repo * Repository ) GetOwner ( ) ( err error ) {
repo . Owner , err = GetUserById ( repo . OwnerId )
return err
}
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-03-20 19:41:24 +04:00
var (
2014-06-25 08:44:48 +04:00
illegalEquals = [ ] string { "raw" , "install" , "api" , "avatar" , "user" , "org" , "help" , "stars" , "issues" , "pulls" , "commits" , "repo" , "template" , "admin" }
2014-03-30 01:50:51 +04:00
illegalSuffixs = [ ] string { ".git" }
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-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-06-19 09:08:03 +04:00
// TODO: need timeout.
_ , stderr , err := process . Exec ( fmt . Sprintf ( "MirrorRepository: %s/%s" , userName , repoName ) ,
"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
}
return git . UnpackRefs ( repoPath )
}
2014-04-13 06:30:00 +04:00
func GetMirror ( repoId int64 ) ( * Mirror , error ) {
m := & Mirror { RepoId : repoId }
2014-06-21 08:51:41 +04:00
has , err := x . Get ( m )
2014-04-13 06:30:00 +04:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrMirrorNotExist
}
return m , nil
}
func UpdateMirror ( m * Mirror ) error {
2014-06-21 08:51:41 +04:00
_ , err := x . Id ( m . Id ) . Update ( m )
2014-04-13 06:30:00 +04:00
return err
}
2014-04-13 05:30:09 +04:00
// MirrorUpdate checks and updates mirror repositories.
func MirrorUpdate ( ) {
2014-06-21 08:51:41 +04:00
if err := x . Iterate ( new ( Mirror ) , func ( idx int , bean interface { } ) error {
2014-04-13 05:30:09 +04:00
m := bean . ( * Mirror )
if m . NextUpdate . After ( time . Now ( ) ) {
return nil
}
2014-06-19 09:08:03 +04:00
// TODO: need timeout.
2014-05-26 04:11:25 +04:00
repoPath := filepath . Join ( setting . RepoRootPath , m . RepoName + ".git" )
2014-06-19 09:08:03 +04:00
if _ , stderr , err := process . ExecDir (
repoPath , fmt . Sprintf ( "MirrorUpdate: %s" , repoPath ) ,
"git" , "remote" , "update" ) ; err != nil {
2014-04-27 11:05:13 +04:00
return errors . New ( "git remote update: " + stderr )
2014-04-13 05:30:09 +04:00
} else if err = git . UnpackRefs ( repoPath ) ; err != nil {
2014-06-27 11:37:01 +04:00
return errors . New ( "UnpackRefs: " + err . Error ( ) )
2014-04-13 05:30:09 +04:00
}
m . NextUpdate = time . Now ( ) . Add ( time . Duration ( m . Interval ) * time . Hour )
2014-04-13 06:30:00 +04:00
return UpdateMirror ( m )
2014-04-13 05:30:09 +04:00
} ) ; err != nil {
log . Error ( "repo.MirrorUpdate: %v" , err )
}
}
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 ) {
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
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-06-19 09:08:03 +04:00
// TODO: need timeout.
2014-04-13 04:35:35 +04:00
// Clone from local repository.
2014-06-19 09:08:03 +04:00
_ , stderr , err := process . Exec (
fmt . Sprintf ( "MigrateRepository(git clone): %s" , repoPath ) ,
"git" , "clone" , repoPath , tmpDir )
2014-04-13 04:35:35 +04:00
if err != nil {
return repo , errors . New ( "git clone: " + stderr )
}
2014-06-19 09:08:03 +04:00
// TODO: need timeout.
2014-04-13 04:35:35 +04:00
// Pull data from source.
2014-06-19 09:08:03 +04:00
if _ , stderr , err = process . ExecDir (
tmpDir , fmt . Sprintf ( "MigrateRepository(git pull): %s" , repoPath ) ,
"git" , "pull" , url ) ; err != nil {
2014-04-13 04:35:35 +04:00
return repo , errors . New ( "git pull: " + stderr )
}
2014-06-19 09:08:03 +04:00
// TODO: need timeout.
2014-04-13 04:35:35 +04:00
// Push data to local repository.
2014-06-19 09:08:03 +04:00
if _ , stderr , err = process . ExecDir (
tmpDir , fmt . Sprintf ( "MigrateRepository(git push): %s" , repoPath ) ,
"git" , "push" , "origin" , "master" ) ; err != nil {
2014-04-13 04:35:35 +04:00
return repo , errors . New ( "git push: " + stderr )
}
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-06-26 17:39:27 +04:00
z , err := zip . Open ( filepath . Join ( setting . RepoRootPath , "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-06-19 09:08:03 +04:00
if _ , stderr , err = process . ExecDir (
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
if _ , stderr , err = process . ExecDir (
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-06-19 09:08:03 +04:00
if _ , stderr , err = process . ExecDir (
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
}
2014-03-26 17:40:02 +04:00
func createHookUpdate ( hookPath , content string ) error {
pu , err := os . OpenFile ( hookPath , os . O_CREATE | os . O_WRONLY , 0777 )
if err != nil {
return err
}
defer pu . Close ( )
2014-03-27 23:24:11 +04:00
_ , err = pu . WriteString ( content )
return err
2014-03-26 17:40:02 +04:00
}
2014-04-08 20:41:33 +04:00
// SetRepoEnvs sets environment variables for command update.
2014-05-03 09:37:49 +04:00
func SetRepoEnvs ( userId int64 , userName , repoName , repoUserName string ) {
2014-04-08 20:41:33 +04:00
os . Setenv ( "userId" , base . ToStr ( userId ) )
os . Setenv ( "userName" , userName )
os . Setenv ( "repoName" , repoName )
2014-05-03 09:37:49 +04:00
os . Setenv ( "repoUserName" , repoUserName )
2014-04-08 20:41:33 +04:00
}
2014-03-11 04:48:58 +04:00
// InitRepository initializes README and .gitignore if needed.
2014-03-11 09:32:36 +04:00
func initRepository ( f string , user * User , repo * Repository , initReadme bool , repoLang , license string ) error {
2014-03-17 19:56:50 +04:00
repoPath := RepoPath ( user . 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
}
2014-04-27 05:06:59 +04:00
rp := strings . NewReplacer ( "\\" , "/" , " " , "\\ " )
2014-03-18 01:00:35 +04:00
// hook/post-update
2014-03-26 17:40:02 +04:00
if err := createHookUpdate ( filepath . Join ( repoPath , "hooks" , "update" ) ,
2014-06-11 03:11:53 +04:00
fmt . Sprintf ( TPL_UPDATE_HOOK , setting . ScriptType ,
2014-04-27 05:06:59 +04:00
rp . Replace ( appPath ) ) ) ; 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-05-26 04:11:25 +04:00
tmpDir := filepath . Join ( os . TempDir ( ) , base . 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-03-11 14:10:19 +04:00
if repoLang != "" {
filePath := "conf/gitignore/" + repoLang
2014-06-04 05:51:25 +04:00
targetPath := path . Join ( tmpDir , fileName [ "gitign" ] )
data , err := bin . Asset ( filePath )
if err == nil {
if err = ioutil . WriteFile ( targetPath , data , os . ModePerm ) ; 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-03-11 08:53:53 +04:00
2014-03-17 19:56:50 +04:00
// LICENSE
2014-03-11 14:10:19 +04:00
if license != "" {
filePath := "conf/license/" + license
2014-06-04 05:51:25 +04:00
targetPath := path . Join ( tmpDir , fileName [ "license" ] )
data , err := bin . Asset ( filePath )
if err == nil {
if err = ioutil . WriteFile ( targetPath , data , os . ModePerm ) ; 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-03-11 08:18:44 +04:00
2014-03-18 01:00:35 +04:00
if len ( fileName ) == 0 {
return nil
}
2014-05-03 09:37:49 +04:00
SetRepoEnvs ( user . Id , user . Name , repo . Name , user . Name )
2014-04-07 22:24:58 +04:00
2014-03-17 19:56:50 +04:00
// Apply changes and commit.
2014-03-27 23:24:11 +04:00
return initRepoCommit ( tmpDir , user . 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
}
2014-06-25 13:14:36 +04:00
sess := x . NewSession ( )
defer sess . Close ( )
if err = sess . Begin ( ) ; err != nil {
return nil , err
}
2014-06-19 09:08:03 +04:00
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 ,
IsBare : lang == "" && license == "" && ! initReadme ,
}
if ! repo . IsBare {
repo . DefaultBranch = "master"
}
if _ , err = sess . Insert ( repo ) ; err != nil {
sess . Rollback ( )
return nil , err
}
2014-06-25 13:14:36 +04:00
var t * Team // Owner team.
2014-06-25 08:44:48 +04:00
mode := WRITABLE
2014-06-19 09:08:03 +04:00
if mirror {
2014-06-25 08:44:48 +04:00
mode = READABLE
2014-06-19 09:08:03 +04:00
}
2014-06-25 13:14:36 +04:00
access := & Access {
UserName : u . LowerName ,
RepoName : strings . ToLower ( path . Join ( u . Name , repo . Name ) ) ,
2014-06-19 09:08:03 +04:00
Mode : mode ,
}
2014-06-25 13:14:36 +04:00
// Give access to all members in owner team.
if u . IsOrganization ( ) {
t , err = u . GetOwnerTeam ( )
if err != nil {
sess . Rollback ( )
return nil , err
}
us , err := GetTeamMembers ( u . Id , t . Id )
if err != nil {
sess . Rollback ( )
return nil , err
}
for _ , u := range us {
access . UserName = u . LowerName
if _ , err = sess . Insert ( access ) ; err != nil {
sess . Rollback ( )
return nil , err
}
}
} else {
if _ , err = sess . Insert ( access ) ; err != nil {
sess . Rollback ( )
return nil , err
2014-06-19 09:08:03 +04:00
}
}
rawSql := "UPDATE `user` SET num_repos = num_repos + 1 WHERE id = ?"
2014-06-25 13:14:36 +04:00
if _ , err = sess . Exec ( rawSql , u . Id ) ; err != nil {
2014-06-19 09:08:03 +04:00
sess . Rollback ( )
return nil , err
}
2014-06-25 13:14:36 +04:00
// Update owner team info and count.
if u . IsOrganization ( ) {
t . RepoIds += "$" + base . ToStr ( repo . Id ) + "|"
t . NumRepos ++
if _ , err = sess . Id ( t . Id ) . AllCols ( ) . Update ( t ) ; err != nil {
sess . Rollback ( )
return nil , err
2014-06-19 09:08:03 +04:00
}
2014-06-25 13:14:36 +04:00
}
if err = sess . Commit ( ) ; err != nil {
2014-06-19 09:08:03 +04:00
return nil , err
}
2014-06-25 13:14:36 +04:00
if u . IsOrganization ( ) {
ous , err := GetOrgUsersByOrgId ( u . Id )
if err != nil {
log . Error ( "repo.CreateRepository(GetOrgUsersByOrgId): %v" , err )
} else {
for _ , ou := range ous {
if err = WatchRepo ( ou . Uid , repo . Id , true ) ; err != nil {
log . Error ( "repo.CreateRepository(WatchRepo): %v" , err )
}
}
}
}
if err = WatchRepo ( u . Id , repo . Id , true ) ; err != nil {
log . Error ( "repo.CreateRepository(WatchRepo2): %v" , err )
2014-06-19 09:08:03 +04:00
}
2014-06-25 13:14:36 +04:00
if err = NewRepoAction ( u , repo ) ; err != nil {
2014-06-19 09:08:03 +04:00
log . Error ( "repo.CreateRepository(NewRepoAction): %v" , err )
}
// No need for init for mirror.
if mirror {
return repo , nil
}
2014-06-25 13:14:36 +04:00
repoPath := RepoPath ( u . Name , repo . Name )
if err = initRepository ( repoPath , u , repo , initReadme , lang , license ) ; err != nil {
if err2 := os . RemoveAll ( repoPath ) ; err2 != nil {
log . Error ( "repo.CreateRepository(initRepository): %v" , err )
return nil , errors . New ( fmt . Sprintf (
"delete repo directory %s/%s failed(2): %v" , u . Name , repo . Name , err2 ) )
}
2014-06-19 09:08:03 +04:00
return nil , err
}
_ , stderr , err := process . ExecDir (
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 )
}
return repo , nil
}
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.
func TransferOwnership ( user * User , newOwner string , repo * Repository ) ( err error ) {
newUser , err := GetUserByName ( newOwner )
if err != nil {
return err
}
// Update accesses.
accesses := make ( [ ] Access , 0 , 10 )
2014-06-21 08:51:41 +04:00
if err = x . Find ( & accesses , & Access { RepoName : user . LowerName + "/" + repo . LowerName } ) ; err != nil {
2014-04-05 02:31:09 +04:00
return err
}
2014-04-05 02:55:17 +04:00
2014-06-21 08:51:41 +04:00
sess := x . NewSession ( )
2014-04-05 02:55:17 +04:00
defer sess . Close ( )
if err = sess . Begin ( ) ; err != nil {
return err
}
2014-04-05 02:31:09 +04:00
for i := range accesses {
accesses [ i ] . RepoName = newUser . LowerName + "/" + repo . LowerName
if accesses [ i ] . UserName == user . LowerName {
accesses [ i ] . UserName = newUser . LowerName
}
2014-04-05 02:55:17 +04:00
if err = UpdateAccessWithSession ( sess , & accesses [ i ] ) ; err != nil {
2014-04-05 02:31:09 +04:00
return err
}
}
// Update repository.
repo . OwnerId = newUser . Id
2014-04-05 02:55:17 +04:00
if _ , err := sess . Id ( repo . Id ) . Update ( repo ) ; err != nil {
sess . Rollback ( )
2014-04-05 02:31:09 +04:00
return err
}
// Update user repository number.
rawSql := "UPDATE `user` SET num_repos = num_repos + 1 WHERE id = ?"
2014-04-05 02:55:17 +04:00
if _ , err = sess . Exec ( rawSql , newUser . Id ) ; err != nil {
sess . Rollback ( )
2014-04-05 02:31:09 +04:00
return err
}
rawSql = "UPDATE `user` SET num_repos = num_repos - 1 WHERE id = ?"
2014-04-05 02:55:17 +04:00
if _ , err = sess . Exec ( rawSql , user . Id ) ; err != nil {
sess . Rollback ( )
2014-04-05 02:31:09 +04:00
return err
}
// Add watch of new owner to repository.
if ! IsWatching ( newUser . Id , repo . Id ) {
if err = WatchRepo ( newUser . Id , repo . Id , true ) ; err != nil {
2014-04-05 02:55:17 +04:00
sess . Rollback ( )
2014-04-05 02:31:09 +04:00
return err
}
}
if err = TransferRepoAction ( user , newUser , repo ) ; err != nil {
2014-04-05 02:55:17 +04:00
sess . Rollback ( )
2014-04-05 02:31:09 +04:00
return err
}
// Change repository directory name.
2014-04-05 02:55:17 +04:00
if err = os . Rename ( RepoPath ( user . Name , repo . Name ) , RepoPath ( newUser . Name , repo . Name ) ) ; err != nil {
sess . Rollback ( )
return err
}
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 ) {
// Update accesses.
2014-04-04 00:33:27 +04:00
accesses := make ( [ ] Access , 0 , 10 )
2014-06-21 08:51:41 +04:00
if err = x . Find ( & accesses , & Access { RepoName : strings . ToLower ( userName + "/" + oldRepoName ) } ) ; err != nil {
2014-04-03 23:50:55 +04:00
return err
}
2014-04-05 02:55:17 +04:00
2014-06-21 08:51:41 +04:00
sess := x . NewSession ( )
2014-04-05 02:55:17 +04:00
defer sess . Close ( )
if err = sess . Begin ( ) ; err != nil {
return err
}
2014-04-03 23:50:55 +04:00
for i := range accesses {
accesses [ i ] . RepoName = userName + "/" + newRepoName
2014-04-05 02:55:17 +04:00
if err = UpdateAccessWithSession ( sess , & accesses [ i ] ) ; err != nil {
2014-04-03 23:50:55 +04:00
return err
}
}
// Change repository directory name.
2014-04-05 02:55:17 +04:00
if err = os . Rename ( RepoPath ( userName , oldRepoName ) , RepoPath ( userName , newRepoName ) ) ; err != nil {
sess . Rollback ( )
return err
}
return sess . Commit ( )
2014-04-03 23:50:55 +04:00
}
2014-03-22 12:44:57 +04:00
func UpdateRepository ( 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 ]
}
2014-06-21 08:51:41 +04:00
_ , err := x . Id ( repo . Id ) . AllCols ( ) . Update ( repo )
2014-03-22 12:44:57 +04:00
return err
}
2014-03-21 00:04:56 +04:00
// DeleteRepository deletes a repository for a user or orgnaztion.
2014-06-28 08:40:07 +04:00
func DeleteRepository ( userId , repoId int64 , userName string ) error {
2014-03-21 00:04:56 +04:00
repo := & Repository { Id : repoId , OwnerId : userId }
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-06-21 08:51:41 +04:00
sess := x . NewSession ( )
2014-04-05 02:31:09 +04:00
defer sess . Close ( )
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-04-05 02:31:09 +04:00
if _ , err = sess . Delete ( & Repository { Id : repoId } ) ; err != nil {
sess . Rollback ( )
2014-03-21 00:04:56 +04:00
return err
}
2014-04-05 02:31:09 +04:00
if _ , err := sess . Delete ( & Access { RepoName : strings . ToLower ( path . Join ( userName , repo . Name ) ) } ) ; err != nil {
sess . Rollback ( )
2014-03-21 00:04:56 +04:00
return err
}
2014-04-13 04:35:35 +04:00
if _ , err := sess . Delete ( & Action { RepoId : repo . Id } ) ; err != nil {
2014-04-05 02:31:09 +04:00
sess . Rollback ( )
2014-03-21 00:04:56 +04:00
return err
}
2014-04-05 02:31:09 +04:00
if _ , err = sess . Delete ( & Watch { RepoId : repoId } ) ; err != nil {
sess . Rollback ( )
2014-03-21 00:04:56 +04:00
return err
}
2014-04-13 06:30:00 +04:00
if _ , err = sess . Delete ( & Mirror { RepoId : repoId } ) ; err != nil {
sess . Rollback ( )
return err
}
2014-05-14 21:04:57 +04:00
if _ , err = sess . Delete ( & IssueUser { RepoId : repoId } ) ; err != nil {
2014-05-14 16:51:04 +04:00
sess . Rollback ( )
return err
}
2014-05-14 21:04:57 +04:00
if _ , err = sess . Delete ( & Milestone { RepoId : repoId } ) ; err != nil {
2014-05-14 16:51:04 +04:00
sess . Rollback ( )
return err
}
2014-05-14 21:04:57 +04:00
if _ , err = sess . Delete ( & Release { RepoId : repoId } ) ; err != nil {
sess . Rollback ( )
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 {
sess . Rollback ( )
return err
}
return nil
} ) ; err != nil {
sess . Rollback ( )
return err
}
if _ , err = sess . Delete ( & Issue { RepoId : repoId } ) ; err != nil {
2014-05-14 17:23:33 +04:00
sess . Rollback ( )
return err
}
2014-04-13 04:35:35 +04:00
rawSql := "UPDATE `user` SET num_repos = num_repos - 1 WHERE id = ?"
if _ , err = sess . Exec ( rawSql , userId ) ; err != nil {
sess . Rollback ( )
return err
}
2014-03-21 00:04:56 +04:00
if err = os . RemoveAll ( RepoPath ( userName , repo . Name ) ) ; err != nil {
2014-06-09 01:53:53 +04:00
sess . Rollback ( )
2014-03-21 00:04:56 +04:00
return err
}
2014-06-09 01:53:53 +04:00
return sess . Commit ( )
2014-03-21 00:04:56 +04:00
}
2014-03-17 22:03:58 +04:00
// GetRepositoryByName returns the repository by given name under user if exists.
2014-03-22 12:44:57 +04:00
func GetRepositoryByName ( userId int64 , repoName string ) ( * Repository , error ) {
2014-03-13 06:27:11 +04:00
repo := & Repository {
2014-03-22 12:44:57 +04:00
OwnerId : userId ,
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
}
2014-03-17 22:03:58 +04:00
// GetRepositoryById returns the repository by given id if exists.
2014-03-28 03:42:10 +04:00
func GetRepositoryById ( id int64 ) ( * Repository , error ) {
repo := & Repository { }
2014-06-21 08:51:41 +04:00
has , err := x . 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
}
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.
func GetRecentUpdatedRepositories ( ) ( repos [ ] * Repository , err error ) {
2014-06-21 08:51:41 +04:00
err = x . Where ( "is_private=?" , false ) . Limit ( 5 ) . 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-05-08 20:24:11 +04:00
// GetCollaboratorNames returns a list of user name of repository's collaborators.
func GetCollaboratorNames ( repoName string ) ( [ ] string , error ) {
2014-05-01 19:32:12 +04:00
accesses := make ( [ ] * Access , 0 , 10 )
2014-06-21 08:51:41 +04:00
if err := x . Find ( & accesses , & Access { RepoName : strings . ToLower ( repoName ) } ) ; err != nil {
2014-05-01 19:32:12 +04:00
return nil , err
}
names := make ( [ ] string , len ( accesses ) )
for i := range accesses {
names [ i ] = accesses [ i ] . UserName
}
return names , nil
}
2014-05-12 23:14:22 +04:00
// GetCollaborativeRepos returns a list of repositories that user is collaborator.
func GetCollaborativeRepos ( uname string ) ( [ ] * Repository , error ) {
uname = strings . ToLower ( uname )
accesses := make ( [ ] * Access , 0 , 10 )
2014-06-21 08:51:41 +04:00
if err := x . Find ( & accesses , & Access { UserName : uname } ) ; err != nil {
2014-05-12 23:14:22 +04:00
return nil , err
}
repos := make ( [ ] * Repository , 0 , 10 )
for _ , access := range accesses {
2014-06-11 12:54:25 +04:00
infos := strings . Split ( access . RepoName , "/" )
if infos [ 0 ] == uname {
2014-05-12 23:14:22 +04:00
continue
}
u , err := GetUserByName ( infos [ 0 ] )
if err != nil {
return nil , err
}
repo , err := GetRepositoryByName ( u . Id , infos [ 1 ] )
if err != nil {
return nil , err
}
repo . Owner = u
repos = append ( repos , repo )
}
return repos , nil
}
2014-05-08 20:24:11 +04:00
// GetCollaborators returns a list of users of repository's collaborators.
func GetCollaborators ( repoName string ) ( us [ ] * User , err error ) {
accesses := make ( [ ] * Access , 0 , 10 )
2014-06-21 08:51:41 +04:00
if err = x . Find ( & accesses , & Access { RepoName : strings . ToLower ( repoName ) } ) ; err != nil {
2014-05-08 20:24:11 +04:00
return nil , err
}
us = make ( [ ] * User , len ( accesses ) )
for i := range accesses {
us [ i ] , err = GetUserByName ( accesses [ i ] . UserName )
if err != nil {
return nil , err
}
}
return us , nil
}
2014-03-21 00:04:56 +04:00
// Watch is connection request for receiving repository notifycation.
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
}
// Watch or unwatch repository.
2014-05-08 00:51:14 +04:00
func WatchRepo ( uid , rid int64 , watch bool ) ( err error ) {
2014-03-21 00:04:56 +04:00
if watch {
2014-06-21 08:51:41 +04:00
if _ , err = x . Insert ( & Watch { RepoId : rid , UserId : uid } ) ; err != nil {
2014-03-21 00:14:50 +04:00
return err
}
rawSql := "UPDATE `repository` SET num_watches = num_watches + 1 WHERE id = ?"
2014-06-21 08:51:41 +04:00
_ , err = x . Exec ( rawSql , rid )
2014-03-21 00:04:56 +04:00
} else {
2014-06-21 08:51:41 +04:00
if _ , err = x . Delete ( & Watch { 0 , uid , rid } ) ; err != nil {
2014-03-21 00:14:50 +04:00
return err
}
rawSql := "UPDATE `repository` SET num_watches = num_watches - 1 WHERE id = ?"
2014-06-21 08:51:41 +04:00
_ , err = x . Exec ( rawSql , rid )
2014-03-21 00:04:56 +04:00
}
return err
}
2014-05-08 00:51:14 +04:00
// GetWatchers returns all watchers of given repository.
func GetWatchers ( rid int64 ) ( [ ] * Watch , error ) {
watches := make ( [ ] * Watch , 0 , 10 )
2014-06-21 08:51:41 +04:00
err := x . Find ( & watches , & Watch { RepoId : rid } )
2014-03-21 00:04:56 +04:00
return watches , err
}
2014-03-25 22:04:57 +04:00
// NotifyWatchers creates batch of actions for every watcher.
2014-03-27 19:37:33 +04:00
func NotifyWatchers ( act * Action ) error {
2014-03-25 22:04:57 +04:00
// Add feeds for user self and all watchers.
2014-05-08 00:51:14 +04:00
watches , err := GetWatchers ( act . RepoId )
2014-03-20 09:31:24 +04:00
if err != nil {
2014-03-25 22:04:57 +04:00
return errors . New ( "repo.NotifyWatchers(get watches): " + err . Error ( ) )
2014-03-20 09:31:24 +04:00
}
2014-03-27 20:48:29 +04:00
// Add feed for actioner.
act . UserId = act . ActUserId
2014-06-21 08:51:41 +04:00
if _ , err = x . InsertOne ( act ) ; err != nil {
2014-03-27 20:48:29 +04:00
return errors . New ( "repo.NotifyWatchers(create action): " + err . Error ( ) )
}
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
2014-06-21 08:51:41 +04:00
if _ , err = x . InsertOne ( act ) ; err != nil {
2014-03-25 22:04:57 +04:00
return errors . New ( "repo.NotifyWatchers(create action): " + err . Error ( ) )
}
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
}
2014-03-21 00:04:56 +04:00
// IsWatching checks if user has watched given repository.
2014-05-08 00:51:14 +04:00
func IsWatching ( uid , rid int64 ) bool {
2014-06-21 08:51:41 +04:00
has , _ := x . Get ( & Watch { 0 , uid , rid } )
2014-03-21 00:04:56 +04:00
return has
2014-03-17 22:03:58 +04:00
}
2014-05-08 00:51:14 +04:00
func ForkRepository ( repoName string , uid int64 ) {
2014-03-18 07:22:19 +04:00
2014-03-17 22:03:58 +04:00
}