all: use errgo instead of fmt.Errorf

utils/ssh/ssh_gocrypto.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package ssh
 
 import (
         "fmt"
         "io"
         "io/ioutil"
         "os/user"
         "strings"
 
         "code.google.com/p/go.crypto/ssh"
+        "github.com/juju/errgo/errors"
 
         "launchpad.net/juju-core/utils"
 )
 
 const sshDefaultPort = 22
 
 // GoCryptoClient is an implementation of Client that
 // uses the embedded go.crypto/ssh SSH client.
 //
 // GoCryptoClient is intentionally limited in the
@@ skipping 32 matching lines @@
                 user:    user,
                 addr:    fmt.Sprintf("%s:%d", host, port),
                 command: shellCommand,
         }}
 }
 
 // Copy implements Client.Copy.
 //
 // Copy is currently unimplemented, and will always return an error.
 func (c *GoCryptoClient) Copy(targets, extraArgs []string, options *Options) error {
-        return fmt.Errorf("scp command is not implemented (OpenSSH scp not available in PATH)")
+        return errors.Newf("scp command is not implemented (OpenSSH scp not available in PATH)")
 }
 
 type goCryptoCommand struct {
         signers []ssh.Signer
         user    string
         addr    string
         command string
         stdin   io.Reader
         stdout  io.Writer
         stderr  io.Writer
         conn    *ssh.ClientConn
         sess    *ssh.Session
 }
 
 var sshDial = ssh.Dial
 
 func (c *goCryptoCommand) ensureSession() (*ssh.Session, error) {
         if c.sess != nil {
                 return c.sess, nil
         }
         if len(c.signers) == 0 {
-                return nil, fmt.Errorf("no private keys available")
+                return nil, errors.Newf("no private keys available")
         }
         if c.user == "" {
                 currentUser, err := user.Current()
                 if err != nil {
-                        return nil, fmt.Errorf("getting current user: %v", err)
+                        return nil, errors.Notef(err, "getting current user")
                 }
                 c.user = currentUser.Username
         }
         config := &ssh.ClientConfig{
                 User: c.user,
                 Auth: []ssh.ClientAuth{
                         ssh.ClientAuthKeyring(keyring{c.signers}),
                 },
         }
         conn, err := sshDial("tcp", c.addr, config)
@@ skipping 33 matching lines @@
         if err0 == nil {
                 err0 = err1
         }
         c.sess = nil
         c.conn = nil
         return err0
 }
 
 func (c *goCryptoCommand) Wait() error {
         if c.sess == nil {
-                return fmt.Errorf("Command has not been started")
+                return errors.Newf("Command has not been started")
         }
         err := c.sess.Wait()
         c.Close()
         return err
 }
 
 func (c *goCryptoCommand) Kill() error {
         if c.sess == nil {
-                return fmt.Errorf("Command has not been started")
+                return errors.Newf("Command has not been started")
         }
         return c.sess.Signal(ssh.SIGKILL)
 }
 
 func (c *goCryptoCommand) SetStdio(stdin io.Reader, stdout, stderr io.Writer) {
         c.stdin = stdin
         c.stdout = stdout
         c.stderr = stderr
 }
 
@@ skipping 32 matching lines @@
 func (k keyring) Key(i int) (ssh.PublicKey, error) {
         if i < 0 || i >= len(k.signers) {
                 // nil key marks the end of the keyring; must not return an error.
                 return nil, nil
         }
         return k.signers[i].PublicKey(), nil
 }
 
 func (k keyring) Sign(i int, rand io.Reader, data []byte) ([]byte, error) {
         if i < 0 || i >= len(k.signers) {
-                return nil, fmt.Errorf("no key at position %d", i)
+                return nil, errors.Newf("no key at position %d", i)
         }
         return k.signers[i].Sign(rand, data)
 }
 
 func splitUserHost(s string) (user, host string) {
         userHost := strings.SplitN(s, "@", 2)
         if len(userHost) == 2 {
                 return userHost[0], userHost[1]
         }
         return "", userHost[0]
 }