repo_editor.go 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513
  1. // Copyright 2016 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 db
  5. import (
  6. "fmt"
  7. "io"
  8. "io/ioutil"
  9. "mime/multipart"
  10. "os"
  11. "os/exec"
  12. "path"
  13. "path/filepath"
  14. "strings"
  15. "time"
  16. gouuid "github.com/satori/go.uuid"
  17. "github.com/unknwon/com"
  18. "github.com/gogs/git-module"
  19. "gogs.io/gogs/internal/conf"
  20. "gogs.io/gogs/internal/db/errors"
  21. "gogs.io/gogs/internal/gitutil"
  22. "gogs.io/gogs/internal/osutil"
  23. "gogs.io/gogs/internal/process"
  24. "gogs.io/gogs/internal/tool"
  25. )
  26. const (
  27. ENV_AUTH_USER_ID = "GOGS_AUTH_USER_ID"
  28. ENV_AUTH_USER_NAME = "GOGS_AUTH_USER_NAME"
  29. ENV_AUTH_USER_EMAIL = "GOGS_AUTH_USER_EMAIL"
  30. ENV_REPO_OWNER_NAME = "GOGS_REPO_OWNER_NAME"
  31. ENV_REPO_OWNER_SALT_MD5 = "GOGS_REPO_OWNER_SALT_MD5"
  32. ENV_REPO_ID = "GOGS_REPO_ID"
  33. ENV_REPO_NAME = "GOGS_REPO_NAME"
  34. ENV_REPO_CUSTOM_HOOKS_PATH = "GOGS_REPO_CUSTOM_HOOKS_PATH"
  35. )
  36. type ComposeHookEnvsOptions struct {
  37. AuthUser *User
  38. OwnerName string
  39. OwnerSalt string
  40. RepoID int64
  41. RepoName string
  42. RepoPath string
  43. }
  44. func ComposeHookEnvs(opts ComposeHookEnvsOptions) []string {
  45. envs := []string{
  46. "SSH_ORIGINAL_COMMAND=1",
  47. ENV_AUTH_USER_ID + "=" + com.ToStr(opts.AuthUser.ID),
  48. ENV_AUTH_USER_NAME + "=" + opts.AuthUser.Name,
  49. ENV_AUTH_USER_EMAIL + "=" + opts.AuthUser.Email,
  50. ENV_REPO_OWNER_NAME + "=" + opts.OwnerName,
  51. ENV_REPO_OWNER_SALT_MD5 + "=" + tool.MD5(opts.OwnerSalt),
  52. ENV_REPO_ID + "=" + com.ToStr(opts.RepoID),
  53. ENV_REPO_NAME + "=" + opts.RepoName,
  54. ENV_REPO_CUSTOM_HOOKS_PATH + "=" + filepath.Join(opts.RepoPath, "custom_hooks"),
  55. }
  56. return envs
  57. }
  58. // ___________ .___.__ __ ___________.__.__
  59. // \_ _____/ __| _/|__|/ |_ \_ _____/|__| | ____
  60. // | __)_ / __ | | \ __\ | __) | | | _/ __ \
  61. // | \/ /_/ | | || | | \ | | |_\ ___/
  62. // /_______ /\____ | |__||__| \___ / |__|____/\___ >
  63. // \/ \/ \/ \/
  64. // discardLocalRepoBranchChanges discards local commits/changes of
  65. // given branch to make sure it is even to remote branch.
  66. func discardLocalRepoBranchChanges(localPath, branch string) error {
  67. if !com.IsExist(localPath) {
  68. return nil
  69. }
  70. // No need to check if nothing in the repository.
  71. if !git.RepoHasBranch(localPath, branch) {
  72. return nil
  73. }
  74. rev := "origin/" + branch
  75. if err := git.RepoReset(localPath, rev, git.ResetOptions{Hard: true}); err != nil {
  76. return fmt.Errorf("reset [revision: %s]: %v", rev, err)
  77. }
  78. return nil
  79. }
  80. func (repo *Repository) DiscardLocalRepoBranchChanges(branch string) error {
  81. return discardLocalRepoBranchChanges(repo.LocalCopyPath(), branch)
  82. }
  83. // CheckoutNewBranch checks out to a new branch from the a branch name.
  84. func (repo *Repository) CheckoutNewBranch(oldBranch, newBranch string) error {
  85. if err := git.RepoCheckout(repo.LocalCopyPath(), newBranch, git.CheckoutOptions{
  86. BaseBranch: oldBranch,
  87. Timeout: time.Duration(conf.Git.Timeout.Pull) * time.Second,
  88. }); err != nil {
  89. return fmt.Errorf("checkout [base: %s, new: %s]: %v", oldBranch, newBranch, err)
  90. }
  91. return nil
  92. }
  93. type UpdateRepoFileOptions struct {
  94. LastCommitID string
  95. OldBranch string
  96. NewBranch string
  97. OldTreeName string
  98. NewTreeName string
  99. Message string
  100. Content string
  101. IsNewFile bool
  102. }
  103. // UpdateRepoFile adds or updates a file in repository.
  104. func (repo *Repository) UpdateRepoFile(doer *User, opts UpdateRepoFileOptions) (err error) {
  105. repoWorkingPool.CheckIn(com.ToStr(repo.ID))
  106. defer repoWorkingPool.CheckOut(com.ToStr(repo.ID))
  107. if err = repo.DiscardLocalRepoBranchChanges(opts.OldBranch); err != nil {
  108. return fmt.Errorf("discard local repo branch[%s] changes: %v", opts.OldBranch, err)
  109. } else if err = repo.UpdateLocalCopyBranch(opts.OldBranch); err != nil {
  110. return fmt.Errorf("update local copy branch[%s]: %v", opts.OldBranch, err)
  111. }
  112. repoPath := repo.RepoPath()
  113. localPath := repo.LocalCopyPath()
  114. if opts.OldBranch != opts.NewBranch {
  115. // Directly return error if new branch already exists in the server
  116. if git.RepoHasBranch(repoPath, opts.NewBranch) {
  117. return errors.BranchAlreadyExists{Name: opts.NewBranch}
  118. }
  119. // Otherwise, delete branch from local copy in case out of sync
  120. if git.RepoHasBranch(localPath, opts.NewBranch) {
  121. if err = git.RepoDeleteBranch(localPath, opts.NewBranch, git.DeleteBranchOptions{
  122. Force: true,
  123. }); err != nil {
  124. return fmt.Errorf("delete branch %q: %v", opts.NewBranch, err)
  125. }
  126. }
  127. if err := repo.CheckoutNewBranch(opts.OldBranch, opts.NewBranch); err != nil {
  128. return fmt.Errorf("checkout new branch[%s] from old branch[%s]: %v", opts.NewBranch, opts.OldBranch, err)
  129. }
  130. }
  131. oldFilePath := path.Join(localPath, opts.OldTreeName)
  132. filePath := path.Join(localPath, opts.NewTreeName)
  133. os.MkdirAll(path.Dir(filePath), os.ModePerm)
  134. // If it's meant to be a new file, make sure it doesn't exist.
  135. if opts.IsNewFile {
  136. if com.IsExist(filePath) {
  137. return ErrRepoFileAlreadyExist{filePath}
  138. }
  139. }
  140. // Ignore move step if it's a new file under a directory.
  141. // Otherwise, move the file when name changed.
  142. if osutil.IsFile(oldFilePath) && opts.OldTreeName != opts.NewTreeName {
  143. if err = git.RepoMove(localPath, opts.OldTreeName, opts.NewTreeName); err != nil {
  144. return fmt.Errorf("git mv %q %q: %v", opts.OldTreeName, opts.NewTreeName, err)
  145. }
  146. }
  147. if err = ioutil.WriteFile(filePath, []byte(opts.Content), 0666); err != nil {
  148. return fmt.Errorf("write file: %v", err)
  149. }
  150. if err = git.RepoAdd(localPath, git.AddOptions{All: true}); err != nil {
  151. return fmt.Errorf("git add --all: %v", err)
  152. } else if err = git.RepoCommit(localPath, doer.NewGitSig(), opts.Message); err != nil {
  153. return fmt.Errorf("commit changes on %q: %v", localPath, err)
  154. }
  155. envs := ComposeHookEnvs(ComposeHookEnvsOptions{
  156. AuthUser: doer,
  157. OwnerName: repo.MustOwner().Name,
  158. OwnerSalt: repo.MustOwner().Salt,
  159. RepoID: repo.ID,
  160. RepoName: repo.Name,
  161. RepoPath: repo.RepoPath(),
  162. })
  163. if err = git.RepoPush(localPath, "origin", opts.NewBranch, git.PushOptions{Envs: envs}); err != nil {
  164. return fmt.Errorf("git push origin %s: %v", opts.NewBranch, err)
  165. }
  166. return nil
  167. }
  168. // GetDiffPreview produces and returns diff result of a file which is not yet committed.
  169. func (repo *Repository) GetDiffPreview(branch, treePath, content string) (diff *gitutil.Diff, err error) {
  170. repoWorkingPool.CheckIn(com.ToStr(repo.ID))
  171. defer repoWorkingPool.CheckOut(com.ToStr(repo.ID))
  172. if err = repo.DiscardLocalRepoBranchChanges(branch); err != nil {
  173. return nil, fmt.Errorf("discard local repo branch[%s] changes: %v", branch, err)
  174. } else if err = repo.UpdateLocalCopyBranch(branch); err != nil {
  175. return nil, fmt.Errorf("update local copy branch[%s]: %v", branch, err)
  176. }
  177. localPath := repo.LocalCopyPath()
  178. filePath := path.Join(localPath, treePath)
  179. os.MkdirAll(filepath.Dir(filePath), os.ModePerm)
  180. if err = ioutil.WriteFile(filePath, []byte(content), 0666); err != nil {
  181. return nil, fmt.Errorf("write file: %v", err)
  182. }
  183. cmd := exec.Command("git", "diff", treePath)
  184. cmd.Dir = localPath
  185. cmd.Stderr = os.Stderr
  186. stdout, err := cmd.StdoutPipe()
  187. if err != nil {
  188. return nil, fmt.Errorf("get stdout pipe: %v", err)
  189. }
  190. if err = cmd.Start(); err != nil {
  191. return nil, fmt.Errorf("start: %v", err)
  192. }
  193. pid := process.Add(fmt.Sprintf("GetDiffPreview [repo_path: %s]", repo.RepoPath()), cmd)
  194. defer process.Remove(pid)
  195. diff, err = gitutil.ParseDiff(stdout, conf.Git.MaxDiffFiles, conf.Git.MaxDiffLines, conf.Git.MaxDiffLineChars)
  196. if err != nil {
  197. return nil, fmt.Errorf("parse diff: %v", err)
  198. }
  199. if err = cmd.Wait(); err != nil {
  200. return nil, fmt.Errorf("wait: %v", err)
  201. }
  202. return diff, nil
  203. }
  204. // ________ .__ __ ___________.__.__
  205. // \______ \ ____ | | _____/ |_ ____ \_ _____/|__| | ____
  206. // | | \_/ __ \| | _/ __ \ __\/ __ \ | __) | | | _/ __ \
  207. // | ` \ ___/| |_\ ___/| | \ ___/ | \ | | |_\ ___/
  208. // /_______ /\___ >____/\___ >__| \___ > \___ / |__|____/\___ >
  209. // \/ \/ \/ \/ \/ \/
  210. //
  211. type DeleteRepoFileOptions struct {
  212. LastCommitID string
  213. OldBranch string
  214. NewBranch string
  215. TreePath string
  216. Message string
  217. }
  218. func (repo *Repository) DeleteRepoFile(doer *User, opts DeleteRepoFileOptions) (err error) {
  219. repoWorkingPool.CheckIn(com.ToStr(repo.ID))
  220. defer repoWorkingPool.CheckOut(com.ToStr(repo.ID))
  221. if err = repo.DiscardLocalRepoBranchChanges(opts.OldBranch); err != nil {
  222. return fmt.Errorf("discard local repo branch[%s] changes: %v", opts.OldBranch, err)
  223. } else if err = repo.UpdateLocalCopyBranch(opts.OldBranch); err != nil {
  224. return fmt.Errorf("update local copy branch[%s]: %v", opts.OldBranch, err)
  225. }
  226. if opts.OldBranch != opts.NewBranch {
  227. if err := repo.CheckoutNewBranch(opts.OldBranch, opts.NewBranch); err != nil {
  228. return fmt.Errorf("checkout new branch[%s] from old branch[%s]: %v", opts.NewBranch, opts.OldBranch, err)
  229. }
  230. }
  231. localPath := repo.LocalCopyPath()
  232. if err = os.Remove(path.Join(localPath, opts.TreePath)); err != nil {
  233. return fmt.Errorf("remove file %q: %v", opts.TreePath, err)
  234. }
  235. if err = git.RepoAdd(localPath, git.AddOptions{All: true}); err != nil {
  236. return fmt.Errorf("git add --all: %v", err)
  237. } else if err = git.RepoCommit(localPath, doer.NewGitSig(), opts.Message); err != nil {
  238. return fmt.Errorf("commit changes to %q: %v", localPath, err)
  239. }
  240. envs := ComposeHookEnvs(ComposeHookEnvsOptions{
  241. AuthUser: doer,
  242. OwnerName: repo.MustOwner().Name,
  243. OwnerSalt: repo.MustOwner().Salt,
  244. RepoID: repo.ID,
  245. RepoName: repo.Name,
  246. RepoPath: repo.RepoPath(),
  247. })
  248. if err = git.RepoPush(localPath, "origin", opts.NewBranch, git.PushOptions{Envs: envs}); err != nil {
  249. return fmt.Errorf("git push origin %s: %v", opts.NewBranch, err)
  250. }
  251. return nil
  252. }
  253. // ____ ___ .__ .___ ___________.___.__
  254. // | | \______ | | _________ __| _/ \_ _____/| | | ____ ______
  255. // | | /\____ \| | / _ \__ \ / __ | | __) | | | _/ __ \ / ___/
  256. // | | / | |_> > |_( <_> ) __ \_/ /_/ | | \ | | |_\ ___/ \___ \
  257. // |______/ | __/|____/\____(____ /\____ | \___ / |___|____/\___ >____ >
  258. // |__| \/ \/ \/ \/ \/
  259. //
  260. // Upload represent a uploaded file to a repo to be deleted when moved
  261. type Upload struct {
  262. ID int64
  263. UUID string `xorm:"uuid UNIQUE"`
  264. Name string
  265. }
  266. // UploadLocalPath returns where uploads is stored in local file system based on given UUID.
  267. func UploadLocalPath(uuid string) string {
  268. return path.Join(conf.Repository.Upload.TempPath, uuid[0:1], uuid[1:2], uuid)
  269. }
  270. // LocalPath returns where uploads are temporarily stored in local file system.
  271. func (upload *Upload) LocalPath() string {
  272. return UploadLocalPath(upload.UUID)
  273. }
  274. // NewUpload creates a new upload object.
  275. func NewUpload(name string, buf []byte, file multipart.File) (_ *Upload, err error) {
  276. if tool.IsMaliciousPath(name) {
  277. return nil, fmt.Errorf("malicious path detected: %s", name)
  278. }
  279. upload := &Upload{
  280. UUID: gouuid.NewV4().String(),
  281. Name: name,
  282. }
  283. localPath := upload.LocalPath()
  284. if err = os.MkdirAll(path.Dir(localPath), os.ModePerm); err != nil {
  285. return nil, fmt.Errorf("mkdir all: %v", err)
  286. }
  287. fw, err := os.Create(localPath)
  288. if err != nil {
  289. return nil, fmt.Errorf("create: %v", err)
  290. }
  291. defer fw.Close()
  292. if _, err = fw.Write(buf); err != nil {
  293. return nil, fmt.Errorf("write: %v", err)
  294. } else if _, err = io.Copy(fw, file); err != nil {
  295. return nil, fmt.Errorf("copy: %v", err)
  296. }
  297. if _, err := x.Insert(upload); err != nil {
  298. return nil, err
  299. }
  300. return upload, nil
  301. }
  302. func GetUploadByUUID(uuid string) (*Upload, error) {
  303. upload := &Upload{UUID: uuid}
  304. has, err := x.Get(upload)
  305. if err != nil {
  306. return nil, err
  307. } else if !has {
  308. return nil, ErrUploadNotExist{0, uuid}
  309. }
  310. return upload, nil
  311. }
  312. func GetUploadsByUUIDs(uuids []string) ([]*Upload, error) {
  313. if len(uuids) == 0 {
  314. return []*Upload{}, nil
  315. }
  316. // Silently drop invalid uuids.
  317. uploads := make([]*Upload, 0, len(uuids))
  318. return uploads, x.In("uuid", uuids).Find(&uploads)
  319. }
  320. func DeleteUploads(uploads ...*Upload) (err error) {
  321. if len(uploads) == 0 {
  322. return nil
  323. }
  324. sess := x.NewSession()
  325. defer sess.Close()
  326. if err = sess.Begin(); err != nil {
  327. return err
  328. }
  329. ids := make([]int64, len(uploads))
  330. for i := 0; i < len(uploads); i++ {
  331. ids[i] = uploads[i].ID
  332. }
  333. if _, err = sess.In("id", ids).Delete(new(Upload)); err != nil {
  334. return fmt.Errorf("delete uploads: %v", err)
  335. }
  336. for _, upload := range uploads {
  337. localPath := upload.LocalPath()
  338. if !osutil.IsFile(localPath) {
  339. continue
  340. }
  341. if err := os.Remove(localPath); err != nil {
  342. return fmt.Errorf("remove upload: %v", err)
  343. }
  344. }
  345. return sess.Commit()
  346. }
  347. func DeleteUpload(u *Upload) error {
  348. return DeleteUploads(u)
  349. }
  350. func DeleteUploadByUUID(uuid string) error {
  351. upload, err := GetUploadByUUID(uuid)
  352. if err != nil {
  353. if IsErrUploadNotExist(err) {
  354. return nil
  355. }
  356. return fmt.Errorf("get upload by UUID[%s]: %v", uuid, err)
  357. }
  358. if err := DeleteUpload(upload); err != nil {
  359. return fmt.Errorf("delete upload: %v", err)
  360. }
  361. return nil
  362. }
  363. type UploadRepoFileOptions struct {
  364. LastCommitID string
  365. OldBranch string
  366. NewBranch string
  367. TreePath string
  368. Message string
  369. Files []string // In UUID format
  370. }
  371. // isRepositoryGitPath returns true if given path is or resides inside ".git" path of the repository.
  372. func isRepositoryGitPath(path string) bool {
  373. return strings.HasSuffix(path, ".git") || strings.Contains(path, ".git"+string(os.PathSeparator))
  374. }
  375. func (repo *Repository) UploadRepoFiles(doer *User, opts UploadRepoFileOptions) (err error) {
  376. if len(opts.Files) == 0 {
  377. return nil
  378. }
  379. uploads, err := GetUploadsByUUIDs(opts.Files)
  380. if err != nil {
  381. return fmt.Errorf("get uploads by UUIDs[%v]: %v", opts.Files, err)
  382. }
  383. repoWorkingPool.CheckIn(com.ToStr(repo.ID))
  384. defer repoWorkingPool.CheckOut(com.ToStr(repo.ID))
  385. if err = repo.DiscardLocalRepoBranchChanges(opts.OldBranch); err != nil {
  386. return fmt.Errorf("discard local repo branch[%s] changes: %v", opts.OldBranch, err)
  387. } else if err = repo.UpdateLocalCopyBranch(opts.OldBranch); err != nil {
  388. return fmt.Errorf("update local copy branch[%s]: %v", opts.OldBranch, err)
  389. }
  390. if opts.OldBranch != opts.NewBranch {
  391. if err = repo.CheckoutNewBranch(opts.OldBranch, opts.NewBranch); err != nil {
  392. return fmt.Errorf("checkout new branch[%s] from old branch[%s]: %v", opts.NewBranch, opts.OldBranch, err)
  393. }
  394. }
  395. localPath := repo.LocalCopyPath()
  396. dirPath := path.Join(localPath, opts.TreePath)
  397. os.MkdirAll(dirPath, os.ModePerm)
  398. // Copy uploaded files into repository
  399. for _, upload := range uploads {
  400. tmpPath := upload.LocalPath()
  401. if !osutil.IsFile(tmpPath) {
  402. continue
  403. }
  404. // Prevent copying files into .git directory, see https://gogs.io/gogs/issues/5558.
  405. if isRepositoryGitPath(upload.Name) {
  406. continue
  407. }
  408. targetPath := path.Join(dirPath, upload.Name)
  409. if err = com.Copy(tmpPath, targetPath); err != nil {
  410. return fmt.Errorf("copy: %v", err)
  411. }
  412. }
  413. if err = git.RepoAdd(localPath, git.AddOptions{All: true}); err != nil {
  414. return fmt.Errorf("git add --all: %v", err)
  415. } else if err = git.RepoCommit(localPath, doer.NewGitSig(), opts.Message); err != nil {
  416. return fmt.Errorf("commit changes on %q: %v", localPath, err)
  417. }
  418. envs := ComposeHookEnvs(ComposeHookEnvsOptions{
  419. AuthUser: doer,
  420. OwnerName: repo.MustOwner().Name,
  421. OwnerSalt: repo.MustOwner().Salt,
  422. RepoID: repo.ID,
  423. RepoName: repo.Name,
  424. RepoPath: repo.RepoPath(),
  425. })
  426. if err = git.RepoPush(localPath, "origin", opts.NewBranch, git.PushOptions{Envs: envs}); err != nil {
  427. return fmt.Errorf("git push origin %s: %v", opts.NewBranch, err)
  428. }
  429. return DeleteUploads(uploads...)
  430. }