grafana-backuper/internal/cmd/backup.go

148 lines
3.7 KiB
Go

package cmd
import (
"context"
"encoding/json"
"fmt"
"slices"
"git.ar21.de/yolokube/grafana-backuper/internal/config"
"git.ar21.de/yolokube/grafana-backuper/pkg/git"
"git.ar21.de/yolokube/grafana-backuper/pkg/grafana"
"github.com/spf13/cobra"
)
func NewBackupCommand(c *config.Config) *cobra.Command {
backupCmd := &cobra.Command{
Use: "backup",
Short: "Back up the dashboards from grafana to a git repository.",
Long: "Back up the dashboards from grafana to a git repository.",
RunE: func(cmd *cobra.Command, _ []string) error {
return backup(cmd.Context(), c)
},
PreRunE: func(_ *cobra.Command, _ []string) error {
return c.Validate()
},
}
backupCmd.PersistentFlags().BoolVar(&c.ForceCommits, "force", false, "Force git commits / ignore existence check")
backupCmd.PersistentFlags().StringVar(&c.GitEmail, "git-email", "", "Git email address")
backupCmd.PersistentFlags().StringVar(&c.GPGKey, "signing-key", "", "Path to the GPG signing key")
return backupCmd
}
func backup(ctx context.Context, c *config.Config) error {
client := grafana.NewClient(
c.GrafanaURL,
grafana.WithToken(c.GrafanaToken),
)
project := git.NewProject(
c.GitRepo,
git.WithBasicAuth(c.GitUser, c.GitPass),
git.WithBranch(c.GitBranch),
)
if err := project.Clone(ctx); err != nil {
return err
}
if err := project.Checkout(); err != nil {
return err
}
if err := project.Pull(ctx); err != nil {
return err
}
var signer git.SignKey
if c.GPGKey != "" {
signer = git.SignKey{KeyFile: c.GPGKey}
if err := signer.ReadKeyFile(); err != nil {
return err
}
}
dashboards, _, err := client.File.Search(ctx, grafana.WithType(grafana.SearchTypeDashboard))
if err != nil {
return err
}
for _, dashboardInfo := range dashboards {
var dashboard *grafana.Dashboard
dashboard, _, err = client.Dashboard.Get(ctx, dashboardInfo.UID)
if err != nil {
return err
}
var versions []*grafana.DashboardVersion
versions, _, err = client.DashboardVersion.List(ctx, dashboardInfo.UID)
if err != nil {
return err
}
slices.Reverse(versions)
var uncommitedVersion bool
for _, version := range versions {
var dashboardVersion *grafana.DashboardVersion
dashboardVersion, _, err = client.DashboardVersion.Get(ctx, dashboardInfo.UID, version.Version)
if err != nil {
return err
}
dashboard.Dashboard = dashboardVersion.Data
dashboard.UpdatedBy = dashboardVersion.CreatedBy
dashboard.Updated = dashboardVersion.Created
dashboard.Version = dashboardVersion.Version
var data []byte
data, err = json.MarshalIndent(grafana.SchemaFromDashboardMeta(dashboard), "", " ")
if err != nil {
return err
}
commitMsg := fmt.Sprintf(
"%s: Update %s to version %d",
dashboardInfo.Title,
dashboardInfo.UID,
dashboardVersion.ID,
)
if dashboardVersion.Message != "" {
commitMsg += fmt.Sprintf(" => %s", dashboardVersion.Message)
}
commitOpts := []git.CommitOption{
git.WithAuthor(dashboardVersion.CreatedBy, ""),
git.WithFileContent(data, dashboardInfo.Title, dashboard.FolderTitle),
git.WithSigner(signer),
}
if c.GitUser != "" {
commitOpts = append(commitOpts, git.WithCommitter(c.GitUser, c.GitEmail))
}
commit := project.NewCommit(commitOpts...)
if commit.Exists(dashboardVersion.DashboardUID, dashboardVersion.ID) && !c.ForceCommits && !uncommitedVersion {
fmt.Fprintf(c.Output, "%s -> already committed\n", commitMsg)
continue
}
uncommitedVersion = true
if err = commit.Create(commitMsg); err != nil {
return err
}
fmt.Fprintln(c.Output, commitMsg)
}
}
if project.HasChanges() {
if err = project.Push(ctx); err != nil {
return err
}
}
return nil
}