repo.go 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990
  1. // Copyright 2014 The Gogs Authors. All rights reserved.
  2. // Use of this source code is governed by a MIT-style
  3. // license that can be found in the LICENSE file.
  4. package models
  5. import (
  6. "errors"
  7. "fmt"
  8. "io/ioutil"
  9. "os"
  10. "path"
  11. "path/filepath"
  12. "sort"
  13. "strings"
  14. "time"
  15. "unicode/utf8"
  16. "github.com/Unknwon/cae/zip"
  17. "github.com/Unknwon/com"
  18. "github.com/gogits/git"
  19. "github.com/gogits/gogs/modules/base"
  20. "github.com/gogits/gogs/modules/bin"
  21. "github.com/gogits/gogs/modules/log"
  22. "github.com/gogits/gogs/modules/process"
  23. "github.com/gogits/gogs/modules/setting"
  24. )
  25. const (
  26. TPL_UPDATE_HOOK = "#!/usr/bin/env %s\n%s update $1 $2 $3\n"
  27. )
  28. var (
  29. ErrRepoAlreadyExist = errors.New("Repository already exist")
  30. ErrRepoNotExist = errors.New("Repository does not exist")
  31. ErrRepoFileNotExist = errors.New("Repository file does not exist")
  32. ErrRepoNameIllegal = errors.New("Repository name contains illegal characters")
  33. ErrRepoFileNotLoaded = errors.New("Repository file not loaded")
  34. ErrMirrorNotExist = errors.New("Mirror does not exist")
  35. )
  36. var (
  37. LanguageIgns, Licenses []string
  38. )
  39. // getAssetList returns corresponding asset list in 'conf'.
  40. func getAssetList(prefix string) []string {
  41. assets := make([]string, 0, 15)
  42. for _, name := range bin.AssetNames() {
  43. if strings.HasPrefix(name, prefix) {
  44. assets = append(assets, strings.TrimPrefix(name, prefix+"/"))
  45. }
  46. }
  47. return assets
  48. }
  49. func LoadRepoConfig() {
  50. // Load .gitignore and license files.
  51. types := []string{"gitignore", "license"}
  52. typeFiles := make([][]string, 2)
  53. for i, t := range types {
  54. files := getAssetList(path.Join("conf", t))
  55. customPath := path.Join(setting.CustomPath, "conf", t)
  56. if com.IsDir(customPath) {
  57. customFiles, err := com.StatDir(customPath)
  58. if err != nil {
  59. log.Fatal("Fail to get custom %s files: %v", t, err)
  60. }
  61. for _, f := range customFiles {
  62. if !com.IsSliceContainsStr(files, f) {
  63. files = append(files, f)
  64. }
  65. }
  66. }
  67. typeFiles[i] = files
  68. }
  69. LanguageIgns = typeFiles[0]
  70. Licenses = typeFiles[1]
  71. sort.Strings(LanguageIgns)
  72. sort.Strings(Licenses)
  73. }
  74. func NewRepoContext() {
  75. zip.Verbose = false
  76. // Check if server has basic git setting.
  77. stdout, stderr, err := process.Exec("NewRepoContext(get setting)", "git", "config", "--get", "user.name")
  78. if err != nil {
  79. log.Fatal("repo.NewRepoContext(fail to get git user.name): %s", stderr)
  80. } else if err != nil || len(strings.TrimSpace(stdout)) == 0 {
  81. if _, stderr, err = process.Exec("NewRepoContext(set email)", "git", "config", "--global", "user.email", "gogitservice@gmail.com"); err != nil {
  82. log.Fatal("repo.NewRepoContext(fail to set git user.email): %s", stderr)
  83. } else if _, stderr, err = process.Exec("NewRepoContext(set name)", "git", "config", "--global", "user.name", "Gogs"); err != nil {
  84. log.Fatal("repo.NewRepoContext(fail to set git user.name): %s", stderr)
  85. }
  86. }
  87. barePath := path.Join(setting.RepoRootPath, "git-bare.zip")
  88. if !com.IsExist(barePath) {
  89. data, err := bin.Asset("conf/content/git-bare.zip")
  90. if err != nil {
  91. log.Fatal("Fail to get asset 'git-bare.zip': %v", err)
  92. } else if err := ioutil.WriteFile(barePath, data, os.ModePerm); err != nil {
  93. log.Fatal("Fail to write asset 'git-bare.zip': %v", err)
  94. }
  95. }
  96. }
  97. // Repository represents a git repository.
  98. type Repository struct {
  99. Id int64
  100. OwnerId int64 `xorm:"UNIQUE(s)"`
  101. Owner *User `xorm:"-"`
  102. ForkId int64
  103. LowerName string `xorm:"UNIQUE(s) INDEX NOT NULL"`
  104. Name string `xorm:"INDEX NOT NULL"`
  105. Description string
  106. Website string
  107. NumWatches int
  108. NumStars int
  109. NumForks int
  110. NumIssues int
  111. NumClosedIssues int
  112. NumOpenIssues int `xorm:"-"`
  113. NumMilestones int `xorm:"NOT NULL DEFAULT 0"`
  114. NumClosedMilestones int `xorm:"NOT NULL DEFAULT 0"`
  115. NumOpenMilestones int `xorm:"-"`
  116. NumTags int `xorm:"-"`
  117. IsPrivate bool
  118. IsMirror bool
  119. IsBare bool
  120. IsGoget bool
  121. DefaultBranch string
  122. Created time.Time `xorm:"CREATED"`
  123. Updated time.Time `xorm:"UPDATED"`
  124. }
  125. func (repo *Repository) GetOwner() (err error) {
  126. repo.Owner, err = GetUserById(repo.OwnerId)
  127. return err
  128. }
  129. // IsRepositoryExist returns true if the repository with given name under user has already existed.
  130. func IsRepositoryExist(u *User, repoName string) (bool, error) {
  131. repo := Repository{OwnerId: u.Id}
  132. has, err := x.Where("lower_name = ?", strings.ToLower(repoName)).Get(&repo)
  133. if err != nil {
  134. return has, err
  135. } else if !has {
  136. return false, nil
  137. }
  138. return com.IsDir(RepoPath(u.Name, repoName)), nil
  139. }
  140. var (
  141. illegalEquals = []string{"debug", "raw", "install", "api", "avatar", "user", "org", "help", "stars", "issues", "pulls", "commits", "repo", "template", "admin", "new"}
  142. illegalSuffixs = []string{".git"}
  143. )
  144. // IsLegalName returns false if name contains illegal characters.
  145. func IsLegalName(repoName string) bool {
  146. repoName = strings.ToLower(repoName)
  147. for _, char := range illegalEquals {
  148. if repoName == char {
  149. return false
  150. }
  151. }
  152. for _, char := range illegalSuffixs {
  153. if strings.HasSuffix(repoName, char) {
  154. return false
  155. }
  156. }
  157. return true
  158. }
  159. // Mirror represents a mirror information of repository.
  160. type Mirror struct {
  161. Id int64
  162. RepoId int64
  163. RepoName string // <user name>/<repo name>
  164. Interval int // Hour.
  165. Updated time.Time `xorm:"UPDATED"`
  166. NextUpdate time.Time
  167. }
  168. // MirrorRepository creates a mirror repository from source.
  169. func MirrorRepository(repoId int64, userName, repoName, repoPath, url string) error {
  170. _, stderr, err := process.ExecTimeout(10*time.Minute,
  171. fmt.Sprintf("MirrorRepository: %s/%s", userName, repoName),
  172. "git", "clone", "--mirror", url, repoPath)
  173. if err != nil {
  174. return errors.New("git clone --mirror: " + stderr)
  175. }
  176. if _, err = x.InsertOne(&Mirror{
  177. RepoId: repoId,
  178. RepoName: strings.ToLower(userName + "/" + repoName),
  179. Interval: 24,
  180. NextUpdate: time.Now().Add(24 * time.Hour),
  181. }); err != nil {
  182. return err
  183. }
  184. return git.UnpackRefs(repoPath)
  185. }
  186. func GetMirror(repoId int64) (*Mirror, error) {
  187. m := &Mirror{RepoId: repoId}
  188. has, err := x.Get(m)
  189. if err != nil {
  190. return nil, err
  191. } else if !has {
  192. return nil, ErrMirrorNotExist
  193. }
  194. return m, nil
  195. }
  196. func UpdateMirror(m *Mirror) error {
  197. _, err := x.Id(m.Id).Update(m)
  198. return err
  199. }
  200. // MirrorUpdate checks and updates mirror repositories.
  201. func MirrorUpdate() {
  202. if err := x.Iterate(new(Mirror), func(idx int, bean interface{}) error {
  203. m := bean.(*Mirror)
  204. if m.NextUpdate.After(time.Now()) {
  205. return nil
  206. }
  207. repoPath := filepath.Join(setting.RepoRootPath, m.RepoName+".git")
  208. if _, stderr, err := process.ExecDir(10*time.Minute,
  209. repoPath, fmt.Sprintf("MirrorUpdate: %s", repoPath),
  210. "git", "remote", "update"); err != nil {
  211. return errors.New("git remote update: " + stderr)
  212. } else if err = git.UnpackRefs(repoPath); err != nil {
  213. return errors.New("UnpackRefs: " + err.Error())
  214. }
  215. m.NextUpdate = time.Now().Add(time.Duration(m.Interval) * time.Hour)
  216. return UpdateMirror(m)
  217. }); err != nil {
  218. log.Error("repo.MirrorUpdate: %v", err)
  219. }
  220. }
  221. // MigrateRepository migrates a existing repository from other project hosting.
  222. func MigrateRepository(u *User, name, desc string, private, mirror bool, url string) (*Repository, error) {
  223. repo, err := CreateRepository(u, name, desc, "", "", private, mirror, false)
  224. if err != nil {
  225. return nil, err
  226. }
  227. // Clone to temprory path and do the init commit.
  228. tmpDir := filepath.Join(os.TempDir(), fmt.Sprintf("%d", time.Now().Nanosecond()))
  229. os.MkdirAll(tmpDir, os.ModePerm)
  230. repoPath := RepoPath(u.Name, name)
  231. repo.IsBare = false
  232. if mirror {
  233. if err = MirrorRepository(repo.Id, u.Name, repo.Name, repoPath, url); err != nil {
  234. return repo, err
  235. }
  236. repo.IsMirror = true
  237. return repo, UpdateRepository(repo)
  238. }
  239. // Clone from local repository.
  240. _, stderr, err := process.ExecTimeout(10*time.Minute,
  241. fmt.Sprintf("MigrateRepository(git clone): %s", repoPath),
  242. "git", "clone", repoPath, tmpDir)
  243. if err != nil {
  244. return repo, errors.New("git clone: " + stderr)
  245. }
  246. // Pull data from source.
  247. if _, stderr, err = process.ExecDir(3*time.Minute,
  248. tmpDir, fmt.Sprintf("MigrateRepository(git pull): %s", repoPath),
  249. "git", "pull", url); err != nil {
  250. return repo, errors.New("git pull: " + stderr)
  251. }
  252. // Push data to local repository.
  253. if _, stderr, err = process.ExecDir(3*time.Minute,
  254. tmpDir, fmt.Sprintf("MigrateRepository(git push): %s", repoPath),
  255. "git", "push", "origin", "master"); err != nil {
  256. return repo, errors.New("git push: " + stderr)
  257. }
  258. return repo, UpdateRepository(repo)
  259. }
  260. // extractGitBareZip extracts git-bare.zip to repository path.
  261. func extractGitBareZip(repoPath string) error {
  262. z, err := zip.Open(filepath.Join(setting.RepoRootPath, "git-bare.zip"))
  263. if err != nil {
  264. return err
  265. }
  266. defer z.Close()
  267. return z.ExtractTo(repoPath)
  268. }
  269. // initRepoCommit temporarily changes with work directory.
  270. func initRepoCommit(tmpPath string, sig *git.Signature) (err error) {
  271. var stderr string
  272. if _, stderr, err = process.ExecDir(-1,
  273. tmpPath, fmt.Sprintf("initRepoCommit(git add): %s", tmpPath),
  274. "git", "add", "--all"); err != nil {
  275. return errors.New("git add: " + stderr)
  276. }
  277. if _, stderr, err = process.ExecDir(-1,
  278. tmpPath, fmt.Sprintf("initRepoCommit(git commit): %s", tmpPath),
  279. "git", "commit", fmt.Sprintf("--author='%s <%s>'", sig.Name, sig.Email),
  280. "-m", "Init commit"); err != nil {
  281. return errors.New("git commit: " + stderr)
  282. }
  283. if _, stderr, err = process.ExecDir(-1,
  284. tmpPath, fmt.Sprintf("initRepoCommit(git push): %s", tmpPath),
  285. "git", "push", "origin", "master"); err != nil {
  286. return errors.New("git push: " + stderr)
  287. }
  288. return nil
  289. }
  290. func createHookUpdate(hookPath, content string) error {
  291. pu, err := os.OpenFile(hookPath, os.O_CREATE|os.O_WRONLY, 0777)
  292. if err != nil {
  293. return err
  294. }
  295. defer pu.Close()
  296. _, err = pu.WriteString(content)
  297. return err
  298. }
  299. // SetRepoEnvs sets environment variables for command update.
  300. func SetRepoEnvs(userId int64, userName, repoName, repoUserName string) {
  301. os.Setenv("userId", base.ToStr(userId))
  302. os.Setenv("userName", userName)
  303. os.Setenv("repoName", repoName)
  304. os.Setenv("repoUserName", repoUserName)
  305. }
  306. // InitRepository initializes README and .gitignore if needed.
  307. func initRepository(f string, user *User, repo *Repository, initReadme bool, repoLang, license string) error {
  308. repoPath := RepoPath(user.Name, repo.Name)
  309. // Create bare new repository.
  310. if err := extractGitBareZip(repoPath); err != nil {
  311. return err
  312. }
  313. rp := strings.NewReplacer("\\", "/", " ", "\\ ")
  314. // hook/post-update
  315. if err := createHookUpdate(filepath.Join(repoPath, "hooks", "update"),
  316. fmt.Sprintf(TPL_UPDATE_HOOK, setting.ScriptType,
  317. rp.Replace(appPath))); err != nil {
  318. return err
  319. }
  320. // Initialize repository according to user's choice.
  321. fileName := map[string]string{}
  322. if initReadme {
  323. fileName["readme"] = "README.md"
  324. }
  325. if repoLang != "" {
  326. fileName["gitign"] = ".gitignore"
  327. }
  328. if license != "" {
  329. fileName["license"] = "LICENSE"
  330. }
  331. // Clone to temprory path and do the init commit.
  332. tmpDir := filepath.Join(os.TempDir(), base.ToStr(time.Now().Nanosecond()))
  333. os.MkdirAll(tmpDir, os.ModePerm)
  334. _, stderr, err := process.Exec(
  335. fmt.Sprintf("initRepository(git clone): %s", repoPath),
  336. "git", "clone", repoPath, tmpDir)
  337. if err != nil {
  338. return errors.New("initRepository(git clone): " + stderr)
  339. }
  340. // README
  341. if initReadme {
  342. defaultReadme := repo.Name + "\n" + strings.Repeat("=",
  343. utf8.RuneCountInString(repo.Name)) + "\n\n" + repo.Description
  344. if err := ioutil.WriteFile(filepath.Join(tmpDir, fileName["readme"]),
  345. []byte(defaultReadme), 0644); err != nil {
  346. return err
  347. }
  348. }
  349. // .gitignore
  350. if repoLang != "" {
  351. filePath := "conf/gitignore/" + repoLang
  352. targetPath := path.Join(tmpDir, fileName["gitign"])
  353. data, err := bin.Asset(filePath)
  354. if err == nil {
  355. if err = ioutil.WriteFile(targetPath, data, os.ModePerm); err != nil {
  356. return err
  357. }
  358. } else {
  359. // Check custom files.
  360. filePath = path.Join(setting.CustomPath, "conf/gitignore", repoLang)
  361. if com.IsFile(filePath) {
  362. if err := com.Copy(filePath, targetPath); err != nil {
  363. return err
  364. }
  365. }
  366. }
  367. }
  368. // LICENSE
  369. if license != "" {
  370. filePath := "conf/license/" + license
  371. targetPath := path.Join(tmpDir, fileName["license"])
  372. data, err := bin.Asset(filePath)
  373. if err == nil {
  374. if err = ioutil.WriteFile(targetPath, data, os.ModePerm); err != nil {
  375. return err
  376. }
  377. } else {
  378. // Check custom files.
  379. filePath = path.Join(setting.CustomPath, "conf/license", license)
  380. if com.IsFile(filePath) {
  381. if err := com.Copy(filePath, targetPath); err != nil {
  382. return err
  383. }
  384. }
  385. }
  386. }
  387. if len(fileName) == 0 {
  388. return nil
  389. }
  390. SetRepoEnvs(user.Id, user.Name, repo.Name, user.Name)
  391. // Apply changes and commit.
  392. return initRepoCommit(tmpDir, user.NewGitSig())
  393. }
  394. // CreateRepository creates a repository for given user or organization.
  395. func CreateRepository(u *User, name, desc, lang, license string, private, mirror, initReadme bool) (*Repository, error) {
  396. if !IsLegalName(name) {
  397. return nil, ErrRepoNameIllegal
  398. }
  399. isExist, err := IsRepositoryExist(u, name)
  400. if err != nil {
  401. return nil, err
  402. } else if isExist {
  403. return nil, ErrRepoAlreadyExist
  404. }
  405. sess := x.NewSession()
  406. defer sess.Close()
  407. if err = sess.Begin(); err != nil {
  408. return nil, err
  409. }
  410. repo := &Repository{
  411. OwnerId: u.Id,
  412. Owner: u,
  413. Name: name,
  414. LowerName: strings.ToLower(name),
  415. Description: desc,
  416. IsPrivate: private,
  417. IsBare: lang == "" && license == "" && !initReadme,
  418. }
  419. if !repo.IsBare {
  420. repo.DefaultBranch = "master"
  421. }
  422. if _, err = sess.Insert(repo); err != nil {
  423. sess.Rollback()
  424. return nil, err
  425. }
  426. var t *Team // Owner team.
  427. mode := WRITABLE
  428. if mirror {
  429. mode = READABLE
  430. }
  431. access := &Access{
  432. UserName: u.LowerName,
  433. RepoName: strings.ToLower(path.Join(u.Name, repo.Name)),
  434. Mode: mode,
  435. }
  436. // Give access to all members in owner team.
  437. if u.IsOrganization() {
  438. t, err = u.GetOwnerTeam()
  439. if err != nil {
  440. sess.Rollback()
  441. return nil, err
  442. }
  443. us, err := GetTeamMembers(u.Id, t.Id)
  444. if err != nil {
  445. sess.Rollback()
  446. return nil, err
  447. }
  448. for _, u := range us {
  449. access.UserName = u.LowerName
  450. if _, err = sess.Insert(access); err != nil {
  451. sess.Rollback()
  452. return nil, err
  453. }
  454. }
  455. } else {
  456. if _, err = sess.Insert(access); err != nil {
  457. sess.Rollback()
  458. return nil, err
  459. }
  460. }
  461. rawSql := "UPDATE `user` SET num_repos = num_repos + 1 WHERE id = ?"
  462. if _, err = sess.Exec(rawSql, u.Id); err != nil {
  463. sess.Rollback()
  464. return nil, err
  465. }
  466. // Update owner team info and count.
  467. if u.IsOrganization() {
  468. t.RepoIds += "$" + base.ToStr(repo.Id) + "|"
  469. t.NumRepos++
  470. if _, err = sess.Id(t.Id).AllCols().Update(t); err != nil {
  471. sess.Rollback()
  472. return nil, err
  473. }
  474. }
  475. if err = sess.Commit(); err != nil {
  476. return nil, err
  477. }
  478. if u.IsOrganization() {
  479. ous, err := GetOrgUsersByOrgId(u.Id)
  480. if err != nil {
  481. log.Error("repo.CreateRepository(GetOrgUsersByOrgId): %v", err)
  482. } else {
  483. for _, ou := range ous {
  484. if err = WatchRepo(ou.Uid, repo.Id, true); err != nil {
  485. log.Error("repo.CreateRepository(WatchRepo): %v", err)
  486. }
  487. }
  488. }
  489. }
  490. if err = WatchRepo(u.Id, repo.Id, true); err != nil {
  491. log.Error("repo.CreateRepository(WatchRepo2): %v", err)
  492. }
  493. if err = NewRepoAction(u, repo); err != nil {
  494. log.Error("repo.CreateRepository(NewRepoAction): %v", err)
  495. }
  496. // No need for init for mirror.
  497. if mirror {
  498. return repo, nil
  499. }
  500. repoPath := RepoPath(u.Name, repo.Name)
  501. if err = initRepository(repoPath, u, repo, initReadme, lang, license); err != nil {
  502. if err2 := os.RemoveAll(repoPath); err2 != nil {
  503. log.Error("repo.CreateRepository(initRepository): %v", err)
  504. return nil, errors.New(fmt.Sprintf(
  505. "delete repo directory %s/%s failed(2): %v", u.Name, repo.Name, err2))
  506. }
  507. return nil, err
  508. }
  509. _, stderr, err := process.ExecDir(-1,
  510. repoPath, fmt.Sprintf("CreateRepository(git update-server-info): %s", repoPath),
  511. "git", "update-server-info")
  512. if err != nil {
  513. return nil, errors.New("CreateRepository(git update-server-info): " + stderr)
  514. }
  515. return repo, nil
  516. }
  517. // GetRepositoriesWithUsers returns given number of repository objects with offset.
  518. // It also auto-gets corresponding users.
  519. func GetRepositoriesWithUsers(num, offset int) ([]*Repository, error) {
  520. repos := make([]*Repository, 0, num)
  521. if err := x.Limit(num, offset).Asc("id").Find(&repos); err != nil {
  522. return nil, err
  523. }
  524. for _, repo := range repos {
  525. repo.Owner = &User{Id: repo.OwnerId}
  526. has, err := x.Get(repo.Owner)
  527. if err != nil {
  528. return nil, err
  529. } else if !has {
  530. return nil, ErrUserNotExist
  531. }
  532. }
  533. return repos, nil
  534. }
  535. // RepoPath returns repository path by given user and repository name.
  536. func RepoPath(userName, repoName string) string {
  537. return filepath.Join(UserPath(userName), strings.ToLower(repoName)+".git")
  538. }
  539. // TransferOwnership transfers all corresponding setting from old user to new one.
  540. func TransferOwnership(u *User, newOwner string, repo *Repository) (err error) {
  541. newUser, err := GetUserByName(newOwner)
  542. if err != nil {
  543. return err
  544. }
  545. sess := x.NewSession()
  546. defer sess.Close()
  547. if err = sess.Begin(); err != nil {
  548. return err
  549. }
  550. if _, err = sess.Where("repo_name = ?", u.LowerName+"/"+repo.LowerName).
  551. And("user_name = ?", u.LowerName).Update(&Access{UserName: newUser.LowerName}); err != nil {
  552. sess.Rollback()
  553. return err
  554. }
  555. if _, err = sess.Where("repo_name = ?", u.LowerName+"/"+repo.LowerName).Update(&Access{
  556. RepoName: newUser.LowerName + "/" + repo.LowerName,
  557. }); err != nil {
  558. sess.Rollback()
  559. return err
  560. }
  561. // Update repository.
  562. repo.OwnerId = newUser.Id
  563. if _, err := sess.Id(repo.Id).Update(repo); err != nil {
  564. sess.Rollback()
  565. return err
  566. }
  567. // Update user repository number.
  568. rawSql := "UPDATE `user` SET num_repos = num_repos + 1 WHERE id = ?"
  569. if _, err = sess.Exec(rawSql, newUser.Id); err != nil {
  570. sess.Rollback()
  571. return err
  572. }
  573. rawSql = "UPDATE `user` SET num_repos = num_repos - 1 WHERE id = ?"
  574. if _, err = sess.Exec(rawSql, u.Id); err != nil {
  575. sess.Rollback()
  576. return err
  577. }
  578. // Change repository directory name.
  579. if err = os.Rename(RepoPath(u.Name, repo.Name), RepoPath(newUser.Name, repo.Name)); err != nil {
  580. sess.Rollback()
  581. return err
  582. }
  583. if err = sess.Commit(); err != nil {
  584. return err
  585. }
  586. // Add watch of new owner to repository.
  587. if !IsWatching(newUser.Id, repo.Id) {
  588. if err = WatchRepo(newUser.Id, repo.Id, true); err != nil {
  589. return err
  590. }
  591. }
  592. if err = TransferRepoAction(u, newUser, repo); err != nil {
  593. return err
  594. }
  595. return nil
  596. }
  597. // ChangeRepositoryName changes all corresponding setting from old repository name to new one.
  598. func ChangeRepositoryName(userName, oldRepoName, newRepoName string) (err error) {
  599. // Update accesses.
  600. accesses := make([]Access, 0, 10)
  601. if err = x.Find(&accesses, &Access{RepoName: strings.ToLower(userName + "/" + oldRepoName)}); err != nil {
  602. return err
  603. }
  604. sess := x.NewSession()
  605. defer sess.Close()
  606. if err = sess.Begin(); err != nil {
  607. return err
  608. }
  609. for i := range accesses {
  610. accesses[i].RepoName = userName + "/" + newRepoName
  611. if err = UpdateAccessWithSession(sess, &accesses[i]); err != nil {
  612. return err
  613. }
  614. }
  615. // Change repository directory name.
  616. if err = os.Rename(RepoPath(userName, oldRepoName), RepoPath(userName, newRepoName)); err != nil {
  617. sess.Rollback()
  618. return err
  619. }
  620. return sess.Commit()
  621. }
  622. func UpdateRepository(repo *Repository) error {
  623. repo.LowerName = strings.ToLower(repo.Name)
  624. if len(repo.Description) > 255 {
  625. repo.Description = repo.Description[:255]
  626. }
  627. if len(repo.Website) > 255 {
  628. repo.Website = repo.Website[:255]
  629. }
  630. _, err := x.Id(repo.Id).AllCols().Update(repo)
  631. return err
  632. }
  633. // DeleteRepository deletes a repository for a user or orgnaztion.
  634. func DeleteRepository(userId, repoId int64, userName string) error {
  635. repo := &Repository{Id: repoId, OwnerId: userId}
  636. has, err := x.Get(repo)
  637. if err != nil {
  638. return err
  639. } else if !has {
  640. return ErrRepoNotExist
  641. }
  642. sess := x.NewSession()
  643. defer sess.Close()
  644. if err = sess.Begin(); err != nil {
  645. return err
  646. }
  647. if _, err = sess.Delete(&Repository{Id: repoId}); err != nil {
  648. sess.Rollback()
  649. return err
  650. }
  651. if _, err := sess.Delete(&Access{RepoName: strings.ToLower(path.Join(userName, repo.Name))}); err != nil {
  652. sess.Rollback()
  653. return err
  654. }
  655. if _, err := sess.Delete(&Action{RepoId: repo.Id}); err != nil {
  656. sess.Rollback()
  657. return err
  658. }
  659. if _, err = sess.Delete(&Watch{RepoId: repoId}); err != nil {
  660. sess.Rollback()
  661. return err
  662. }
  663. if _, err = sess.Delete(&Mirror{RepoId: repoId}); err != nil {
  664. sess.Rollback()
  665. return err
  666. }
  667. if _, err = sess.Delete(&IssueUser{RepoId: repoId}); err != nil {
  668. sess.Rollback()
  669. return err
  670. }
  671. if _, err = sess.Delete(&Milestone{RepoId: repoId}); err != nil {
  672. sess.Rollback()
  673. return err
  674. }
  675. if _, err = sess.Delete(&Release{RepoId: repoId}); err != nil {
  676. sess.Rollback()
  677. return err
  678. }
  679. // Delete comments.
  680. if err = x.Iterate(&Issue{RepoId: repoId}, func(idx int, bean interface{}) error {
  681. issue := bean.(*Issue)
  682. if _, err = sess.Delete(&Comment{IssueId: issue.Id}); err != nil {
  683. sess.Rollback()
  684. return err
  685. }
  686. return nil
  687. }); err != nil {
  688. sess.Rollback()
  689. return err
  690. }
  691. if _, err = sess.Delete(&Issue{RepoId: repoId}); err != nil {
  692. sess.Rollback()
  693. return err
  694. }
  695. rawSql := "UPDATE `user` SET num_repos = num_repos - 1 WHERE id = ?"
  696. if _, err = sess.Exec(rawSql, userId); err != nil {
  697. sess.Rollback()
  698. return err
  699. }
  700. if err = os.RemoveAll(RepoPath(userName, repo.Name)); err != nil {
  701. sess.Rollback()
  702. return err
  703. }
  704. return sess.Commit()
  705. }
  706. // GetRepositoryByName returns the repository by given name under user if exists.
  707. func GetRepositoryByName(userId int64, repoName string) (*Repository, error) {
  708. repo := &Repository{
  709. OwnerId: userId,
  710. LowerName: strings.ToLower(repoName),
  711. }
  712. has, err := x.Get(repo)
  713. if err != nil {
  714. return nil, err
  715. } else if !has {
  716. return nil, ErrRepoNotExist
  717. }
  718. return repo, err
  719. }
  720. // GetRepositoryById returns the repository by given id if exists.
  721. func GetRepositoryById(id int64) (*Repository, error) {
  722. repo := &Repository{}
  723. has, err := x.Id(id).Get(repo)
  724. if err != nil {
  725. return nil, err
  726. } else if !has {
  727. return nil, ErrRepoNotExist
  728. }
  729. return repo, nil
  730. }
  731. // GetRepositories returns a list of repositories of given user.
  732. func GetRepositories(uid int64, private bool) ([]*Repository, error) {
  733. repos := make([]*Repository, 0, 10)
  734. sess := x.Desc("updated")
  735. if !private {
  736. sess.Where("is_private=?", false)
  737. }
  738. err := sess.Find(&repos, &Repository{OwnerId: uid})
  739. return repos, err
  740. }
  741. // GetRecentUpdatedRepositories returns the list of repositories that are recently updated.
  742. func GetRecentUpdatedRepositories() (repos []*Repository, err error) {
  743. err = x.Where("is_private=?", false).Limit(5).Desc("updated").Find(&repos)
  744. return repos, err
  745. }
  746. // GetRepositoryCount returns the total number of repositories of user.
  747. func GetRepositoryCount(user *User) (int64, error) {
  748. return x.Count(&Repository{OwnerId: user.Id})
  749. }
  750. // GetCollaboratorNames returns a list of user name of repository's collaborators.
  751. func GetCollaboratorNames(repoName string) ([]string, error) {
  752. accesses := make([]*Access, 0, 10)
  753. if err := x.Find(&accesses, &Access{RepoName: strings.ToLower(repoName)}); err != nil {
  754. return nil, err
  755. }
  756. names := make([]string, len(accesses))
  757. for i := range accesses {
  758. names[i] = accesses[i].UserName
  759. }
  760. return names, nil
  761. }
  762. // GetCollaborativeRepos returns a list of repositories that user is collaborator.
  763. func GetCollaborativeRepos(uname string) ([]*Repository, error) {
  764. uname = strings.ToLower(uname)
  765. accesses := make([]*Access, 0, 10)
  766. if err := x.Find(&accesses, &Access{UserName: uname}); err != nil {
  767. return nil, err
  768. }
  769. repos := make([]*Repository, 0, 10)
  770. for _, access := range accesses {
  771. infos := strings.Split(access.RepoName, "/")
  772. if infos[0] == uname {
  773. continue
  774. }
  775. u, err := GetUserByName(infos[0])
  776. if err != nil {
  777. return nil, err
  778. }
  779. repo, err := GetRepositoryByName(u.Id, infos[1])
  780. if err != nil {
  781. return nil, err
  782. }
  783. repo.Owner = u
  784. repos = append(repos, repo)
  785. }
  786. return repos, nil
  787. }
  788. // GetCollaborators returns a list of users of repository's collaborators.
  789. func GetCollaborators(repoName string) (us []*User, err error) {
  790. accesses := make([]*Access, 0, 10)
  791. if err = x.Find(&accesses, &Access{RepoName: strings.ToLower(repoName)}); err != nil {
  792. return nil, err
  793. }
  794. us = make([]*User, len(accesses))
  795. for i := range accesses {
  796. us[i], err = GetUserByName(accesses[i].UserName)
  797. if err != nil {
  798. return nil, err
  799. }
  800. }
  801. return us, nil
  802. }
  803. // Watch is connection request for receiving repository notifycation.
  804. type Watch struct {
  805. Id int64
  806. UserId int64 `xorm:"UNIQUE(watch)"`
  807. RepoId int64 `xorm:"UNIQUE(watch)"`
  808. }
  809. // Watch or unwatch repository.
  810. func WatchRepo(uid, rid int64, watch bool) (err error) {
  811. if watch {
  812. if _, err = x.Insert(&Watch{RepoId: rid, UserId: uid}); err != nil {
  813. return err
  814. }
  815. rawSql := "UPDATE `repository` SET num_watches = num_watches + 1 WHERE id = ?"
  816. _, err = x.Exec(rawSql, rid)
  817. } else {
  818. if _, err = x.Delete(&Watch{0, uid, rid}); err != nil {
  819. return err
  820. }
  821. rawSql := "UPDATE `repository` SET num_watches = num_watches - 1 WHERE id = ?"
  822. _, err = x.Exec(rawSql, rid)
  823. }
  824. return err
  825. }
  826. // GetWatchers returns all watchers of given repository.
  827. func GetWatchers(rid int64) ([]*Watch, error) {
  828. watches := make([]*Watch, 0, 10)
  829. err := x.Find(&watches, &Watch{RepoId: rid})
  830. return watches, err
  831. }
  832. // NotifyWatchers creates batch of actions for every watcher.
  833. func NotifyWatchers(act *Action) error {
  834. // Add feeds for user self and all watchers.
  835. watches, err := GetWatchers(act.RepoId)
  836. if err != nil {
  837. return errors.New("repo.NotifyWatchers(get watches): " + err.Error())
  838. }
  839. // Add feed for actioner.
  840. act.UserId = act.ActUserId
  841. if _, err = x.InsertOne(act); err != nil {
  842. return errors.New("repo.NotifyWatchers(create action): " + err.Error())
  843. }
  844. for i := range watches {
  845. if act.ActUserId == watches[i].UserId {
  846. continue
  847. }
  848. act.Id = 0
  849. act.UserId = watches[i].UserId
  850. if _, err = x.InsertOne(act); err != nil {
  851. return errors.New("repo.NotifyWatchers(create action): " + err.Error())
  852. }
  853. }
  854. return nil
  855. }
  856. // IsWatching checks if user has watched given repository.
  857. func IsWatching(uid, rid int64) bool {
  858. has, _ := x.Get(&Watch{0, uid, rid})
  859. return has
  860. }
  861. func ForkRepository(repoName string, uid int64) {
  862. }