func LoadRepoConfig() { workDir, err := base.ExecDir() if err != nil { qlog.Fatalf("Fail to get work directory: %s\n", err) } // Load .gitignore and license files. types := []string{"gitignore", "license"} typeFiles := make([][]string, 2) for i, t := range types { cfgPath := filepath.Join(workDir, "conf", t) files, err := com.StatDir(cfgPath) if err != nil { qlog.Fatalf("Fail to get default %s files: %v\n", t, err) } cfgPath = filepath.Join(workDir, "custom/conf/gitignore") if com.IsDir(cfgPath) { customFiles, err := com.StatDir(cfgPath) if err != nil { qlog.Fatalf("Fail to get custom %s files: %v\n", t, err) } for _, f := range customFiles { if !com.IsSliceContainsStr(files, f) { files = append(files, f) } } } typeFiles[i] = files } LanguageIgns = typeFiles[0] Licenses = typeFiles[1] }
func SetEngine() (err error) { switch DbCfg.Type { case "mysql": orm, err = xorm.NewEngine("mysql", fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8", DbCfg.User, DbCfg.Pwd, DbCfg.Host, DbCfg.Name)) case "postgres": orm, err = xorm.NewEngine("postgres", fmt.Sprintf("user=%s password=%s dbname=%s sslmode=%s", DbCfg.User, DbCfg.Pwd, DbCfg.Name, DbCfg.SslMode)) case "sqlite3": os.MkdirAll(path.Dir(DbCfg.Path), os.ModePerm) orm, err = xorm.NewEngine("sqlite3", DbCfg.Path) default: return fmt.Errorf("Unknown database type: %s", DbCfg.Type) } if err != nil { return fmt.Errorf("models.init(fail to conntect database): %v", err) } // WARNNING: for serv command, MUST remove the output to os.stdout, // so use log file to instead print to stdout. execDir, _ := base.ExecDir() logPath := execDir + "/log/xorm.log" os.MkdirAll(path.Dir(logPath), os.ModePerm) f, err := os.Create(logPath) if err != nil { return fmt.Errorf("models.init(fail to create xorm.log): %v", err) } orm.Logger = f orm.ShowSQL = true orm.ShowDebug = true orm.ShowErr = true return nil }
func runFix(k *cli.Context) { execDir, _ := base.ExecDir() newLogger(execDir) base.NewConfigContext() models.LoadModelsConfig() if models.UseSQLite3 { os.Chdir(execDir) } models.SetEngine() err := models.Fix() if err != nil { fmt.Println(err) } else { fmt.Println("Fix successfully!") } }
func runDump(*cli.Context) { base.NewConfigContext() models.LoadModelsConfig() models.SetEngine() log.Printf("Dumping local repositories...%s", base.RepoRootPath) zip.Verbose = false defer os.Remove("gogs-repo.zip") if err := zip.PackTo(base.RepoRootPath, "gogs-repo.zip", true); err != nil { log.Fatalf("Fail to dump local repositories: %v", err) } log.Printf("Dumping database...") defer os.Remove("gogs-db.sql") if err := models.DumpDatabase("gogs-db.sql"); err != nil { log.Fatalf("Fail to dump database: %v", err) } fileName := fmt.Sprintf("gogs-dump-%d.zip", time.Now().Unix()) log.Printf("Packing dump files...") z, err := zip.Create(fileName) if err != nil { os.Remove(fileName) log.Fatalf("Fail to create %s: %v", fileName, err) } execDir, _ := base.ExecDir() z.AddFile("gogs-repo.zip", path.Join(execDir, "gogs-repo.zip")) z.AddFile("gogs-db.sql", path.Join(execDir, "gogs-db.sql")) z.AddFile("custom/conf/app.ini", path.Join(execDir, "custom/conf/app.ini")) z.AddDir("log", path.Join(execDir, "log")) if err = z.Close(); err != nil { os.Remove(fileName) log.Fatalf("Fail to save %s: %v", fileName, err) } log.Println("Finish dumping!") }
// for command: ./gogs update func runUpdate(c *cli.Context) { cmd := os.Getenv("SSH_ORIGINAL_COMMAND") if cmd == "" { return } execDir, _ := base.ExecDir() newUpdateLogger(execDir) base.NewConfigContext() models.LoadModelsConfig() if models.UseSQLite3 { os.Chdir(execDir) } models.SetEngine() args := c.Args() if len(args) != 3 { qlog.Fatal("received less 3 parameters") } if args[0] == "" { qlog.Fatal("refName is empty, shouldn't use") } //updateEnv(args[0], args[1], args[2]) userName := os.Getenv("userName") userId, _ := strconv.ParseInt(os.Getenv("userId"), 10, 64) //repoId := os.Getenv("repoId") repoUserName := os.Getenv("repoUserName") repoName := os.Getenv("repoName") models.Update(args[0], args[1], args[2], userName, repoUserName, repoName, userId) }
func runDump(*cli.Context) { base.NewConfigContext() log.Printf("Dumping local repositories...%s", base.RepoRootPath) zip.Verbose = false defer os.Remove("gogs-repo.zip") if err := zip.PackTo(base.RepoRootPath, "gogs-repo.zip", true); err != nil { log.Fatalf("Fail to dump local repositories: %v", err) } z, err := zip.Create("gogs-dump.zip") if err != nil { os.Remove("gogs-dump.zip") log.Fatalf("Fail to create gogs-dump.zip: %v", err) } execDir, _ := base.ExecDir() z.AddFile("gogs-repo.zip", path.Join(execDir, "gogs-repo.zip")) z.AddFile("custom/conf/app.ini", path.Join(execDir, "custom/conf/app.ini")) z.AddDir("log", path.Join(execDir, "log")) z.Close() log.Println("Finish dumping!") }
// for command: ./gogs update func runUpdate(c *cli.Context) { execDir, _ := base.ExecDir() newLogger(execDir) base.NewConfigContext() models.LoadModelsConfig() if models.UseSQLite3 { os.Chdir(execDir) } models.SetEngine() args := c.Args() if len(args) != 3 { log.Error("received less 3 parameters") return } refName := args[0] if refName == "" { log.Error("refName is empty, shouldn't use") return } oldCommitId := args[1] newCommitId := args[2] isNew := strings.HasPrefix(oldCommitId, "0000000") if isNew && strings.HasPrefix(newCommitId, "0000000") { log.Error("old rev and new rev both 000000") return } userName := os.Getenv("userName") userId := os.Getenv("userId") //repoId := os.Getenv("repoId") repoName := os.Getenv("repoName") f := models.RepoPath(userName, repoName) gitUpdate := exec.Command("git", "update-server-info") gitUpdate.Dir = f gitUpdate.Run() repo, err := git.OpenRepository(f) if err != nil { log.Error("runUpdate.Open repoId: %v", err) return } newOid, err := git.NewOidFromString(newCommitId) if err != nil { log.Error("runUpdate.Ref repoId: %v", err) return } newCommit, err := repo.LookupCommit(newOid) if err != nil { log.Error("runUpdate.Ref repoId: %v", err) return } var l *list.List // if a new branch if isNew { l, err = repo.CommitsBefore(newCommit.Id()) if err != nil { log.Error("Find CommitsBefore erro:", err) return } } else { oldOid, err := git.NewOidFromString(oldCommitId) if err != nil { log.Error("runUpdate.Ref repoId: %v", err) return } oldCommit, err := repo.LookupCommit(oldOid) if err != nil { log.Error("runUpdate.Ref repoId: %v", err) return } l = repo.CommitsBetween(newCommit, oldCommit) } if err != nil { log.Error("runUpdate.Commit repoId: %v", err) return } sUserId, err := strconv.Atoi(userId) if err != nil { log.Error("runUpdate.Parse userId: %v", err) return } repos, err := models.GetRepositoryByName(int64(sUserId), repoName) if err != nil { log.Error("runUpdate.GetRepositoryByName userId: %v", err) return } commits := make([]*base.PushCommit, 0) var maxCommits = 3 var actEmail string for e := l.Front(); e != nil; e = e.Next() { commit := e.Value.(*git.Commit) if actEmail == "" { actEmail = commit.Committer.Email } commits = append(commits, &base.PushCommit{commit.Id().String(), commit.Message(), commit.Author.Email, commit.Author.Name}) if len(commits) >= maxCommits { break } } //commits = append(commits, []string{lastCommit.Id().String(), lastCommit.Message()}) if err = models.CommitRepoAction(int64(sUserId), userName, actEmail, repos.Id, repoName, git.BranchName(refName), &base.PushCommits{l.Len(), commits}); err != nil { log.Error("runUpdate.models.CommitRepoAction: %v", err) } }
func runServ(k *cli.Context) { execDir, _ := base.ExecDir() newLogger(execDir) base.NewConfigContext() models.LoadModelsConfig() if models.UseSQLite3 { os.Chdir(execDir) } models.SetEngine() keys := strings.Split(os.Args[2], "-") if len(keys) != 2 { println("auth file format error") log.Error("auth file format error") return } keyId, err := strconv.ParseInt(keys[1], 10, 64) if err != nil { println("auth file format error") log.Error("auth file format error", err) return } user, err := models.GetUserByKeyId(keyId) if err != nil { println("You have no right to access") log.Error("SSH visit error: %v", err) return } cmd := os.Getenv("SSH_ORIGINAL_COMMAND") if cmd == "" { println("Hi", user.Name, "! You've successfully authenticated, but Gogs does not provide shell access.") return } verb, args := parseCmd(cmd) repoPath := strings.Trim(args, "'") rr := strings.SplitN(repoPath, "/", 2) if len(rr) != 2 { println("Unavilable repository", args) log.Error("Unavilable repository %v", args) return } repoUserName := rr[0] repoName := rr[1] if strings.HasSuffix(repoName, ".git") { repoName = repoName[:len(repoName)-4] } isWrite := In(verb, COMMANDS_WRITE) isRead := In(verb, COMMANDS_READONLY) repoUser, err := models.GetUserByName(repoUserName) if err != nil { fmt.Println("You have no right to access") log.Error("Get user failed", err) return } // access check switch { case isWrite: has, err := models.HasAccess(user.LowerName, path.Join(repoUserName, repoName), models.AU_WRITABLE) if err != nil { println("Inernel error:", err) log.Error(err.Error()) return } else if !has { println("You have no right to write this repository") log.Error("User %s has no right to write repository %s", user.Name, repoPath) return } case isRead: repo, err := models.GetRepositoryByName(repoUser.Id, repoName) if err != nil { println("Get repository error:", err) log.Error("Get repository error: " + err.Error()) return } if !repo.IsPrivate { break } has, err := models.HasAccess(user.Name, repoPath, models.AU_READABLE) if err != nil { println("Inernel error") log.Error(err.Error()) return } if !has { has, err = models.HasAccess(user.Name, repoPath, models.AU_WRITABLE) if err != nil { println("Inernel error") log.Error(err.Error()) return } } if !has { println("You have no right to access this repository") log.Error("You have no right to access this repository") return } default: println("Unknown command") log.Error("Unknown command") return } // for update use os.Setenv("userName", user.Name) os.Setenv("userId", strconv.Itoa(int(user.Id))) os.Setenv("repoName", repoName) gitcmd := exec.Command(verb, repoPath) gitcmd.Dir = base.RepoRootPath gitcmd.Stdout = os.Stdout gitcmd.Stdin = os.Stdin gitcmd.Stderr = os.Stderr if err = gitcmd.Run(); err != nil { println("execute command error:", err.Error()) log.Error("execute command error: " + err.Error()) return } }