284 lines
7.8 KiB
Go
284 lines
7.8 KiB
Go
// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved
|
|
//
|
|
// This Source Code Form is subject to the terms of the MIT License.
|
|
// If a copy of the MIT was not distributed with this file,
|
|
// You can obtain one at https://github.com/gogf/gf.
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gogf/gf/v2/container/gtype"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
"github.com/gogf/gf/v2/os/gfile"
|
|
"github.com/gogf/gf/v2/os/gfsnotify"
|
|
"github.com/gogf/gf/v2/os/gproc"
|
|
"github.com/gogf/gf/v2/os/gtime"
|
|
"github.com/gogf/gf/v2/os/gtimer"
|
|
"github.com/gogf/gf/v2/util/gtag"
|
|
|
|
"hotgo/internal/library/hggen/internal/utility/mlog"
|
|
)
|
|
|
|
var Run = cRun{}
|
|
|
|
type cRun struct {
|
|
g.Meta `name:"run" usage:"{cRunUsage}" brief:"{cRunBrief}" eg:"{cRunEg}" dc:"{cRunDc}"`
|
|
}
|
|
|
|
type cRunApp struct {
|
|
File string // Go run file name.
|
|
Path string // Directory storing built binary.
|
|
Options string // Extra "go run" options.
|
|
Args string // Custom arguments.
|
|
WatchPaths []string // Watch paths for live reload.
|
|
}
|
|
|
|
const (
|
|
cRunUsage = `gf run FILE [OPTION]`
|
|
cRunBrief = `running go codes with hot-compiled-like feature`
|
|
cRunEg = `
|
|
gf run main.go
|
|
gf run main.go --args "server -p 8080"
|
|
gf run main.go -mod=vendor
|
|
gf run main.go -w "manifest/config/*.yaml"
|
|
`
|
|
cRunDc = `
|
|
The "run" command is used for running go codes with hot-compiled-like feature,
|
|
which compiles and runs the go codes asynchronously when codes change.
|
|
`
|
|
cRunFileBrief = `building file path.`
|
|
cRunPathBrief = `output directory path for built binary file. it's "./" in default`
|
|
cRunExtraBrief = `the same options as "go run"/"go build" except some options as follows defined`
|
|
cRunArgsBrief = `custom arguments for your process`
|
|
cRunWatchPathsBrief = `watch additional paths for live reload, separated by ",". i.e. "manifest/config/*.yaml"`
|
|
)
|
|
|
|
var process *gproc.Process
|
|
|
|
func init() {
|
|
gtag.Sets(g.MapStrStr{
|
|
`cRunUsage`: cRunUsage,
|
|
`cRunBrief`: cRunBrief,
|
|
`cRunEg`: cRunEg,
|
|
`cRunDc`: cRunDc,
|
|
`cRunFileBrief`: cRunFileBrief,
|
|
`cRunPathBrief`: cRunPathBrief,
|
|
`cRunExtraBrief`: cRunExtraBrief,
|
|
`cRunArgsBrief`: cRunArgsBrief,
|
|
`cRunWatchPathsBrief`: cRunWatchPathsBrief,
|
|
})
|
|
}
|
|
|
|
type (
|
|
cRunInput struct {
|
|
g.Meta `name:"run" config:"gfcli.run"`
|
|
File string `name:"FILE" arg:"true" brief:"{cRunFileBrief}" v:"required"`
|
|
Path string `name:"path" short:"p" brief:"{cRunPathBrief}" d:"./"`
|
|
Extra string `name:"extra" short:"e" brief:"{cRunExtraBrief}"`
|
|
Args string `name:"args" short:"a" brief:"{cRunArgsBrief}"`
|
|
WatchPaths []string `name:"watchPaths" short:"w" brief:"{cRunWatchPathsBrief}"`
|
|
}
|
|
cRunOutput struct{}
|
|
)
|
|
|
|
func (c cRun) Index(ctx context.Context, in cRunInput) (out *cRunOutput, err error) {
|
|
if !gfile.Exists(in.File) {
|
|
mlog.Fatalf(`given file "%s" not found`, in.File)
|
|
}
|
|
if !gfile.IsFile(in.File) {
|
|
mlog.Fatalf(`given "%s" is not a file`, in.File)
|
|
}
|
|
// Necessary check.
|
|
if gproc.SearchBinary("go") == "" {
|
|
mlog.Fatalf(`command "go" not found in your environment, please install golang first to proceed this command`)
|
|
}
|
|
|
|
if len(in.WatchPaths) == 1 {
|
|
in.WatchPaths = strings.Split(in.WatchPaths[0], ",")
|
|
mlog.Printf("watchPaths: %v", in.WatchPaths)
|
|
}
|
|
|
|
app := &cRunApp{
|
|
File: in.File,
|
|
Path: filepath.FromSlash(in.Path),
|
|
Options: in.Extra,
|
|
Args: in.Args,
|
|
WatchPaths: in.WatchPaths,
|
|
}
|
|
dirty := gtype.NewBool()
|
|
|
|
outputPath := app.genOutputPath()
|
|
callbackFunc := func(event *gfsnotify.Event) {
|
|
if !event.IsWrite() && !event.IsCreate() && !event.IsRemove() && !event.IsRename() {
|
|
return
|
|
}
|
|
|
|
if gfile.ExtName(event.Path) != "go" {
|
|
return
|
|
}
|
|
|
|
// Variable `dirty` is used for running the changes only one in one second.
|
|
if !dirty.Cas(false, true) {
|
|
return
|
|
}
|
|
|
|
// With some delay in case of multiple code changes in very short interval.
|
|
gtimer.SetTimeout(ctx, 1500*gtime.MS, func(ctx context.Context) {
|
|
defer dirty.Set(false)
|
|
mlog.Printf(`watched file changes: %s`, event.String())
|
|
app.Run(ctx, outputPath)
|
|
})
|
|
}
|
|
|
|
if len(app.WatchPaths) > 0 {
|
|
for _, path := range app.WatchPaths {
|
|
_, err = gfsnotify.Add(gfile.RealPath(path), callbackFunc)
|
|
if err != nil {
|
|
mlog.Fatal(err)
|
|
}
|
|
}
|
|
} else {
|
|
_, err = gfsnotify.Add(gfile.RealPath("."), callbackFunc)
|
|
if err != nil {
|
|
mlog.Fatal(err)
|
|
}
|
|
}
|
|
|
|
go app.Run(ctx, outputPath)
|
|
|
|
gproc.AddSigHandlerShutdown(func(sig os.Signal) {
|
|
app.End(ctx, sig, outputPath)
|
|
os.Exit(0)
|
|
})
|
|
gproc.Listen()
|
|
|
|
select {}
|
|
}
|
|
|
|
func (app *cRunApp) Run(ctx context.Context, outputPath string) {
|
|
// Rebuild and run the codes.
|
|
mlog.Printf("build: %s", app.File)
|
|
|
|
// In case of `pipe: too many open files` error.
|
|
// Build the app.
|
|
buildCommand := fmt.Sprintf(
|
|
`go build -o %s %s %s`,
|
|
outputPath,
|
|
app.Options,
|
|
app.File,
|
|
)
|
|
mlog.Print(buildCommand)
|
|
result, err := gproc.ShellExec(ctx, buildCommand)
|
|
if err != nil {
|
|
mlog.Printf("build error: \n%s%s", result, err.Error())
|
|
return
|
|
}
|
|
// Kill the old process if build successfully.
|
|
if process != nil {
|
|
if err := process.Kill(); err != nil {
|
|
mlog.Debugf("kill process error: %s", err.Error())
|
|
}
|
|
}
|
|
// Run the binary file.
|
|
runCommand := fmt.Sprintf(`%s %s`, outputPath, app.Args)
|
|
mlog.Print(runCommand)
|
|
if runtime.GOOS == "windows" {
|
|
// Special handling for windows platform.
|
|
// DO NOT USE "cmd /c" command.
|
|
process = gproc.NewProcess(outputPath, strings.Fields(app.Args))
|
|
} else {
|
|
process = gproc.NewProcessCmd(runCommand, nil)
|
|
}
|
|
if pid, err := process.Start(ctx); err != nil {
|
|
mlog.Printf("build running error: %s", err.Error())
|
|
} else {
|
|
mlog.Printf("build running pid: %d", pid)
|
|
}
|
|
}
|
|
|
|
func (app *cRunApp) End(ctx context.Context, sig os.Signal, outputPath string) {
|
|
// Delete the binary file.
|
|
// firstly, kill the process.
|
|
if process != nil {
|
|
if sig != nil && runtime.GOOS != "windows" {
|
|
if err := process.Signal(sig); err != nil {
|
|
mlog.Debugf("send signal to process error: %s", err.Error())
|
|
if err := process.Kill(); err != nil {
|
|
mlog.Debugf("kill process error: %s", err.Error())
|
|
}
|
|
} else {
|
|
waitCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
|
defer cancel()
|
|
done := make(chan error, 1)
|
|
go func() {
|
|
select {
|
|
case <-waitCtx.Done():
|
|
done <- waitCtx.Err()
|
|
case done <- process.Wait():
|
|
}
|
|
}()
|
|
err := <-done
|
|
if err != nil {
|
|
mlog.Debugf("process wait error: %s", err.Error())
|
|
if err := process.Kill(); err != nil {
|
|
mlog.Debugf("kill process error: %s", err.Error())
|
|
}
|
|
} else {
|
|
mlog.Debug("process exited gracefully")
|
|
}
|
|
}
|
|
} else {
|
|
if err := process.Kill(); err != nil {
|
|
mlog.Debugf("kill process error: %s", err.Error())
|
|
}
|
|
}
|
|
}
|
|
if err := gfile.RemoveFile(outputPath); err != nil {
|
|
mlog.Printf("delete binary file error: %s", err.Error())
|
|
} else {
|
|
mlog.Printf("deleted binary file: %s", outputPath)
|
|
}
|
|
}
|
|
|
|
func (app *cRunApp) genOutputPath() (outputPath string) {
|
|
var renamePath string
|
|
outputPath = gfile.Join(app.Path, gfile.Name(app.File))
|
|
if runtime.GOOS == "windows" {
|
|
outputPath += ".exe"
|
|
if gfile.Exists(outputPath) {
|
|
renamePath = outputPath + "~"
|
|
if err := gfile.Rename(outputPath, renamePath); err != nil {
|
|
mlog.Print(err)
|
|
}
|
|
}
|
|
}
|
|
return filepath.FromSlash(outputPath)
|
|
}
|
|
|
|
func matchWatchPaths(watchPaths []string, eventPath string) bool {
|
|
for _, path := range watchPaths {
|
|
absPath, err := filepath.Abs(path)
|
|
if err != nil {
|
|
mlog.Printf("match watchPath '%s' error: %s", path, err.Error())
|
|
continue
|
|
}
|
|
matched, err := filepath.Match(absPath, eventPath)
|
|
if err != nil {
|
|
mlog.Printf("match watchPath '%s' error: %s", path, err.Error())
|
|
continue
|
|
}
|
|
if matched {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|