Adam Majer
9ef8209622
Use temp /run instance directory for the config Use ./config.json as default from within the process
607 lines
19 KiB
Go
607 lines
19 KiB
Go
package main
|
|
|
|
/*
|
|
* This file is part of Autogits.
|
|
*
|
|
* Copyright © 2024 SUSE LLC
|
|
*
|
|
* Autogits is free software: you can redistribute it and/or modify it under
|
|
* the terms of the GNU General Public License as published by the Free Software
|
|
* Foundation, either version 2 of the License, or (at your option) any later
|
|
* version.
|
|
*
|
|
* Autogits is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
|
* PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* Foobar. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"io/fs"
|
|
"math/rand"
|
|
"net/url"
|
|
"os"
|
|
"os/signal"
|
|
"path"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"src.opensuse.org/autogits/common"
|
|
)
|
|
|
|
const (
|
|
AppName = "direct_workflow"
|
|
GitAuthor = "AutoGits prjgit-updater"
|
|
GitEmail = "autogits-direct@noreply@src.opensuse.org"
|
|
)
|
|
|
|
var configuredRepos map[string][]*common.AutogitConfig
|
|
var gitea common.Gitea
|
|
|
|
var orgLinks map[string]*PackageRebaseLink
|
|
|
|
func isConfiguredOrg(org *common.Organization) bool {
|
|
_, found := configuredRepos[org.Username]
|
|
return found
|
|
}
|
|
|
|
type RepositoryActionProcessor struct{}
|
|
|
|
func (*RepositoryActionProcessor) ProcessFunc(request *common.Request) error {
|
|
action := request.Data.(*common.RepositoryWebhookEvent)
|
|
configs, configFound := configuredRepos[action.Organization.Username]
|
|
|
|
if !configFound {
|
|
common.LogInfo("Repository event for", action.Organization.Username, ". Not configured. Ignoring.", action.Organization.Username)
|
|
return nil
|
|
}
|
|
|
|
for _, config := range configs {
|
|
if org, repo, _ := config.GetPrjGit(); org == action.Repository.Owner.Username && repo == action.Repository.Name {
|
|
common.LogError("+ ignoring repo event for PrjGit repository", config.GitProjectName)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
for _, config := range configs {
|
|
processConfiguredRepositoryAction(action, config)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func processConfiguredRepositoryAction(action *common.RepositoryWebhookEvent, config *common.AutogitConfig) {
|
|
gitOrg, gitPrj, gitBranch := config.GetPrjGit()
|
|
git, err := gh.CreateGitHandler(config.Organization)
|
|
common.PanicOnError(err)
|
|
defer git.Close()
|
|
|
|
configBranch := config.Branch
|
|
if len(configBranch) == 0 {
|
|
configBranch = action.Repository.Default_Branch
|
|
if common.IsRemovedBranch(configBranch) {
|
|
common.LogDebug(" - default branch has deleted suffix. Skipping")
|
|
return
|
|
}
|
|
}
|
|
|
|
prjGitRepo, err := gitea.CreateRepositoryIfNotExist(git, gitOrg, gitPrj)
|
|
if err != nil {
|
|
common.LogError("Error accessing/creating prjgit:", gitOrg, gitPrj, gitBranch, err)
|
|
return
|
|
}
|
|
|
|
remoteName, err := git.GitClone(gitPrj, gitBranch, prjGitRepo.SSHURL)
|
|
common.PanicOnError(err)
|
|
|
|
switch action.Action {
|
|
case "created":
|
|
if action.Repository.Object_Format_Name != "sha256" {
|
|
common.LogError(" - '%s' repo is not sha256. Ignoring.", action.Repository.Name)
|
|
return
|
|
}
|
|
common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--depth", "1", action.Repository.Clone_Url, action.Repository.Name))
|
|
defer git.GitExecQuietOrPanic(gitPrj, "submodule", "deinit", "--all")
|
|
|
|
branch := strings.TrimSpace(git.GitExecWithOutputOrPanic(path.Join(gitPrj, action.Repository.Name), "branch", "--show-current"))
|
|
if branch != configBranch {
|
|
if err := git.GitExec(path.Join(gitPrj, action.Repository.Name), "fetch", "--depth", "1", "origin", configBranch+":"+configBranch); err != nil {
|
|
common.LogError("error fetching branch", configBranch, ". ignoring as non-existent.", err) // no branch? so ignore repo here
|
|
return
|
|
}
|
|
common.PanicOnError(git.GitExec(path.Join(gitPrj, action.Repository.Name), "checkout", configBranch))
|
|
}
|
|
common.PanicOnError(git.GitExec(gitPrj, "commit", "-m", "Auto-inclusion "+action.Repository.Name))
|
|
if !noop {
|
|
common.PanicOnError(git.GitExec(gitPrj, "push"))
|
|
}
|
|
|
|
case "deleted":
|
|
if stat, err := os.Stat(filepath.Join(git.GetPath(), gitPrj, action.Repository.Name)); err != nil || !stat.IsDir() {
|
|
common.LogDebug("delete event for", action.Repository.Name, "-- not in project. Ignoring")
|
|
return
|
|
}
|
|
common.PanicOnError(git.GitExec(gitPrj, "rm", action.Repository.Name))
|
|
common.PanicOnError(git.GitExec(gitPrj, "commit", "-m", "Automatic package removal via Direct Workflow"))
|
|
if !noop {
|
|
git.GitExecOrPanic(gitPrj, "push", remoteName)
|
|
}
|
|
|
|
default:
|
|
common.LogError("Unknown action type:", action.Action)
|
|
return
|
|
}
|
|
}
|
|
|
|
type PushActionProcessor struct{}
|
|
|
|
func (*PushActionProcessor) ProcessFunc(request *common.Request) error {
|
|
action := request.Data.(*common.PushWebhookEvent)
|
|
configs, configFound := configuredRepos[action.Repository.Owner.Username]
|
|
|
|
if !configFound {
|
|
common.LogDebug("Repository event for", action.Repository.Owner.Username, ". Not configured. Ignoring.")
|
|
return nil
|
|
}
|
|
|
|
for _, config := range configs {
|
|
if gitOrg, gitPrj, _ := config.GetPrjGit(); gitOrg == action.Repository.Owner.Username && gitPrj == action.Repository.Name {
|
|
common.LogInfo("+ ignoring push to PrjGit repository", config.GitProjectName)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
for _, config := range configs {
|
|
processConfiguredPushAction(action, config)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func processConfiguredPushAction(action *common.PushWebhookEvent, config *common.AutogitConfig) {
|
|
gitOrg, gitPrj, gitBranch := config.GetPrjGit()
|
|
git, err := gh.CreateGitHandler(config.Organization)
|
|
common.PanicOnError(err)
|
|
defer git.Close()
|
|
|
|
common.LogDebug("push to:", action.Repository.Owner.Username, action.Repository.Name, "for:", gitOrg, gitPrj, gitBranch)
|
|
branch := config.Branch
|
|
if len(branch) == 0 {
|
|
if common.IsRemovedBranch(branch) {
|
|
common.LogDebug(" + default branch has removed suffix:", branch, "Skipping.")
|
|
return
|
|
}
|
|
branch = action.Repository.Default_Branch
|
|
common.LogDebug(" + using default branch", branch)
|
|
}
|
|
|
|
prjGitRepo, err := gitea.CreateRepositoryIfNotExist(git, gitOrg, gitPrj)
|
|
if err != nil {
|
|
common.LogError("Error accessing/creating prjgit:", gitOrg, gitPrj, err)
|
|
return
|
|
}
|
|
|
|
remoteName, err := git.GitClone(gitPrj, gitBranch, prjGitRepo.SSHURL)
|
|
common.PanicOnError(err)
|
|
headCommitId, err := git.GitRemoteHead(gitPrj, remoteName, gitBranch)
|
|
common.PanicOnError(err)
|
|
commit, ok := git.GitSubmoduleCommitId(gitPrj, action.Repository.Name, headCommitId)
|
|
for ok && action.Head_Commit.Id == commit {
|
|
common.LogDebug(" -- nothing to do, commit already in ProjectGit")
|
|
return
|
|
}
|
|
|
|
if stat, err := os.Stat(filepath.Join(git.GetPath(), gitPrj, action.Repository.Name)); err != nil {
|
|
git.GitExecOrPanic(gitPrj, "submodule", "--quiet", "add", "--depth", "1", action.Repository.Clone_Url, action.Repository.Name)
|
|
common.LogDebug("Pushed to package that is not part of the project. Re-adding...", err)
|
|
} else if !stat.IsDir() {
|
|
common.LogError("Pushed to a package that is not a submodule but exists in the project. Ignoring.")
|
|
return
|
|
}
|
|
git.GitExecOrPanic(gitPrj, "submodule", "update", "--init", "--depth", "1", "--checkout", action.Repository.Name)
|
|
defer git.GitExecQuietOrPanic(gitPrj, "submodule", "deinit", "--all")
|
|
|
|
if err := git.GitExec(filepath.Join(gitPrj, action.Repository.Name), "fetch", "--depth", "1", "--force", remoteName, branch+":"+branch); err != nil {
|
|
common.LogError("Error fetching branch:", branch, "Ignoring as non-existent.", err)
|
|
return
|
|
}
|
|
id, err := git.GitRemoteHead(filepath.Join(gitPrj, action.Repository.Name), remoteName, branch)
|
|
common.PanicOnError(err)
|
|
if action.Head_Commit.Id == id {
|
|
git.GitExecOrPanic(filepath.Join(gitPrj, action.Repository.Name), "checkout", id)
|
|
git.GitExecOrPanic(gitPrj, "commit", "-a", "-m", "Automatic update via push via Direct Workflow")
|
|
if !noop {
|
|
git.GitExecOrPanic(gitPrj, "push", remoteName)
|
|
}
|
|
return
|
|
}
|
|
|
|
common.LogDebug("push of refs not on the configured branch", branch, ". ignoring.")
|
|
}
|
|
|
|
func verifyProjectState(git common.Git, org string, config *common.AutogitConfig, configs []*common.AutogitConfig) (err error) {
|
|
defer func() {
|
|
e := recover()
|
|
if e != nil {
|
|
errCast, ok := e.(error)
|
|
if ok {
|
|
err = errCast
|
|
}
|
|
}
|
|
}()
|
|
|
|
gitOrg, gitPrj, gitBranch := config.GetPrjGit()
|
|
repo, err := gitea.CreateRepositoryIfNotExist(git, gitOrg, gitPrj)
|
|
if err != nil {
|
|
return fmt.Errorf("Error fetching or creating '%s/%s' -- aborting verifyProjectState(). Err: %w", gitOrg, gitPrj, err)
|
|
}
|
|
|
|
remoteName, err := git.GitClone(gitPrj, gitBranch, repo.SSHURL)
|
|
common.PanicOnError(err)
|
|
defer git.GitExecQuietOrPanic(gitPrj, "submodule", "deinit", "--all")
|
|
|
|
common.LogDebug(" * Getting submodule list")
|
|
sub, err := git.GitSubmoduleList(gitPrj, "HEAD")
|
|
common.PanicOnError(err)
|
|
|
|
common.LogDebug(" * Getting package links")
|
|
var pkgLinks []*PackageRebaseLink
|
|
if f, err := fs.Stat(os.DirFS(path.Join(git.GetPath(), gitPrj)), common.PrjLinksFile); err == nil && (f.Mode()&fs.ModeType == 0) && f.Size() < 1000000 {
|
|
if data, err := os.ReadFile(path.Join(git.GetPath(), gitPrj, common.PrjLinksFile)); err == nil {
|
|
pkgLinks, err = parseProjectLinks(data)
|
|
if err != nil {
|
|
common.LogError("Cannot parse project links file:", err.Error())
|
|
pkgLinks = nil
|
|
} else {
|
|
ResolveLinks(org, pkgLinks, gitea)
|
|
}
|
|
}
|
|
} else {
|
|
common.LogInfo(" - No package links defined")
|
|
}
|
|
|
|
/* Check existing submodule that they are updated */
|
|
isGitUpdated := false
|
|
next_package:
|
|
for filename, commitId := range sub {
|
|
// ignore project gits
|
|
//for _, c := range configs {
|
|
if gitPrj == filename {
|
|
common.LogDebug(" prjgit as package? ignoring project git:", filename)
|
|
continue next_package
|
|
}
|
|
//}
|
|
|
|
branch := config.Branch
|
|
common.LogDebug(" verifying package: %s -> %s(%s)", commitId, filename, branch)
|
|
if repo, err := gitea.GetRepository(org, filename); repo == nil && err == nil {
|
|
common.LogDebug(" repository removed...")
|
|
git.GitExecOrPanic(gitPrj, "rm", filename)
|
|
isGitUpdated = true
|
|
continue
|
|
}
|
|
if len(branch) == 0 {
|
|
branch = repo.DefaultBranch
|
|
if common.IsRemovedBranch(branch) {
|
|
common.LogDebug(" Default branch for", filename, "is excluded")
|
|
git.GitExecOrPanic(gitPrj, "rm", filename)
|
|
isGitUpdated = true
|
|
continue
|
|
}
|
|
}
|
|
|
|
commits, err := gitea.GetRecentCommits(org, filename, branch, 10)
|
|
if err != nil {
|
|
common.LogDebug(" -> failed to fetch recent commits for package:", filename, " Err:", err)
|
|
continue
|
|
}
|
|
|
|
idx := 1000
|
|
for i, c := range commits {
|
|
if c.SHA == commitId {
|
|
idx = i
|
|
break
|
|
}
|
|
}
|
|
|
|
var link *PackageRebaseLink
|
|
for _, l := range pkgLinks {
|
|
if l.Pkg == filename {
|
|
link = l
|
|
|
|
common.LogDebug(" -> linked package")
|
|
// so, we need to rebase here. Can't really optimize, so clone entire package tree and remote
|
|
pkgPath := path.Join(gitPrj, filename)
|
|
git.GitExecOrPanic(gitPrj, "submodule", "update", "--init", "--checkout", filename)
|
|
git.GitExecOrPanic(pkgPath, "fetch", "origin", commits[0].SHA)
|
|
git.GitExecOrPanic(pkgPath, "tag", "NOW")
|
|
git.GitExecOrPanic(pkgPath, "fetch", "origin")
|
|
git.GitExecOrPanic(pkgPath, "remote", "add", "parent", link.parentRepo.SSHURL)
|
|
git.GitExecOrPanic(pkgPath, "fetch", "parent")
|
|
git.GitExecOrPanic(pkgPath, "rebase", "--onto", "parent", link.SourceBranch)
|
|
|
|
nCommits := len(common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkgPath, "rev-list", "^NOW", "HEAD"), "\n"))
|
|
if nCommits > 0 {
|
|
if !noop {
|
|
git.GitExecOrPanic(pkgPath, "push", "-f", "origin", "HEAD:"+branch)
|
|
}
|
|
isGitUpdated = true
|
|
}
|
|
|
|
break
|
|
}
|
|
}
|
|
|
|
if link == nil {
|
|
if idx == 0 {
|
|
// up-to-date
|
|
continue
|
|
} else if idx < len(commits) { // update
|
|
common.PanicOnError(git.GitExec(gitPrj, "submodule", "update", "--init", "--depth", "1", "--checkout", filename))
|
|
common.PanicOnError(git.GitExec(filepath.Join(gitPrj, filename), "fetch", "--depth", "1", "origin", commits[0].SHA))
|
|
common.PanicOnError(git.GitExec(filepath.Join(gitPrj, filename), "checkout", commits[0].SHA))
|
|
common.LogDebug(" -> updated to", commits[0].SHA)
|
|
isGitUpdated = true
|
|
} else {
|
|
// probably need `merge-base` or `rev-list` here instead, or the project updated already
|
|
common.LogInfo(" *** Cannot find SHA of last matching update for package:", filename, " Ignoring")
|
|
}
|
|
}
|
|
}
|
|
|
|
// find all missing repositories, and add them
|
|
common.LogDebug("checking for missing repositories...")
|
|
repos, err := gitea.GetOrganizationRepositories(org)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
common.LogDebug(" nRepos:", len(repos))
|
|
|
|
/* Check repositories in org to make sure they are included in project git */
|
|
next_repo:
|
|
for _, r := range repos {
|
|
// for _, c := range configs {
|
|
if gitPrj == r.Name {
|
|
// ignore project gits
|
|
continue next_repo
|
|
}
|
|
// }
|
|
|
|
for repo := range sub {
|
|
if repo == r.Name {
|
|
// not missing
|
|
continue next_repo
|
|
}
|
|
}
|
|
|
|
common.LogDebug(" -- checking repository:", r.Name)
|
|
|
|
branch := config.Branch
|
|
if len(branch) == 0 {
|
|
branch = r.DefaultBranch
|
|
if common.IsRemovedBranch(branch) {
|
|
continue
|
|
}
|
|
}
|
|
if commits, err := gitea.GetRecentCommits(org, r.Name, branch, 1); err != nil || len(commits) == 0 {
|
|
// assumption that package does not exist, so not part of project
|
|
// https://github.com/go-gitea/gitea/issues/31976
|
|
|
|
// or, we do not have commits here
|
|
continue
|
|
}
|
|
|
|
// add repository to git project
|
|
common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--depth", "1", r.CloneURL, r.Name))
|
|
|
|
curBranch := strings.TrimSpace(git.GitExecWithOutputOrPanic(path.Join(gitPrj, r.Name), "branch", "--show-current"))
|
|
if branch != curBranch {
|
|
if err := git.GitExec(path.Join(gitPrj, r.Name), "fetch", "--depth", "1", "origin", branch+":"+branch); err != nil {
|
|
return fmt.Errorf("Fetching branch %s for %s/%s failed. Ignoring.", branch, repo.Owner.UserName, r.Name)
|
|
}
|
|
common.PanicOnError(git.GitExec(path.Join(gitPrj, r.Name), "checkout", branch))
|
|
}
|
|
|
|
isGitUpdated = true
|
|
}
|
|
|
|
if isGitUpdated {
|
|
common.PanicOnError(git.GitExec(gitPrj, "commit", "-a", "-m", "Automatic update via push via Direct Workflow -- SYNC"))
|
|
if !noop {
|
|
git.GitExecOrPanic(gitPrj, "push", remoteName)
|
|
}
|
|
}
|
|
|
|
common.LogInfo("Verification finished for ", org, ", prjgit:", config.GitProjectName)
|
|
return nil
|
|
}
|
|
|
|
var checkOnStart bool
|
|
var noop bool
|
|
var checkInterval time.Duration
|
|
|
|
func checkOrg(org string, configs []*common.AutogitConfig) {
|
|
git, err := gh.CreateGitHandler(org)
|
|
if err != nil {
|
|
common.LogError("Failed to allocate GitHandler:", err)
|
|
return
|
|
}
|
|
defer git.Close()
|
|
|
|
for _, config := range configs {
|
|
common.LogInfo(" ++ starting verification, org:", org, "config:", config.GitProjectName)
|
|
if err := verifyProjectState(git, org, config, configs); err != nil {
|
|
common.LogError(" *** verification failed, org:", org, err)
|
|
} else {
|
|
common.LogError(" ++ verification complete, org:", org, config.GitProjectName)
|
|
}
|
|
}
|
|
}
|
|
|
|
func checkRepos() {
|
|
for org, configs := range configuredRepos {
|
|
if checkInterval > 0 {
|
|
sleepInterval := checkInterval - checkInterval/2 + time.Duration(rand.Int63n(int64(checkInterval)))
|
|
common.LogInfo(" - sleep interval", sleepInterval, "until next check")
|
|
time.Sleep(sleepInterval)
|
|
}
|
|
|
|
checkOrg(org, configs)
|
|
}
|
|
}
|
|
|
|
func consistencyCheckProcess() {
|
|
if checkOnStart {
|
|
savedCheckInterval := checkInterval
|
|
checkInterval = 0
|
|
common.LogInfo("== Startup consistency check begin...")
|
|
checkRepos()
|
|
common.LogInfo("== Startup consistency check done...")
|
|
checkInterval = savedCheckInterval
|
|
}
|
|
|
|
for {
|
|
checkRepos()
|
|
}
|
|
}
|
|
|
|
var DebugMode bool
|
|
var gh common.GitHandlerGenerator
|
|
|
|
func updateConfiguration(configFilename string, orgs *[]string) {
|
|
configFile, err := common.ReadConfigFile(configFilename)
|
|
if err != nil {
|
|
common.LogError(err)
|
|
os.Exit(4)
|
|
}
|
|
|
|
configs, _ := common.ResolveWorkflowConfigs(gitea, configFile)
|
|
configuredRepos = make(map[string][]*common.AutogitConfig)
|
|
*orgs = make([]string, 0, 1)
|
|
for _, c := range configs {
|
|
if slices.Contains(c.Workflows, "direct") {
|
|
common.LogDebug(" + adding org:", c.Organization, ", branch:", c.Branch, ", prjgit:", c.GitProjectName)
|
|
configs := configuredRepos[c.Organization]
|
|
if configs == nil {
|
|
configs = make([]*common.AutogitConfig, 0, 1)
|
|
}
|
|
configs = append(configs, c)
|
|
configuredRepos[c.Organization] = configs
|
|
|
|
*orgs = append(*orgs, c.Organization)
|
|
}
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
configFilename := flag.String("config", "config.json", "List of PrjGit")
|
|
giteaUrl := flag.String("gitea-url", "https://src.opensuse.org", "Gitea instance")
|
|
rabbitUrl := flag.String("url", "amqps://rabbit.opensuse.org", "URL for RabbitMQ instance")
|
|
flag.BoolVar(&DebugMode, "debug", false, "Extra debugging information")
|
|
flag.BoolVar(&noop, "dry", false, "Dry mode. Do not push changes to remote repo.")
|
|
flag.BoolVar(&checkOnStart, "check-on-start", false, "Check all repositories for consistency on start, without delays")
|
|
checkIntervalHours := flag.Float64("check-interval", 5, "Check interval (+-random delay) for repositories for consitency, in hours")
|
|
basePath := flag.String("repo-path", "", "Repository path. Default is temporary directory")
|
|
flag.Parse()
|
|
|
|
if err := common.RequireGiteaSecretToken(); err != nil {
|
|
common.LogError(err)
|
|
os.Exit(1)
|
|
}
|
|
if err := common.RequireRabbitSecrets(); err != nil {
|
|
common.LogError(err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if cf := os.Getenv("AUTOGITS_CONFIG"); len(cf) > 0 {
|
|
*configFilename = cf
|
|
}
|
|
if url := os.Getenv("AUTOGITS_URL"); len(url) > 0 {
|
|
*giteaUrl = url
|
|
}
|
|
if url := os.Getenv("AUTOGITS_RABBITURL"); len(url) > 0 {
|
|
*rabbitUrl = url
|
|
}
|
|
if debug := os.Getenv("AUTOGITS_DEBUG"); len(debug) > 0 {
|
|
DebugMode = true
|
|
}
|
|
if check := os.Getenv("AUTOGITS_CHECK_ON_START"); len(check) > 0 {
|
|
checkOnStart = true
|
|
}
|
|
if p := os.Getenv("AUTOGITS_REPO_PATH"); len(p) > 0 {
|
|
*basePath = p
|
|
}
|
|
|
|
defs := &common.RabbitMQGiteaEventsProcessor{}
|
|
var err error
|
|
|
|
if len(*basePath) == 0 {
|
|
*basePath, err = os.MkdirTemp(os.TempDir(), AppName)
|
|
if err != nil {
|
|
common.LogError(err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
gh, err = common.AllocateGitWorkTree(*basePath, GitAuthor, GitEmail)
|
|
if err != nil {
|
|
common.LogError(err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// handle reconfiguration
|
|
signalChannel := make(chan os.Signal, 1)
|
|
defer close(signalChannel)
|
|
go func() {
|
|
for {
|
|
sig, ok := <-signalChannel
|
|
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
if sig != syscall.SIGHUP {
|
|
common.LogError("Unexpected signal received:", sig)
|
|
continue
|
|
}
|
|
common.LogError("*** Reconfiguring ***")
|
|
updateConfiguration(*configFilename, &defs.Orgs)
|
|
defs.Connection().UpdateTopics(defs)
|
|
}
|
|
}()
|
|
signal.Notify(signalChannel, syscall.SIGHUP)
|
|
|
|
checkInterval = time.Duration(*checkIntervalHours) * time.Hour
|
|
|
|
gitea = common.AllocateGiteaTransport(*giteaUrl)
|
|
CurrentUser, err := gitea.GetCurrentUser()
|
|
if err != nil {
|
|
common.LogError("Cannot fetch current user:", err)
|
|
os.Exit(2)
|
|
}
|
|
common.LogInfo("Current User:", CurrentUser.UserName)
|
|
|
|
updateConfiguration(*configFilename, &defs.Orgs)
|
|
|
|
defs.Connection().RabbitURL, err = url.Parse(*rabbitUrl)
|
|
if err != nil {
|
|
common.LogError("cannot parse server URL. Err:", err)
|
|
os.Exit(3)
|
|
}
|
|
|
|
go consistencyCheckProcess()
|
|
common.LogInfo("defs:", *defs)
|
|
|
|
defs.Handlers = make(map[string]common.RequestProcessor)
|
|
defs.Handlers[common.RequestType_Push] = &PushActionProcessor{}
|
|
defs.Handlers[common.RequestType_Repository] = &RepositoryActionProcessor{}
|
|
|
|
common.LogError(common.ProcessRabbitMQEvents(defs))
|
|
}
|