Merge pull request #14 from ncode/juliano/improvements

cleanups, systemd command and move to slog

Author: ncode

README.md

@@ -1,45 +1,124 @@
-# TagIt 
+# TagIt
+
 [![Go Report Card](https://goreportcard.com/badge/github.com/ncode/tagit)](https://goreportcard.com/report/github.com/ncode/tagit)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![codecov](https://codecov.io/gh/ncode/tagit/graph/badge.svg?token=ISXEH274YD)](https://codecov.io/gh/ncode/tagit)
 
+TagIt is a tool that updates Consul service registration tags with outputs of a script. It copies the current service registration and appends the output of the script line by line as tags, while keeping the original tags.
+
+## Table of Contents
+
+- [Why TagIt?](#why-tagit)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Run Command](#run-command)
+  - [Cleanup Command](#cleanup-command)
+  - [Systemd Command](#systemd-command)
+- [How It Works](#how-it-works)
+- [Examples](#examples)
+- [Contributing](#contributing)
+- [License](#license)
 
-Update consul registration tags with outputs of a script.
-It copies the current service registration and appends the output of the script line by line as tags, while keeping the original tags.
+## Why TagIt?
 
-## Why?
+TagIt addresses a feature that's currently missing from Consul. You can read more about the need for this functionality in [this Consul issue](https://github.com/hashicorp/consul/issues/1048).
 
-Basically because it's a very useful feature that is missing from consul. Read more about it [here](https://github.com/hashicorp/consul/issues/1048).
-A few scenarios where this can be useful:
+Here are some scenarios where TagIt can be useful:
 
-1. Your databases are under mydb.service.consul, and you would like to ensure that all the writes go to the leader
-   1. You run a script that checks the leader and updates the tag
-2. You have a service that is not consul aware, but you would like to use consul for service discovery
-   1. You run a script that checks the service and updates the tags
-3. You have a load or a webserver, and you would like to have tags for all vhosts that are served by this server
-   1. You run a script that checks the vhosts and updates the tags
-4. Pretty much any services that are not consul aware, but you would like to use consul for service discovery
-   1. You run a script that checks the service and updates the tags
+1. **Database Leader Tagging**: Ensure all writes go to the leader by tagging it appropriately.
+2. **Non-Consul-Aware Service Discovery**: Use Consul for service discovery with services that aren't Consul-aware.
+3. **Web Server VHost Tagging**: Tag all vhosts served by a web server or load balancer.
+4. **Generic Service Tagging**: Tag any services for Consul-based service discovery.
 
-## How to test it?
+## Installation
+
+To install TagIt, use the following commands:
 
 ```bash
-$ git clone github.com/ncode/tagit
-$ cd configs/development
-$ make
+$ git clone https://github.com/ncode/tagit
+$ cd tagit
+$ go build
 ```
 
+## Usage
+
+TagIt provides three main commands: `run`, `cleanup`, and `systemd`.
+
+### Run Command
+
+The `run` command starts TagIt and continuously updates the tags based on the script output:
+
+```bash
+$ ./tagit run --consul-addr=127.0.0.1:8500 --service-id=my-service1 --script=./examples/tagit/example.sh --interval=5s --tag-prefix=tagit
+```
+
+### Cleanup Command
+
+The `cleanup` command removes all tags with the specified prefix from the service:
+
+```bash
+$ ./tagit cleanup --consul-addr=127.0.0.1:8500 --service-id=my-service1 --tag-prefix=tagit
+```
+
+### Systemd Command
+
+The `systemd` command generates a systemd service file for TagIt:
+
+```bash
+./tagit systemd --service-id=my-service1 --script=./examples/tagit/example.sh --tag-prefix=tagit --interval=5s --user=tagit --group=tagit
+```
+
+This command will output a systemd service file that you can use to run TagIt as a system service.
+
+## How It Works
+
+TagIt interacts with Consul as follows:
+
 ```mermaid
 sequenceDiagram
     participant tagit
     participant consul
     loop execute script on interval
-        tagit->>consul: Do you have a service with id my-service1?
-        consul->>tagit: Yes, here it is and that's the current registration
-        tagit->>consul: Update current registration adding or removing prefixed tags wiht the output of the script
+        tagit->>consul: Query service with ID
+        consul->>tagit: Return current service registration
+        tagit->>tagit: Execute script and process output
+        tagit->>consul: Update service registration with new tags
     end
 ```
 
-## Todo
+## Examples
+
+Here's an example of how to test TagIt:
+
+1. Start a Consul agent in development mode:
+   ```bash
+   consul agent -dev &
+   ```
+
+2. Register a service with Consul:
+   ```bash
+   curl --request PUT --data @examples/consul/my-service1.json http://127.0.0.1:8500/v1/agent/service/register
+   ```
+
+3. Run TagIt:
+   ```bash
+   ./tagit run --consul-addr=127.0.0.1:8500 --service-id=my-service1 --script=./examples/tagit/example.sh --interval=5s --tag-prefix=tagit
+   ```
+
+4. Generate a systemd service file:
+   ```bash
+   ./tagit systemd --service-id=my-service1 --script=./examples/tagit/example.sh --tag-prefix=tagit --interval=5s --user=tagit --group=tagit > /etc/systemd/system/tagit-my-service1.service
+   ```
+
+5. Clean up the tags:
+   ```bash
+   ./tagit cleanup --consul-addr=127.0.0.1:8500 --service-id=my-service1 --tag-prefix=tagit
+   ```
+
+## Contributing
+
+Contributions to TagIt are welcome! Please feel free to submit a Pull Request.
+
+## License
 
-- [ ] Adds a systemd unit file generator
+TagIt is licensed under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for details.

cmd/cleanup.go

@@ -16,40 +16,55 @@ limitations under the License.
 package cmd
 
 import (
-	"fmt"
+	"log/slog"
+	"os"
+
 	"github.com/hashicorp/consul/api"
 	"github.com/ncode/tagit/pkg/tagit"
 	"github.com/spf13/cobra"
-	"os"
 )
 
 // cleanupCmd represents the cleanup command
 var cleanupCmd = &cobra.Command{
 	Use:   "cleanup",
 	Short: "cleanup removes all services with the tag prefix from a given consul service",
 	Run: func(cmd *cobra.Command, args []string) {
+		logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
+			Level: slog.LevelInfo,
+		}))
+
 		config := api.DefaultConfig()
 		config.Address = cmd.InheritedFlags().Lookup("consul-addr").Value.String()
 		config.Token = cmd.InheritedFlags().Lookup("token").Value.String()
+
 		consulClient, err := api.NewClient(config)
 		if err != nil {
-			fmt.Printf("error creating consul client: %s", err.Error())
+			logger.Error("Failed to create Consul client", "error", err)
 			os.Exit(1)
 		}
 
+		serviceID := cmd.InheritedFlags().Lookup("service-id").Value.String()
+		tagPrefix := cmd.InheritedFlags().Lookup("tag-prefix").Value.String()
+
 		t := tagit.New(
 			tagit.NewConsulAPIWrapper(consulClient),
 			&tagit.CmdExecutor{},
-			cmd.InheritedFlags().Lookup("service-id").Value.String(),
-			cmd.InheritedFlags().Lookup("script").Value.String(),
-			0,
-			cmd.InheritedFlags().Lookup("tag-prefix").Value.String(),
+			serviceID,
+			"", // script is not needed for cleanup
+			0,  // interval is not needed for cleanup
+			tagPrefix,
+			logger,
 		)
+
+		logger.Info("Starting tag cleanup", "serviceID", serviceID, "tagPrefix", tagPrefix)
+
 		err = t.CleanupTags()
 		if err != nil {
-			fmt.Printf("error cleaning up tags: %s", err.Error())
+			logger.Error("Failed to clean up tags", "error", err)
 			os.Exit(1)
 		}
+
+		logger.Info("Tag cleanup completed successfully")
 	},
 }
 

cmd/run.go

@@ -17,13 +17,14 @@ package cmd
 
 import (
 	"context"
-	"fmt"
+	"log/slog"
 	"os"
+	"os/signal"
+	"syscall"
 	"time"
 
 	"github.com/hashicorp/consul/api"
 	"github.com/ncode/tagit/pkg/tagit"
-
 	"github.com/spf13/cobra"
 )
 
@@ -36,37 +37,93 @@ var runCmd = &cobra.Command{
 example: tagit run -s my-super-service -x '/tmp/tag-role.sh'
 `,
 	Run: func(cmd *cobra.Command, args []string) {
-		interval := cmd.InheritedFlags().Lookup("interval").Value.String()
-		ctx := context.Background()
+		logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
+			Level: slog.LevelInfo,
+		}))
+
+		interval, err := cmd.InheritedFlags().GetString("interval")
+		if err != nil {
+			logger.Error("Failed to get interval flag", "error", err)
+			os.Exit(1)
+		}
+
 		if interval == "" || interval == "0" {
-			fmt.Println("interval is required")
+			logger.Error("Interval is required")
 			os.Exit(1)
 		}
 
 		validInterval, err := time.ParseDuration(interval)
 		if err != nil {
-			fmt.Printf("invalid interval %s: %s", interval, err.Error())
+			logger.Error("Invalid interval", "interval", interval, "error", err)
 			os.Exit(1)
 		}
 
 		config := api.DefaultConfig()
-		config.Address = cmd.InheritedFlags().Lookup("consul-addr").Value.String()
-		config.Token = cmd.InheritedFlags().Lookup("token").Value.String()
+		config.Address, err = cmd.InheritedFlags().GetString("consul-addr")
+		if err != nil {
+			logger.Error("Failed to get consul-addr flag", "error", err)
+			os.Exit(1)
+		}
+		config.Token, err = cmd.InheritedFlags().GetString("token")
+		if err != nil {
+			logger.Error("Failed to get token flag", "error", err)
+			os.Exit(1)
+		}
+
 		consulClient, err := api.NewClient(config)
 		if err != nil {
-			fmt.Printf("error creating consul client: %s", err.Error())
+			logger.Error("Failed to create Consul client", "error", err)
+			os.Exit(1)
+		}
+
+		serviceID, err := cmd.InheritedFlags().GetString("service-id")
+		if err != nil {
+			logger.Error("Failed to get service-id flag", "error", err)
+			os.Exit(1)
+		}
+		script, err := cmd.InheritedFlags().GetString("script")
+		if err != nil {
+			logger.Error("Failed to get script flag", "error", err)
+			os.Exit(1)
+		}
+		tagPrefix, err := cmd.InheritedFlags().GetString("tag-prefix")
+		if err != nil {
+			logger.Error("Failed to get tag-prefix flag", "error", err)
 			os.Exit(1)
 		}
 
 		t := tagit.New(
 			tagit.NewConsulAPIWrapper(consulClient),
 			&tagit.CmdExecutor{},
-			cmd.InheritedFlags().Lookup("service-id").Value.String(),
-			cmd.InheritedFlags().Lookup("script").Value.String(),
+			serviceID,
+			script,
 			validInterval,
-			cmd.InheritedFlags().Lookup("tag-prefix").Value.String(),
+			tagPrefix,
+			logger,
 		)
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		// Setup signal handling for graceful shutdown
+		sigCh := make(chan os.Signal, 1)
+		signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+
+		go func() {
+			sig := <-sigCh
+			logger.Info("Received signal, shutting down", "signal", sig)
+			cancel()
+		}()
+
+		logger.Info("Starting tagit",
+			"serviceID", serviceID,
+			"script", script,
+			"interval", validInterval,
+			"tagPrefix", tagPrefix)
+
 		t.Run(ctx)
+
+		logger.Info("Tagit has stopped")
 	},
 }