use go-cmd/cmd

buildPackage.go

@@ -62,7 +62,7 @@ func (c *controlBox) buildPackage() (bool, error) {
 		os.Unsetenv("GO111MODULE")
 		path := c.pathL.String() + "@latest"
 		cmd := []string{"go", "install", "-v", "-x", path}
-		if r := Run(cmd); r.Error == nil {
+		if r := shell.Run(cmd); r.Error == nil {
 			log.Warn("go install worked")
 		} else {
 			return false, errors.New("go install")
@@ -84,7 +84,7 @@ func (c *controlBox) buildPackage() (bool, error) {
 			cmd = append(cmd, "-ldflags", "-X "+flag)
 		}
 
-		if r := Run(cmd); r.Error == nil {
+		if r := shell.Run(cmd); r.Error == nil {
 			log.Warn("go build worked")
 		} else {
 			return false, errors.New("go build")
@@ -118,11 +118,11 @@ func (c *controlBox) buildPackage() (bool, error) {
 		log.Warn("mkdir failed")
 		return false, errors.New("mkdir files/usr/bin")
 	}
-	if r := Run([]string{"cp", fullfilename, "files/usr/bin"}); r.Error != nil {
+	if r := shell.Run([]string{"cp", fullfilename, "files/usr/bin"}); r.Error != nil {
 		log.Warn("cp failed")
 		return false, r.Error
 	}
-	if r := Run([]string{"strip", "files/usr/bin/" + filename}); r.Error != nil {
+	if r := shell.Run([]string{"strip", "files/usr/bin/" + filename}); r.Error != nil {
 		log.Warn("strip failed")
 		return false, r.Error
 	}
@@ -142,7 +142,7 @@ func (c *controlBox) buildPackage() (bool, error) {
 		if !shell.Mkdir(path) {
 			return false, errors.New("no files/usr/lib")
 		}
-		if r := Run([]string{"cp", readme, path}); r.Error != nil {
+		if r := shell.Run([]string{"cp", readme, path}); r.Error != nil {
 			return false, r.Error
 		}
 	}
@@ -151,7 +151,7 @@ func (c *controlBox) buildPackage() (bool, error) {
 		return false, errors.New("write control file")
 	}
 	if shell.Exists("postinst") {
-		Run([]string{"cp", "postinst", "files/DEBIAN/"})
+		shell.Run([]string{"cp", "postinst", "files/DEBIAN/"})
 	}
 
 	if c.status == nil {
@@ -167,26 +167,26 @@ func (c *controlBox) buildPackage() (bool, error) {
 		} else {
 			os.Setenv("GO111MODULE", "off")
 		}
-		Run([]string{"./build"})
+		shell.Run([]string{"./build"})
 	}
 
-	Run([]string{"dpkg-deb", "--build", "files", fulldebname})
+	shell.Run([]string{"dpkg-deb", "--build", "files", fulldebname})
 	if shell.Exists(fulldebname) {
 	} else {
 		log.Warn("build failed")
 		return false, errors.New("dpkg-deb --build failed")
 	}
-	Run([]string{"dpkg-deb", "-I", fulldebname})
+	shell.Run([]string{"dpkg-deb", "-I", fulldebname})
-	Run([]string{"dpkg-deb", "-c", fulldebname})
+	shell.Run([]string{"dpkg-deb", "-c", fulldebname})
 
 	// cleanup files
 	if shell.Exists("files") {
 		if argv.KeepFiles {
 			log.Info("keeping the build files/")
 		} else {
-			Run([]string{"rm", "-rf", "files"})
+			shell.Run([]string{"rm", "-rf", "files"})
 			log.Info("running sync")
-			Run([]string{"sync"})
+			shell.Run([]string{"sync"})
 			if shell.Exists("files") {
 				log.Warn("rm -rf files/ failed. Run() returned false")
 				return false, errors.New("rm files/")
@@ -256,7 +256,8 @@ func (c *controlBox) computeControlValues() bool {
 // stamp := time.Now().UTC().Format("2006/01/02 15:04:05 UTC")
 
 func (c *controlBox) getDateStamp(tag string) string {
-	_, out := c.status.RunCmd([]string{"git", "log", "-1", "--format=%at", tag})
+	r := c.status.Run([]string{"git", "log", "-1", "--format=%at", tag})
+	out := strings.Join(r.Stdout, "\n")
 	out = strings.TrimSpace(out)
 
 	// Convert the string to an integer

cmd.go

@@ -1,184 +0,0 @@
-package main
-
-// this is a simplified interaction with the excellent
-// go-cmd/cmd package to work 'shell' like.
-
-// in all cases here, STDERR -> STDOUT
-// If you want the output from whatever you run
-// to be captured like it appears when you see it
-// on the command line, this is what this tries to do
-
-/*
-	if r := shell.Run([]{"ping", "-c", "3", "localhost"}); r.Error == nil {
-		if r.Exit == 0 {
-			log.Println("ran ok")
-		} else {
-			log.Println("ran")
-		}
-		// all stdout/stderr captured in r.Stdout
-	}
-*/
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/go-cmd/cmd"
-	"go.wit.com/log"
-)
-
-func Run(args []string) cmd.Status {
-	return PwdRun("", args)
-}
-
-// absolutely doesn't echo anything
-func PwdRunQuiet(pwd string, args []string) cmd.Status {
-	var arg0 string
-	var argx []string
-	// Check if the slice has at least one element (the command name)
-	if len(args) == 0 {
-		var s cmd.Status
-		s.Error = errors.New("Error: Command slice is empty.")
-		return s
-	}
-	if len(args) == 1 {
-		// Pass the first element as the command, and the rest as variadic arguments
-		arg0 = args[0]
-	} else {
-		arg0 = args[0]
-		argx = args[1:]
-	}
-
-	// Start a long-running process, capture stdout and stderr
-	findCmd := cmd.NewCmd(arg0, argx...)
-	if pwd != "" {
-		findCmd.Dir = pwd
-	}
-	statusChan := findCmd.Start() // non-blocking
-
-	ticker := time.NewTicker(2 * time.Second)
-
-	// this is interesting, maybe useful, but wierd, but neat. interesting even
-	// Print last line of stdout every 2s
-	go func() {
-		for range ticker.C {
-			status := findCmd.Status()
-			n := len(status.Stdout)
-			if n != 0 {
-				fmt.Println(status.Stdout[n-1])
-			}
-		}
-	}()
-
-	// Stop command after 1 hour
-	go func() {
-		<-time.After(1 * time.Hour)
-		findCmd.Stop()
-	}()
-
-	// Check if command is done
-	select {
-	case finalStatus := <-statusChan:
-		log.Info("finalStatus =", finalStatus.Exit, finalStatus.Error)
-		return finalStatus
-		// done
-	default:
-		// no, still running
-	}
-
-	// Block waiting for command to exit, be stopped, or be killed
-	finalStatus := <-statusChan
-	return finalStatus
-}
-
-func blah(cmd []string) {
-	r := Run(cmd)
-	log.Info("cmd =", r.Cmd)
-	log.Info("complete =", r.Complete)
-	log.Info("exit =", r.Exit)
-	log.Info("err =", r.Error)
-	log.Info("len(stdout+stderr) =", len(r.Stdout))
-}
-
-// run these to see confirm the sytem behaves as expected
-func RunTest() {
-	blah([]string{"ping", "-c", "3", "localhost"})
-	blah([]string{"exit", "0"})
-	blah([]string{"exit", "-1"})
-	blah([]string{"true"})
-	blah([]string{"false"})
-	blah([]string{"grep", "root", "/etc/", "/proc/cmdline", "/usr/bin/chmod"})
-	blah([]string{"grep", "root", "/proc/cmdline"})
-	fmt.Sprint("blahdone")
-}
-
-// sets the exec dir if it's sent
-// combines stdout and stderr
-// echo's output
-func PwdRun(pwd string, args []string) cmd.Status {
-	var save []string // combined stdout & stderr
-	var arg0 string
-	var argx []string
-	// Check if the slice has at least one element (the command name)
-	if len(args) == 0 {
-		var s cmd.Status
-		s.Error = errors.New("Error: Command slice is empty.")
-		return s
-	}
-	if len(args) == 1 {
-		// Pass the first element as the command, and the rest as variadic arguments
-		arg0 = args[0]
-	} else {
-		arg0 = args[0]
-		argx = args[1:]
-	}
-
-	// Disable output buffering, enable streaming
-	cmdOptions := cmd.Options{
-		Buffered:  false,
-		Streaming: true,
-	}
-
-	// Create Cmd with options
-	envCmd := cmd.NewCmdOptions(cmdOptions, arg0, argx...)
-	if pwd != "" {
-		envCmd.Dir = pwd
-	}
-
-	// Print STDOUT and STDERR lines streaming from Cmd
-	doneChan := make(chan struct{})
-	go func() {
-		defer close(doneChan)
-		// Done when both channels have been closed
-		// https://dave.cheney.net/2013/04/30/curious-channels
-		for envCmd.Stdout != nil || envCmd.Stderr != nil {
-			select {
-			case line, open := <-envCmd.Stdout:
-				if !open {
-					envCmd.Stdout = nil
-					continue
-				}
-				save = append(save, line)
-				fmt.Println(line)
-			case line, open := <-envCmd.Stderr:
-				if !open {
-					envCmd.Stderr = nil
-					continue
-				}
-				save = append(save, line)
-				fmt.Println(line)
-			}
-		}
-	}()
-
-	// Run and wait for Cmd to return, discard Status
-	<-envCmd.Start()
-
-	// Wait for goroutine to print everything
-	<-doneChan
-
-	s := envCmd.Status()
-	s.Stdout = save
-	return s
-}