Merge pull request #1 from gadost/refactor

Refactor

Author: gadost

.github/workflows/release_build.yml

@@ -0,0 +1,31 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  build:
+    name: GoReleaser build
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.17.5
+        id: go
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@master
+        with:
+          version: latest
+          args: release --rm-dist
+        env:
+          GITHUB_TOKEN: ${{ secrets.GO_RELEASER_GITHUB_TOKEN_DFSNOTIFY }}

Dockerfile

@@ -1,7 +1,7 @@
-FROM golang:1.11-alpine
-MAINTAINER nikolaev.makc@gmail.com
+FROM golang:1.18-alpine
+LABEL maintainer=nikolaev.makc@gmail.com
 RUN apk add --no-cache git
 WORKDIR /go/src/docker-fsnotify-event-handler
 COPY . .
 RUN go get -d -v ./... && go install -v ./... && rm -rf /go/src
-CMD ["docker-fsnotify-event-handler"]
+CMD ["docker-fsnotify-event-handler start"]

README.md

@@ -1,32 +1,54 @@
-## overview
+# docker-fsnotify-event-handler
+
+## Overview
+
 docker-fsnotify-event-handler developed for processing some filesystem events like letsencrypt cert renew for one domain on multiply hosts ( f.e. on my case - N nginx instances on different hosts using same certs. On certs renew le companion reloading only one nginx, other all proceed using old certs.).
 
 ## Install
 
 ```bash
-go get github.com/gadost/docker-fsnotify-event-handler
-cd $GOPATH/src/github.com/gadost/docker-fsnotify-event-handler
+git clone github.com/gadost/docker-fsnotify-event-handler
+cd docker-fsnotify-event-handler
 go build .
 export WATCH_PATH=/path/to/watch ; ./docker-fsnotify-event-handler
 
 ```
-## Struct
+
+## Environment
+
 ```golang
-RedisAddr  string  `env:"REDIS_ADDR" envDefault:"localhost:6379"`
-RedisPass  string  `env:"REDIS_PASS" envDefault:""`
-RedisDB    int     `env:"REDIS_DB" envDefault:"0"`
-AgentsSet  string  `env:"AGENTS_SET_NAME" envDefault:"agents"`
-QueueName  string  `env:"QUEUE_NAME" envDefault:"lecc"`
-AgentName  string  `env:"HOSTNAME"`
+// redis host , pass , db
+RedisAddr string `env:"REDIS_ADDR" envDefault:"localhost:6379"`
+RedisPass string `env:"REDIS_PASS" envDefault:""`
+RedisDB   int    `env:"REDIS_DB" envDefault:"0"`
+
+// agent set 
+AgentsSet string `env:"AGENTS_SET_NAME" envDefault:"agents"`
+QueueName string `env:"QUEUE_NAME" envDefault:"lecc"`
+AgentName string `env:"HOSTNAME"`
+
+//check interval
+Interval  int    `env:"INTERVAL" envDefault:"20"`
+
+// Path to watch
+Path      string `env:"WATCH_PATH"`
+
+// Docker image "test/image"
+Image     string `env:"IMAGE"`
+
+// execute command when event happens ( f.e. "nginx -s reload" )
+Command   string `env:"COMMAND"`
+
 ```
 
 ## Docker example
 
 ```bash
-docker run -it --privileged --network=host -v /var/run/docker.sock:/var/run/docker.sock -v /root/gotest:/dir -e WATCH_PATH=/dir -e "REDIS_ADDR=somehost:6379" maxn/docker-fsnotify-event-handler:v1
+docker run -it --privileged --network=host -v /var/run/docker.sock:/var/run/docker.sock -v /path/to/watching/dir:/dir -e WATCH_PATH=/dir -e "REDIS_ADDR=somehost:6379" maxn/docker-fsnotify-event-handler:latest
 ```
 
-## build
+## Build
+
 ```bash
 docker build .
 ```

app/app.go

@@ -0,0 +1,82 @@
+package app
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/go-redis/redis"
+)
+
+var c Config
+
+func Start() {
+	c.MarshalConfig()
+	//define watcher
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	defer watcher.Close()
+
+	client := c.Client()
+	c.RegisterAgent(client)
+	go c.Walking(watcher)
+	go QueueProcessor(client)
+	c.CheckEvent(watcher, client)
+}
+
+func (c *Config) Walking(watcher *fsnotify.Watcher) {
+	_ = filepath.Walk(c.Path, func(path string, f os.FileInfo, err error) error {
+		watcher.Add(path)
+		return nil
+	})
+}
+
+func (c Config) CheckEvent(watcher *fsnotify.Watcher, client *redis.Client) {
+	done := make(chan bool)
+	go func() {
+		for {
+			select {
+			case event := <-watcher.Events:
+				fi, err := os.Stat(event.Name)
+				if err != nil {
+					break
+				}
+				if fi.Mode().IsDir() {
+					watcher.Add(event.Name)
+					break
+				}
+				if AllowedEvents(event.Op.String()) {
+					log.Println("event:", event)
+					AddToQueue(c.AgentName, "wait", client)
+				}
+			case err := <-watcher.Errors:
+				log.Println("error:", err)
+			}
+		}
+	}()
+	<-done
+}
+
+func QueueProcessor(client *redis.Client) {
+	for {
+		<-time.After(time.Duration(c.Interval) * time.Second)
+		go CheckQueue(c.AgentName, "wait", client)
+	}
+}
+
+func AllowedEvents(e string) bool {
+	switch e {
+	case
+		"RENAME",
+		"CHMOD",
+		"CREATE",
+		"WRITE":
+		return true
+	}
+	return false
+}

