Use config in pusher

src/pusher/main.go

 
 import (
 	"flag"
-	"os"
 
+	"config"
 	"grafana"
 )
 
-// The Grafana API client needs to be global to the package since we need it in
-// the webhook handlers
+// The Grafana API client and the config need to be global to the package since
+// we need them in the webhook handlers.
 // TODO: Find a better way to pass it to the handlers
-var grafanaClient *grafana.Client
+var (
+	grafanaClient *grafana.Client
+	cfg           *config.Config
+)
 
 var (
-	grafanaURL       = flag.String("grafana-url", "", "Base URL of the Grafana instance")
-	grafanaAPIKey    = flag.String("api-key", "", "API key to use in authenticated requests")
-	clonePath        = flag.String("clone-path", "/tmp/grafana-dashboards", "Path to directory where the repo will be cloned")
-	repoURL          = flag.String("git-repo", "", "SSH URL for the Git repository, without the user part")
-	privateKeyPath   = flag.String("private-key", "", "Path to the private key used to talk with the Git remote")
-	webhookInterface = flag.String("webhook-interface", "127.0.0.1", "Interface on which the GitLab webhook will be exposed")
-	webhookPort      = flag.Int("webhook-port", 8080, "Port on which the GitLab webhook will be exposed")
-	webhookPath      = flag.String("webhook-path", "/gitlab-webhook", "Path at which GitLab should send payloads to the webhook")
-	webhookSecret    = flag.String("webhook-secret", "", "Secret GitLab will use to send payloads to the webhook")
+	configFile = flag.String("config", "config.yaml", "Path to the configuration file")
 )
 
 func main() {
 	flag.Parse()
 
-	if *grafanaURL == "" {
-		println("Error: No Grafana URL provided")
-		flag.Usage()
-		os.Exit(1)
-	}
-	if *grafanaAPIKey == "" {
-		println("Error: No Grafana API key provided")
-		flag.Usage()
-		os.Exit(1)
-	}
-	if *repoURL == "" {
-		println("Error: No Git repository provided")
-		flag.Usage()
-		os.Exit(1)
-	}
-	if *privateKeyPath == "" {
-		println("Error: No private key provided")
-		flag.Usage()
-		os.Exit(1)
-	}
-	if *webhookSecret == "" {
-		println("Error: No webhook secret provided")
-		flag.Usage()
-		os.Exit(1)
+	cfg, err := config.Load(*configFile)
+	if err != nil {
+		panic(err)
 	}
 
-	grafanaClient = grafana.NewClient(*grafanaURL, *grafanaAPIKey)
+	grafanaClient = grafana.NewClient(cfg.Grafana.BaseURL, cfg.Grafana.APIKey)
 
-	if err := SetupWebhook(); err != nil {
+	if err := SetupWebhook(cfg); err != nil {
 		panic(err)
 	}
 }

src/pusher/webhook.go

 
 import (
 	"io/ioutil"
-	"strconv"
 	"strings"
 
+	"config"
 	puller "puller"
 
 	"gopkg.in/go-playground/webhooks.v3"
 	"gopkg.in/go-playground/webhooks.v3/gitlab"
 )
 
-func SetupWebhook() error {
+func SetupWebhook(cfg *config.Config) error {
 	hook := gitlab.New(&gitlab.Config{
-		Secret: "mysecret",
+		Secret: cfg.Webhook.Secret,
 	})
 	hook.RegisterEvents(HandlePush, gitlab.PushEvents)
 
 	return webhooks.Run(
 		hook,
-		*webhookInterface+":"+strconv.Itoa(*webhookPort),
-		*webhookPath,
+		cfg.Webhook.Interface+":"+cfg.Webhook.Port,
+		cfg.Webhook.Path,
 	)
 }
 
 	// Grafana will auto-update the version number after we pushed the new
 	// dashboards, so we use the puller mechanic to pull the updated numbers and
 	// commit them in the git repo.
-	if err = puller.PullGrafanaAndCommit(
-		grafanaClient, *repoURL, *clonePath, *privateKeyPath,
-	); err != nil {
+	if err = puller.PullGrafanaAndCommit(grafanaClient, cfg); err != nil {
 		panic(err)
 	}
 }
 
 func pushFile(filename string) error {
-	filePath := *clonePath + "/" + filename
+	filePath := cfg.Git.ClonePath + "/" + filename
 	fileContent, err := ioutil.ReadFile(filePath)
 	if err != nil {
 		return err