Added hot config reloading

This diff adds the ability to reload the config with a `kill -hup`
on the process. If the config is not valid the old config will be
used and an error will be logged for you.

Author: michaeljs1990

.gitignore

@@ -1,3 +1,3 @@
 vendor
-test
 config.yaml
+git-sync

go.mod

@@ -1,4 +1,4 @@
-module cgit.xrt0x.com/xrt0x/test
+module cgit.xrt0x.com/xrt0x/git-sync
 
 require (
 	github.com/google/go-github/v21 v21.0.0

main.go

@@ -9,10 +9,12 @@ import (
 	"io/ioutil"
 	"net/http"
 	"os"
+	"os/signal"
 	"path"
 	"regexp"
 	"strings"
 	"sync"
+	"syscall"
 	"time"
 
 	// Sorry the naming here got kinda bad of note gconfig is for configuration
@@ -52,6 +54,11 @@ var (
 	SshProtocolRegex, _  = regexp.Compile("^ssh://|.*:.*")
 )
 
+var (
+	globalConf = Config{}
+	configLock = sync.RWMutex{}
+)
+
 // Config is the parent level of our YAML data that
 // all other config should tie back into.
 type Config struct {
@@ -187,7 +194,6 @@ func (r GithubConfig) toRepos(c Config) []repo {
 			Username:    r.Username,
 			CgitSection: r.Username,
 			CgitOwner:   r.Username,
-			Description: *v.Description,
 		}
 
 		// Need to add support here for using different kinds of urls but currently
@@ -503,8 +509,13 @@ func repoWorker(wg *sync.WaitGroup, rc <-chan repo) {
 }
 
 // Feed the channel all the information that it needs
-func feedChannel(jobs chan repo, c Config, oneshot bool) {
+func feedChannel(jobs chan repo, oneshot bool) {
 	for {
+		// Get the latest config that might have been updated
+		configLock.RLock()
+		c := globalConf
+		configLock.RUnlock()
+
 		for _, v := range c.Repos {
 			jobs <- v.toRepo(c)
 		}
@@ -532,6 +543,66 @@ func launchWorkers(workers int, wg *sync.WaitGroup, rc <-chan repo) {
 	}
 }
 
+// I'm not in love with what is going on here but in practice it should work just fine.
+// I think the one edge case is that this will make it so we can't validate a required
+// field that could be empty. I can't think of any reason I would need that though. So
+// what we are doing, is taking YAML, something that is half sane for human config and
+// populating the Config struct. We then turn it into JSON so we can pass it to the JSON
+// schema validator. Modern problems require modern solutions.
+func loadConfig(config string) (Config, error) {
+	c := Config{}
+
+	// Load our config into memory and do some error checking
+	dat, err := ioutil.ReadFile(config)
+	if err != nil {
+		return c, err
+	}
+
+	err = yaml.Unmarshal(dat, &c)
+	if err != nil {
+		return c, err
+	}
+
+	b, err := json.Marshal(c)
+	if err != nil {
+		return c, err
+	}
+
+	compiler := jsonschema.NewCompiler()
+	if err := compiler.AddResource("schema.json", strings.NewReader(schema)); err != nil {
+		return c, err
+	}
+
+	schema, err := compiler.Compile("schema.json")
+	if err != nil {
+		return c, err
+	}
+
+	if err := schema.Validate(strings.NewReader(string(b))); err != nil {
+		return c, err
+	}
+
+	return c, nil
+}
+
+func handleSignals(signals <-chan os.Signal, config string) {
+	for signal := range signals {
+		switch signal {
+		case syscall.SIGHUP:
+			log.Warn("Config reload requested")
+			newConfig, err := loadConfig(config)
+			if err != nil {
+				log.Error("Config not reloaded :", err.Error())
+			} else {
+				configLock.RLock()
+				globalConf = newConfig
+				configLock.RUnlock()
+				log.Warn("Config reload finished")
+			}
+		}
+	}
+}
+
 func main() {
 	conf := flag.String("config", "config.yaml", "Config file to start the application with")
 	workers := flag.Int("workers", 1, "The number of workers trying to update repos")
@@ -568,43 +639,13 @@ func main() {
 		log.SetLevel(log.WarnLevel)
 	}
 
-	// Load our config into memory and do some error checking
-	dat, err := ioutil.ReadFile(*conf)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// I'm not in love with what is going on here but in practice it should work just fine.
-	// I think the one edge case is that this will make it so we can't validate a required
-	// field that could be empty. I can't think of any reason I would need that though. So
-	// what we are doing, is taking YAML, something that is half sane for human config and
-	// populating the Config struct. We then turn it into JSON so we can pass it to the JSON
-	// schema validator. Modern problems require modern solutions.
-	config := Config{}
-	err = yaml.Unmarshal(dat, &config)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	b, err := json.Marshal(config)
+	config, err := loadConfig(*conf)
 	if err != nil {
-		fmt.Println(err)
-		return
+		log.Fatal(err.Error())
 	}
 
-	compiler := jsonschema.NewCompiler()
-	if err := compiler.AddResource("schema.json", strings.NewReader(schema)); err != nil {
-		log.Fatal(err)
-	}
-
-	schema, err := compiler.Compile("schema.json")
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	if err := schema.Validate(strings.NewReader(string(b))); err != nil {
-		log.Fatal(err)
-	}
+	// Set the global conf no mutex is needed at this time
+	globalConf = config
 
 	// If we have gotten this far and not failed we think it's all good
 	log.Info("Configuration has been validated")
@@ -621,9 +662,14 @@ func main() {
 	// as a one time service so you can use it in a cron if desired
 	var wg sync.WaitGroup
 	queue := make(chan repo, *workers*2)
-	go feedChannel(queue, config, *oneshot)
+	go feedChannel(queue, *oneshot)
 	launchWorkers(*workers, &wg, queue)
 
+	// Handle hot config reloads on SIGHUP
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, syscall.SIGHUP)
+	go handleSignals(signals, *conf)
+
 	// Hang for now but later this should do some checking for
 	// signals that may be sent to the processes as well as managing
 	// when the queue should have jobs pushed onto it again