Add simple sync mode

config.example.yaml

@@ -10,6 +10,7 @@ grafana:
     # case-insensitive and optional.
     ignore_prefix: test
 
+
 # Settings to interact with the Git repository. Currently only SSH repos are
 # supported.
 git:
@@ -33,7 +34,22 @@ git:
         # Author's email.
         email: grafana-dashboard-manager@company.tld
 
-# Configuration for the Git -> Grafana pusher.
+# An alternative to Git synchronisation is the "simple sync" mode. This will
+# only back up your dashboards on the disk and won't do anything else.
+# Here is an example of the synchronisation for the simple sync mode:
+#
+#   simple_sync:
+#       sync_path: /etc/grafana-dashboards
+#
+# Note that if Git settings are supplied, the settings there will be used even
+# if there are settings for the "simple sync" mode. In this case, if settings for
+# the "simple sync" mode are supplied, they will be ignored by the configuration.
+# Note also that the "simple sync" mode doesn't work with the pusher, which needs
+# Git settings to work.
+
+
+# Configuration for the Git -> Grafana pusher. Optional (only required if you
+# try to run the pusher).
 pusher:
     # Mode which will define how the pusher will sync with the Git remote.
     # Currently, only two modes are supported:

src/config/config.go

@@ -13,14 +13,16 @@ import (
 var (
 	ErrPusherInvalidSyncMode   = errors.New("Invalid sync mode in the pusher settings")
 	ErrPusherConfigNotMatching = errors.New("The pusher config doesn't match with the one expected from the pusher sync mode")
+	ErrNoSyncSettings          = errors.New("At least one of the simple_sync or the git settings must be set")
 )
 
 // Config is the Go representation of the configuration file. It is filled when
 // parsing the said file.
 type Config struct {
-	Grafana GrafanaSettings `yaml:"grafana"`
-	Git     GitSettings     `yaml:"git"`
-	Pusher  PusherSettings  `yaml:"pusher"`
+	Grafana    GrafanaSettings     `yaml:"grafana"`
+	SimpleSync *SimpleSyncSettings `yaml:"simple_sync,omitempty"`
+	Git        *GitSettings        `yaml:"git,omitempty"`
+	Pusher     *PusherSettings     `yaml:"pusher,omitempty"`
 }
 
 // GrafanaSettings contains the data required to talk to the Grafana HTTP API.
@@ -30,6 +32,14 @@ type GrafanaSettings struct {
 	IgnorePrefix string `yaml:"ignore_prefix,omitempty"`
 }
 
+// SimpleSyncSettings contains minimal data on the synchronisation process. It is
+// expected to be found if there is no Git settings.
+// If both simple sync settings and Git settings are found, the Git settings
+// will be used.
+type SimpleSyncSettings struct {
+	SyncPath string `yaml:"sync_path"`
+}
+
 // GitSettings contains the data required to interact with the Git repository.
 type GitSettings struct {
 	URL            string              `yaml:"url"`
@@ -82,6 +92,13 @@ func Load(filename string) (cfg *Config, err error) {
 	if err = yaml.Unmarshal(rawCfg, cfg); err != nil {
 		return
 	}
+
+	// Check if at least one settings group exists for synchronisation settings.
+	if cfg.Git == nil && cfg.SimpleSync == nil {
+		err = ErrNoSyncSettings
+		return
+	}
+
 	// Since we always compare the prefix against a slug, we need to make sure
 	// the prefix is a slug itself.
 	cfg.Grafana.IgnorePrefix = slug.Make(cfg.Grafana.IgnorePrefix)
@@ -95,7 +112,7 @@ func Load(filename string) (cfg *Config, err error) {
 // Returns an error if the sync mode isn't in the allowed modes, or if at least
 // one of the fields expected to hold a non-zero-value holds the zero-value for
 // its type.
-func validatePusherSettings(cfg PusherSettings) error {
+func validatePusherSettings(cfg *PusherSettings) error {
 	config := cfg.Config
 	var configValid bool
 	switch cfg.Mode {

src/git/git.go

@@ -22,7 +22,7 @@ import (
 // authentication data needed to talk to the Git remote.
 type Repository struct {
 	Repo *gogit.Repository
-	cfg  config.GitSettings
+	cfg  *config.GitSettings
 	auth *gitssh.PublicKeys
 }
 
@@ -32,7 +32,7 @@ type Repository struct {
 // and needs the repository to be cloned from remote before it is usable.
 // Returns an error if there was an issue opening the clone path or loading
 // authentication data.
-func NewRepository(cfg config.GitSettings) (r *Repository, invalidRepo bool, err error) {
+func NewRepository(cfg *config.GitSettings) (r *Repository, invalidRepo bool, err error) {
 	// Load the repository.
 	repo, err := gogit.PlainOpen(cfg.ClonePath)
 	if err != nil {

src/puller/main.go

@@ -25,6 +25,18 @@ func main() {
 		logrus.Panic(err)
 	}
 
+	// Tell the user which sync mode we use.
+	var syncMode string
+	if cfg.Git != nil {
+		syncMode = "git"
+	} else {
+		syncMode = "simple"
+	}
+
+	logrus.WithFields(logrus.Fields{
+		"sync_mode": syncMode,
+	}).Info("Sync mode set")
+
 	// Initialise the Grafana API client.
 	client := grafana.NewClient(cfg.Grafana.BaseURL, cfg.Grafana.APIKey)
 	// Run the puller.

src/puller/puller.go

@@ -25,20 +25,33 @@ type diffVersion struct {
 // which name starts with "test", 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, cfg *config.Config) error {
-	// Clone or pull the repo
-	repo, _, err := git.NewRepository(cfg.Git)
-	if err != nil {
-		return err
-	}
+func PullGrafanaAndCommit(client *grafana.Client, cfg *config.Config) (err error) {
+	var repo *git.Repository
+	var w *gogit.Worktree
+	var syncPath string
+
+	// Only do Git stuff if there's a configuration for that. On "simple sync"
+	// mode, we don't need do do any versioning.
+	// We need to set syncPath accordingly, though, because we use it later.
+	if cfg.Git != nil {
+		syncPath = cfg.Git.ClonePath
+
+		// Clone or pull the repo
+		repo, _, err = git.NewRepository(cfg.Git)
+		if err != nil {
+			return err
+		}
 
-	if err = repo.Sync(false); err != nil {
-		return err
-	}
+		if err = repo.Sync(false); err != nil {
+			return err
+		}
 
-	w, err := repo.Repo.Worktree()
-	if err != nil {
-		return err
+		w, err = repo.Repo.Worktree()
+		if err != nil {
+			return err
+		}
+	} else {
+		syncPath = cfg.SimpleSync.SyncPath
 	}
 
 	// Get URIs for all known dashboards
@@ -52,7 +65,7 @@ func PullGrafanaAndCommit(client *grafana.Client, cfg *config.Config) error {
 
 	// Load versions
 	logrus.Info("Getting local dashboard versions")
-	dbVersions, err := getDashboardsVersions(cfg.Git.ClonePath)
+	dbVersions, err := getDashboardsVersions(syncPath)
 	if err != nil {
 		return err
 	}
@@ -96,7 +109,7 @@ func PullGrafanaAndCommit(client *grafana.Client, cfg *config.Config) error {
 			}).Info("Grafana has a newer version, updating")
 
 			if err = addDashboardChangesToRepo(
-				dashboard, cfg.Git.ClonePath, w,
+				dashboard, syncPath, w,
 			); err != nil {
 				return err
 			}
@@ -112,24 +125,36 @@ func PullGrafanaAndCommit(client *grafana.Client, cfg *config.Config) error {
 		}
 	}
 
-	status, err := w.Status()
-	if err != nil {
-		return err
-	}
+	// Only do Git stuff if there's a configuration for that. On "simple sync"
+	// mode, we don't need do do any versioning.
+	if cfg.Git != nil {
+		var status gogit.Status
+		status, err = w.Status()
+		if err != nil {
+			return err
+		}
 
-	// Check if there's uncommited changes, and if that's the case, commit them.
-	if !status.IsClean() {
-		logrus.Info("Comitting changes")
+		// Check if there's uncommited changes, and if that's the case, commit
+		// them.
+		if !status.IsClean() {
+			logrus.Info("Comitting changes")
 
-		if err = commitNewVersions(dbVersions, dv, w, cfg); err != nil {
-			return err
+			if err = commitNewVersions(dbVersions, dv, w, cfg); 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 = repo.Push(); 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 = repo.Push(); err != nil {
+			return err
+		}
+	} else {
+		// If we're on simple sync mode, write versions and don't do anything
+		// else.
+		if err = writeVersions(dbVersions, dv, syncPath); err != nil {
+			return err
+		}
 	}
 
 	return nil
@@ -146,8 +171,12 @@ func addDashboardChangesToRepo(
 		return err
 	}
 
-	if _, err := worktree.Add(slugExt); err != nil {
-		return err
+	// If worktree is nil, it means that it hasn't been initialised, which means
+	// the sync mode is "simple sync" and not Git.
+	if worktree != nil {
+		if _, err := worktree.Add(slugExt); err != nil {
+			return err
+		}
 	}
 
 	return nil

src/pusher/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"flag"
+	"os"
 
 	"config"
 	"grafana"
@@ -33,6 +34,11 @@ func main() {
 		logrus.Panic(err)
 	}
 
+	if cfg.Git == nil || cfg.Pusher == nil {
+		logrus.Info("The git configuration or the pusher configuration (or both) is not defined in the configuration file. The pusher cannot start unless both are defined.")
+		os.Exit(0)
+	}
+
 	// Initialise the Grafana API client.
 	grafanaClient := grafana.NewClient(cfg.Grafana.BaseURL, cfg.Grafana.APIKey)