Use config in puller

src/puller/main.go

 
 import (
 	"flag"
-	"os"
 
+	"config"
 	"grafana"
 )
 
 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")
+	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)
+	cfg, err := config.Load(*configFile)
+	if err != nil {
+		panic(err)
 	}
 
-	client := grafana.NewClient(*grafanaURL, *grafanaAPIKey)
-	if err := PullGrafanaAndCommit(
-		client, *repoURL, *clonePath, *privateKeyPath,
-	); err != nil {
+	client := grafana.NewClient(cfg.Grafana.BaseURL, cfg.Grafana.APIKey)
+	if err := PullGrafanaAndCommit(client, cfg); err != nil {
 		panic(err)
 	}
 }

src/puller/puller.go

 	"io/ioutil"
 	"os"
 
+	"config"
 	"git"
 	"grafana"
 
 // PullGrafanaAndCommit pulls all the dashboards from Grafana then commits each
 // of them to Git except for those that have a newer or equal version number
 // already versionned in the repo
-func PullGrafanaAndCommit(
-	client *grafana.Client,
-	repoURL string, clonePath string, privateKeyPath string,
-) error {
+func PullGrafanaAndCommit(client *grafana.Client, cfg *config.Config) error {
 	// Clone or pull the repo
-	repo, err := git.Sync(repoURL, clonePath, privateKeyPath)
+	repo, err := git.Sync(cfg.Git.URL, cfg.Git.ClonePath, cfg.Git.PrivateKeyPath)
 	if err != nil {
 		return err
 	}
 	dv := make(map[string]diffVersion)
 
 	// Load versions
-	dbVersions, err := getDashboardsVersions()
+	dbVersions, err := getDashboardsVersions(cfg.Git.ClonePath)
 	if err != nil {
 		return err
 	}
 		// changes in the repo and add the modified file to the git index.
 		version, ok := dbVersions[dashboard.Slug]
 		if !ok || dashboard.Version > version {
-			if err = addDashboardChangesToRepo(dashboard, w); err != nil {
+			if err = addDashboardChangesToRepo(
+				dashboard, cfg.Git.ClonePath, w,
+			); err != nil {
 				return err
 			}
 
 
 	// Check if there's uncommited changes, and if that's the case, commit them.
 	if !status.IsClean() {
-		if err = commitNewVersions(dbVersions, dv, w); err != nil {
+		if err = commitNewVersions(
+			dbVersions, dv, w, cfg.Git.ClonePath,
+		); err != nil {
 			return err
 		}
 	}
 
 	// Push the changes (we don't do it in the if clause above in case there are
 	// pending commits in the local repo that haven't been pushed yet).
-	if err = git.Push(repo, privateKeyPath); err != nil {
+	if err = git.Push(repo, cfg.Git.PrivateKeyPath); err != nil {
 		return err
 	}
 
 // file to the git index so it can be comitted afterwards.
 // Returns an error if there was an issue with either of the steps.
 func addDashboardChangesToRepo(
-	dashboard *grafana.Dashboard, worktree *gogit.Worktree,
+	dashboard *grafana.Dashboard, clonePath string, worktree *gogit.Worktree,
 ) error {
 	slugExt := dashboard.Slug + ".json"
-	if err := rewriteFile(
-		*clonePath+"/"+slugExt,
-		dashboard.RawJSON,
-	); err != nil {
+	if err := rewriteFile(clonePath+"/"+slugExt, dashboard.RawJSON); err != nil {
 		return err
 	}
 

src/puller/versions.go

 // If the file doesn't exist, returns an empty map.
 // Return an error if there was an issue looking for the file (except when the
 // file doesn't exist), reading it or formatting its content into a map.
-func getDashboardsVersions() (versions map[string]int, err error) {
+func getDashboardsVersions(clonePath string) (versions map[string]int, err error) {
 	versions = make(map[string]int)
 
-	filename := *clonePath + "/versions.json"
+	filename := clonePath + "/versions.json"
 
 	_, err = os.Stat(filename)
 	if os.IsNotExist(err) {
 // "versions.json" file.
 // Returns an error if there was an issue when conerting to JSON, indenting or
 // writing on disk.
-func writeVersions(versions map[string]int, dv map[string]diffVersion) (err error) {
+func writeVersions(
+	versions map[string]int, dv map[string]diffVersion, clonePath string,
+) (err error) {
 	for slug, diff := range dv {
 		versions[slug] = diff.newVersion
 	}
 		return
 	}
 
-	filename := *clonePath + "/versions.json"
+	filename := clonePath + "/versions.json"
 	return rewriteFile(filename, indentedJSON)
 }
 
 // file, adding it to the index or creating the commit.
 func commitNewVersions(
 	versions map[string]int, dv map[string]diffVersion, worktree *gogit.Worktree,
+	clonePath string,
 ) (err error) {
-	if err = writeVersions(versions, dv); err != nil {
+	if err = writeVersions(versions, dv, clonePath); err != nil {
 		return err
 	}