adds systemd command to help generating the service

Author: ncode

cmd/systemd.go

@@ -1,5 +1,5 @@
 /*
-Copyright © 2024 Juliano Martinez <[email protected]>
+Copyright © 2024 Juliano Martinez
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,31 +17,63 @@ package cmd
 
 import (
 	"fmt"
+	"os"
+
 	"github.com/ncode/tagit/pkg/systemd"
 	"github.com/spf13/cobra"
 )
 
 // systemdCmd represents the systemd command
 var systemdCmd = &cobra.Command{
 	Use:   "systemd",
-	Short: "systemd generate a systemd service, that you can use for the tagit service",
+	Short: "Generate a systemd service file for TagIt",
+	Long: `The systemd command generates a systemd service file for TagIt.
+This allows you to easily set up TagIt as a system service that starts
+automatically on boot and can be managed using systemctl.
+
+Example usage:
+  tagit systemd --service-id=my-service --script=/path/to/script.sh --tag-prefix=tagit --interval=5s --user=tagit --group=tagit
+`,
 	Run: func(cmd *cobra.Command, args []string) {
-		fields := &systemd.Fields{
-			User:       cmd.PersistentFlags().Lookup("user").Value.String(),
-			Group:      cmd.PersistentFlags().Lookup("group").Value.String(),
-			ConsulAddr: cmd.InheritedFlags().Lookup("consul-addr").Value.String(),
-			ServiceID:  cmd.InheritedFlags().Lookup("service-id").Value.String(),
-			Script:     cmd.InheritedFlags().Lookup("script").Value.String(),
-			TagPrefix:  cmd.InheritedFlags().Lookup("tag-prefix").Value.String(),
-			Interval:   cmd.InheritedFlags().Lookup("interval").Value.String(),
-			Token:      cmd.InheritedFlags().Lookup("token").Value.String(),
+		flags := make(map[string]string)
+		for _, flag := range append(systemd.GetRequiredFlags(), systemd.GetOptionalFlags()...) {
+			flags[flag], _ = cmd.Flags().GetString(flag)
 		}
-		fmt.Println(systemd.RenderTemplate(fields))
+
+		fields, err := systemd.NewFieldsFromFlags(flags)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			os.Exit(1)
+		}
+
+		serviceFile, err := systemd.RenderTemplate(fields)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error generating systemd service file: %v\n", err)
+			os.Exit(1)
+		}
+
+		fmt.Println(serviceFile)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(systemdCmd)
-	systemdCmd.PersistentFlags().StringP("user", "u", "nobody", "user to run the service")
-	systemdCmd.PersistentFlags().StringP("group", "g", "nobody", "group to run the service")
+
+	// Define flags for all required and optional fields
+	systemdCmd.Flags().String("service-id", "", "ID of the service (required)")
+	systemdCmd.Flags().String("script", "", "Path to the script to execute (required)")
+	systemdCmd.Flags().String("tag-prefix", "", "Prefix for tags (required)")
+	systemdCmd.Flags().String("interval", "", "Interval for script execution (required)")
+	systemdCmd.Flags().String("token", "", "Consul token (optional)")
+	systemdCmd.Flags().String("consul-addr", "", "Consul address (optional)")
+	systemdCmd.Flags().String("user", "", "User to run the service as (required)")
+	systemdCmd.Flags().String("group", "", "Group to run the service as (required)")
+
+	// Mark required flags
+	systemdCmd.MarkFlagRequired("service-id")
+	systemdCmd.MarkFlagRequired("script")
+	systemdCmd.MarkFlagRequired("tag-prefix")
+	systemdCmd.MarkFlagRequired("interval")
+	systemdCmd.MarkFlagRequired("user")
+	systemdCmd.MarkFlagRequired("group")
 }

pkg/systemd/systemd.go

@@ -2,23 +2,14 @@ package systemd
 
 import (
 	"bytes"
+	"fmt"
+	"strings"
 	"text/template"
 )
 
-// Fields is the struct that holds the fields for the systemd service.
-type Fields struct {
-	ServiceID  string
-	Script     string
-	TagPrefix  string
-	Interval   string
-	Token      string
-	ConsulAddr string
-	User       string
-	Group      string
-}
-
-// serviceTemplate is the template for the systemd service.
-var serviceTemplate = `
+const (
+	templateName     = "serviceTemplate"
+	templateContents = `
 [Unit]
 Description=Tagit {{ .ServiceID }}
 After=network.target
@@ -27,7 +18,7 @@ Wants=network-online.target
 
 [Service]
 Type=simple
-ExecStart=/usr/bin/tagit run -s {{ .ServiceID }} -x {{ .Script }} -p {{ .TagPrefix }} -i {{ .Interval }}{{- if .Token }} -t {{ .Token }}{{- end }}{{ if .ConsulAddr }} -c {{ .ConsulAddr }}{{- end }}
+ExecStart=/usr/bin/tagit run -s {{ .ServiceID }} -x {{ .Script }} -p {{ .TagPrefix }} -i {{ .Interval }}{{ if .Token }} -t {{ .Token }}{{ end }}{{ if .ConsulAddr }} -c {{ .ConsulAddr }}{{ end }}
 Environment=HOME=/var/run/taggit/{{ .ServiceID }}
 Restart=always
 User={{ .User }}
@@ -36,19 +27,100 @@ Group={{ .Group }}
 [Install]
 WantedBy=multi-user.target
 `
+)
+
+// Fields is the struct that holds the fields for the systemd service.
+type Fields struct {
+	ServiceID  string
+	Script     string
+	TagPrefix  string
+	Interval   string
+	Token      string
+	ConsulAddr string
+	User       string
+	Group      string
+}
+
+var parsedTemplate *template.Template
+
+func init() {
+	var err error
+	parsedTemplate, err = template.New(templateName).Parse(templateContents)
+	if err != nil {
+		panic(fmt.Sprintf("Failed to parse template: %v", err))
+	}
+}
 
 // RenderTemplate renders the template for the systemd service.
 func RenderTemplate(fields *Fields) (string, error) {
-	tmpl, err := template.New("serviceTemplate").Parse(serviceTemplate)
-	if err != nil {
-		return "", err
+	if err := validateFields(fields); err != nil {
+		return "", fmt.Errorf("field validation failed: %w", err)
 	}
 
 	var tmplBuffer bytes.Buffer
-	err = tmpl.Execute(&tmplBuffer, fields)
+	err := parsedTemplate.Execute(&tmplBuffer, fields)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to execute template: %w", err)
 	}
 
 	return tmplBuffer.String(), nil
 }
+
+func validateFields(fields *Fields) error {
+	var missingFields []string
+
+	if fields.ServiceID == "" {
+		missingFields = append(missingFields, "ServiceID")
+	}
+	if fields.Script == "" {
+		missingFields = append(missingFields, "Script")
+	}
+	if fields.TagPrefix == "" {
+		missingFields = append(missingFields, "TagPrefix")
+	}
+	if fields.Interval == "" {
+		missingFields = append(missingFields, "Interval")
+	}
+	if fields.User == "" {
+		missingFields = append(missingFields, "User")
+	}
+	if fields.Group == "" {
+		missingFields = append(missingFields, "Group")
+	}
+
+	if len(missingFields) > 0 {
+		return fmt.Errorf("missing required fields: %s", strings.Join(missingFields, ", "))
+	}
+
+	return nil
+}
+
+// NewFieldsFromFlags creates a new Fields struct from command line flags.
+func NewFieldsFromFlags(flags map[string]string) (*Fields, error) {
+	fields := &Fields{
+		ServiceID:  flags["service-id"],
+		Script:     flags["script"],
+		TagPrefix:  flags["tag-prefix"],
+		Interval:   flags["interval"],
+		Token:      flags["token"],
+		ConsulAddr: flags["consul-addr"],
+		User:       flags["user"],
+		Group:      flags["group"],
+	}
+
+	if err := validateFields(fields); err != nil {
+		return nil, err
+	}
+
+	return fields, nil
+}
+
+// GetRequiredFlags returns a list of required flag names.
+func GetRequiredFlags() []string {
+	return []string{"service-id", "script", "tag-prefix", "interval", "user", "group"}
+}
+
+// GetOptionalFlags returns a list of optional flag names.
+func GetOptionalFlags() []string {
+	return []string{"token", "consul-addr"}
+}