go-vet friendly codebase

- distinguish log.Error and log.Errorf functions - Initialize structs with field names - A bit of unreachable code (defers)
ipfs · Oct 25, 2014 · 184c254 · 184c254
1 parent 210b5df
commit 184c254
Show file tree

Hide file tree

Showing 38 changed files with 187 additions and 188 deletions.
diff --git a/blocks/set/dbset.go b/blocks/set/dbset.go
@@ -11,6 +11,7 @@ type datastoreBlockSet struct {
 	bset   BlockSet
 }
 
+// NewDBWrapperSet returns a new blockset wrapping a given datastore
 func NewDBWrapperSet(d ds.Datastore, bset BlockSet) BlockSet {
 	return &datastoreBlockSet{
 		dstore: d,
@@ -21,7 +22,7 @@ func NewDBWrapperSet(d ds.Datastore, bset BlockSet) BlockSet {
 func (d *datastoreBlockSet) AddBlock(k util.Key) {
 	err := d.dstore.Put(k.DsKey(), []byte{})
 	if err != nil {
-		log.Error("blockset put error: %s", err)
+		log.Errorf("blockset put error: %s", err)
 	}
 
 	d.bset.AddBlock(k)

diff --git a/commands/cli/parse_test.go b/commands/cli/parse_test.go
@@ -26,10 +26,10 @@ func TestOptionParsing(t *testing.T) {
 		t.Error("Should have passed")
 	}
 	if len(opts) != 4 || opts["beep"] != "" || opts["boop"] != "lol" || opts["c"] != "" || opts["foo"] != "5" {
-		t.Error("Returned options were defferent than expected: %v", opts)
+		t.Errorf("Returned options were defferent than expected: %v", opts)
 	}
 	if len(input) != 2 || input[0] != "test2" || input[1] != "beep" {
-		t.Error("Returned input was different than expected: %v", input)
+		t.Errorf("Returned input was different than expected: %v", input)
 	}
 
 	_, _, err = parseOptions([]string{"-beep=1", "-boop=2", "-beep=3"})
@@ -39,9 +39,9 @@ func TestOptionParsing(t *testing.T) {
 
 	path, args := parsePath([]string{"test", "beep", "boop"}, cmd)
 	if len(path) != 1 || path[0] != "test" {
-		t.Error("Returned path was defferent than expected: %v", path)
+		t.Errorf("Returned path was defferent than expected: %v", path)
 	}
 	if len(args) != 2 || args[0] != "beep" || args[1] != "boop" {
-		t.Error("Returned args were different than expected: %v", args)
+		t.Errorf("Returned args were different than expected: %v", args)
 	}
 }
diff --git a/commands/command_test.go b/commands/command_test.go
@@ -73,8 +73,8 @@ func TestOptionValidation(t *testing.T) {
 	req = NewEmptyRequest()
 	req.SetOption("b", ":)")
 	res = cmd.Call(req)
-	if res.Error == nil {
-		t.Error(res.Error, "Should have failed (string value not convertible to int)")
+	if res.Error() == nil {
+		t.Error(res.Error(), "Should have failed (string value not convertible to int)")
 	}
 }
 

diff --git a/core/commands/refs.go b/core/commands/refs.go
@@ -43,7 +43,7 @@ func printRefs(n *core.IpfsNode, nd *mdag.Node, refSeen map[u.Key]bool, recursiv
 		if recursive {
 			nd, err := n.DAG.Get(u.Key(link.Hash))
 			if err != nil {
-				log.Error("error: cannot retrieve %s (%s)\n", link.Hash.B58String(), err)
+				log.Errorf("error: cannot retrieve %s (%s)", link.Hash.B58String(), err)
 				return
 			}
 

diff --git a/core/core.go b/core/core.go
@@ -6,8 +6,8 @@ import (
 	"fmt"
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
-	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
 	b58 "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-base58"
+	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
 	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 
 	bserv "github.com/jbenet/go-ipfs/blockservice"
@@ -230,25 +230,25 @@ func initIdentity(cfg *config.Config, peers peer.Peerstore, online bool) (peer.P
 func initConnections(ctx context.Context, cfg *config.Config, pstore peer.Peerstore, route *dht.IpfsDHT) {
 	for _, p := range cfg.Bootstrap {
 		if p.PeerID == "" {
-			log.Error("error: peer does not include PeerID. %v", p)
+			log.Errorf("error: peer does not include PeerID. %v", p)
 		}
 
 		maddr, err := ma.NewMultiaddr(p.Address)
 		if err != nil {
-			log.Error("%s", err)
+			log.Error(err)
 			continue
 		}
 
 		// setup peer
 		npeer, err := pstore.Get(peer.DecodePrettyID(p.PeerID))
 		if err != nil {
-			log.Error("Bootstrapping error: %v", err)
+			log.Errorf("Bootstrapping error: %v", err)
 			continue
 		}
 		npeer.AddAddress(maddr)
 
 		if _, err = route.Connect(ctx, npeer); err != nil {
-			log.Error("Bootstrapping error: %v", err)
+			log.Errorf("Bootstrapping error: %v", err)
 		}
 	}
 }
diff --git a/daemon/daemon.go b/daemon/daemon.go
@@ -53,13 +53,13 @@ func NewDaemonListener(ipfsnode *core.IpfsNode, addr ma.Multiaddr, confdir strin
 
 	ofi, err := os.Create(confdir + "/rpcaddress")
 	if err != nil {
-		log.Warning("Could not create rpcaddress file: %s", err)
+		log.Warningf("Could not create rpcaddress file: %s", err)
 		return nil, err
 	}
 
 	_, err = ofi.Write([]byte(addr.String()))
 	if err != nil {
-		log.Warning("Could not write to rpcaddress file: %s", err)
+		log.Warningf("Could not write to rpcaddress file: %s", err)
 		return nil, err
 	}
 	ofi.Close()
@@ -148,7 +148,7 @@ func (dl *DaemonListener) handleConnection(conn manet.Conn) {
 		err = fmt.Errorf("Invalid Command: '%s'", command.Command)
 	}
 	if err != nil {
-		log.Error("%s: %s", command.Command, err)
+		log.Errorf("%s: %s", command.Command, err)
 		fmt.Fprintln(conn, err)
 	}
 }

diff --git a/daemon/daemon_client.go b/daemon/daemon_client.go
@@ -72,7 +72,7 @@ func serverIsRunning(confdir string) bool {
 	var err error
 	confdir, err = u.TildeExpansion(confdir)
 	if err != nil {
-		log.Error("Tilde Expansion Failed: %s", err)
+		log.Errorf("Tilde Expansion Failed: %s", err)
 		return false
 	}
 	lk, err := daemonLock(confdir)

diff --git a/diagnostics/diag.go b/diagnostics/diag.go
@@ -105,7 +105,7 @@ func (d *Diagnostics) GetDiagnostic(timeout time.Duration) ([]*DiagInfo, error)
 	log.Debug("Begin Diagnostic")
 
 	peers := d.getPeers()
-	log.Debug("Sending diagnostic request to %d peers.", len(peers))
+	log.Debugf("Sending diagnostic request to %d peers.", len(peers))
 
 	var out []*DiagInfo
 	di := d.getDiagInfo()
@@ -116,12 +116,12 @@ func (d *Diagnostics) GetDiagnostic(timeout time.Duration) ([]*DiagInfo, error)
 	respdata := make(chan []byte)
 	sends := 0
 	for _, p := range peers {
-		log.Debug("Sending getDiagnostic to: %s", p)
+		log.Debugf("Sending getDiagnostic to: %s", p)
 		sends++
 		go func(p peer.Peer) {
 			data, err := d.getDiagnosticFromPeer(ctx, p, pmes)
 			if err != nil {
-				log.Error("GetDiagnostic error: %v", err)
+				log.Errorf("GetDiagnostic error: %v", err)
 				respdata <- nil
 				return
 			}
@@ -147,7 +147,7 @@ func AppendDiagnostics(data []byte, cur []*DiagInfo) []*DiagInfo {
 		err := dec.Decode(di)
 		if err != nil {
 			if err != io.EOF {
-				log.Error("error decoding DiagInfo: %v", err)
+				log.Errorf("error decoding DiagInfo: %v", err)
 			}
 			break
 		}
@@ -189,7 +189,7 @@ func (d *Diagnostics) sendRequest(ctx context.Context, p peer.Peer, pmes *pb.Mes
 	}
 
 	rtt := time.Since(start)
-	log.Info("diagnostic request took: %s", rtt.String())
+	log.Infof("diagnostic request took: %s", rtt.String())
 
 	rpmes := new(pb.Message)
 	if err := proto.Unmarshal(rmes.Data(), rpmes); err != nil {
@@ -200,7 +200,7 @@ func (d *Diagnostics) sendRequest(ctx context.Context, p peer.Peer, pmes *pb.Mes
 }
 
 func (d *Diagnostics) handleDiagnostic(p peer.Peer, pmes *pb.Message) (*pb.Message, error) {
-	log.Debug("HandleDiagnostic from %s for id = %s", p, pmes.GetDiagID())
+	log.Debugf("HandleDiagnostic from %s for id = %s", p, pmes.GetDiagID())
 	resp := newMessage(pmes.GetDiagID())
 	d.diagLock.Lock()
 	_, found := d.diagMap[pmes.GetDiagID()]
@@ -220,12 +220,12 @@ func (d *Diagnostics) handleDiagnostic(p peer.Peer, pmes *pb.Message) (*pb.Messa
 	respdata := make(chan []byte)
 	sendcount := 0
 	for _, p := range d.getPeers() {
-		log.Debug("Sending diagnostic request to peer: %s", p)
+		log.Debugf("Sending diagnostic request to peer: %s", p)
 		sendcount++
 		go func(p peer.Peer) {
 			out, err := d.getDiagnosticFromPeer(ctx, p, pmes)
 			if err != nil {
-				log.Error("getDiagnostic error: %v", err)
+				log.Errorf("getDiagnostic error: %v", err)
 				respdata <- nil
 				return
 			}
@@ -237,7 +237,7 @@ func (d *Diagnostics) handleDiagnostic(p peer.Peer, pmes *pb.Message) (*pb.Messa
 		out := <-respdata
 		_, err := buf.Write(out)
 		if err != nil {
-			log.Error("getDiagnostic write output error: %v", err)
+			log.Errorf("getDiagnostic write output error: %v", err)
 			continue
 		}
 	}
@@ -263,18 +263,18 @@ func (d *Diagnostics) HandleMessage(ctx context.Context, mes msg.NetMessage) msg
 	pmes := new(pb.Message)
 	err := proto.Unmarshal(mData, pmes)
 	if err != nil {
-		log.Error("Failed to decode protobuf message: %v", err)
+		log.Errorf("Failed to decode protobuf message: %v", err)
 		return nil
 	}
 
 	// Print out diagnostic
-	log.Info("[peer: %s] Got message from [%s]\n",
+	log.Infof("[peer: %s] Got message from [%s]\n",
 		d.self.ID().Pretty(), mPeer.ID().Pretty())
 
 	// dispatch handler.
 	rpmes, err := d.handleDiagnostic(mPeer, pmes)
 	if err != nil {
-		log.Error("handleDiagnostic error: %s", err)
+		log.Errorf("handleDiagnostic error: %s", err)
 		return nil
 	}
 
@@ -286,7 +286,7 @@ func (d *Diagnostics) HandleMessage(ctx context.Context, mes msg.NetMessage) msg
 	// serialize response msg
 	rmes, err := msg.FromObject(mPeer, rpmes)
 	if err != nil {
-		log.Error("Failed to encode protobuf message: %v", err)
+		log.Errorf("Failed to encode protobuf message: %v", err)
 		return nil
 	}
 

diff --git a/exchange/bitswap/bitswap.go b/exchange/bitswap/bitswap.go
@@ -88,13 +88,13 @@ func (bs *bitswap) Block(parent context.Context, k u.Key) (*blocks.Block, error)
 				log.Debug("bitswap dialing peer: %s", p)
 				err := bs.sender.DialPeer(p)
 				if err != nil {
-					log.Error("Error sender.DialPeer(%s)", p)
+					log.Errorf("Error sender.DialPeer(%s)", p)
 					return
 				}
 
 				response, err := bs.sender.SendRequest(ctx, p, message)
 				if err != nil {
-					log.Error("Error sender.SendRequest(%s)", p)
+					log.Errorf("Error sender.SendRequest(%s)", p)
 					return
 				}
 				// FIXME ensure accounting is handled correctly when

diff --git a/fuse/ipns/ipns_test.go b/fuse/ipns/ipns_test.go
@@ -254,7 +254,7 @@ func TestFastRepublish(t *testing.T) {
 	hasPublished := func() bool {
 		res, err := node.Namesys.Resolve(pubkeyHash)
 		if err != nil {
-			t.Fatal("resolve err: %v", err)
+			t.Fatalf("resolve err: %v", err)
 		}
 		return res != resolvedHash
 	}
@@ -264,7 +264,7 @@ func TestFastRepublish(t *testing.T) {
 	// at this point, should not have written dataA and not have written dataB
 	rbuf, err := ioutil.ReadFile(fname)
 	if err != nil || !bytes.Equal(rbuf, dataA) {
-		t.Fatal("Data inconsistent! %v %v", err, string(rbuf))
+		t.Fatalf("Data inconsistent! %v %v", err, string(rbuf))
 	}
 
 	if hasPublished() {
@@ -276,7 +276,7 @@ func TestFastRepublish(t *testing.T) {
 	// at this point, should have written written dataB, but not published it
 	rbuf, err = ioutil.ReadFile(fname)
 	if err != nil || !bytes.Equal(rbuf, dataB) {
-		t.Fatal("Data inconsistent! %v %v", err, string(rbuf))
+		t.Fatalf("Data inconsistent! %v %v", err, string(rbuf))
 	}
 
 	if hasPublished() {
@@ -288,7 +288,7 @@ func TestFastRepublish(t *testing.T) {
 	// at this point, should have written written dataB, and published it
 	rbuf, err = ioutil.ReadFile(fname)
 	if err != nil || !bytes.Equal(rbuf, dataB) {
-		t.Fatal("Data inconsistent! %v %v", err, string(rbuf))
+		t.Fatalf("Data inconsistent! %v %v", err, string(rbuf))
 	}
 
 	if !hasPublished() {