opensource/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2025-09-10 09:52:20 +08:00
Code Issues Projects Releases Wiki Activity

logs: removed all log.Errors unhelpful to users

Browse Source 
Let's save log.Error for things the user can take action on.
Moved all our diagnostics to log.Debug. We can ideally reduce them
even further.
This commit is contained in:
Juan Batiz-Benet
2015-02-03 01:06:07 -08:00
parent 61c97f80a3
commit 58f39687cf
29 changed files with 81 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
blocks/set/dbset.go
View File

@ -22,7 +22,7 @@ func NewDBWrapperSet(d ds.Datastore, bset BlockSet) BlockSet {
func (d *datastoreBlockSet) AddBlock(k util.Key) { func (d *datastoreBlockSet) AddBlock(k util.Key) {
err := d.dstore.Put(k.DsKey(), []byte{}) err := d.dstore.Put(k.DsKey(), []byte{})
if err != nil { if err != nil {
log.Errorf("blockset put error: %s", err) log.Debugf("blockset put error: %s", err)
} }
d.bset.AddBlock(k) d.bset.AddBlock(k)

2
blockservice/blockservice.go
View File

@ -122,7 +122,7 @@ func (s *BlockService) GetBlocks(ctx context.Context, ks []u.Key) <-chan *blocks
rblocks, err := s.Exchange.GetBlocks(ctx, misses) rblocks, err := s.Exchange.GetBlocks(ctx, misses)
if err != nil { if err != nil {
log.Errorf("Error with GetBlocks: %s", err) log.Debugf("Error with GetBlocks: %s", err)
return return
} }

6
cmd/ipfs/main.go
View File

@ -483,20 +483,20 @@ func (i *cmdInvocation) setupInterruptHandler() {
n, err := ctx.GetNode() n, err := ctx.GetNode()
if err != nil { if err != nil {
log.Error(err) log.Error(err)
log.Critical("Received interrupt signal, terminating...") fmt.Println("Received interrupt signal, terminating...")
os.Exit(-1) os.Exit(-1)
} }
switch count { switch count {
case 0: case 0:
log.Critical("Received interrupt signal, shutting down...") fmt.Println("Received interrupt signal, shutting down...")
go func() { go func() {
n.Close() n.Close()
log.Info("Gracefully shut down.") log.Info("Gracefully shut down.")
}() }()
default: default:
log.Critical("Received another interrupt before graceful shutdown, terminating...") fmt.Println("Received another interrupt before graceful shutdown, terminating...")
os.Exit(-1) os.Exit(-1)
} }
} }

2
commands/http/handler.go
View File

@ -129,7 +129,7 @@ func (i Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// w.WriteHeader(200) // w.WriteHeader(200)
err = copyChunks(applicationJson, w, out) err = copyChunks(applicationJson, w, out)
if err != nil { if err != nil {
log.Error(err) log.Debug(err)
} }
return return
} }

2
core/commands/ping.go
View File

@ -150,7 +150,7 @@ func pingPeer(ctx context.Context, n *core.IpfsNode, pid peer.ID, numPings int)
ctx, _ := context.WithTimeout(ctx, kPingTimeout) ctx, _ := context.WithTimeout(ctx, kPingTimeout)
took, err := n.Routing.Ping(ctx, pid) took, err := n.Routing.Ping(ctx, pid)
if err != nil { if err != nil {
log.Errorf("Ping error: %s", err) log.Debugf("Ping error: %s", err)
outChan <- &PingResult{Text: fmt.Sprintf("Ping error: %s", err)} outChan <- &PingResult{Text: fmt.Sprintf("Ping error: %s", err)}
break break
} }

2
core/commands/refs.go
View File

@ -110,7 +110,6 @@ Note: list all refs recursively with -r.
for _, o := range objs { for _, o := range objs {
if _, err := rw.WriteRefs(o); err != nil { if _, err := rw.WriteRefs(o); err != nil {
log.Error(err)
eptr.SetError(err) eptr.SetError(err)
return return
} }
@ -153,7 +152,6 @@ Displays the hashes of all local objects.
for k := range allKeys { for k := range allKeys {
s := k.Pretty() + "\n" s := k.Pretty() + "\n"
if _, err := pipew.Write([]byte(s)); err != nil { if _, err := pipew.Write([]byte(s)); err != nil {
log.Error(err)
eptr.SetError(err) eptr.SetError(err)
return return
} }

2
core/commands/swarm.go
View File

@ -240,7 +240,7 @@ ipfs swarm disconnect /ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQA
conns := n.PeerHost.Network().ConnsToPeer(addr.ID()) conns := n.PeerHost.Network().ConnsToPeer(addr.ID())
for _, conn := range conns { for _, conn := range conns {
if !conn.RemoteMultiaddr().Equal(taddr) { if !conn.RemoteMultiaddr().Equal(taddr) {
log.Error("it's not", conn.RemoteMultiaddr(), taddr) log.Debug("it's not", conn.RemoteMultiaddr(), taddr)
continue continue
} }

11
core/corehttp/gateway_handler.go
View File

@ -155,7 +155,7 @@ func (i *gatewayHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
errmsg = errmsg + "bad request for " + r.URL.Path errmsg = errmsg + "bad request for " + r.URL.Path
} }
w.Write([]byte(errmsg)) w.Write([]byte(errmsg))
log.Error(errmsg) log.Debug(errmsg)
} }
func (i *gatewayHandler) getHandler(w http.ResponseWriter, r *http.Request) { func (i *gatewayHandler) getHandler(w http.ResponseWriter, r *http.Request) {
@ -174,7 +174,6 @@ func (i *gatewayHandler) getHandler(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusBadRequest) w.WriteHeader(http.StatusBadRequest)
} }
log.Error(err)
w.Write([]byte(err.Error())) w.Write([]byte(err.Error()))
return return
} }
@ -290,7 +289,7 @@ func (i *gatewayHandler) putHandler(w http.ResponseWriter, r *http.Request) {
urlPath := r.URL.Path urlPath := r.URL.Path
pathext := urlPath[5:] pathext := urlPath[5:]
var err error var err error
if urlPath == IpfsPathPrefix + "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn/" { if urlPath == IpfsPathPrefix+"QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn/" {
i.putEmptyDirHandler(w, r) i.putEmptyDirHandler(w, r)
return return
} }
@ -326,7 +325,7 @@ func (i *gatewayHandler) putHandler(w http.ResponseWriter, r *http.Request) {
err = fmt.Errorf("Cannot override existing object") err = fmt.Errorf("Cannot override existing object")
w.WriteHeader(http.StatusBadRequest) w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error())) w.Write([]byte(err.Error()))
log.Error("%s", err) log.Debug("%s", err)
return return
} }
@ -450,7 +449,7 @@ func webError(w http.ResponseWriter, message string, err error, defaultCode int)
func webErrorWithCode(w http.ResponseWriter, message string, err error, code int) { func webErrorWithCode(w http.ResponseWriter, message string, err error, code int) {
w.WriteHeader(code) w.WriteHeader(code)
log.Errorf("%s: %s", message, err) log.Debugf("%s: %s", message, err)
w.Write([]byte(message + ": " + err.Error())) w.Write([]byte(message + ": " + err.Error()))
} }
@ -458,7 +457,7 @@ func webErrorWithCode(w http.ResponseWriter, message string, err error, code int
func internalWebError(w http.ResponseWriter, err error) { func internalWebError(w http.ResponseWriter, err error) {
w.WriteHeader(http.StatusInternalServerError) w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error())) w.Write([]byte(err.Error()))
log.Error("%s", err) log.Debug("%s", err)
} }
// Directory listing template // Directory listing template

