Skip to content

Backup/Restore commands #1637

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 4 commits into from
Closed

Backup/Restore commands #1637

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
3e61f49
Restore-command added
bkcsoft Apr 13, 2017
8c70820
Add changelog
bkcsoft Apr 13, 2017
77ef391
Update changelog
bkcsoft Apr 28, 2017
b0c7a3b
Fix stuff
bkcsoft Apr 28, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 3 additions & 0 deletions changelog/unreleased/restore-backup.yml
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,3 @@
title: Implement proper `gitea restore` & `gitea backup`. Deprecating `gitea dump`
kind: feature
pull_request: 1637
197 changes: 197 additions & 0 deletions cmd/backup.go
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,197 @@
// Copyright 2017 the Gitea Authors. All rights reserved.
// Copyright 2017 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.

package cmd

import (
"fmt"
"io/ioutil"
"os"
"path"
"runtime/debug"
"time"

"github.com/Unknwon/cae/zip"
"github.com/Unknwon/com"
"github.com/urfave/cli"
"gopkg.in/ini.v1"

"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
)

// Backup files and database
var Backup = cli.Command{
Name: "backup",
Usage: "Backup files and database",
Description: `Backup dumps and compresses all related files and database into zip file,
which can be used for migrating Gitea to another server. The output format is meant to be
portable among all supported database engines.`,
Action: runBackup,
Flags: []cli.Flag{
cli.StringFlag{
Name: "config, c",
Value: "custom/conf/app.ini",
Usage: "Custom configuration `FILE` path",
},
cli.StringFlag{
Name: "tempdir, t",
Value: os.TempDir(),
Usage: "Temporary directory `PATH`",
},
cli.StringFlag{
Name: "target",
Value: "./",
Usage: "Target directory `PATH` to save backup archive",
},
cli.BoolFlag{
Name: "verbose, v",
Usage: "Show process details",
},
cli.BoolTFlag{
Name: "db",
Usage: "Backup the database (default: true)",
},
cli.BoolTFlag{
Name: "repos",
Usage: "Backup repositories (default: true)",
},
cli.BoolTFlag{
Name: "data",
Usage: "Backup attachments and avatars (default: true)",
},
cli.BoolTFlag{
Name: "custom",
Usage: "Backup custom files (default: true)",
},
},
}

const (
archiveRootDir = "gitea-backup"
backupVersion = 1
)

