refactor: use internal/pkg to refactor structure

main.go

@@ -1,81 +1,119 @@
 package main
 
 import (
-	"fmt"
 	"log"
 	"os"
-	"os/exec"
+	"os/signal"
+	"syscall"
 
-	"filelistener/cfg"
-
-	"github.com/fsnotify/fsnotify"
+	"gitea.urkob.com/urko/git-webhook-ci/cfg"
+	"gitea.urkob.com/urko/git-webhook-ci/internal/watcher"
+	pkgwatcher "gitea.urkob.com/urko/git-webhook-ci/pkg/watcher"
 )
 
+var watcherIface pkgwatcher.WatcherIface
+
 func main() {
 	isProd := os.Getenv("ENV") == "prod"
 	config := cfg.NewConfig(isProd)
 
-	// Create new watcher.
-	watcher, err := fsnotify.NewWatcher()
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer watcher.Close()
+	watcherIface = watcher.NewWatcher(pkgwatcher.Deploy)
 
-	// Start listening for events.
-	go func() {
-		for {
-			select {
-			case event, ok := <-watcher.Events:
-				if !ok {
-					log.Printf("<-watcher.Events: %s\n", err)
-					return
-				}
-				if !event.Has(fsnotify.Write) {
-					log.Printf("is not Write: %s\n", event.Name)
-					continue
-				}
-
-				if err := deploy(config.ScriptBinaryPath, config.WebhookScriptPath); err != nil {
-					log.Printf("deploy: %s\n", err)
-					continue
-				}
-			case err, ok := <-watcher.Errors:
-				if !ok {
-					return
-				}
-				log.Printf("<-watcher.Errors: %s\n", err)
-			}
+	defer func() {
+		if err := watcherIface.Close(); err != nil {
+			log.Fatalf("watcherIface.Close: %s\n", err)
 		}
 	}()
 
-	// Add a path.
-	err = watcher.Add(config.FileToWatchPath)
-	if err != nil {
-		log.Fatal(err)
+	if err := watcherIface.Monitor(config.FileToWatchPath); err != nil {
+		log.Fatalf("watcherIface.Monitor: %s\n", err)
 	}
 
+	errors := make(chan error)
+	watcherIface.Listen(config.ScriptBinaryPath, config.WebhookScriptPath, errors)
+
+	// Handle termination on ctrl+signalChan
+	signalChan := make(chan os.Signal)
+	signal.Notify(signalChan, os.Interrupt, syscall.SIGTERM)
+
+	go func() {
+		<-signalChan
+		os.Exit(1)
+	}()
+
+	go func(errors chan error) {
+		for {
+			select {
+			case err := <-errors:
+				if err != nil {
+					log.Fatalf("watcherIface.Monitor: %s\n", err)
+					return
+				}
+			}
+		}
+	}(errors)
+
 	// Block main goroutine forever.
 	<-make(chan struct{})
+
+	// watcher, err := fsnotify.NewWatcher()
+	// if err != nil {
+	// 	log.Fatal(err)
+	// }
+	// defer watcher.Close()
+
+	// // Start listening for events.
+	// go func() {
+	// 	for {
+	// 		select {
+	// 		case event, ok := <-watcher.Events:
+	// 			if !ok {
+	// 				log.Printf("<-watcher.Events: %s\n", err)
+	// 				return
+	// 			}
+	// 			if !event.Has(fsnotify.Write) {
+	// 				log.Printf("is not Write: %s\n", event.Name)
+	// 				continue
+	// 			}
+
+	// 			if err := deploy(config.ScriptBinaryPath, config.WebhookScriptPath); err != nil {
+	// 				log.Printf("deploy: %s\n", err)
+	// 				continue
+	// 			}
+	// 		case err, ok := <-watcher.Errors:
+	// 			if !ok {
+	// 				return
+	// 			}
+	// 			log.Printf("<-watcher.Errors: %s\n", err)
+	// 		}
+	// 	}
+	// }()
+
+	// if err = watcher.Add(config.FileToWatchPath); err != nil {
+	// 	log.Fatal(err)
+	// }
+
+	// // Block main goroutine forever.
+	// <-make(chan struct{})
 }
 
-func deploy(binaryPath, scriptPath string) error {
-	err := execute(binaryPath, scriptPath)
-	if err != nil {
-		return fmt.Errorf("execute: %s", err)
-	}
-	log.Println("deploy done")
-	return nil
-}
+// func deploy(binaryPath, scriptPath string) error {
+// 	err := execute(binaryPath, scriptPath)
+// 	if err != nil {
+// 		return fmt.Errorf("execute: %s", err)
+// 	}
+// 	log.Println("deploy done")
+// 	return nil
+// }
 
-func execute(binaryPath, scriptPath string) error {
-	cmd := exec.Command(binaryPath, scriptPath)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
+// func execute(binaryPath, scriptPath string) error {
+// 	cmd := exec.Command(binaryPath, scriptPath)
+// 	cmd.Stdout = os.Stdout
+// 	cmd.Stderr = os.Stderr
 
-	if err := cmd.Run(); err != nil {
-		return fmt.Errorf("cmd.Run %s", err)
-	}
+// 	if err := cmd.Run(); err != nil {
+// 		return fmt.Errorf("cmd.Run %s", err)
+// 	}
 
-	return nil
-}
+// 	return nil
+// }