2
core/corerepo/gc.go
View File

@ -51,7 +51,7 @@ func GarbageCollectAsync(n *core.IpfsNode, ctx context.Context) (<-chan *KeyRemo
if !n.Pinning.IsPinned(k) { if !n.Pinning.IsPinned(k) {
err := n.Blockstore.DeleteBlock(k) err := n.Blockstore.DeleteBlock(k)
if err != nil { if err != nil {
log.Errorf("Error removing key from blockstore: %s", err) log.Debugf("Error removing key from blockstore: %s", err)
continue continue
} }
select { select {

16
diagnostics/diag.go
View File

@ -187,7 +187,7 @@ func (d *Diagnostics) getDiagnosticFromPeers(ctx context.Context, peers map[peer
defer wg.Done() defer wg.Done()
out, err := d.getDiagnosticFromPeer(ctx, p, pmes) out, err := d.getDiagnosticFromPeer(ctx, p, pmes)
if err != nil { if err != nil {
log.Errorf("Error getting diagnostic from %s: %s", p, err) log.Debugf("Error getting diagnostic from %s: %s", p, err)
return return
} }
for d := range out { for d := range out {
@ -234,17 +234,17 @@ func (d *Diagnostics) getDiagnosticFromPeer(ctx context.Context, p peer.ID, pmes
for { for {
rpmes := new(pb.Message) rpmes := new(pb.Message)
if err := r.ReadMsg(rpmes); err != nil { if err := r.ReadMsg(rpmes); err != nil {
log.Errorf("Error reading diagnostic from stream: %s", err) log.Debugf("Error reading diagnostic from stream: %s", err)
return return
} }
if rpmes == nil { if rpmes == nil {
log.Error("Got no response back from diag request.") log.Debug("Got no response back from diag request.")
return return
} }
di, err := decodeDiagJson(rpmes.GetData()) di, err := decodeDiagJson(rpmes.GetData())
if err != nil { if err != nil {
log.Error(err) log.Debug(err)
return return
} }
@ -276,7 +276,7 @@ func (d *Diagnostics) HandleMessage(ctx context.Context, s inet.Stream) error {
// deserialize msg // deserialize msg
pmes := new(pb.Message) pmes := new(pb.Message)
if err := r.ReadMsg(pmes); err != nil { if err := r.ReadMsg(pmes); err != nil {
log.Errorf("Failed to decode protobuf message: %v", err) log.Debugf("Failed to decode protobuf message: %v", err)
return nil return nil
} }
@ -292,7 +292,7 @@ func (d *Diagnostics) HandleMessage(ctx context.Context, s inet.Stream) error {
resp := newMessage(pmes.GetDiagID()) resp := newMessage(pmes.GetDiagID())
resp.Data = d.getDiagInfo().Marshal() resp.Data = d.getDiagInfo().Marshal()
if err := w.WriteMsg(resp); err != nil { if err := w.WriteMsg(resp); err != nil {
log.Errorf("Failed to write protobuf message over stream: %s", err) log.Debugf("Failed to write protobuf message over stream: %s", err)
return err return err
} }
@ -305,14 +305,14 @@ func (d *Diagnostics) HandleMessage(ctx context.Context, s inet.Stream) error {
dpeers, err := d.getDiagnosticFromPeers(ctx, d.getPeers(), pmes) dpeers, err := d.getDiagnosticFromPeers(ctx, d.getPeers(), pmes)
if err != nil { if err != nil {
log.Errorf("diagnostic from peers err: %s", err) log.Debugf("diagnostic from peers err: %s", err)
return err return err
} }
for b := range dpeers { for b := range dpeers {
resp := newMessage(pmes.GetDiagID()) resp := newMessage(pmes.GetDiagID())
resp.Data = b.Marshal() resp.Data = b.Marshal()
if err := w.WriteMsg(resp); err != nil { if err := w.WriteMsg(resp); err != nil {
log.Errorf("Failed to write protobuf message over stream: %s", err) log.Debugf("Failed to write protobuf message over stream: %s", err)
return err return err
} }
} }

18
exchange/bitswap/bitswap.go
View File

@ -211,7 +211,7 @@ func (bs *bitswap) sendWantlistMsgToPeers(ctx context.Context, m bsmsg.BitSwapMe
go func(p peer.ID) { go func(p peer.ID) {
defer wg.Done() defer wg.Done()
if err := bs.send(ctx, p, m); err != nil { if err := bs.send(ctx, p, m); err != nil {
log.Error(err) // TODO remove if too verbose log.Debug(err) // TODO remove if too verbose
} }
}(peerToQuery) }(peerToQuery)
} }
@ -258,7 +258,7 @@ func (bs *bitswap) sendWantlistToProviders(ctx context.Context, entries []wantli
err := bs.sendWantlistToPeers(ctx, sendToPeers) err := bs.sendWantlistToPeers(ctx, sendToPeers)
if err != nil { if err != nil {
log.Errorf("sendWantlistToPeers error: %s", err) log.Debugf("sendWantlistToPeers error: %s", err)
} }
} }
@ -268,12 +268,12 @@ func (bs *bitswap) ReceiveMessage(ctx context.Context, p peer.ID, incoming bsmsg
defer log.EventBegin(ctx, "receiveMessage", p, incoming).Done() defer log.EventBegin(ctx, "receiveMessage", p, incoming).Done()
if p == "" { if p == "" {
log.Error("Received message from nil peer!") log.Debug("Received message from nil peer!")
// TODO propagate the error upward // TODO propagate the error upward
return "", nil return "", nil
} }
if incoming == nil { if incoming == nil {
log.Error("Got nil bitswap message!") log.Debug("Got nil bitswap message!")
// TODO propagate the error upward // TODO propagate the error upward
return "", nil return "", nil
} }
@ -287,7 +287,7 @@ func (bs *bitswap) ReceiveMessage(ctx context.Context, p peer.ID, incoming bsmsg
for _, block := range incoming.Blocks() { for _, block := range incoming.Blocks() {
hasBlockCtx, _ := context.WithTimeout(ctx, hasBlockTimeout) hasBlockCtx, _ := context.WithTimeout(ctx, hasBlockTimeout)
if err := bs.HasBlock(hasBlockCtx, block); err != nil { if err := bs.HasBlock(hasBlockCtx, block); err != nil {
log.Error(err) log.Debug(err)
} }
} }
var keys []u.Key var keys []u.Key
@ -308,7 +308,7 @@ func (bs *bitswap) PeerConnected(p peer.ID) {
close(peers) close(peers)
err := bs.sendWantlistToPeers(context.TODO(), peers) err := bs.sendWantlistToPeers(context.TODO(), peers)
if err != nil { if err != nil {
log.Errorf("error sending wantlist: %s", err) log.Debugf("error sending wantlist: %s", err)
} }
} }
@ -329,13 +329,13 @@ func (bs *bitswap) cancelBlocks(ctx context.Context, bkeys []u.Key) {
for _, p := range bs.engine.Peers() { for _, p := range bs.engine.Peers() {
err := bs.send(ctx, p, message) err := bs.send(ctx, p, message)
if err != nil { if err != nil {
log.Errorf("Error sending message: %s", err) log.Debugf("Error sending message: %s", err)
} }
} }
} }
func (bs *bitswap) ReceiveError(err error) { func (bs *bitswap) ReceiveError(err error) {
log.Errorf("Bitswap ReceiveError: %s", err) log.Debugf("Bitswap ReceiveError: %s", err)
// TODO log the network error // TODO log the network error
// TODO bubble the network error up to the parent context/error logger // TODO bubble the network error up to the parent context/error logger
} }
@ -413,7 +413,7 @@ func (bs *bitswap) clientWorker(parent context.Context) {
providers := bs.network.FindProvidersAsync(child, keys[0], maxProvidersPerRequest) providers := bs.network.FindProvidersAsync(child, keys[0], maxProvidersPerRequest)
err := bs.sendWantlistToPeers(ctx, providers) err := bs.sendWantlistToPeers(ctx, providers)
if err != nil { if err != nil {
log.Errorf("error sending wantlist: %s", err) log.Debugf("error sending wantlist: %s", err)
} }
case <-parent.Done(): case <-parent.Done():
return return

8
exchange/bitswap/network/ipfs_impl.go
View File

@ -62,7 +62,7 @@ func (bsnet *impl) SendMessage(
defer s.Close() defer s.Close()
if err := outgoing.ToNet(s); err != nil { if err := outgoing.ToNet(s); err != nil {
log.Errorf("error: %s", err) log.Debugf("error: %s", err)
return err return err
} }
@ -81,13 +81,13 @@ func (bsnet *impl) SendRequest(
defer s.Close() defer s.Close()
if err := outgoing.ToNet(s); err != nil { if err := outgoing.ToNet(s); err != nil {
log.Errorf("error: %s", err) log.Debugf("error: %s", err)
return nil, err return nil, err
} }
incoming, err := bsmsg.FromNet(s) incoming, err := bsmsg.FromNet(s)
if err != nil { if err != nil {
log.Errorf("error: %s", err) log.Debugf("error: %s", err)
return incoming, err return incoming, err
} }
@ -150,7 +150,7 @@ func (bsnet *impl) handleNewStream(s inet.Stream) {
received, err := bsmsg.FromNet(s) received, err := bsmsg.FromNet(s)
if err != nil { if err != nil {
go bsnet.receiver.ReceiveError(err) go bsnet.receiver.ReceiveError(err)
log.Errorf("bitswap net handleNewStream from %s error: %s", s.Conn().RemotePeer(), err) log.Debugf("bitswap net handleNewStream from %s error: %s", s.Conn().RemotePeer(), err)
return return
} }

6
exchange/reprovide/reprovide.go
View File

@ -41,7 +41,7 @@ func (rp *Reprovider) ProvideEvery(ctx context.Context, tick time.Duration) {
case <-after: case <-after:
err := rp.Reprovide(ctx) err := rp.Reprovide(ctx)
if err != nil { if err != nil {
log.Error(err) log.Debug(err)
} }
after = time.After(tick) after = time.After(tick)
} }
@ -57,7 +57,7 @@ func (rp *Reprovider) Reprovide(ctx context.Context) error {
op := func() error { op := func() error {
err := rp.rsys.Provide(ctx, k) err := rp.rsys.Provide(ctx, k)
if err != nil { if err != nil {
log.Warningf("Failed to provide key: %s", err) log.Debugf("Failed to provide key: %s", err)
} }
return err return err
} }
@ -66,7 +66,7 @@ func (rp *Reprovider) Reprovide(ctx context.Context) error {
// eventually work contexts into it. low priority. // eventually work contexts into it. low priority.
err := backoff.Retry(op, backoff.NewExponentialBackOff()) err := backoff.Retry(op, backoff.NewExponentialBackOff())
if err != nil { if err != nil {
log.Errorf("Providing failed after number of retries: %s", err) log.Debugf("Providing failed after number of retries: %s", err)
return err return err
} }
} }

45
fuse/ipns/ipns_unix.go
View File

@ -99,7 +99,6 @@ func CreateRoot(n *core.IpfsNode, keys []ci.PrivKey, ipfsroot string) (*Root, er
pub := k.GetPublic() pub := k.GetPublic()
hash, err := pub.Hash() hash, err := pub.Hash()
if err != nil { if err != nil {
log.Errorf("Read Root Error: %s", err)
return nil, err return nil, err
} }
root.LocalLink = &Link{u.Key(hash).Pretty()} root.LocalLink = &Link{u.Key(hash).Pretty()}
@ -108,7 +107,7 @@ func CreateRoot(n *core.IpfsNode, keys []ci.PrivKey, ipfsroot string) (*Root, er
for _, k := range keys { for _, k := range keys {
hash, err := k.GetPublic().Hash() hash, err := k.GetPublic().Hash()
if err != nil { if err != nil {
log.Error("failed to hash public key.") log.Debug("failed to hash public key.")
continue continue
} }
name := u.Key(hash).Pretty() name := u.Key(hash).Pretty()
@ -169,7 +168,6 @@ func (*Root) Attr() fuse.Attr {
// Lookup performs a lookup under this node. // Lookup performs a lookup under this node.
func (s *Root) Lookup(name string, intr fs.Intr) (fs.Node, fuse.Error) { func (s *Root) Lookup(name string, intr fs.Intr) (fs.Node, fuse.Error) {
log.Debugf("ipns: Root Lookup: '%s'", name)
switch name { switch name {
case "mach_kernel", ".hidden", "._.": case "mach_kernel", ".hidden", "._.":
// Just quiet some log noise on OS X. // Just quiet some log noise on OS X.
@ -188,7 +186,6 @@ func (s *Root) Lookup(name string, intr fs.Intr) (fs.Node, fuse.Error) {
return nd, nil return nd, nil
} }
log.Debugf("ipns: Falling back to resolution for [%s].", name)
resolved, err := s.Ipfs.Namesys.Resolve(s.Ipfs.Context(), name) resolved, err := s.Ipfs.Namesys.Resolve(s.Ipfs.Context(), name)
if err != nil { if err != nil {
log.Warningf("ipns: namesys resolve error: %s", err) log.Warningf("ipns: namesys resolve error: %s", err)
@ -200,7 +197,6 @@ func (s *Root) Lookup(name string, intr fs.Intr) (fs.Node, fuse.Error) {
// ReadDir reads a particular directory. Disallowed for root. // ReadDir reads a particular directory. Disallowed for root.
func (r *Root) ReadDir(intr fs.Intr) ([]fuse.Dirent, fuse.Error) { func (r *Root) ReadDir(intr fs.Intr) ([]fuse.Dirent, fuse.Error) {
log.Debug("Read Root.")
listing := []fuse.Dirent{ listing := []fuse.Dirent{
fuse.Dirent{ fuse.Dirent{
Name: "local", Name: "local",
@ -211,7 +207,6 @@ func (r *Root) ReadDir(intr fs.Intr) ([]fuse.Dirent, fuse.Error) {
pub := k.GetPublic() pub := k.GetPublic()
hash, err := pub.Hash() hash, err := pub.Hash()
if err != nil { if err != nil {
log.Errorf("Read Root Error: %s", err)
continue continue
} }
ent := fuse.Dirent{ ent := fuse.Dirent{
@ -257,7 +252,7 @@ func (s *Node) Attr() fuse.Attr {
if s.cached == nil { if s.cached == nil {
err := s.loadData() err := s.loadData()
if err != nil { if err != nil {
log.Errorf("Error loading PBData for file: '%s'", s.name) log.Debugf("Error loading PBData for file: '%s'", s.name)
} }
} }
switch s.cached.GetType() { switch s.cached.GetType() {
@ -266,7 +261,7 @@ func (s *Node) Attr() fuse.Attr {
case ftpb.Data_File, ftpb.Data_Raw: case ftpb.Data_File, ftpb.Data_Raw:
size, err := ft.DataSize(s.Nd.Data) size, err := ft.DataSize(s.Nd.Data)
if err != nil { if err != nil {
log.Errorf("Error getting size of file: %s", err) log.Debugf("Error getting size of file: %s", err)
size = 0 size = 0
} }
if size == 0 { if size == 0 {
@ -284,14 +279,13 @@ func (s *Node) Attr() fuse.Attr {
Blocks: uint64(len(s.Nd.Links)), Blocks: uint64(len(s.Nd.Links)),
} }
default: default:
log.Error("Invalid data type.") log.Debug("Invalid data type.")
return fuse.Attr{} return fuse.Attr{}
} }
} }
// Lookup performs a lookup under this node. // Lookup performs a lookup under this node.
func (s *Node) Lookup(name string, intr fs.Intr) (fs.Node, fuse.Error) { func (s *Node) Lookup(name string, intr fs.Intr) (fs.Node, fuse.Error) {
log.Debugf("ipns: node[%s] Lookup '%s'", s.name, name)
nodes, err := s.Ipfs.Resolver.ResolveLinks(s.Nd, []string{name}) nodes, err := s.Ipfs.Resolver.ResolveLinks(s.Nd, []string{name})
if err != nil { if err != nil {
// todo: make this error more versatile. // todo: make this error more versatile.
@ -322,7 +316,6 @@ func (n *Node) makeChild(name string, node *mdag.Node) *Node {
// ReadDir reads the link structure as directory entries // ReadDir reads the link structure as directory entries
func (s *Node) ReadDir(intr fs.Intr) ([]fuse.Dirent, fuse.Error) { func (s *Node) ReadDir(intr fs.Intr) ([]fuse.Dirent, fuse.Error) {
log.Debug("Node ReadDir")
entries := make([]fuse.Dirent, len(s.Nd.Links)) entries := make([]fuse.Dirent, len(s.Nd.Links))
for i, link := range s.Nd.Links { for i, link := range s.Nd.Links {
n := link.Name n := link.Name
@ -381,9 +374,9 @@ func (s *Node) Read(req *fuse.ReadRequest, resp *fuse.ReadResponse, intr fs.Intr
} }
func (n *Node) Write(req *fuse.WriteRequest, resp *fuse.WriteResponse, intr fs.Intr) fuse.Error { func (n *Node) Write(req *fuse.WriteRequest, resp *fuse.WriteResponse, intr fs.Intr) fuse.Error {
log.Debugf("ipns: Node Write [%s]: flags = %s, offset = %d, size = %d", n.name, req.Flags.String(), req.Offset, len(req.Data)) // log.Debugf("ipns: Node Write [%s]: flags = %s, offset = %d, size = %d", n.name, req.Flags.String(), req.Offset, len(req.Data))
if IpnsReadonly { if IpnsReadonly {
log.Error("Attempted to write on readonly ipns filesystem.") log.Debug("Attempted to write on readonly ipns filesystem.")
return fuse.EPERM return fuse.EPERM
} }
@ -391,7 +384,6 @@ func (n *Node) Write(req *fuse.WriteRequest, resp *fuse.WriteResponse, intr fs.I
// Create a DagModifier to allow us to change the existing dag node // Create a DagModifier to allow us to change the existing dag node
dmod, err := uio.NewDagModifier(n.Nd, n.Ipfs.DAG, chunk.DefaultSplitter) dmod, err := uio.NewDagModifier(n.Nd, n.Ipfs.DAG, chunk.DefaultSplitter)
if err != nil { if err != nil {
log.Errorf("Error creating dag modifier: %s", err)
return err return err
} }
n.dagMod = dmod n.dagMod = dmod
@ -405,7 +397,6 @@ func (n *Node) Write(req *fuse.WriteRequest, resp *fuse.WriteResponse, intr fs.I
} }
func (n *Node) Flush(req *fuse.FlushRequest, intr fs.Intr) fuse.Error { func (n *Node) Flush(req *fuse.FlushRequest, intr fs.Intr) fuse.Error {
log.Debugf("Got flush request [%s]!", n.name)
if IpnsReadonly { if IpnsReadonly {
return nil return nil
} }
@ -414,12 +405,11 @@ func (n *Node) Flush(req *fuse.FlushRequest, intr fs.Intr) fuse.Error {
if n.dagMod != nil { if n.dagMod != nil {
newNode, err := n.dagMod.GetNode() newNode, err := n.dagMod.GetNode()
if err != nil { if err != nil {
log.Errorf("Error getting dag node from dagMod: %s", err)
return err return err
} }
if n.parent != nil { if n.parent != nil {
log.Debug("updating self in parent!") log.Error("updating self in parent!")
err := n.parent.update(n.name, newNode) err := n.parent.update(n.name, newNode)
if err != nil { if err != nil {
log.Criticalf("error in updating ipns dag tree: %s", err) log.Criticalf("error in updating ipns dag tree: %s", err)
@ -465,7 +455,6 @@ func (n *Node) wasChanged() {
} }
func (n *Node) republishRoot() error { func (n *Node) republishRoot() error {
log.Debug("Republish root")
// We should already be the root, this is just a sanity check // We should already be the root, this is just a sanity check
var root *Node var root *Node
@ -484,28 +473,22 @@ func (n *Node) republishRoot() error {
ndkey, err := root.Nd.Key() ndkey, err := root.Nd.Key()
if err != nil { if err != nil {
log.Errorf("getKey error: %s", err)
return err return err
} }
log.Debug("Publishing changes!")
err = n.Ipfs.Namesys.Publish(n.Ipfs.Context(), root.key, ndkey) err = n.Ipfs.Namesys.Publish(n.Ipfs.Context(), root.key, ndkey)
if err != nil { if err != nil {
log.Errorf("ipns: Publish Failed: %s", err)
return err return err
} }
return nil return nil
} }
func (n *Node) Fsync(req *fuse.FsyncRequest, intr fs.Intr) fuse.Error { func (n *Node) Fsync(req *fuse.FsyncRequest, intr fs.Intr) fuse.Error {
log.Debug("Got fsync request!")
return nil return nil
} }
func (n *Node) Mkdir(req *fuse.MkdirRequest, intr fs.Intr) (fs.Node, fuse.Error) { func (n *Node) Mkdir(req *fuse.MkdirRequest, intr fs.Intr) (fs.Node, fuse.Error) {
log.Debug("Got mkdir request!")
if IpnsReadonly { if IpnsReadonly {
log.Error("Attempted to call mkdir on readonly filesystem.")
return nil, fuse.EPERM return nil, fuse.EPERM
} }
dagnd := &mdag.Node{Data: ft.FolderPBData()} dagnd := &mdag.Node{Data: ft.FolderPBData()}
@ -552,14 +535,12 @@ func (n *Node) Open(req *fuse.OpenRequest, resp *fuse.OpenResponse, intr fs.Intr
} }
func (n *Node) Mknod(req *fuse.MknodRequest, intr fs.Intr) (fs.Node, fuse.Error) { func (n *Node) Mknod(req *fuse.MknodRequest, intr fs.Intr) (fs.Node, fuse.Error) {
log.Debug("Got mknod request!")
return nil, nil return nil, nil
} }
func (n *Node) Create(req *fuse.CreateRequest, resp *fuse.CreateResponse, intr fs.Intr) (fs.Node, fs.Handle, fuse.Error) { func (n *Node) Create(req *fuse.CreateRequest, resp *fuse.CreateResponse, intr fs.Intr) (fs.Node, fs.Handle, fuse.Error) {
log.Debugf("Got create request: %s", req.Name)
if IpnsReadonly { if IpnsReadonly {
log.Error("Attempted to call Create on a readonly filesystem.") log.Debug("Attempted to call Create on a readonly filesystem.")
return nil, nil, fuse.EPERM return nil, nil, fuse.EPERM
} }
@ -571,7 +552,6 @@ func (n *Node) Create(req *fuse.CreateRequest, resp *fuse.CreateResponse, intr f
err := nnode.AddNodeLink(req.Name, nd) err := nnode.AddNodeLink(req.Name, nd)
if err != nil { if err != nil {
log.Errorf("Error adding child to node: %s", err)
return nil, nil, err return nil, nil, err
} }
if n.parent != nil { if n.parent != nil {
@ -589,16 +569,13 @@ func (n *Node) Create(req *fuse.CreateRequest, resp *fuse.CreateResponse, intr f
} }
func (n *Node) Remove(req *fuse.RemoveRequest, intr fs.Intr) fuse.Error { func (n *Node) Remove(req *fuse.RemoveRequest, intr fs.Intr) fuse.Error {
log.Debugf("[%s] Got Remove request: %s", n.name, req.Name)
if IpnsReadonly { if IpnsReadonly {
log.Error("Attempted to call Remove on a readonly filesystem.")
return fuse.EPERM return fuse.EPERM
} }
nnode := n.Nd.Copy() nnode := n.Nd.Copy()
err := nnode.RemoveNodeLink(req.Name) err := nnode.RemoveNodeLink(req.Name)
if err != nil { if err != nil {
log.Error("Remove: No such file.")
return fuse.ENOENT return fuse.ENOENT
} }
@ -615,9 +592,8 @@ func (n *Node) Remove(req *fuse.RemoveRequest, intr fs.Intr) fuse.Error {
} }
func (n *Node) Rename(req *fuse.RenameRequest, newDir fs.Node, intr fs.Intr) fuse.Error { func (n *Node) Rename(req *fuse.RenameRequest, newDir fs.Node, intr fs.Intr) fuse.Error {
log.Debugf("Got Rename request '%s' -> '%s'", req.OldName, req.NewName)
if IpnsReadonly { if IpnsReadonly {
log.Error("Attempted to call Rename on a readonly filesystem.") log.Debug("Attempted to call Rename on a readonly filesystem.")
return fuse.EPERM return fuse.EPERM
} }
@ -637,7 +613,6 @@ func (n *Node) Rename(req *fuse.RenameRequest, newDir fs.Node, intr fs.Intr) fus
case *Node: case *Node:
err := newDir.Nd.AddNodeLink(req.NewName, mdn) err := newDir.Nd.AddNodeLink(req.NewName, mdn)
if err != nil { if err != nil {
log.Errorf("Error adding node to new dir on rename: %s", err)
return err return err
} }
default: default:
@ -649,8 +624,6 @@ func (n *Node) Rename(req *fuse.RenameRequest, newDir fs.Node, intr fs.Intr) fus
// Updates the child of this node, specified by name to the given newnode // Updates the child of this node, specified by name to the given newnode
func (n *Node) update(name string, newnode *mdag.Node) error { func (n *Node) update(name string, newnode *mdag.Node) error {
log.Debugf("update '%s' in '%s'", name, n.name)
nnode, err := n.Nd.UpdateNodeLink(name, newnode) nnode, err := n.Nd.UpdateNodeLink(name, newnode)
if err != nil { if err != nil {
return err return err

4
fuse/mount/mount.go
View File

@ -107,7 +107,7 @@ func (m *mount) unmount() error {
if err == nil { if err == nil {
return nil return nil
} }
log.Error("fuse unmount err: %s", err) log.Debug("fuse unmount err: %s", err)
// try closing the fuseConn // try closing the fuseConn
err = m.fuseConn.Close() err = m.fuseConn.Close()
@ -115,7 +115,7 @@ func (m *mount) unmount() error {
return nil return nil
} }
if err != nil { if err != nil {
log.Error("fuse conn error: %s", err) log.Debug("fuse conn error: %s", err)
} }
// try mount.ForceUnmountManyTimes // try mount.ForceUnmountManyTimes

2
fuse/readonly/readonly_unix.go
View File

@ -110,7 +110,7 @@ func (s *Node) Attr() fuse.Attr {
} }
default: default:
log.Error("Invalid data type.") log.Debug("Invalid data type.")
return fuse.Attr{} return fuse.Attr{}
} }
} }

2
importer/chunk/splitting.go
View File

@ -38,7 +38,7 @@ func (ss *SizeSplitter) Split(r io.Reader) chan []byte {
return return
} }
if err != nil { if err != nil {
log.Errorf("Block split error: %s", err) log.Debugf("Block split error: %s", err)
return return
} }
} }

4
merkledag/merkledag.go
View File

@ -136,7 +136,7 @@ func FetchGraph(ctx context.Context, root *Node, serv DAGService) chan struct{}
nd, err := lnk.GetNode(serv) nd, err := lnk.GetNode(serv)
if err != nil { if err != nil {
log.Error(err) log.Debug(err)
return return
} }
@ -199,7 +199,7 @@ func (ds *dagService) GetNodes(ctx context.Context, keys []u.Key) []NodeGetter {
nd, err := Decoded(blk.Data) nd, err := Decoded(blk.Data)
if err != nil { if err != nil {
// NB: can happen with improperly formatted input data // NB: can happen with improperly formatted input data
log.Error("Got back bad block!") log.Debug("Got back bad block!")
return return
} }
is := FindLinks(keys, blk.Key(), 0) is := FindLinks(keys, blk.Key(), 0)

5
namesys/publisher.go
View File

@ -43,19 +43,16 @@ func (p *ipnsPublisher) Publish(ctx context.Context, k ci.PrivKey, value u.Key)
// validate `value` is a ref (multihash) // validate `value` is a ref (multihash)
_, err := mh.FromB58String(value.Pretty()) _, err := mh.FromB58String(value.Pretty())
if err != nil { if err != nil {
log.Errorf("hash cast failed: %s", value)
return fmt.Errorf("publish value must be str multihash. %v", err) return fmt.Errorf("publish value must be str multihash. %v", err)
} }
data, err := createRoutingEntryData(k, value) data, err := createRoutingEntryData(k, value)
if err != nil { if err != nil {
log.Error("entry creation failed.")
return err return err
} }
pubkey := k.GetPublic() pubkey := k.GetPublic()
pkbytes, err := pubkey.Bytes() pkbytes, err := pubkey.Bytes()
if err != nil { if err != nil {
log.Error("pubkey getbytes failed.")
return err return err
} }
@ -120,7 +117,7 @@ func ValidateIpnsRecord(k u.Key, val []byte) error {
case pb.IpnsEntry_EOL: case pb.IpnsEntry_EOL:
t, err := u.ParseRFC3339(string(entry.GetValidity())) t, err := u.ParseRFC3339(string(entry.GetValidity()))
if err != nil { if err != nil {
log.Error("Failed parsing time for ipns record EOL") log.Debug("Failed parsing time for ipns record EOL")
return err return err
} }
if time.Now().After(t) { if time.Now().After(t) {

4
p2p/net/swarm/swarm_listen.go
View File

@ -33,7 +33,7 @@ func (s *Swarm) listen(addrs []ma.Multiaddr) error {
retErr.Errors = make([]error, len(addrs)) retErr.Errors = make([]error, len(addrs))
} }
retErr.Errors[i] = err retErr.Errors[i] = err
log.Errorf("Failed to listen on: %s - %s", addr, err) log.Debugf("Failed to listen on: %s - %s", addr, err)
} }
} }
@ -122,7 +122,7 @@ func (s *Swarm) connHandler(c *ps.Conn) *Conn {
sc, err := s.newConnSetup(ctx, c) sc, err := s.newConnSetup(ctx, c)
if err != nil { if err != nil {
log.Error(err) log.Debug(err)
log.Event(ctx, "newConnHandlerDisconnect", lgbl.NetConn(c.NetConn()), lgbl.Error(err)) log.Event(ctx, "newConnHandlerDisconnect", lgbl.NetConn(c.NetConn()), lgbl.Error(err))
c.Close() // boom. close it. c.Close() // boom. close it.
return nil return nil

8
p2p/net/swarm/swarm_test.go
View File

@ -22,25 +22,25 @@ func EchoStreamHandler(stream inet.Stream) {
// pull out the ipfs conn // pull out the ipfs conn
c := stream.Conn() c := stream.Conn()
log.Debugf("%s ponging to %s", c.LocalPeer(), c.RemotePeer()) log.Infof("%s ponging to %s", c.LocalPeer(), c.RemotePeer())
buf := make([]byte, 4) buf := make([]byte, 4)
for { for {
if _, err := stream.Read(buf); err != nil { if _, err := stream.Read(buf); err != nil {
if err != io.EOF { if err != io.EOF {
log.Error("ping receive error:", err) log.Info("ping receive error:", err)
} }
return return
} }
if !bytes.Equal(buf, []byte("ping")) { if !bytes.Equal(buf, []byte("ping")) {
log.Errorf("ping receive error: ping != %s %v", buf, buf) log.Infof("ping receive error: ping != %s %v", buf, buf)
return return
} }
if _, err := stream.Write([]byte("pong")); err != nil { if _, err := stream.Write([]byte("pong")); err != nil {
log.Error("pond send error:", err) log.Info("pond send error:", err)
return return
} }
} }

7
p2p/protocol/mux.go
View File

@ -24,9 +24,8 @@ type streamHandlerMap map[ID]inet.StreamHandler
// It contains the handlers for each protocol accepted. // It contains the handlers for each protocol accepted.
// It dispatches handlers for streams opened by remote peers. // It dispatches handlers for streams opened by remote peers.
type Mux struct { type Mux struct {
lock sync.RWMutex
lock sync.RWMutex handlers streamHandlerMap
handlers streamHandlerMap
defaultHandler inet.StreamHandler defaultHandler inet.StreamHandler
} }
@ -50,13 +49,11 @@ func (m *Mux) Protocols() []ID {
// readHeader reads the stream and returns the next Handler function // readHeader reads the stream and returns the next Handler function
// according to the muxer encoding. // according to the muxer encoding.
func (m *Mux) readHeader(s io.Reader) (ID, inet.StreamHandler, error) { func (m *Mux) readHeader(s io.Reader) (ID, inet.StreamHandler, error) {
// log.Error("ReadProtocolHeader")
p, err := ReadHeader(s) p, err := ReadHeader(s)
if err != nil { if err != nil {
return "", nil, err return "", nil, err
} }
// log.Debug("readHeader got:", p)
m.lock.RLock() m.lock.RLock()
defer m.lock.RUnlock() defer m.lock.RUnlock()
h, found := m.handlers[p] h, found := m.handlers[p]

4
p2p/test/backpressure/backpressure_test.go
View File

@ -66,9 +66,9 @@ a problem.
// our request handler. can do stuff here. we // our request handler. can do stuff here. we
// simulate something taking time by waiting // simulate something taking time by waiting
// on requestHandled // on requestHandled
log.Error("request worker handling...") log.Debug("request worker handling...")
<-requestHandled <-requestHandled
log.Error("request worker done!") log.Debug("request worker done!")
receiverRatelimit <- struct{}{} // release receiverRatelimit <- struct{}{} // release
}() }()
} }

6
routing/dht/dht_test.go
View File

@ -262,7 +262,7 @@ func waitForWellFormedTables(t *testing.T, dhts []*IpfsDHT, minPeers, avgPeers i
for { for {
select { select {
case <-timeoutA: case <-timeoutA:
log.Errorf("did not reach well-formed routing tables by %s", timeout) log.Debugf("did not reach well-formed routing tables by %s", timeout)
return false // failed return false // failed
case <-time.After(5 * time.Millisecond): case <-time.After(5 * time.Millisecond):
if checkTables() { if checkTables() {
@ -322,7 +322,7 @@ func TestBootstrap(t *testing.T) {
} }
}() }()
waitForWellFormedTables(t, dhts, 7, 10, 5*time.Second) waitForWellFormedTables(t, dhts, 7, 10, 20*time.Second)
close(stop) close(stop)
if u.Debug { if u.Debug {
@ -407,7 +407,7 @@ func TestPeriodicBootstrap(t *testing.T) {
// this is async, and we dont know when it's finished with one cycle, so keep checking // this is async, and we dont know when it's finished with one cycle, so keep checking
// until the routing tables look better, or some long timeout for the failure case. // until the routing tables look better, or some long timeout for the failure case.
waitForWellFormedTables(t, dhts, 7, 10, 5*time.Second) waitForWellFormedTables(t, dhts, 7, 10, 20*time.Second)
if u.Debug { if u.Debug {
printRoutingTables(dhts) printRoutingTables(dhts)

4
routing/grandcentral/client.go
View File

@ -44,13 +44,13 @@ func (c *Client) FindProvidersAsync(ctx context.Context, k u.Key, max int) <-cha
request := pb.NewMessage(pb.Message_GET_PROVIDERS, string(k), 0) request := pb.NewMessage(pb.Message_GET_PROVIDERS, string(k), 0)
response, err := c.proxy.SendRequest(ctx, request) response, err := c.proxy.SendRequest(ctx, request)
if err != nil { if err != nil {
log.Error(errors.Wrap(err)) log.Debug(errors.Wrap(err))
return return
} }
for _, p := range pb.PBPeersToPeerInfos(response.GetProviderPeers()) { for _, p := range pb.PBPeersToPeerInfos(response.GetProviderPeers()) {
select { select {
case <-ctx.Done(): case <-ctx.Done():
log.Error(errors.Wrap(ctx.Err())) log.Debug(errors.Wrap(ctx.Err()))
return return
case ch <- p: case ch <- p:
} }

4
routing/grandcentral/proxy/loopback.go
View File

@ -2,9 +2,9 @@ package proxy
import ( import (
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context" context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
ggio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/gogoprotobuf/io"
inet "github.com/jbenet/go-ipfs/p2p/net" inet "github.com/jbenet/go-ipfs/p2p/net"
peer "github.com/jbenet/go-ipfs/p2p/peer" peer "github.com/jbenet/go-ipfs/p2p/peer"
ggio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/gogoprotobuf/io"
dhtpb "github.com/jbenet/go-ipfs/routing/dht/pb" dhtpb "github.com/jbenet/go-ipfs/routing/dht/pb"
errors "github.com/jbenet/go-ipfs/util/debugerror" errors "github.com/jbenet/go-ipfs/util/debugerror"
) )
@ -39,7 +39,7 @@ func (lb *Loopback) handleNewStream(s inet.Stream) {
pbr := ggio.NewDelimitedReader(s, inet.MessageSizeMax) pbr := ggio.NewDelimitedReader(s, inet.MessageSizeMax)
var incoming dhtpb.Message var incoming dhtpb.Message
if err := pbr.ReadMsg(&incoming); err != nil { if err := pbr.ReadMsg(&incoming); err != nil {
log.Error(errors.Wrap(err)) log.Debug(errors.Wrap(err))
return return
} }
ctx := context.TODO() ctx := context.TODO()

14
routing/grandcentral/server.go
View File

@ -53,16 +53,16 @@ func (s *Server) handleMessage(
dskey := util.Key(req.GetKey()).DsKey() dskey := util.Key(req.GetKey()).DsKey()
val, err := s.datastore.Get(dskey) val, err := s.datastore.Get(dskey)
if err != nil { if err != nil {
log.Error(errors.Wrap(err)) log.Debug(errors.Wrap(err))
return "", nil return "", nil
} }
rawRecord, ok := val.([]byte) rawRecord, ok := val.([]byte)
if !ok { if !ok {
log.Errorf("datastore had non byte-slice value for %v", dskey) log.Debugf("datastore had non byte-slice value for %v", dskey)
return "", nil return "", nil
} }
if err := proto.Unmarshal(rawRecord, response.Record); err != nil { if err := proto.Unmarshal(rawRecord, response.Record); err != nil {
log.Error("failed to unmarshal dht record from datastore") log.Debug("failed to unmarshal dht record from datastore")
return "", nil return "", nil
} }
// TODO before merging: if we know any providers for the requested value, return those. // TODO before merging: if we know any providers for the requested value, return those.
@ -72,12 +72,12 @@ func (s *Server) handleMessage(
// TODO before merging: verifyRecord(req.GetRecord()) // TODO before merging: verifyRecord(req.GetRecord())
data, err := proto.Marshal(req.GetRecord()) data, err := proto.Marshal(req.GetRecord())
if err != nil { if err != nil {
log.Error(err) log.Debug(err)
return "", nil return "", nil
} }
dskey := util.Key(req.GetKey()).DsKey() dskey := util.Key(req.GetKey()).DsKey()
if err := s.datastore.Put(dskey, data); err != nil { if err := s.datastore.Put(dskey, data); err != nil {
log.Error(err) log.Debug(err)
return "", nil return "", nil
} }
return p, req // TODO before merging: verify that we should return record return p, req // TODO before merging: verify that we should return record
@ -91,7 +91,7 @@ func (s *Server) handleMessage(
for _, provider := range req.GetProviderPeers() { for _, provider := range req.GetProviderPeers() {
providerID := peer.ID(provider.GetId()) providerID := peer.ID(provider.GetId())
if providerID != p { if providerID != p {
log.Errorf("provider message came from third-party %s", p) log.Debugf("provider message came from third-party %s", p)
continue continue
} }
for _, maddr := range provider.Addresses() { for _, maddr := range provider.Addresses() {
@ -107,7 +107,7 @@ func (s *Server) handleMessage(
} }
} }
if err := s.datastore.Put(pkey, providers); err != nil { if err := s.datastore.Put(pkey, providers); err != nil {
log.Error(err) log.Debug(err)
return "", nil return "", nil
} }
return "", nil return "", nil

4
tour/tour.go
View File

@ -72,8 +72,8 @@ func compareDottedInts(i, o string) bool {
ivis, err1 := strconv.Atoi(vis) ivis, err1 := strconv.Atoi(vis)
ivos, err2 := strconv.Atoi(vos) ivos, err2 := strconv.Atoi(vos)
if err1 != nil || err2 != nil { if err1 != nil || err2 != nil {
log.Error(err1) log.Debug(err1)
log.Error(err2) log.Debug(err2)
panic("tour ID LessThan: not an int") panic("tour ID LessThan: not an int")
} }

2
updates/updates.go
View File

@ -90,7 +90,7 @@ func init() {
var err error var err error
currentVersion, err = parseVersion() currentVersion, err = parseVersion()
if err != nil { if err != nil {
log.Errorf("invalid version number in code (must be semver): %q", Version) log.Criticalf("invalid version number in code (must be semver): %q", Version)
os.Exit(1) os.Exit(1)
} }
log.Infof("go-ipfs Version: %s", currentVersion) log.Infof("go-ipfs Version: %s", currentVersion)