Merge branch 'develop'

Author: theothertomelliott

.travis.yml

@@ -1,7 +1,7 @@
 language: go
 
 before_script:
-  - wget https://github.com/spf13/hugo/releases/download/v0.29/hugo_0.29_Linux-64bit.tar.gz -O /tmp/hugo.tar.gz
+  - wget https://github.com/spf13/hugo/releases/download/v0.32.3/hugo_0.32.3_Linux-64bit.tar.gz -O /tmp/hugo.tar.gz
   - mkdir /tmp/hugo
   - tar -xvf /tmp/hugo.tar.gz -C /tmp/hugo
   - export PATH=$PATH:/tmp/hugo/
@@ -10,7 +10,6 @@ before_install:
   - go get github.com/mitchellh/gox
 
 go:
-  - 1.7
   - 1.8
   - 1.9
 deploy:

Makefile

@@ -9,7 +9,7 @@ build:
 	./build.sh
 
 test:
-	go test -race -cover $(PKGS)
+	go test -timeout 3m -race -cover $(PKGS)
 
 checkdocs:
 	./check_docs.sh

build.go

@@ -1,6 +1,6 @@
-//+build !go1.7
+//+build !go1.8
 
 package main
 
-// Upgrade to Go version 1.7 to compile edward.
-func init() { Go_version_1_7_required_for_compilation() }
+// Upgrade to Go version 1.8 to compile edward.
+func init() { Go_version_1_8_required_for_compilation() }

builder/build.go

@@ -0,0 +1,77 @@
+package builder
+
+import (
+	"github.com/pkg/errors"
+	"github.com/yext/edward/commandline"
+	"github.com/yext/edward/home"
+	"github.com/yext/edward/instance"
+	"github.com/yext/edward/services"
+	"github.com/yext/edward/tracker"
+)
+
+type builder struct {
+	Cfg       services.OperationConfig
+	Overrides services.ContextOverride
+}
+
+func New(cfg services.OperationConfig, overrides services.ContextOverride) *builder {
+	return &builder{
+		Cfg:       cfg,
+		Overrides: overrides,
+	}
+}
+
+func (b *builder) Build(dirConfig *home.EdwardConfiguration, task tracker.Task, service ...*services.ServiceConfig) error {
+	for _, service := range service {
+		if b.Cfg.IsExcluded(service) {
+			return nil
+		}
+		err := b.BuildWithTracker(dirConfig, task.Child(service.GetName()), service, false)
+		if err != nil {
+			return errors.WithStack(err)
+		}
+	}
+	return nil
+}
+
+// BuildWithTracker builds a service.
+// If force is false, the build will be skipped if the service is already running.
+func (b *builder) BuildWithTracker(dirConfig *home.EdwardConfiguration, task tracker.Task, service *services.ServiceConfig, force bool) error {
+	if service.Commands.Build == "" {
+		return nil
+	}
+	if task == nil {
+		return errors.New("task is nil")
+	}
+	job := task.Child("Build")
+	job.SetState(tracker.TaskStateInProgress)
+
+	c, err := instance.Load(dirConfig, service, b.Overrides)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	if !force && c.Pid != 0 {
+		job.SetState(tracker.TaskStateWarning, "Already running")
+		return nil
+	}
+
+	err = instance.DeleteAllStatusesForService(service, dirConfig.StateDir)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	cmd, err := commandline.ConstructCommand(b.Cfg.WorkingDir, service.Path, service.Commands.Build, c.Getenv)
+	if err != nil {
+		job.SetState(tracker.TaskStateFailed, err.Error())
+		return errors.WithStack(err)
+	}
+
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		job.SetState(tracker.TaskStateFailed, err.Error(), string(out))
+		return errors.WithMessage(err, "running build command")
+	}
+
+	job.SetState(tracker.TaskStateSuccess)
+	return nil
+}

cmd/autocomplete.go

@@ -9,10 +9,10 @@ import (
 	"github.com/yext/edward/config"
 )
 
