all: use errgo instead of fmt.Errorf

environs/manual/init.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package manual
 
 import (
         "bytes"
         "fmt"
         "io"
         "regexp"
         "strconv"
         "strings"
 
+        "github.com/juju/errgo/errors"
+
         "launchpad.net/juju-core/instance"
         "launchpad.net/juju-core/utils"
         "launchpad.net/juju-core/utils/ssh"
 )
 
 // checkProvisionedScript is the script to run on the remote machine
 // to check if a machine has already been provisioned.
 //
 // This is a little convoluted to avoid returning an error in the
 // common case of no matching files.
 const checkProvisionedScript = "ls /etc/init/ | grep juju.*\\.conf || exit 0"
 
 // checkProvisioned checks if any juju upstart jobs already
 // exist on the host machine.
 func checkProvisioned(host string) (bool, error) {
         logger.Infof("Checking if %s is already provisioned", host)
         cmd := ssh.Command("ubuntu@"+host, []string{"/bin/bash"}, nil)
         var stdout, stderr bytes.Buffer
         cmd.Stdout = &stdout
         cmd.Stderr = &stderr
         cmd.Stdin = strings.NewReader(checkProvisionedScript)
         if err := cmd.Run(); err != nil {
                 if stderr.Len() != 0 {
-                        err = fmt.Errorf("%v (%v)", err, strings.TrimSpace(stderr.String()))
+                        err = errors.Newf("%v (%v)", err, strings.TrimSpace(stderr.String()))
                 }
                 return false, err
         }
         output := strings.TrimSpace(stdout.String())
         provisioned := len(output) > 0
         if provisioned {
                 logger.Infof("%s is already provisioned [%q]", host, output)
         } else {
                 logger.Infof("%s is not provisioned", host)
         }
         return provisioned, nil
 }
 
 // DetectSeriesAndHardwareCharacteristics detects the OS
 // series and hardware characteristics of the remote machine
 // by connecting to the machine and executing a bash script.
 func DetectSeriesAndHardwareCharacteristics(host string) (hc instance.HardwareCharacteristics, series string, err error) {
         logger.Infof("Detecting series and characteristics on %s", host)
         cmd := ssh.Command("ubuntu@"+host, []string{"/bin/bash"}, nil)
         var stdout, stderr bytes.Buffer
         cmd.Stdout = &stdout
         cmd.Stderr = &stderr
         cmd.Stdin = bytes.NewBufferString(detectionScript)
         if err := cmd.Run(); err != nil {
                 if stderr.Len() != 0 {
-                        err = fmt.Errorf("%v (%v)", err, strings.TrimSpace(stderr.String()))
+                        err = errors.Newf("%v (%v)", err, strings.TrimSpace(stderr.String()))
                 }
                 return hc, "", err
         }
         lines := strings.Split(stdout.String(), "\n")
         series = strings.TrimSpace(lines[0])
 
         // Normalise arch.
         arch := strings.TrimSpace(lines[1])
         for _, re := range archREs {
                 if re.Match([]byte(arch)) {
                         hc.Arch = &re.arch
                         break
                 }
         }
         if hc.Arch == nil {
-                err = fmt.Errorf("unrecognised architecture: %s", arch)
+                err = errors.Newf("unrecognised architecture: %s", arch)
                 return hc, "", err
         }
 
         // HardwareCharacteristics wants memory in megabytes,
         // meminfo reports it in kilobytes.
         memkB := strings.Fields(lines[2])[1] // "MemTotal: NNN kB"
         hc.Mem = new(uint64)
         *hc.Mem, err = strconv.ParseUint(memkB, 10, 0)
         *hc.Mem /= 1024
 
@@ skipping 86 matching lines @@
         var options ssh.Options
         options.AllowPasswordAuthentication()
         options.EnablePTY()
         cmd = ssh.Command(host, []string{"sudo", "/bin/bash -c " + utils.ShQuote(script)}, &options)
         var stderr bytes.Buffer
         cmd.Stdin = stdin
         cmd.Stdout = stdout // for sudo prompt
         cmd.Stderr = &stderr
         if err := cmd.Run(); err != nil {
                 if stderr.Len() != 0 {
-                        err = fmt.Errorf("%v (%v)", err, strings.TrimSpace(stderr.String()))
+                        err = errors.Newf("%v (%v)", err, strings.TrimSpace(stderr.String()))
                 }
                 return err
         }
         return nil
 }
 
 const initUbuntuScript = `
 set -e
 (id ubuntu &> /dev/null) || useradd -m ubuntu
 umask 0077
 temp=$(mktemp)
 echo 'ubuntu ALL=(ALL) NOPASSWD:ALL' > $temp
 install -m 0440 $temp /etc/sudoers.d/90-juju-ubuntu
 rm $temp
 su ubuntu -c 'install -D -m 0600 /dev/null ~/.ssh/authorized_keys'
 export authorized_keys=%s
 if [ ! -z "$authorized_keys" ]; then
     su ubuntu -c 'printf "%%s\n" "$authorized_keys" >> ~/.ssh/authorized_keys'
 fi`