app/event.go

@@ -0,0 +1,40 @@
+package app
+
+import (
+	"log"
+	"strings"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/client"
+	"golang.org/x/net/context"
+)
+
+func Handler() {
+	cli, err := client.NewClientWithOpts(client.FromEnv)
+	if err != nil {
+		panic(err)
+	}
+
+	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
+	if err != nil {
+		panic(err)
+	}
+
+	for _, container := range containers {
+		if container.Image == c.Image {
+			log.Println(container.ID)
+			config := types.ExecConfig{AttachStdout: true, AttachStderr: true,
+				Cmd: c.GenerateCmd()}
+			res, _ := cli.ContainerExecCreate(context.Background(), container.ID, config)
+			log.Println("Processing event: ", container.ID, " event id: ", res.ID)
+			err := cli.ContainerExecStart(context.Background(), res.ID, types.ExecStartCheck{Detach: true, Tty: true})
+			if err != nil {
+				log.Print(err)
+			}
+		}
+	}
+}
+
+func (c Config) GenerateCmd() []string {
+	return strings.Split(c.Command, " ")
+}

app/sqs.go

@@ -0,0 +1,76 @@
+package app
+
+import (
+	"log"
+
+	"github.com/caarlos0/env"
+	"github.com/go-redis/redis"
+)
+
+type Config struct {
+	RedisAddr string `env:"REDIS_ADDR" envDefault:"localhost:6379"`
+	RedisPass string `env:"REDIS_PASS" envDefault:""`
+	RedisDB   int    `env:"REDIS_DB" envDefault:"0"`
+	AgentsSet string `env:"AGENTS_SET_NAME" envDefault:"agents"`
+	QueueName string `env:"QUEUE_NAME" envDefault:"lecc"`
+	AgentName string `env:"HOSTNAME"`
+	Interval  int    `env:"INTERVAL" envDefault:"20"`
+	Path      string `env:"WATCH_PATH"`
+	Command   string `env:"COMMAND"`
+	Image     string `env:"IMAGE"`
+}
+
+var rClient *redis.Client
+
+// Define Client Redis from config
+func (c *Config) Client() *redis.Client {
+	rClient = redis.NewClient(&redis.Options{
+		Addr:     c.RedisAddr,
+		Password: c.RedisPass,
+		DB:       c.RedisDB,
+	})
+	_, err := rClient.Ping().Result()
+	if err != nil {
+		log.Println("Redis server unreachable! Exit..")
+		panic(err)
+	}
+	return rClient
+}
+
+func (c *Config) MarshalConfig() *Config {
+	cfg := Config{}
+	if err := env.Parse(&cfg); err != nil {
+		log.Printf("%+v\n", err)
+	}
+	return &cfg
+}
+
+func (c *Config) RegisterAgent(rClient *redis.Client) {
+	err := rClient.SAdd(c.AgentsSet, c.AgentName)
+	log.Println(err)
+}
+
+func QueueComplited(k string, v string, rClient *redis.Client) {
+	err := rClient.Set(k, v, 0).Err()
+	if err != nil {
+		log.Print(err)
+	}
+}
+func AddToQueue(k string, v string, rClient *redis.Client) {
+	err := rClient.Set(k, v, 0).Err()
+	if err != nil {
+		log.Print(err)
+	}
+}
+
+func CheckQueue(k string, v string, rClient *redis.Client) {
+	val, err := rClient.Get(k).Result()
+	if err != nil {
+		log.Print(err)
+	} else {
+		if val == v {
+			Handler()
+			QueueComplited(k, "done", rClient)
+		}
+	}
+}

cmd/root.go

@@ -0,0 +1,51 @@
+/*
+Copyright © 2022 NAME HERE <EMAIL ADDRESS>
+
+*/
+package cmd
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+
+
+// rootCmd represents the base command when called without any subcommands
+var rootCmd = &cobra.Command{
+	Use:   "docker-fsnotify-event-handler",
+	Short: "A brief description of your application",
+	Long: `A longer description that spans multiple lines and likely contains
+examples and usage of using your application. For example:
+
+Cobra is a CLI library for Go that empowers applications.
+This application is a tool to generate the needed files
+to quickly create a Cobra application.`,
+	// Uncomment the following line if your bare application
+	// has an action associated with it:
+	// Run: func(cmd *cobra.Command, args []string) { },
+}
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+	err := rootCmd.Execute()
+	if err != nil {
+		os.Exit(1)
+	}
+}
+
+func init() {
+	// Here you will define your flags and configuration settings.
+	// Cobra supports persistent flags, which, if defined here,
+	// will be global for your application.
+
+	// rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.docker-fsnotify-event-handler.yaml)")
+
+	// Cobra also supports local flags, which will only run
+	// when this action is called directly.
+	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+