dev.go

package command

import (
	"errors"
	"fmt"
	"github.com/fsnotify/fsnotify"
	"github.com/jader1992/gocore/framework"
	"github.com/jader1992/gocore/framework/cobra"
	"github.com/jader1992/gocore/framework/contract"
	"github.com/jader1992/gocore/framework/util"
	"io/fs"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"syscall"
	"time"
)

// devConfig 代表调试模式的配置信息
type devConfig struct {
	Port    string   // 调试模式最终监听的端口，默认为8070
	Backend struct { // 后段调试模式设置
		RefreshTime   int    // 调试模式后端更新时间，如果文件变更，等待3s才进行一次更新，能让频繁保存变更更为顺畅, 默认1s
		Port          string //  后端监听端口， 默认 8072
		MonitorFolder string // 监听文件夹，默认为AppFolder
		cmd           string // 执行的命令
	}
	Frontend struct {
		Port string // 前端启动端口，默认8071
	}
}

// 初始化配置文件
func initDevConfig(c framework.Container) *devConfig {
	// 设置默认值
	devConfig := &devConfig{
		Port: "8087",
		Backend: struct {
			RefreshTime   int
			Port          string
			MonitorFolder string
			cmd           string
		}{
			1,
			"8072",
			"",
			"",
		},
		Frontend: struct{ Port string }{
			"8071",
		},
	}

	// 容器中获取配置服务
	config := c.MustMake(contract.ConfigKey).(contract.Config)

	// 每个配置项进行检查
	if config.IsExist("app.dev.port") {
		devConfig.Port = config.GetString("app.dev.port")
	}

	if config.IsExist("app.dev.backend.refresh_time") {
		devConfig.Backend.RefreshTime = config.GetInt("app.dev.backend.refresh_time")
	}
	if config.IsExist("app.dev.backend.port") {
		devConfig.Backend.Port = config.GetString("app.dev.backend.port")
	}

	if config.IsExist("app.dev.backend.cmd") {
		devConfig.Backend.cmd = config.GetString("app.dev.backend.cmd")
	}

	// monitorFolder 默认使用目录服务的AppFolder()
	monitorFolder := config.GetString("app.dev.backend.monitor_folder")
	if monitorFolder == "" {
		appService := c.MustMake(contract.AppKey).(contract.App)
		devConfig.Backend.MonitorFolder = appService.AppFolder()
	}

	if config.IsExist("app.dev.frontend.port") {
		devConfig.Frontend.Port = config.GetString("app.dev.frontend.port")
	}

	return devConfig
}

type Proxy struct {
	devConfig   *devConfig // 配置文件
	backendPid  int        // 当前服务的backend服务pid
	frontendPid int        // 当前服务的frontend服务的pid
}

// 重新启动一个proxy网关
func (p *Proxy) newProxyReverseProxy(frontend, backend *url.URL) *httputil.ReverseProxy {
	if p.frontendPid == 0 && p.backendPid == 0 {
		fmt.Println("前后段的服务都不存在")
		return nil
	}

	// 后段服务存在
	if p.backendPid != 0 && p.frontendPid == 0 {
		return httputil.NewSingleHostReverseProxy(backend)
	}

	// 前端服务存在
	if p.frontendPid != 0 && p.backendPid == 0 {
		return httputil.NewSingleHostReverseProxy(frontend)
	}

	// 两个都有: 先创建一个后端服务的directory
	director := func(req *http.Request) {
		if req.URL.Path == "/" || req.URL.Path == "/app.js" { // 如果路径是这两个直接转发到前端路由
			req.URL.Scheme = frontend.Scheme
			req.URL.Host = frontend.Host
		} else {
			req.URL.Scheme = backend.Scheme
			req.URL.Host = backend.Host
		}
	}

	// 定义一个NotFoundErr
	NotFoundErr := errors.New("response is 404, need to redirect")

	// 思路：先请求后端路由，如果后端路由不存在，再请求前端理由
	return &httputil.ReverseProxy{
		Director: director,
		ModifyResponse: func(response *http.Response) error {
			if response.StatusCode == 404 {
				return NotFoundErr
			}
			return nil
		},
		ErrorHandler: func(writer http.ResponseWriter, request *http.Request, err error) {
			if errors.Is(err, NotFoundErr) {
				httputil.NewSingleHostReverseProxy(frontend).ServeHTTP(writer, request)
			}
		},
	}
}