func runBackup(c *cli.Context) error {
zip.Verbose = c.Bool("verbose")
if c.IsSet("config") {
setting.CustomConf = c.String("config")
}
setting.NewContext()
models.LoadConfigs()
if err := models.SetEngine(); err != nil {
return err
}

// Setup temp-dir
tmpDir := c.String("tempdir")
if !com.IsExist(tmpDir) {
log.Fatal(0, "'--tempdir' does not exist: %s", tmpDir)
}
rootDir, err := ioutil.TempDir(tmpDir, "gitea-backup-")
if err != nil {
log.Fatal(0, "Fail to create backup root directory '%s': %v", rootDir, err)
}
defer func(rootDir string) {
os.RemoveAll(rootDir)
}(rootDir)
log.Info("Backup root directory: %s", rootDir)

// Metadata
metaFile := path.Join(rootDir, "metadata.ini")
metadata := ini.Empty()
metadata.Section("").Key("VERSION").SetValue(fmt.Sprintf("%d", backupVersion))
metadata.Section("").Key("DATE_TIME").SetValue(time.Now().String())
metadata.Section("").Key("GITEA_VERSION").SetValue(setting.AppVer)
if err = metadata.SaveTo(metaFile); err != nil {
log.Fatal(0, "Fail to save metadata '%s': %v", metaFile, err)
}

// Create ZIP-file
archiveName := path.Join(c.String("target"), fmt.Sprintf("gitea-backup-%d.zip", time.Now().Unix()))
log.Info("Packing backup files to: %s", archiveName)

z, err := zip.Create(archiveName)
if err != nil {
log.Fatal(0, "Fail to create backup archive '%s': %v", archiveName, err)
}
defer func(archiveName string) {
if r := recover(); r != nil {
var ok bool
err, ok = r.(error)
if !ok {
err = fmt.Errorf("pkg: %v", r)
}
debug.PrintStack()
log.Info("Removing partial backup-file %s\n", archiveName)
os.Remove(archiveName)
log.Fatal(9, "%v\n", err)
}
}(archiveName)

// Add metadata-file
if err = z.AddFile(archiveRootDir+"/metadata.ini", metaFile); err != nil {
log.Fatal(0, "Fail to include 'metadata.ini': %v", err)
}

// Database
if c.Bool("db") {
log.Info("Backing up database")
dbDir := path.Join(rootDir, "db")
if err = models.DumpDatabase(dbDir); err != nil {
log.Fatal(0, "Fail to dump database: %v", err)
}
if err = z.AddDir(archiveRootDir+"/db", dbDir); err != nil {
log.Fatal(0, "Fail to include 'db': %v", err)
}
}

// Custom files
if c.Bool("custom") {
log.Info("Backing up custom files")
if err = z.AddDir(archiveRootDir+"/custom", setting.CustomPath); err != nil {
log.Fatal(0, "Fail to include 'custom': %v", err)
}
}

// Data files
if c.Bool("data") {
log.Info("Backing up attachments and avatars")
for _, dir := range []string{"attachments", "avatars"} {
dirPath := path.Join(setting.AppDataPath, dir)
if !com.IsDir(dirPath) {
continue
}

if err = z.AddDir(path.Join(archiveRootDir+"/data", dir), dirPath); err != nil {
log.Fatal(0, "Fail to include 'data': %v", err)
}
}
}

// Repositories
if c.Bool("repos") {
log.Info("Backing up repositories")
reposDump := path.Join(rootDir, "repositories.zip")
log.Info("Dumping repositories in '%s'", setting.RepoRootPath)
if err = zip.PackTo(setting.RepoRootPath, reposDump, true); err != nil {
log.Fatal(0, "Fail to dump repositories: %v", err)
}
log.Info("Repositories dumped to: %s", reposDump)

if err = z.AddFile(archiveRootDir+"/repositories.zip", reposDump); err != nil {
log.Fatal(0, "Fail to include 'repositories.zip': %v", err)
}
}

if err = z.Close(); err != nil {
log.Fatal(0, "Fail to save backup archive '%s': %v", archiveName, err)
}

os.RemoveAll(rootDir)
log.Info("Backup succeed! Archive is located at: %s", archiveName)
return nil
}
71 changes: 36 additions & 35 deletions cmd/dump.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,24 +8,24 @@ package cmd
import (
"fmt"
"io/ioutil"
"log"
"os"
"path"
"path/filepath"
"time"

"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"

"github.com/Unknwon/cae/zip"
"github.com/Unknwon/com"
"github.com/urfave/cli"
)

