simplify how we log commands

pkg/commands/oscommands/cmd_obj.go

@@ -22,16 +22,20 @@ type ICmdObj interface {
 	// runs the command and runs a callback function on each line of the output. If the callback returns true for the boolean value, we kill the process and return.
 	RunAndProcessLines(onLine func(line string) (bool, error)) error
 
-	// logs command
-	Log() ICmdObj
+	// Marks the command object as readonly, so that when it is run, we don't log it to the user.
+	// We only want to log commands to the user which change state in some way.
+	DontLog() ICmdObj
+	ShouldLog() bool
 }
 
 type CmdObj struct {
 	cmdStr string
 	cmd    *exec.Cmd
 
-	runner     ICmdObjRunner
-	logCommand func(ICmdObj)
+	runner ICmdObjRunner
+
+	// if set to true, we don't want to log the command to the user.
+	dontLog bool
 }
 
 func (self *CmdObj) GetCmd() *exec.Cmd {
@@ -52,12 +56,15 @@ func (self *CmdObj) GetEnvVars() []string {
 	return self.cmd.Env
 }
 
-func (self *CmdObj) Log() ICmdObj {
-	self.logCommand(self)
-
+func (self *CmdObj) DontLog() ICmdObj {
+	self.dontLog = true
 	return self
 }
 
+func (self *CmdObj) ShouldLog() bool {
+	return !self.dontLog
+}
+
 func (self *CmdObj) Run() error {
 	return self.runner.Run(self)
 }

pkg/commands/oscommands/cmd_obj_builder.go

@@ -35,10 +35,9 @@ func (self *CmdObjBuilder) New(cmdStr string) ICmdObj {
 	cmd.Env = os.Environ()
 
 	return &CmdObj{
-		cmdStr:     cmdStr,
-		cmd:        cmd,
-		runner:     self.runner,
-		logCommand: self.logCmdObj,
+		cmdStr: cmdStr,
+		cmd:    cmd,
+		runner: self.runner,
 	}
 }
 
@@ -47,10 +46,9 @@ func (self *CmdObjBuilder) NewFromArgs(args []string) ICmdObj {
 	cmd.Env = os.Environ()
 
 	return &CmdObj{
-		cmdStr:     strings.Join(args, " "),
-		cmd:        cmd,
-		runner:     self.runner,
-		logCommand: self.logCmdObj,
+		cmdStr: strings.Join(args, " "),
+		cmd:    cmd,
+		runner: self.runner,
 	}
 }
 

pkg/commands/oscommands/cmd_obj_runner.go

@@ -22,12 +22,19 @@ type cmdObjRunner struct {
 var _ ICmdObjRunner = &cmdObjRunner{}
 
 func (self *cmdObjRunner) Run(cmdObj ICmdObj) error {
+	if cmdObj.ShouldLog() {
+		self.logCmdObj(cmdObj)
+	}
+
 	_, err := self.RunWithOutput(cmdObj)
 	return err
 }
 
 func (self *cmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
-	self.logCmdObj(cmdObj)
+	if cmdObj.ShouldLog() {
+		self.logCmdObj(cmdObj)
+	}
+
 	output, err := sanitisedCommandOutput(cmdObj.GetCmd().CombinedOutput())
 	if err != nil {
 		self.log.WithField("command", cmdObj.ToString()).Error(output)
@@ -36,6 +43,10 @@ func (self *cmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
 }
 
 func (self *cmdObjRunner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error {
+	if cmdObj.ShouldLog() {
+		self.logCmdObj(cmdObj)
+	}
+
 	cmd := cmdObj.GetCmd()
 	stdoutPipe, err := cmd.StdoutPipe()
 	if err != nil {

pkg/commands/oscommands/exec_live.go

@@ -66,7 +66,9 @@ func RunCommandWithOutputLiveAux(
 	startCmd func(cmd *exec.Cmd) (*cmdHandler, error),
 ) error {
 	c.Log.WithField("command", cmdObj.ToString()).Info("RunCommand")
-	c.LogCommand(cmdObj.ToString(), true)
+	if cmdObj.ShouldLog() {
+		c.LogCommand(cmdObj.ToString(), true)
+	}
 	cmd := cmdObj.AddEnvVars("LANG=en_US.UTF-8", "LC_ALL=en_US.UTF-8").GetCmd()
 
 	var stderr bytes.Buffer

pkg/commands/oscommands/os.go

@@ -87,22 +87,6 @@ func NewOSCommand(common *common.Common, platform *Platform) *OSCommand {
 	return c
 }
 
-func (c *OSCommand) WithSpan(span string) *OSCommand {
-	// sometimes .WithSpan(span) will be called where span actually is empty, in
-	// which case we don't need to log anything so we can just return early here
-	// with the original struct
-	if span == "" {
-		return c
-	}
-
-	newOSCommand := &OSCommand{}
-	*newOSCommand = *c
-	newOSCommand.CmdLogSpan = span
-	newOSCommand.Cmd.logCmdObj = newOSCommand.LogCmdObj
-	newOSCommand.Cmd.runner = &cmdObjRunner{log: c.Log, logCmdObj: newOSCommand.LogCmdObj}
-	return newOSCommand
-}
-
 func (c *OSCommand) LogCmdObj(cmdObj ICmdObj) {
 	c.LogCommand(cmdObj.ToString(), true)
 }
@@ -110,7 +94,7 @@ func (c *OSCommand) LogCmdObj(cmdObj ICmdObj) {
 func (c *OSCommand) LogCommand(cmdStr string, commandLine bool) {
 	c.Log.WithField("command", cmdStr).Info("RunCommand")
 
-	if c.onRunCommand != nil && c.CmdLogSpan != "" {
+	if c.onRunCommand != nil {
 		c.onRunCommand(NewCmdLogEntry(cmdStr, c.CmdLogSpan, commandLine))
 	}
 }