// rebuildBackend 重新编译后端
func (p *Proxy) rebuildBackend() error {
	cmdBuild := exec.Command(p.devConfig.Backend.cmd, "build", "backend")
	cmdBuild.Stdout = os.Stdout
	cmdBuild.Stderr = os.Stderr

	// start 启动指定的命令但不等待它完成, 如果 Start 成功返回，则 c.Process 字段将被设置
	if err := cmdBuild.Start(); err == nil {
		// 等待命令退出并等待任何复制到 stdin 或从 stdout 或 stderr 复制完成
		err := cmdBuild.Wait()
		if err != nil {
			return err
		}
	}
	return nil
}

// restartBackend 启动后段服务
func (p *Proxy) restartBackend() error {
	// 杀死之前的进程
	if p.backendPid != 0 {
		_ = syscall.Kill(p.backendPid, syscall.SIGKILL) // 杀死之前的进程
		p.backendPid = 0
	}

	// 设置随机端口，真实后段的端口
	port := p.devConfig.Backend.Port
	address := fmt.Sprintf(":" + port)

	// 使用命令行启动后段进程
	fmt.Println(address)
	cmd := exec.Command(p.devConfig.Backend.cmd, "app", "start", "--address="+address)
	cmd.Stdout = os.Stdout
	cmd.Stdout = os.Stderr
	fmt.Println("启动后端服务： ", "http://127.0.0.1:"+port)
	err := cmd.Start()
	if err != nil {
		fmt.Println(err)
	}

	p.backendPid = cmd.Process.Pid
	fmt.Println("后端服务pid：", p.backendPid)
	return nil
}

// 重新启动前端服务
func (p *Proxy) restartFrontend() error {
	// 启动前端调试模式
	// 如果已经开启了npm run serve, 杀死进程
	if p.frontendPid != 0 {
		_ = syscall.Kill(p.frontendPid, syscall.SIGKILL)
		p.frontendPid = 0
	}

	// 否则开启npm run serve
	port := p.devConfig.Frontend.Port
	path, err := exec.LookPath("npm")
	if err != nil {
		return err
	}

	cmd := exec.Command(path, "run", "dev")
	cmd.Env = os.Environ()
	cmd.Env = append(cmd.Env, fmt.Sprintf("%s%s", "PORT=", port))
	cmd.Stdout = os.NewFile(0, os.DevNull)
	cmd.Stderr = os.Stderr

	// 因为npm run serve 是控制台挂起模式，所以这里使用go routine启动
	err = cmd.Start()
	fmt.Println("启动前端服务: ", "http://127.0.0.1:"+port)
	if err != nil {
		fmt.Println(err)
	}

	p.frontendPid = cmd.Process.Pid
	fmt.Println("前端服务pid： ", p.frontendPid)

	return nil
}

// startProxy 开启网关，且根据参数启动前端服务或者后端服务
func (p *Proxy) startProxy(startFrontend, startBackend bool) error {
	var backendURL, frontendURL *url.URL
	var err error

	// 启动后端
	if startBackend {
		if err := p.restartBackend(); err != nil {
			return err
		}
	}
	// 启动前端
	if startFrontend {
		if err := p.restartFrontend(); err != nil {
			return err
		}
	}

	if frontendURL, err = url.Parse(fmt.Sprintf("%s%s", "http://127.0.0.1:", p.devConfig.Frontend.Port)); err != nil {
		return err
	}

	if backendURL, err = url.Parse(fmt.Sprintf("%s%s", "http://127.0.0.1:", p.devConfig.Backend.Port)); err != nil {
		return err
	}

	// 设置反向代理

	proxyReverse := p.newProxyReverseProxy(frontendURL, backendURL)
	proxyServer := &http.Server{
		Addr:    "127.0.0.1:" + p.devConfig.Port,
		Handler: proxyReverse,
	}

	fmt.Println("代理服务启动：", "https://"+proxyServer.Addr)

	// 启动服务
	err = proxyServer.ListenAndServe()
	if err != nil {
		fmt.Println(err)
	}
	return nil
}