// CmdDump represents the available dump sub-command.
var CmdDump = cli.Command{
// Dump represents the available dump sub-command.
var Dump = cli.Command{
Name: "dump",
Usage: "Dump Gitea files and database",
Usage: "DEPRICATED! Dump Gitea files and database",
Description: `Dump compresses all related files and database into zip file.
It can be used for backup and capture Gitea server image to send to maintainer`,
Action: runDump,
Expand Down Expand Up @@ -59,65 +59,66 @@ func runDump(ctx *cli.Context) error {
setting.NewServices() // cannot access session settings otherwise
models.LoadConfigs()

err := models.SetEngine()
if err != nil {
log.Info("")

if err := models.SetEngine(); err != nil {
return err
}

tmpDir := ctx.String("tempdir")
if _, err := os.Stat(tmpDir); os.IsNotExist(err) {
log.Fatalf("Path does not exist: %s", tmpDir)
log.Fatal(4, "Path does not exist: %s", tmpDir)
}
TmpWorkDir, err := ioutil.TempDir(tmpDir, "gitea-dump-")
if err != nil {
log.Fatalf("Failed to create tmp work directory: %v", err)
log.Fatal(4, "Failed to create tmp work directory: %v", err)
}
log.Printf("Creating tmp work dir: %s", TmpWorkDir)
log.Info("Creating tmp work dir: %s", TmpWorkDir)

reposDump := path.Join(TmpWorkDir, "gitea-repo.zip")
dbDump := path.Join(TmpWorkDir, "gitea-db.sql")

log.Printf("Dumping local repositories...%s", setting.RepoRootPath)
log.Info("Dumping local repositories...%s", setting.RepoRootPath)
zip.Verbose = ctx.Bool("verbose")
if err := zip.PackTo(setting.RepoRootPath, reposDump, true); err != nil {
log.Fatalf("Failed to dump local repositories: %v", err)
if err = zip.PackTo(setting.RepoRootPath, reposDump, true); err != nil {
log.Fatal(4, "Failed to dump local repositories: %v", err)
}

targetDBType := ctx.String("database")
if len(targetDBType) > 0 && targetDBType != models.DbCfg.Type {
log.Printf("Dumping database %s => %s...", models.DbCfg.Type, targetDBType)
log.Info("Dumping database %s => %s...", models.DbCfg.Type, targetDBType)
} else {
log.Printf("Dumping database...")
log.Info("Dumping database...")
}

if err := models.DumpDatabase(dbDump, targetDBType); err != nil {
log.Fatalf("Failed to dump database: %v", err)
if err = models.DumpDatabaseOld(dbDump, targetDBType); err != nil {
log.Fatal(4, "Failed to dump database: %v", err)
}

fileName := fmt.Sprintf("gitea-dump-%d.zip", time.Now().Unix())
log.Printf("Packing dump files...")
log.Info("Packing dump files...")
z, err := zip.Create(fileName)
if err != nil {
log.Fatalf("Failed to create %s: %v", fileName, err)
log.Fatal(4, "Failed to create %s: %v", fileName, err)
}

if err := z.AddFile("gitea-repo.zip", reposDump); err != nil {
log.Fatalf("Failed to include gitea-repo.zip: %v", err)
if err = z.AddFile("gitea-repo.zip", reposDump); err != nil {
log.Fatal(4, "Failed to include gitea-repo.zip: %v", err)
}
if err := z.AddFile("gitea-db.sql", dbDump); err != nil {
log.Fatalf("Failed to include gitea-db.sql: %v", err)
if err = z.AddFile("gitea-db.sql", dbDump); err != nil {
log.Fatal(4, "Failed to include gitea-db.sql: %v", err)
}
customDir, err := os.Stat(setting.CustomPath)
if err == nil && customDir.IsDir() {
if err := z.AddDir("custom", setting.CustomPath); err != nil {
log.Fatalf("Failed to include custom: %v", err)
if err = z.AddDir("custom", setting.CustomPath); err != nil {
log.Fatal(4, "Failed to include custom: %v", err)
}
} else {
log.Printf("Custom dir %s doesn't exist, skipped", setting.CustomPath)
log.Info("Custom dir %s doesn't exist, skipped", setting.CustomPath)
}

if com.IsExist(setting.AppDataPath) {
log.Printf("Packing data directory...%s", setting.AppDataPath)
log.Info("Packing data directory...%s", setting.AppDataPath)

var sessionAbsPath string
if setting.SessionConfig.Provider == "file" {
Expand All @@ -126,30 +127,30 @@ func runDump(ctx *cli.Context) error {
}
sessionAbsPath, _ = filepath.Abs(setting.SessionConfig.ProviderConfig)
}
if err := zipAddDirectoryExclude(z, "data", setting.AppDataPath, sessionAbsPath); err != nil {
log.Fatalf("Failed to include data directory: %v", err)
if err = zipAddDirectoryExclude(z, "data", setting.AppDataPath, sessionAbsPath); err != nil {
log.Fatal(4, "Failed to include data directory: %v", err)
}
}

if err := z.AddDir("log", setting.LogRootPath); err != nil {
log.Fatalf("Failed to include log: %v", err)
if err = z.AddDir("log", setting.LogRootPath); err != nil {
log.Fatal(4, "Failed to include log: %v", err)
}

if err = z.Close(); err != nil {
_ = os.Remove(fileName)
log.Fatalf("Failed to save %s: %v", fileName, err)
log.Fatal(4, "Failed to save %s: %v", fileName, err)
}

if err := os.Chmod(fileName, 0600); err != nil {
log.Printf("Can't change file access permissions mask to 0600: %v", err)
log.Info("Can't change file access permissions mask to 0600: %v", err)
}

log.Printf("Removing tmp work dir: %s", TmpWorkDir)
log.Info("Removing tmp work dir: %s", TmpWorkDir)

if err := os.RemoveAll(TmpWorkDir); err != nil {
log.Fatalf("Failed to remove %s: %v", TmpWorkDir, err)
log.Fatal(4, "Failed to remove %s: %v", TmpWorkDir, err)
}
log.Printf("Finish dumping in file %s", fileName)
log.Info("Finish dumping in file %s", fileName)

return nil
}
Expand Down
Loading