repo_editor.go 16 KB

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