bee/cmd/commands/dlv/dlv_amd64.go

// Copyright 2017 bee authors
//
// Licensed under the Apache License, Version 2.0 (the "License"): you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.

// Package dlv ...
package dlv

import (
	"flag"
	"fmt"
	"net"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/beego/bee/cmd/commands"
	"github.com/beego/bee/cmd/commands/version"
	beeLogger "github.com/beego/bee/logger"
	"github.com/beego/bee/utils"
	"github.com/gadelkareem/delve/service"
	"github.com/gadelkareem/delve/service/debugger"
	"github.com/gadelkareem/delve/service/rpc2"
	"github.com/gadelkareem/delve/service/rpccommon"
	"github.com/gadelkareem/delve/pkg/terminal"
	"github.com/fsnotify/fsnotify"
)

var cmdDlv = &commands.Command{
	CustomFlags: true,
	UsageLine:   "dlv [-package=\"\"] [-port=8181] [-verbose=false]",
	Short:       "Start a debugging session using Delve",
	Long: `dlv command start a debugging session using debugging tool Delve.

  To debug your application using Delve, use: {{"$ bee dlv" | bold}}

  For more information on Delve: https://github.com/gadelkareem/delve
`,
	PreRun: func(cmd *commands.Command, args []string) { version.ShowShortVersionBanner() },
	Run:    runDlv,
}

var (
	packageName string
	verbose     bool
	port        int
)

func init() {
	fs := flag.NewFlagSet("dlv", flag.ContinueOnError)
	fs.StringVar(&packageName, "package", "", "The package to debug (Must have a main package)")
	fs.BoolVar(&verbose, "verbose", false, "Enable verbose mode")
	fs.IntVar(&port, "port", 8181, "Port to listen to for clients")
	cmdDlv.Flag = *fs
	commands.AvailableCommands = append(commands.AvailableCommands, cmdDlv)
}

func runDlv(cmd *commands.Command, args []string) int {
	if err := cmd.Flag.Parse(args); err != nil {
		beeLogger.Log.Fatalf("Error while parsing flags: %v", err.Error())
	}

	var (
		addr       = fmt.Sprintf("127.0.0.1:%d", port)
		paths      = make([]string, 0)
		notifyChan = make(chan int)
	)

	if err := loadPathsToWatch(&paths); err != nil {
		beeLogger.Log.Fatalf("Error while loading paths to watch: %v", err.Error())
	}
	go startWatcher(paths, notifyChan)
	return startDelveDebugger(addr, notifyChan)
}

// buildDebug builds a debug binary in the current working directory
func buildDebug() (string, error) {
	args := []string{"-gcflags", "-N -l", "-o", "debug"}
	args = append(args, utils.SplitQuotedFields("-ldflags='-linkmode internal'")...)
	args = append(args, packageName)
	if err := utils.GoCommand("build", args...); err != nil {
		return "", err
	}

	fp, err := filepath.Abs("./debug")
	if err != nil {
		return "", err
	}
	return fp, nil
}

// loadPathsToWatch loads the paths that needs to be watched for changes
func loadPathsToWatch(paths *[]string) error {
	directory, err := os.Getwd()
	if err != nil {
		return err
	}
	filepath.Walk(directory, func(path string, info os.FileInfo, _ error) error {
		if strings.HasSuffix(info.Name(), "docs") {
			return filepath.SkipDir
		}
		if strings.HasSuffix(info.Name(), "swagger") {
			return filepath.SkipDir
		}
		if strings.HasSuffix(info.Name(), "vendor") {
			return filepath.SkipDir
		}

		if filepath.Ext(info.Name()) == ".go" {
			*paths = append(*paths, path)
		}
		return nil
	})
	return nil
}

// startDelveDebugger starts the Delve debugger server
func startDelveDebugger(addr string, ch chan int) int {
	beeLogger.Log.Info("Starting Delve Debugger...")

	fp, err := buildDebug()
	if err != nil {
		beeLogger.Log.Fatalf("Error while building debug binary: %v", err)
	}
	defer os.Remove(fp)

	abs, err := filepath.Abs("./debug")
	if err != nil {
		beeLogger.Log.Fatalf("%v", err)
	}

	// Create and start the debugger server
	listener, err := net.Listen("tcp", addr)
	if err != nil {
		beeLogger.Log.Fatalf("Could not start listener: %s", err)
	}
	defer listener.Close()

	server := rpccommon.NewServer(&service.Config{
		Listener:    listener,
		AcceptMulti: true,
		APIVersion:  2,
		ProcessArgs: []string{abs},
		Debugger: debugger.Config{
			AttachPid:  0,
			WorkingDir: ".",
			Backend:    "default",
		},
	})
	if err := server.Run(); err != nil {
		beeLogger.Log.Fatalf("Could not start debugger server: %v", err)
	}

	// Start the Delve client REPL
	client := rpc2.NewClient(addr)
	// Make sure the client is restarted when new changes are introduced
	go func() {
		for {
			if val := <-ch; val == 0 {
				if _, err := client.Restart(true); err != nil {
					utils.Notify("Error while restarting the client: "+err.Error(), "bee")
				} else {
					if verbose {
						utils.Notify("Delve Debugger Restarted", "bee")
					}
				}
			}
		}
	}()

	// Create the terminal and connect it to the client debugger
	term := terminal.New(client, nil)
	status, err := term.Run()
	if err != nil {
		beeLogger.Log.Fatalf("Could not start Delve REPL: %v", err)
	}

	// Stop and kill the debugger server once user quits the REPL
	if err := server.Stop(); err != nil {
		beeLogger.Log.Fatalf("Could not stop Delve server: %v", err)
	}
	return status
}

var eventsModTime = make(map[string]int64)

// startWatcher starts the fsnotify watcher on the passed paths
func startWatcher(paths []string, ch chan int) {
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		beeLogger.Log.Fatalf("Could not start the watcher: %v", err)
	}
	defer watcher.Close()

	// Feed the paths to the watcher
	for _, path := range paths {
		if err := watcher.Add(path); err != nil {
			beeLogger.Log.Fatalf("Could not set a watch on path: %v", err)
		}
	}

	for {
		select {
		case evt := <-watcher.Events:
			build := true
			if filepath.Ext(evt.Name) != ".go" {
				continue
			}

			mt := utils.GetFileModTime(evt.Name)
			if t := eventsModTime[evt.Name]; mt == t {
				build = false
			}
			eventsModTime[evt.Name] = mt

			if build {
				go func() {
					if verbose {
						utils.Notify("Rebuilding application with the new changes", "bee")
					}

					// Wait 1s before re-build until there is no file change
					scheduleTime := time.Now().Add(1 * time.Second)
					time.Sleep(time.Until(scheduleTime))
					_, err := buildDebug()
					if err != nil {
						utils.Notify("Build Failed: "+err.Error(), "bee")
					} else {
						ch <- 0 // Notify listeners
					}
				}()
			}
		case err := <-watcher.Errors:
			if err != nil {
				ch <- -1
			}
		}
	}
}