Fork to maintain patches against the official gitea for https://code.ceondo.com https://github.com/go-gitea/gitea

migrations.go 23KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779
  1. // Copyright 2015 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 migrations
  5. import (
  6. "bytes"
  7. "encoding/json"
  8. "fmt"
  9. "io/ioutil"
  10. "os"
  11. "path"
  12. "path/filepath"
  13. "strings"
  14. "time"
  15. "github.com/Unknwon/com"
  16. "github.com/go-xorm/xorm"
  17. gouuid "github.com/satori/go.uuid"
  18. "gopkg.in/ini.v1"
  19. "code.gitea.io/gitea/modules/base"
  20. "code.gitea.io/gitea/modules/log"
  21. "code.gitea.io/gitea/modules/setting"
  22. )
  23. const minDBVersion = 4
  24. // Migration describes on migration from lower version to high version
  25. type Migration interface {
  26. Description() string
  27. Migrate(*xorm.Engine) error
  28. }
  29. type migration struct {
  30. description string
  31. migrate func(*xorm.Engine) error
  32. }
  33. // NewMigration creates a new migration
  34. func NewMigration(desc string, fn func(*xorm.Engine) error) Migration {
  35. return &migration{desc, fn}
  36. }
  37. // Description returns the migration's description
  38. func (m *migration) Description() string {
  39. return m.description
  40. }
  41. // Migrate executes the migration
  42. func (m *migration) Migrate(x *xorm.Engine) error {
  43. return m.migrate(x)
  44. }
  45. // Version describes the version table. Should have only one row with id==1
  46. type Version struct {
  47. ID int64 `xorm:"pk autoincr"`
  48. Version int64
  49. }
  50. // This is a sequence of migrations. Add new migrations to the bottom of the list.
  51. // If you want to "retire" a migration, remove it from the top of the list and
  52. // update minDBVersion accordingly
  53. var migrations = []Migration{
  54. // v0 -> v4: before 0.6.0 -> 0.7.33
  55. NewMigration("fix locale file load panic", fixLocaleFileLoadPanic), // V4 -> V5:v0.6.0
  56. NewMigration("trim action compare URL prefix", trimCommitActionAppURLPrefix), // V5 -> V6:v0.6.3
  57. NewMigration("generate issue-label from issue", issueToIssueLabel), // V6 -> V7:v0.6.4
  58. NewMigration("refactor attachment table", attachmentRefactor), // V7 -> V8:v0.6.4
  59. NewMigration("rename pull request fields", renamePullRequestFields), // V8 -> V9:v0.6.16
  60. NewMigration("clean up migrate repo info", cleanUpMigrateRepoInfo), // V9 -> V10:v0.6.20
  61. NewMigration("generate rands and salt for organizations", generateOrgRandsAndSalt), // V10 -> V11:v0.8.5
  62. NewMigration("convert date to unix timestamp", convertDateToUnix), // V11 -> V12:v0.9.2
  63. NewMigration("convert LDAP UseSSL option to SecurityProtocol", ldapUseSSLToSecurityProtocol), // V12 -> V13:v0.9.37
  64. // v13 -> v14:v0.9.87
  65. NewMigration("set comment updated with created", setCommentUpdatedWithCreated),
  66. // v14 -> v15
  67. NewMigration("create user column diff view style", createUserColumnDiffViewStyle),
  68. // v15 -> v16
  69. NewMigration("create user column allow create organization", createAllowCreateOrganizationColumn),
  70. // V16 -> v17
  71. NewMigration("create repo unit table and add units for all repos", addUnitsToTables),
  72. // v17 -> v18
  73. NewMigration("set protect branches updated with created", setProtectedBranchUpdatedWithCreated),
  74. // v18 -> v19
  75. NewMigration("add external login user", addExternalLoginUser),
  76. // v19 -> v20
  77. NewMigration("generate and migrate Git hooks", generateAndMigrateGitHooks),
  78. // v20 -> v21
  79. NewMigration("use new avatar path name for security reason", useNewNameAvatars),
  80. // v21 -> v22
  81. NewMigration("rewrite authorized_keys file via new format", useNewPublickeyFormat),
  82. // v22 -> v23
  83. NewMigration("generate and migrate wiki Git hooks", generateAndMigrateWikiGitHooks),
  84. // v23 -> v24
  85. NewMigration("add user openid table", addUserOpenID),
  86. // v24 -> v25
  87. NewMigration("change the key_id and primary_key_id type", changeGPGKeysColumns),
  88. // v25 -> v26
  89. NewMigration("add show field in user openid table", addUserOpenIDShow),
  90. // v26 -> v27
  91. NewMigration("generate and migrate repo and wiki Git hooks", generateAndMigrateGitHookChains),
  92. // v27 -> v28
  93. NewMigration("change mirror interval from hours to time.Duration", convertIntervalToDuration),
  94. // v28 -> v29
  95. NewMigration("add field for repo size", addRepoSize),
  96. // v29 -> v30
  97. NewMigration("add commit status table", addCommitStatus),
  98. // v30 -> 31
  99. NewMigration("add primary key to external login user", addExternalLoginUserPK),
  100. // 31 -> 32
  101. NewMigration("add field for login source synchronization", addLoginSourceSyncEnabledColumn),
  102. // v32 -> v33
  103. NewMigration("add units for team", addUnitsToRepoTeam),
  104. // v33 -> v34
  105. NewMigration("remove columns from action", removeActionColumns),
  106. // v34 -> v35
  107. NewMigration("give all units to owner teams", giveAllUnitsToOwnerTeams),
  108. // v35 -> v36
  109. NewMigration("adds comment to an action", addCommentIDToAction),
  110. // v36 -> v37
  111. NewMigration("regenerate git hooks", regenerateGitHooks36),
  112. // v37 -> v38
  113. NewMigration("unescape user full names", unescapeUserFullNames),
  114. // v38 -> v39
  115. NewMigration("remove commits and settings unit types", removeCommitsUnitType),
  116. // v39 -> v40
  117. NewMigration("adds time tracking and stopwatches", addTimetracking),
  118. // v40 -> v41
  119. NewMigration("migrate protected branch struct", migrateProtectedBranchStruct),
  120. // v41 -> v42
  121. NewMigration("add default value to user prohibit_login", addDefaultValueToUserProhibitLogin),
  122. // v42 -> v43
  123. NewMigration("add tags to releases and sync existing repositories", releaseAddColumnIsTagAndSyncTags),
  124. // v43 -> v44
  125. NewMigration("fix protected branch can push value to false", fixProtectedBranchCanPushValue),
  126. // v44 -> v45
  127. NewMigration("remove duplicate unit types", removeDuplicateUnitTypes),
  128. // v45 -> v46
  129. NewMigration("remove index column from repo_unit table", removeIndexColumnFromRepoUnitTable),
  130. }
  131. // Migrate database to current version
  132. func Migrate(x *xorm.Engine) error {
  133. if err := x.Sync(new(Version)); err != nil {
  134. return fmt.Errorf("sync: %v", err)
  135. }
  136. currentVersion := &Version{ID: 1}
  137. has, err := x.Get(currentVersion)
  138. if err != nil {
  139. return fmt.Errorf("get: %v", err)
  140. } else if !has {
  141. // If the version record does not exist we think
  142. // it is a fresh installation and we can skip all migrations.
  143. currentVersion.ID = 0
  144. currentVersion.Version = int64(minDBVersion + len(migrations))
  145. if _, err = x.InsertOne(currentVersion); err != nil {
  146. return fmt.Errorf("insert: %v", err)
  147. }
  148. }
  149. v := currentVersion.Version
  150. if minDBVersion > v {
  151. log.Fatal(4, `Gitea no longer supports auto-migration from your previously installed version.
  152. Please try to upgrade to a lower version (>= v0.6.0) first, then upgrade to current version.`)
  153. return nil
  154. }
  155. if int(v-minDBVersion) > len(migrations) {
  156. // User downgraded Gitea.
  157. currentVersion.Version = int64(len(migrations) + minDBVersion)
  158. _, err = x.Id(1).Update(currentVersion)
  159. return err
  160. }
  161. for i, m := range migrations[v-minDBVersion:] {
  162. log.Info("Migration: %s", m.Description())
  163. if err = m.Migrate(x); err != nil {
  164. return fmt.Errorf("do migrate: %v", err)
  165. }
  166. currentVersion.Version = v + int64(i) + 1
  167. if _, err = x.Id(1).Update(currentVersion); err != nil {
  168. return err
  169. }
  170. }
  171. return nil
  172. }
  173. func fixLocaleFileLoadPanic(_ *xorm.Engine) error {
  174. cfg, err := ini.Load(setting.CustomConf)
  175. if err != nil {
  176. return fmt.Errorf("load custom config: %v", err)
  177. }
  178. cfg.DeleteSection("i18n")
  179. if err = cfg.SaveTo(setting.CustomConf); err != nil {
  180. return fmt.Errorf("save custom config: %v", err)
  181. }
  182. setting.Langs = strings.Split(strings.Replace(strings.Join(setting.Langs, ","), "fr-CA", "fr-FR", 1), ",")
  183. return nil
  184. }
  185. func trimCommitActionAppURLPrefix(x *xorm.Engine) error {
  186. type PushCommit struct {
  187. Sha1 string
  188. Message string
  189. AuthorEmail string
  190. AuthorName string
  191. }
  192. type PushCommits struct {
  193. Len int
  194. Commits []*PushCommit
  195. CompareURL string `json:"CompareUrl"`
  196. }
  197. type Action struct {
  198. ID int64 `xorm:"pk autoincr"`
  199. Content string `xorm:"TEXT"`
  200. }
  201. results, err := x.Query("SELECT `id`,`content` FROM `action` WHERE `op_type`=?", 5)
  202. if err != nil {
  203. return fmt.Errorf("select commit actions: %v", err)
  204. }
  205. sess := x.NewSession()
  206. defer sess.Close()
  207. if err = sess.Begin(); err != nil {
  208. return err
  209. }
  210. var pushCommits *PushCommits
  211. for _, action := range results {
  212. actID := com.StrTo(string(action["id"])).MustInt64()
  213. if actID == 0 {
  214. continue
  215. }
  216. pushCommits = new(PushCommits)
  217. if err = json.Unmarshal(action["content"], pushCommits); err != nil {
  218. return fmt.Errorf("unmarshal action content[%d]: %v", actID, err)
  219. }
  220. infos := strings.Split(pushCommits.CompareURL, "/")
  221. if len(infos) <= 4 {
  222. continue
  223. }
  224. pushCommits.CompareURL = strings.Join(infos[len(infos)-4:], "/")
  225. p, err := json.Marshal(pushCommits)
  226. if err != nil {
  227. return fmt.Errorf("marshal action content[%d]: %v", actID, err)
  228. }
  229. if _, err = sess.Id(actID).Update(&Action{
  230. Content: string(p),
  231. }); err != nil {
  232. return fmt.Errorf("update action[%d]: %v", actID, err)
  233. }
  234. }
  235. return sess.Commit()
  236. }
  237. func issueToIssueLabel(x *xorm.Engine) error {
  238. type IssueLabel struct {
  239. ID int64 `xorm:"pk autoincr"`
  240. IssueID int64 `xorm:"UNIQUE(s)"`
  241. LabelID int64 `xorm:"UNIQUE(s)"`
  242. }
  243. issueLabels := make([]*IssueLabel, 0, 50)
  244. results, err := x.Query("SELECT `id`,`label_ids` FROM `issue`")
  245. if err != nil {
  246. if strings.Contains(err.Error(), "no such column") ||
  247. strings.Contains(err.Error(), "Unknown column") {
  248. return nil
  249. }
  250. return fmt.Errorf("select issues: %v", err)
  251. }
  252. for _, issue := range results {
  253. issueID := com.StrTo(issue["id"]).MustInt64()
  254. // Just in case legacy code can have duplicated IDs for same label.
  255. mark := make(map[int64]bool)
  256. for _, idStr := range strings.Split(string(issue["label_ids"]), "|") {
  257. labelID := com.StrTo(strings.TrimPrefix(idStr, "$")).MustInt64()
  258. if labelID == 0 || mark[labelID] {
  259. continue
  260. }
  261. mark[labelID] = true
  262. issueLabels = append(issueLabels, &IssueLabel{
  263. IssueID: issueID,
  264. LabelID: labelID,
  265. })
  266. }
  267. }
  268. sess := x.NewSession()
  269. defer sess.Close()
  270. if err = sess.Begin(); err != nil {
  271. return err
  272. }
  273. if err = sess.Sync2(new(IssueLabel)); err != nil {
  274. return fmt.Errorf("Sync2: %v", err)
  275. } else if _, err = sess.Insert(issueLabels); err != nil {
  276. return fmt.Errorf("insert issue-labels: %v", err)
  277. }
  278. return sess.Commit()
  279. }
  280. func attachmentRefactor(x *xorm.Engine) error {
  281. type Attachment struct {
  282. ID int64 `xorm:"pk autoincr"`
  283. UUID string `xorm:"uuid INDEX"`
  284. // For rename purpose.
  285. Path string `xorm:"-"`
  286. NewPath string `xorm:"-"`
  287. }
  288. results, err := x.Query("SELECT * FROM `attachment`")
  289. if err != nil {
  290. return fmt.Errorf("select attachments: %v", err)
  291. }
  292. attachments := make([]*Attachment, 0, len(results))
  293. for _, attach := range results {
  294. if !com.IsExist(string(attach["path"])) {
  295. // If the attachment is already missing, there is no point to update it.
  296. continue
  297. }
  298. attachments = append(attachments, &Attachment{
  299. ID: com.StrTo(attach["id"]).MustInt64(),
  300. UUID: gouuid.NewV4().String(),
  301. Path: string(attach["path"]),
  302. })
  303. }
  304. sess := x.NewSession()
  305. defer sess.Close()
  306. if err = sess.Begin(); err != nil {
  307. return err
  308. }
  309. if err = sess.Sync2(new(Attachment)); err != nil {
  310. return fmt.Errorf("Sync2: %v", err)
  311. }
  312. // Note: Roll back for rename can be a dead loop,
  313. // so produces a backup file.
  314. var buf bytes.Buffer
  315. buf.WriteString("# old path -> new path\n")
  316. // Update database first because this is where error happens the most often.
  317. for _, attach := range attachments {
  318. if _, err = sess.Id(attach.ID).Update(attach); err != nil {
  319. return err
  320. }
  321. attach.NewPath = path.Join(setting.AttachmentPath, attach.UUID[0:1], attach.UUID[1:2], attach.UUID)
  322. buf.WriteString(attach.Path)
  323. buf.WriteString("\t")
  324. buf.WriteString(attach.NewPath)
  325. buf.WriteString("\n")
  326. }
  327. // Then rename attachments.
  328. isSucceed := true
  329. defer func() {
  330. if isSucceed {
  331. return
  332. }
  333. dumpPath := path.Join(setting.LogRootPath, "attachment_path.dump")
  334. ioutil.WriteFile(dumpPath, buf.Bytes(), 0666)
  335. log.Info("Failed to rename some attachments, old and new paths are saved into: %s", dumpPath)
  336. }()
  337. for _, attach := range attachments {
  338. if err = os.MkdirAll(path.Dir(attach.NewPath), os.ModePerm); err != nil {
  339. isSucceed = false
  340. return err
  341. }
  342. if err = os.Rename(attach.Path, attach.NewPath); err != nil {
  343. isSucceed = false
  344. return err
  345. }
  346. }
  347. return sess.Commit()
  348. }
  349. func renamePullRequestFields(x *xorm.Engine) (err error) {
  350. type PullRequest struct {
  351. ID int64 `xorm:"pk autoincr"`
  352. PullID int64 `xorm:"INDEX"`
  353. PullIndex int64
  354. HeadBarcnh string
  355. IssueID int64 `xorm:"INDEX"`
  356. Index int64
  357. HeadBranch string
  358. }
  359. if err = x.Sync(new(PullRequest)); err != nil {
  360. return fmt.Errorf("sync: %v", err)
  361. }
  362. results, err := x.Query("SELECT `id`,`pull_id`,`pull_index`,`head_barcnh` FROM `pull_request`")
  363. if err != nil {
  364. if strings.Contains(err.Error(), "no such column") {
  365. return nil
  366. }
  367. return fmt.Errorf("select pull requests: %v", err)
  368. }
  369. sess := x.NewSession()
  370. defer sess.Close()
  371. if err = sess.Begin(); err != nil {
  372. return err
  373. }
  374. var pull *PullRequest
  375. for _, pr := range results {
  376. pull = &PullRequest{
  377. ID: com.StrTo(pr["id"]).MustInt64(),
  378. IssueID: com.StrTo(pr["pull_id"]).MustInt64(),
  379. Index: com.StrTo(pr["pull_index"]).MustInt64(),
  380. HeadBranch: string(pr["head_barcnh"]),
  381. }
  382. if pull.Index == 0 {
  383. continue
  384. }
  385. if _, err = sess.Id(pull.ID).Update(pull); err != nil {
  386. return err
  387. }
  388. }
  389. return sess.Commit()
  390. }
  391. func cleanUpMigrateRepoInfo(x *xorm.Engine) (err error) {
  392. type (
  393. User struct {
  394. ID int64 `xorm:"pk autoincr"`
  395. LowerName string
  396. }
  397. Repository struct {
  398. ID int64 `xorm:"pk autoincr"`
  399. OwnerID int64
  400. LowerName string
  401. }
  402. )
  403. repos := make([]*Repository, 0, 25)
  404. if err = x.Where("is_mirror=?", false).Find(&repos); err != nil {
  405. return fmt.Errorf("select all non-mirror repositories: %v", err)
  406. }
  407. var user *User
  408. for _, repo := range repos {
  409. user = &User{ID: repo.OwnerID}
  410. has, err := x.Get(user)
  411. if err != nil {
  412. return fmt.Errorf("get owner of repository[%d - %d]: %v", repo.ID, repo.OwnerID, err)
  413. } else if !has {
  414. continue
  415. }
  416. configPath := filepath.Join(setting.RepoRootPath, user.LowerName, repo.LowerName+".git/config")
  417. // In case repository file is somehow missing.
  418. if !com.IsFile(configPath) {
  419. continue
  420. }
  421. cfg, err := ini.Load(configPath)
  422. if err != nil {
  423. return fmt.Errorf("open config file: %v", err)
  424. }
  425. cfg.DeleteSection("remote \"origin\"")
  426. if err = cfg.SaveToIndent(configPath, "\t"); err != nil {
  427. return fmt.Errorf("save config file: %v", err)
  428. }
  429. }
  430. return nil
  431. }
  432. func generateOrgRandsAndSalt(x *xorm.Engine) (err error) {
  433. type User struct {
  434. ID int64 `xorm:"pk autoincr"`
  435. Rands string `xorm:"VARCHAR(10)"`
  436. Salt string `xorm:"VARCHAR(10)"`
  437. }
  438. orgs := make([]*User, 0, 10)
  439. if err = x.Where("type=1").And("rands=''").Find(&orgs); err != nil {
  440. return fmt.Errorf("select all organizations: %v", err)
  441. }
  442. sess := x.NewSession()
  443. defer sess.Close()
  444. if err = sess.Begin(); err != nil {
  445. return err
  446. }
  447. for _, org := range orgs {
  448. if org.Rands, err = base.GetRandomString(10); err != nil {
  449. return err
  450. }
  451. if org.Salt, err = base.GetRandomString(10); err != nil {
  452. return err
  453. }
  454. if _, err = sess.Id(org.ID).Update(org); err != nil {
  455. return err
  456. }
  457. }
  458. return sess.Commit()
  459. }
  460. // TAction defines the struct for migrating table action
  461. type TAction struct {
  462. ID int64 `xorm:"pk autoincr"`
  463. CreatedUnix int64
  464. }
  465. // TableName will be invoked by XORM to customrize the table name
  466. func (t *TAction) TableName() string { return "action" }
  467. // TNotice defines the struct for migrating table notice
  468. type TNotice struct {
  469. ID int64 `xorm:"pk autoincr"`
  470. CreatedUnix int64
  471. }
  472. // TableName will be invoked by XORM to customrize the table name
  473. func (t *TNotice) TableName() string { return "notice" }
  474. // TComment defines the struct for migrating table comment
  475. type TComment struct {
  476. ID int64 `xorm:"pk autoincr"`
  477. CreatedUnix int64
  478. }
  479. // TableName will be invoked by XORM to customrize the table name
  480. func (t *TComment) TableName() string { return "comment" }
  481. // TIssue defines the struct for migrating table issue
  482. type TIssue struct {
  483. ID int64 `xorm:"pk autoincr"`
  484. DeadlineUnix int64
  485. CreatedUnix int64
  486. UpdatedUnix int64
  487. }
  488. // TableName will be invoked by XORM to customrize the table name
  489. func (t *TIssue) TableName() string { return "issue" }
  490. // TMilestone defines the struct for migrating table milestone
  491. type TMilestone struct {
  492. ID int64 `xorm:"pk autoincr"`
  493. DeadlineUnix int64
  494. ClosedDateUnix int64
  495. }
  496. // TableName will be invoked by XORM to customrize the table name
  497. func (t *TMilestone) TableName() string { return "milestone" }
  498. // TAttachment defines the struct for migrating table attachment
  499. type TAttachment struct {
  500. ID int64 `xorm:"pk autoincr"`
  501. CreatedUnix int64
  502. }
  503. // TableName will be invoked by XORM to customrize the table name
  504. func (t *TAttachment) TableName() string { return "attachment" }
  505. // TLoginSource defines the struct for migrating table login_source
  506. type TLoginSource struct {
  507. ID int64 `xorm:"pk autoincr"`
  508. CreatedUnix int64
  509. UpdatedUnix int64
  510. }
  511. // TableName will be invoked by XORM to customrize the table name
  512. func (t *TLoginSource) TableName() string { return "login_source" }
  513. // TPull defines the struct for migrating table pull_request
  514. type TPull struct {
  515. ID int64 `xorm:"pk autoincr"`
  516. MergedUnix int64
  517. }
  518. // TableName will be invoked by XORM to customrize the table name
  519. func (t *TPull) TableName() string { return "pull_request" }
  520. // TRelease defines the struct for migrating table release
  521. type TRelease struct {
  522. ID int64 `xorm:"pk autoincr"`
  523. CreatedUnix int64
  524. }
  525. // TableName will be invoked by XORM to customrize the table name
  526. func (t *TRelease) TableName() string { return "release" }
  527. // TRepo defines the struct for migrating table repository
  528. type TRepo struct {
  529. ID int64 `xorm:"pk autoincr"`
  530. CreatedUnix int64
  531. UpdatedUnix int64
  532. }
  533. // TableName will be invoked by XORM to customrize the table name
  534. func (t *TRepo) TableName() string { return "repository" }
  535. // TMirror defines the struct for migrating table mirror
  536. type TMirror struct {
  537. ID int64 `xorm:"pk autoincr"`
  538. UpdatedUnix int64
  539. NextUpdateUnix int64
  540. }
  541. // TableName will be invoked by XORM to customrize the table name
  542. func (t *TMirror) TableName() string { return "mirror" }
  543. // TPublicKey defines the struct for migrating table public_key
  544. type TPublicKey struct {
  545. ID int64 `xorm:"pk autoincr"`
  546. CreatedUnix int64
  547. UpdatedUnix int64
  548. }
  549. // TableName will be invoked by XORM to customrize the table name
  550. func (t *TPublicKey) TableName() string { return "public_key" }
  551. // TDeployKey defines the struct for migrating table deploy_key
  552. type TDeployKey struct {
  553. ID int64 `xorm:"pk autoincr"`
  554. CreatedUnix int64
  555. UpdatedUnix int64
  556. }
  557. // TableName will be invoked by XORM to customrize the table name
  558. func (t *TDeployKey) TableName() string { return "deploy_key" }
  559. // TAccessToken defines the struct for migrating table access_token
  560. type TAccessToken struct {
  561. ID int64 `xorm:"pk autoincr"`
  562. CreatedUnix int64
  563. UpdatedUnix int64
  564. }
  565. // TableName will be invoked by XORM to customrize the table name
  566. func (t *TAccessToken) TableName() string { return "access_token" }
  567. // TUser defines the struct for migrating table user
  568. type TUser struct {
  569. ID int64 `xorm:"pk autoincr"`
  570. CreatedUnix int64
  571. UpdatedUnix int64
  572. }
  573. // TableName will be invoked by XORM to customrize the table name
  574. func (t *TUser) TableName() string { return "user" }
  575. // TWebhook defines the struct for migrating table webhook
  576. type TWebhook struct {
  577. ID int64 `xorm:"pk autoincr"`
  578. CreatedUnix int64
  579. UpdatedUnix int64
  580. }
  581. // TableName will be invoked by XORM to customrize the table name
  582. func (t *TWebhook) TableName() string { return "webhook" }
  583. func convertDateToUnix(x *xorm.Engine) (err error) {
  584. log.Info("This migration could take up to minutes, please be patient.")
  585. type Bean struct {
  586. ID int64 `xorm:"pk autoincr"`
  587. Created time.Time
  588. Updated time.Time
  589. Merged time.Time
  590. Deadline time.Time
  591. ClosedDate time.Time
  592. NextUpdate time.Time
  593. }
  594. var tables = []struct {
  595. name string
  596. cols []string
  597. bean interface{}
  598. }{
  599. {"action", []string{"created"}, new(TAction)},
  600. {"notice", []string{"created"}, new(TNotice)},
  601. {"comment", []string{"created"}, new(TComment)},
  602. {"issue", []string{"deadline", "created", "updated"}, new(TIssue)},
  603. {"milestone", []string{"deadline", "closed_date"}, new(TMilestone)},
  604. {"attachment", []string{"created"}, new(TAttachment)},
  605. {"login_source", []string{"created", "updated"}, new(TLoginSource)},
  606. {"pull_request", []string{"merged"}, new(TPull)},
  607. {"release", []string{"created"}, new(TRelease)},
  608. {"repository", []string{"created", "updated"}, new(TRepo)},
  609. {"mirror", []string{"updated", "next_update"}, new(TMirror)},
  610. {"public_key", []string{"created", "updated"}, new(TPublicKey)},
  611. {"deploy_key", []string{"created", "updated"}, new(TDeployKey)},
  612. {"access_token", []string{"created", "updated"}, new(TAccessToken)},
  613. {"user", []string{"created", "updated"}, new(TUser)},
  614. {"webhook", []string{"created", "updated"}, new(TWebhook)},
  615. }
  616. for _, table := range tables {
  617. log.Info("Converting table: %s", table.name)
  618. if err = x.Sync2(table.bean); err != nil {
  619. return fmt.Errorf("Sync [table: %s]: %v", table.name, err)
  620. }
  621. offset := 0
  622. for {
  623. beans := make([]*Bean, 0, 100)
  624. if err = x.Table(table.name).Asc("id").Limit(100, offset).Find(&beans); err != nil {
  625. return fmt.Errorf("select beans [table: %s, offset: %d]: %v", table.name, offset, err)
  626. }
  627. log.Trace("Table [%s]: offset: %d, beans: %d", table.name, offset, len(beans))
  628. if len(beans) == 0 {
  629. break
  630. }
  631. offset += 100
  632. baseSQL := "UPDATE `" + table.name + "` SET "
  633. for _, bean := range beans {
  634. valSQLs := make([]string, 0, len(table.cols))
  635. for _, col := range table.cols {
  636. fieldSQL := ""
  637. fieldSQL += col + "_unix = "
  638. switch col {
  639. case "deadline":
  640. if bean.Deadline.IsZero() {
  641. continue
  642. }
  643. fieldSQL += com.ToStr(bean.Deadline.Unix())
  644. case "created":
  645. fieldSQL += com.ToStr(bean.Created.Unix())
  646. case "updated":
  647. fieldSQL += com.ToStr(bean.Updated.Unix())
  648. case "closed_date":
  649. fieldSQL += com.ToStr(bean.ClosedDate.Unix())
  650. case "merged":
  651. fieldSQL += com.ToStr(bean.Merged.Unix())
  652. case "next_update":
  653. fieldSQL += com.ToStr(bean.NextUpdate.Unix())
  654. }
  655. valSQLs = append(valSQLs, fieldSQL)
  656. }
  657. if len(valSQLs) == 0 {
  658. continue
  659. }
  660. if _, err = x.Exec(baseSQL + strings.Join(valSQLs, ",") + " WHERE id = " + com.ToStr(bean.ID)); err != nil {
  661. return fmt.Errorf("update bean [table: %s, id: %d]: %v", table.name, bean.ID, err)
  662. }
  663. }
  664. }
  665. }
  666. return nil
  667. }