Thank you

[Huzaifa-MS]

I just wanted to say thank you to @cosmtrek for the air project. It made hot reloading my go app much easier. Thank you I appreciate the time and effort you and all the other contributors put into this project. It made my life easier and all your guys' work is appreciated.

For anyone wanting a self implemented hot reload feature that works without polling here is what I was using before (just the code really)

Main.go // client or app code

func main() {
	// Hot Reloading
	if len(os.Args) >= 2 && os.Args[1] == "-hr" {
		cmdArgs := []string{"templ", "generate", "--watch", "--proxy=http://127.0.0.1:8080", "--proxyport=8081", `--cmd=go run .`, "-open-browser=false"}
		// should sig from Hotreload be here instead since it is top level control flow?
		// but it would make it harder to port
		utils.Hotreload(cmdArgs...)
	}
	// utils.HotreloadTest()
}

Utils.go // library code

package utils

import (
	"log"
	"os"
	"os/exec"
	"os/signal"
	"path/filepath"
	"reflect"
	"runtime"
	"strings"
	"sync"
	"syscall"
	"time"

	"github.com/fsnotify/fsnotify"
)

// If err != nil then show the err with msgs using given logging function
func IfErr(loggingFunction func(...any), err error, msgs ...string) {
	if err != nil {
		loggingFunction(msgs, err)
	}
}

// Unable to get names of function parameters at the moment
func LogFuncCall(fn interface{}, args ...interface{}) {
	fnName := runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name()
	log.Println("function Name: ", fnName)

	for _, arg := range args {
		argValue := reflect.ValueOf(arg)
		argType := reflect.TypeOf(arg)
		log.Printf("Argument=%s\t type=%s\t value=%v\n", argType.Name(), argValue.Type(), argValue.Interface())
	}
}

var exitHotReloadCh chan bool
var fileWatcherCh chan string
var mutex sync.RWMutex
var wg sync.WaitGroup

// 1st time run
var cmd *exec.Cmd

// runs a for loop and restarts based on file changes
func hotreload(cmdArgs []string) {
	// startCmd in different files based on OS being built for
	for _, arg := range os.Args[1:] {
		if arg != "-hr" {
			cmdArgs = append(cmdArgs, arg)
		}
	}

	cmd = startCmd(cmd, cmdArgs)
	log.Println(cmd)
	go setupFileWatcher()
	log.Println("After setupFileWatcher")

	exitHotReloadCh = make(chan bool)
	wg.Add(1)
	for {
		select {
		case <-exitHotReloadCh:
			mutex.Lock()
			stopCmd(cmd)
			mutex.Unlock()
			log.Println("exitHotreloadCh hotreload")
			wg.Done()
			return
		case <-fileWatcherCh:
			log.Println("D1: Restarting cmd due to change on: ")
			cmd = restartCmd(cmd, cmdArgs)
			time.Sleep(100 * time.Millisecond)

		default:
			time.Sleep(100 * time.Millisecond)
		}
	}
}
func restartCmd(cmd *exec.Cmd, cmdArgs []string) *exec.Cmd {
	// mutex needed even??
	mutex.Lock()
	// stopCmd and startCmd in different files based on OS being built for
	stopCmd(cmd)
	mutex.Unlock()
	return startCmd(cmd, cmdArgs)
}

func setupFileWatcher() {
	absPath, err := filepath.Abs("main.go")
	IfErr(log.Fatal, err, "Error getting absolute path: ")
	projectDir := filepath.Dir(absPath)

	filesSelector := func(fp string) bool {
		return filepath.Ext(fp) == ".go" && filepath.Base(fp) != "hotreload.go" && !strings.Contains(fp, "_templ.go")
	}
	fileEventSelector := func(event fsnotify.Event) bool {
		return event.Op&fsnotify.Create == fsnotify.Create ||
			event.Op&fsnotify.Write == fsnotify.Write ||
			event.Op&fsnotify.Remove == fsnotify.Remove
	}

	watcher, err := fsnotify.NewWatcher()
	IfErr(log.Fatal, err)
	defer watcher.Close()

	err = watcher.Add(projectDir)
	IfErr(log.Fatal, err)

	log.Println("FileWatcher Watching: ", watcher.WatchList())
	wg.Add(1)
	fileWatcherCh = make(chan string)
	for {
		select {
		// don't love this signal control flow. May be better way
		case <-exitHotReloadCh:
			log.Println("exitHotreloadCh setupFileWatcher")
			wg.Done()
			return
		case event, ok := <-watcher.Events:
			log.Printf("Event: %v\n", event)
			if !ok {
				log.Println("watcher.Events not ok")
				return
			}

			if fileEventSelector(event) {
				if filesSelector(event.Name) {
					log.Println("D1: Restarting cmd due to change on: ", event.Name)
					fileWatcherCh <- "event.Name"
					continue
				}
			}
			time.Sleep(100 * time.Millisecond)
		case err, ok := <-watcher.Errors:
			log.Printf("File Watcher error: %v\n", err)
			if !ok {
				log.Println("watcher.Error not ok")
				return
			}
		}
	}

}

func Hotreload(cmdArgs ...string) {
	if len(cmdArgs) == 0 {
		cmdArgs = []string{"go", "run", "*.go"}
	}

	// Hot Reloading
	// sig is used to make main program not close out till ctrl+c is pressed
	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

	defer func() {
		if r := recover(); r != nil {
			log.Fatal("Recovered in main", r)
		}
	}()

	go hotreload(cmdArgs)

	log.Println("before sig")
	<-sig
	log.Println("after sig")
	close(exitHotReloadCh)
	wg.Wait()
	// needed to close hotreload process
	os.Exit(0)
}

// hotreload test
func HotreloadTest() {
	for {
		log.Println("Hotreload test: ", time.Now().Format("2006-01-02 15:04:05"))
		time.Sleep(2 * time.Second)
	}
}