Merge pull request #361 from ArthurSens/arthursens/standalone-cli-tool-314

Add generate command

Author: metalmatze

filesystem.go

@@ -171,68 +171,17 @@ func cmdFilesystem(logger log.Logger, reg *prometheus.Registry, promClient api.C
 					level.Debug(logger).Log("msg", "reading", "file", f)
 					reconcilesTotal.Inc()
 
-					bytes, err := os.ReadFile(f)
+					err := writeRuleFile(logger, f, prometheusFolder, genericRules)
 					if err != nil {
 						reconcilesErrors.Inc()
-						return fmt.Errorf("failed to read file %q: %w", f, err)
+						level.Error(logger).Log("msg", "error creating rule file", "file", f)
 					}
 
-					var config v1alpha1.ServiceLevelObjective
-					if err := yaml.UnmarshalStrict(bytes, &config); err != nil {
-						reconcilesErrors.Inc()
-						return fmt.Errorf("failed to unmarshal objective %q: %w", f, err)
-					}
-
-					objective, err := config.Internal()
-					if err != nil {
-						reconcilesErrors.Inc()
-						return fmt.Errorf("failed to get objective: %w", err)
-					}
-
-					increases, err := objective.IncreaseRules()
-					if err != nil {
-						reconcilesErrors.Inc()
-						return fmt.Errorf("failed to get increase rules: %w", err)
-					}
-					burnrates, err := objective.Burnrates()
-					if err != nil {
-						reconcilesErrors.Inc()
-						return fmt.Errorf("failed to get burn rate rules: %w", err)
-					}
-
-					rule := monitoringv1.PrometheusRuleSpec{
-						Groups: []monitoringv1.RuleGroup{increases, burnrates},
-					}
-
-					if genericRules {
-						rules, err := objective.GenericRules()
-						if err == nil {
-							rule.Groups = append(rule.Groups, rules)
-						} else {
-							if err != slo.ErrGroupingUnsupported {
-								return fmt.Errorf("failed to get generic rules: %w", err)
-							}
-							level.Warn(logger).Log(
-								"msg", "objective with grouping unsupported with generic rules",
-								"objective", objective.Name(),
-							)
-						}
-					}
-
-					bytes, err = yaml.Marshal(rule)
+					objective, err := objectiveFromFile(f)
 					if err != nil {
 						reconcilesErrors.Inc()
-						return fmt.Errorf("failed to marshal recording rules: %w", err)
-					}
-
-					_, file := filepath.Split(f)
-					path := filepath.Join(prometheusFolder, file)
-
-					if err := os.WriteFile(path, bytes, 0o644); err != nil {
-						reconcilesErrors.Inc()
-						return fmt.Errorf("failed to write file %q: %w", path, err)
+						level.Error(logger).Log("msg", "failed to get objective from file", "file", f)
 					}
-
 					objectives.Set(objective)
 
 					reload <- struct{}{} // Trigger a Prometheus reload
@@ -343,3 +292,65 @@ func (s *FilesystemObjectiveServer) List(ctx context.Context, req *connect.Reque
 		Objectives: objectives,
 	}), nil
 }
+
+func writeRuleFile(logger log.Logger, file, prometheusFolder string, genericRules bool) error {
+	objective, err := objectiveFromFile(file)
+	if err != nil {
+		return fmt.Errorf("failed to get objective: %w", err)
+	}
+
+	increases, err := objective.IncreaseRules()
+	if err != nil {
+		return fmt.Errorf("failed to get increase rules: %w", err)
+	}
+	burnrates, err := objective.Burnrates()
+	if err != nil {
+		return fmt.Errorf("failed to get burn rate rules: %w", err)
+	}
+
+	rule := monitoringv1.PrometheusRuleSpec{
+		Groups: []monitoringv1.RuleGroup{increases, burnrates},
+	}
+
+	if genericRules {
+		rules, err := objective.GenericRules()
+		if err == nil {
+			rule.Groups = append(rule.Groups, rules)
+		} else {
+			if err != slo.ErrGroupingUnsupported {
+				return fmt.Errorf("failed to get generic rules: %w", err)
+			}
+			level.Warn(logger).Log(
+				"msg", "objective with grouping unsupported with generic rules",
+				"objective", objective.Name(),
+			)
+		}
+	}
+
+	bytes, err := yaml.Marshal(rule)
+	if err != nil {
+		return fmt.Errorf("failed to marshal recording rules: %w", err)
+	}
+
+	_, f := filepath.Split(file)
+	path := filepath.Join(prometheusFolder, f)
+
+	if err := os.WriteFile(path, bytes, 0o644); err != nil {
+		return fmt.Errorf("failed to write file %q: %w", path, err)
+	}
+	return nil
+}
+
+func objectiveFromFile(file string) (slo.Objective, error) {
+	bytes, err := os.ReadFile(file)
+	if err != nil {
+		return slo.Objective{}, fmt.Errorf("failed to read file %q: %w", file, err)
+	}
+
+	var config v1alpha1.ServiceLevelObjective
+	if err := yaml.UnmarshalStrict(bytes, &config); err != nil {
+		return slo.Objective{}, fmt.Errorf("failed to unmarshal objective %q: %w", file, err)
+	}
+
+	return config.Internal()
+}

generate.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2023 Pyrra Authors.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+import (
+	"path/filepath"
+
+	"github.com/go-kit/log"
+	"github.com/go-kit/log/level"
+)
+
+func cmdGenerate(logger log.Logger, configFiles, prometheusFolder string, genericRules bool) int {
+	filenames, err := filepath.Glob(configFiles)
+	if err != nil {
+		level.Error(logger).Log("msg", "getting file names", "err", err)
+		return 1
+	}
+
+	for _, file := range filenames {
+		err := writeRuleFile(logger, file, prometheusFolder, genericRules)
+		if err != nil {
+			level.Error(logger).Log("msg", "generating rule files", "err", err)
+			return 1
+		}
+	}
+	return 0
+}

main.go

@@ -69,6 +69,11 @@ var CLI struct {
 		ConfigMapMode bool   `default:"false" help:"If the generated recording rules should instead be saved to config maps in the default Prometheus format."`
 		GenericRules  bool   `default:"false" help:"Enabled generic recording rules generation to make it easier for tools like Grafana."`
 	} `cmd:"" help:"Runs Pyrra's Kubernetes operator and backend for the API."`
+	Generate struct {
+		ConfigFiles      string `default:"/etc/pyrra/*.yaml" help:"The folder where Pyrra finds the config files to use."`
+		PrometheusFolder string `default:"/etc/prometheus/pyrra/" help:"The folder where Pyrra writes the generated Prometheus rules and alerts."`
+		GenericRules     bool   `default:"false" help:"Enabled generic recording rules generation to make it easier for tools like Grafana."`
+	} `cmd:"" help:"Read SLO config files and rewrites them as Prometheus rules and alerts."`
 }
 
 func main() {
@@ -151,6 +156,13 @@ func main() {
 			CLI.Kubernetes.ConfigMapMode,
 			CLI.Kubernetes.GenericRules,
 		)
+	case "generate":
+		code = cmdGenerate(
+			logger,
+			CLI.Generate.ConfigFiles,
+			CLI.Generate.PrometheusFolder,
+			CLI.Generate.GenericRules,
+		)
 	}
 	os.Exit(code)
 }