-func autocompleteServicesAndGroups(logger *log.Logger) {
+func autocompleteServicesAndGroups(homeDir string, logger *log.Logger) {
 	printCommandChildren(RootCmd)
 
-	configPath, err := config.GetConfigPathFromWorkingDirectory()
+	configPath, err := config.GetConfigPathFromWorkingDirectory(homeDir)
 	if err != nil {
 		logger.Println("Autocomplete> Error getting config path:", err)
 		return

cmd/restart.go

@@ -10,16 +10,20 @@ var restartCmd = &cobra.Command{
 	Use:   "restart",
 	Short: "Rebuild and relaunch a service or a group",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return errors.WithStack(
-			edwardClient.Restart(
-				args,
-				*restartFlags.force,
-				*restartFlags.skipBuild,
-				*restartFlags.tail,
-				*restartFlags.noWatch,
-				*restartFlags.exclude,
-			),
+		err := edwardClient.Restart(
+			args,
+			*restartFlags.force,
+			*restartFlags.skipBuild,
+			*restartFlags.noWatch,
+			*restartFlags.exclude,
 		)
+		if err != nil {
+			return errors.WithStack(err)
+		}
+		if *restartFlags.tail {
+			return errors.WithStack(edwardClient.Log(args, getSignalChannel()))
+		}
+		return nil
 	},
 }
 

cmd/root.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"path"
 	"path/filepath"
 
 	lumberjack "gopkg.in/natefinch/lumberjack.v2"
@@ -37,37 +38,66 @@ var RootCmd = &cobra.Command{
 Build, start and manage service instances with a single command.`,
 	SilenceUsage: true,
 	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+
+		var dirConfig *home.EdwardConfiguration
+		var err error
+		dirConfig = &home.EdwardConfiguration{}
+		if edwardHome != "" {
+			err = dirConfig.InitializeWithDir(edwardHome)
+		} else {
+			err = dirConfig.Initialize()
+		}
+		if err != nil {
+			return errors.WithStack(err)
+		}
+
 		if redirectLogs {
 			logger = log.New(os.Stdout, fmt.Sprintf("%v >", os.Args), log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
 		}
-		if logFile != "" {
-			prefix := "edward"
-			if len(args) > 0 {
-				prefix = fmt.Sprintf("%s %s", cmd.Use, args[0])
-			}
-			logger = log.New(&lumberjack.Logger{
-				Filename:   logFile,
-				MaxSize:    50, // megabytes
-				MaxBackups: 30,
-				MaxAge:     1, //days
-			}, fmt.Sprintf("%s > ", prefix), log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
+
+		prefix := "edward"
+		if len(args) > 0 {
+			prefix = fmt.Sprintf("%s %s", cmd.Use, args[0])
 		}
+		logger = log.New(&lumberjack.Logger{
+			Filename:   path.Join(dirConfig.EdwardLogDir, "edward.log"),
+			MaxSize:    50, // megabytes
+			MaxBackups: 30,
+			MaxAge:     1, //days
+		}, fmt.Sprintf("%s > ", prefix), log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
+
 		// Begin logging
 		logger.Printf("=== Edward v%v ===\n", common.EdwardVersion)
 		logger.Printf("Args: %v\n", os.Args)
+		// Recover from any panic and log appropriately
+		defer func() {
+			if r := recover(); r != nil {
+				fmt.Println("Recovered from panic:", r)
+				if logger != nil {
+					logger.Printf("Recovered from panic: %v", r)
+				}
+			}
+			if logger != nil {
+				logger.Printf("=== Exiting ===\n")
+			}
+		}()
 
 		// Set the default config path
 		if configPath == "" {
 			var err error
-			configPath, err = config.GetConfigPathFromWorkingDirectory()
+			tmpDirCfg := &home.EdwardConfiguration{}
+			err = tmpDirCfg.Initialize()
+			if err != nil {
+				return errors.WithStack(err)
+			}
+			configPath, err = config.GetConfigPathFromWorkingDirectory(tmpDirCfg.Dir)
 			if err != nil {
 				return errors.WithStack(err)
 			}
 		}
 
 		command := cmd.Use
 
-		var err error
 		if command != "generate" {
 			edwardClient, err = edward.NewClientWithConfig(configPath, common.EdwardVersion, logger)
 			if err != nil {
@@ -84,6 +114,8 @@ Build, start and manage service instances with a single command.`,
 			}
 		}
 
+		edwardClient.DirConfig = dirConfig
+
 		// Set service checks to restart the client on sudo as needed
 		edwardClient.ServiceChecks = func(sgs []services.ServiceOrGroup) error {
 			return errors.WithStack(sudoIfNeeded(sgs))
@@ -102,21 +134,20 @@ Build, start and manage service instances with a single command.`,
 		if command != "stop" {
 			// Check for legacy pidfiles and error out if any are found
 			for _, service := range edwardClient.ServiceMap() {
-				if _, err := os.Stat(service.GetPidPathLegacy()); !os.IsNotExist(err) {
+				if _, err := os.Stat(service.GetPidPathLegacy(edwardClient.DirConfig.PidDir)); !os.IsNotExist(err) {
 					return errors.New("one or more services were started with an older version of Edward. Please run `edward stop` to stop these instances")
 				}
 			}
 		}
 
 		if command != "run" {
 			checkUpdateChan = make(chan interface{})
-			go checkUpdateAvailable(checkUpdateChan)
+			go checkUpdateAvailable(edwardClient.DirConfig.Dir, checkUpdateChan)
 		}
 
 		return nil
 	},
 	PersistentPostRun: func(cmd *cobra.Command, args []string) {
-		defer logger.Printf("=== Exiting ===\n")
 		if checkUpdateChan != nil { //&& !didAutoComplete { // TODO: skip when autocompleting
 			updateAvailable, ok := (<-checkUpdateChan).(bool)
 			if ok && updateAvailable {
@@ -131,8 +162,10 @@ Build, start and manage service instances with a single command.`,
 // This is called by main.main(). It only needs to happen once to the rootCmd.
 func Execute() {
 
-	if err := home.EdwardConfig.Initialize(); err != nil {
-		fmt.Printf("%+v", err)
+	defaultHome := &home.EdwardConfiguration{}
+	err := defaultHome.Initialize()
+	if err != nil {
+		panic(err)
 	}
 
 	logPrefix := "edward"
@@ -141,15 +174,15 @@ func Execute() {
 	}
 
 	logger = log.New(&lumberjack.Logger{
-		Filename:   filepath.Join(home.EdwardConfig.EdwardLogDir, "edward.log"),
+		Filename:   filepath.Join(defaultHome.EdwardLogDir, "edward.log"),
 		MaxSize:    50, // megabytes
 		MaxBackups: 30,
 		MaxAge:     1, //days
 	}, logPrefix, log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
 
 	for _, arg := range os.Args {
 		if arg == "--generate-bash-completion" {
-			autocompleteServicesAndGroups(logger)
+			autocompleteServicesAndGroups(defaultHome.Dir, logger)
 			return
 		}
 	}
@@ -163,13 +196,15 @@ func Execute() {
 var configPath string
 var redirectLogs bool
 var logFile string
+var edwardHome string
 
 func init() {
 	cobra.OnInitialize(initConfig)
 
 	RootCmd.PersistentFlags().StringVar(&logFile, "logfile", "", "Write logs to `PATH`")
 	RootCmd.PersistentFlags().StringVarP(&configPath, "config", "c", "", "Use service configuration file at `PATH`")
 	RootCmd.PersistentFlags().BoolVar(&redirectLogs, "redirect_logs", false, "Redirect edward logs to the console")
+	RootCmd.PersistentFlags().StringVar(&edwardHome, "edward_home", "", "")
 	err := RootCmd.PersistentFlags().MarkHidden("redirect_logs")
 	if err != nil {
 		panic(err)
@@ -178,6 +213,10 @@ func init() {
 	if err != nil {
 		panic(err)
 	}
+	err = RootCmd.PersistentFlags().MarkHidden("edward_home")
+	if err != nil {
+		panic(err)
+	}
 }
 
 // initConfig reads in config file and ENV variables if set.
@@ -206,9 +245,9 @@ func initConfig() {
 	}
 }
 
-func checkUpdateAvailable(checkUpdateChan chan interface{}) {
+func checkUpdateAvailable(homeDir string, checkUpdateChan chan interface{}) {
 	defer close(checkUpdateChan)
-	updateAvailable, latestVersion, err := updates.UpdateAvailable("yext", "edward", common.EdwardVersion, filepath.Join(home.EdwardConfig.Dir, ".cache/version"), logger)
+	updateAvailable, latestVersion, err := updates.UpdateAvailable("yext", "edward", common.EdwardVersion, filepath.Join(homeDir, ".cache/version"), logger)
 	if err != nil {
 		logger.Println("Error checking for updates:", err)
 		return

cmd/run.go

@@ -18,11 +18,12 @@ var runCmd = &cobra.Command{
 			return fmt.Errorf("service not found: %s", args[0])
 		}
 		r := &runner.Runner{
-			Service: service,
+			Service:   service,
+			DirConfig: edwardClient.DirConfig,
 		}
 		r.NoWatch = *runFlags.noWatch
 		r.WorkingDir = *runFlags.directory
-		r.Logger = logger
+		r.Logger = edwardClient.Logger
 		err := r.Run(args)
 		return errors.WithStack(err)
 	},

cmd/start.go

@@ -10,9 +10,14 @@ var startCmd = &cobra.Command{
 	Use:   "start",
 	Short: "Build and launch a service or a group",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return errors.WithStack(
-			edwardClient.Start(args, *startFlags.skipBuild, *startFlags.tail, *startFlags.noWatch, *startFlags.exclude),
-		)
+		err := edwardClient.Start(args, *startFlags.skipBuild, *startFlags.noWatch, *startFlags.exclude)
+		if err != nil {
+			return errors.WithStack(err)
+		}
+		if *startFlags.tail {
+			return errors.WithStack(edwardClient.Log(args, getSignalChannel()))
+		}
+		return nil
 	},
 }