// 监听应用文件夹
func (p *Proxy) monitorBackend() error {
	// 监听
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		return err
	}
	defer func(watcher *fsnotify.Watcher) {
		_ = watcher.Close()
	}(watcher)

	// 开启监听目标文件夹
	appFolder := p.devConfig.Backend.MonitorFolder
	fmt.Println("监控文件夹：", appFolder)

	// 监听所有子目录，需要使用filepath.walk
	_ = filepath.Walk(appFolder, func(path string, info fs.FileInfo, err error) error {
		if info != nil && !info.IsDir() {
			return nil
		}

		// 如果是隐藏的目录比如 . 或者 .. 则不用进行监控
		if util.IsHiddenDIrectory(path) {
			return nil
		}
		return watcher.Add(path)
	})

	// 开启计时时间机制
	refreshTime := p.devConfig.Backend.RefreshTime
	t := time.NewTimer(time.Duration(refreshTime) * time.Second)

	// 先停止计时器
	t.Stop()

	for {
		select {
		case <-t.C:
			// 计时器时间到了，代表之前有文件更新事件重置过计时器
			// 既有文件更新
			fmt.Println("...检测到文件更新，重新启动服务...")
			if err := p.rebuildBackend(); err != nil {
				fmt.Println("重新编译失败: ", err.Error())
			} else {
				if err := p.restartBackend(); err != nil {
					fmt.Println("重新启动失败：" + err.Error())
				}
			}
			fmt.Println("...检测到文件更新，重新服务结束...")
			// 停止计时器
			t.Stop()
		case _, ok := <-watcher.Events:
			if !ok {
				continue
			}
			// 有文件更新事件，重置计时器
			t.Reset(time.Duration(refreshTime) * time.Second)
		case err, ok := <-watcher.Errors:
			if !ok {
				continue
			}
			// 如果有文件监听错误，则停止计时器
			fmt.Println("监听文件夹错误: ", err.Error())
			t.Reset(time.Duration(refreshTime) * time.Second)
		}
	}
}

// NewProxy 初始化一个网关
func NewProxy(c framework.Container) *Proxy {
	devConfig := initDevConfig(c)
	return &Proxy{devConfig: devConfig}
}

// 初始化命令
func initDevCommand() *cobra.Command {
	devCommand.AddCommand(devBackendCommand)
	devCommand.AddCommand(devFrontendCommand)
	devCommand.AddCommand(devAllCommand)
	return devCommand
}

var devCommand = &cobra.Command{
	Use:   "dev",
	Short: "调式模式",
	RunE: func(c *cobra.Command, args []string) error {
		_ = c.Help()
		return nil
	},
}

var devBackendCommand = &cobra.Command{
	Use:   "backend",
	Short: "启动后端调试模式",
	RunE: func(c *cobra.Command, args []string) error {
		proxy := NewProxy(c.GetContainer())
		go func() {
			_ = proxy.monitorBackend()
		}()
		if err := proxy.startProxy(false, true); err != nil {
			return err
		}
		return nil
	},
}

var devFrontendCommand = &cobra.Command{
	Use:   "frontend",
	Short: "前端调试模式",
	RunE: func(c *cobra.Command, args []string) error {
		proxy := NewProxy(c.GetContainer())
		return proxy.startProxy(true, false)
	},
}

var devAllCommand = &cobra.Command{
	Use:   "all",
	Short: "同时启动前端和后端调试",
	RunE: func(c *cobra.Command, args []string) error {
		proxy := NewProxy(c.GetContainer())
		go func() {
			_ = proxy.monitorBackend()
		}()
		if err := proxy.startProxy(true, true); err != nil {
			return err
		}
		return nil
	},
}