forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-28 15:46:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

all: Fix logging

Browse source 
Signed-off-by: Lewis Marshall <lewis@lmars.net>
This commit is contained in:
Lewis Marshall 2017-04-21 10:28:19 +01:00
parent bcf2622f29
commit 4c6648ef49
25 changed files with 177 additions and 194 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
p2p/adapters/inproc.go
View file

@ -20,7 +20,7 @@ import (
"fmt"
"sync"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/discover"
)
@ -121,7 +121,7 @@ func (self *SimNode) Disconnect(rid []byte) error {
// na := self.network.GetNodeAdapter(id)
// peer = na.(*SimNode).GetPeer(self.Id)
// peer.RW = nil
glog.V(6).Infof("dropped peer %v", id)
log.Trace(fmt.Sprintf("dropped peer %v", id))
return nil
}
@ -158,10 +158,10 @@ func (self *SimNode) Connect(rid []byte) error {
func (self *SimNode) RunProtocol(id *NodeId, rw, rrw p2p.MsgReadWriter, peer *Peer) error {
if self.Run == nil {
glog.V(6).Infof("no protocol starting on peer %v (connection with %v)", self.Id, id)
log.Trace(fmt.Sprintf("no protocol starting on peer %v (connection with %v)", self.Id, id))
return nil
}
glog.V(6).Infof("protocol starting on peer %v (connection with %v)", self.Id, id)
log.Trace(fmt.Sprintf("protocol starting on peer %v (connection with %v)", self.Id, id))
p := p2p.NewPeer(id.NodeID, Name(id.Bytes()), []p2p.Cap{})
go func() {
self.network.DidConnect(self.Id, id)
@ -169,7 +169,7 @@ func (self *SimNode) RunProtocol(id *NodeId, rw, rrw p2p.MsgReadWriter, peer *Pe
<-peer.Readyc
self.Disconnect(id.Bytes())
peer.Errc <- err
glog.V(6).Infof("protocol quit on peer %v (connection with %v broken: %v)", self.Id, id, err)
log.Trace(fmt.Sprintf("protocol quit on peer %v (connection with %v broken: %v)", self.Id, id, err))
self.network.DidDisconnect(self.Id, id)
}()
return nil

17
p2p/protocols/protocol.go
View file

@ -34,8 +34,7 @@ import (
"reflect"
"time"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/discover"
)
@ -223,7 +222,7 @@ func (self *Peer) Register(msg interface{}, handler func(interface{}) error) uin
if !found {
panic(fmt.Sprintf("message type '%v' unknown ", typ))
}
glog.V(logger.Detail).Infof("register handle for %v", typ)
log.Trace(fmt.Sprintf("register handle for %v", typ))
self.handlers[typ] = append(self.handlers[typ], handler)
return code
}
@ -243,7 +242,7 @@ func (self *Peer) Run() error {
err := <-self.Errc
d := &Disconnect{err}
for _, f := range self.handlers[reflect.TypeOf(d)] {
glog.V(6).Infof("disconnect hook for %v", d)
log.Trace(fmt.Sprintf("disconnect hook for %v", d))
f(err)
}
return err
@ -268,7 +267,7 @@ func (self *Peer) Send(msg interface{}) error {
if !found {
return errorf(ErrInvalidMsgType, "%v", code)
}
glog.V(logger.Detail).Infof("=> msg #%d TO %v : %v", code, self.ID(), msg)
log.Trace(fmt.Sprintf("=> msg #%d TO %v : %v", code, self.ID(), msg))
go func() {
self.wErrc <- p2p.Send(self.rw, uint64(code), msg)
}()
@ -304,7 +303,7 @@ func (self *Peer) handleIncoming() (interface{}, error) {
if err != nil {
return nil, err
}
glog.V(logger.Detail).Infof("<= %v", msg)
log.Trace(fmt.Sprintf("<= %v", msg))
// make sure that the payload has been fully consumed
defer msg.Discard()
@ -326,7 +325,7 @@ func (self *Peer) handleIncoming() (interface{}, error) {
if err := msg.Decode(val.Interface()); err != nil {
return nil, errorf(ErrDecode, "<= %v: %v", msg, err)
}
glog.V(logger.Detail).Infof("<= %v FROM %v %v %v", msg, self.ID(), req, typ)
log.Trace(fmt.Sprintf("<= %v FROM %v %v %v", msg, self.ID(), req, typ))
// call the registered handler callbacks
// a registered callback take the decoded message as argument as an interface
@ -335,11 +334,11 @@ func (self *Peer) handleIncoming() (interface{}, error) {
// chosen based on the proper type in the first place
handlers := self.handlers[typ]
if len(handlers) == 0 {
glog.V(6).Infof("no handler (msg code %v)", msg.Code)
log.Trace(fmt.Sprintf("no handler (msg code %v)", msg.Code))
// return nil, errorf(ErrNoHandler, "(msg code %v)", msg.Code)
} else {
for i, f := range handlers {
glog.V(6).Infof("handler %v for %v", i, typ)
log.Trace(fmt.Sprintf("handler %v for %v", i, typ))
err = f(req.Interface())
if err != nil {
return nil, errorf(ErrHandler, "(msg code %v): %v", msg.Code, err)

17
p2p/protocols/protocol_test.go
View file

@ -2,19 +2,18 @@ package protocols
import (
"fmt"
"os"
"testing"
"time"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/adapters"
p2ptest "github.com/ethereum/go-ethereum/p2p/testing"
)
func init() {
glog.SetV(logger.Error)
glog.SetToStderr(true)
log.Root().SetHandler(log.LvlFilterHandler(log.LvlError, log.StreamHandler(os.Stderr, log.TerminalFormat(false))))
}
// handshake message type
@ -65,13 +64,13 @@ func newProtocol(pp *p2ptest.TestPeerPool) adapters.ProtoCall {
peer.Register(&kill{}, func(msg interface{}) error {
id := msg.(*kill).C
pp.Get(id).Drop(fmt.Errorf("killed"))
glog.V(logger.Detail).Infof("id %v killed", id)
log.Trace(fmt.Sprintf("id %v killed", id))
return nil
})
// for testing we can trigger self induced disconnect upon receiving drop message
peer.Register(&drop{}, func(msg interface{}) error {
glog.V(logger.Detail).Infof("dropped")
log.Trace("dropped")
return fmt.Errorf("dropped")
})
@ -107,11 +106,11 @@ func newProtocol(pp *p2ptest.TestPeerPool) adapters.ProtoCall {
return peer.Send(lhs)
})
glog.V(logger.Detail).Infof("adding peer %v", peer)
log.Trace(fmt.Sprintf("adding peer %v", peer))
pp.Add(peer)
defer pp.Remove(peer)
err = peer.Run()
glog.V(logger.Detail).Infof("peer %v protocol quitting: %v", peer, err)
log.Trace(fmt.Sprintf("peer %v protocol quitting: %v", peer, err))
return err
}
@ -280,7 +279,7 @@ func runMultiplePeers(t *testing.T, peer int, errs ...error) {
// time.Sleep(1)
for !pp.Has(s.Ids[0]) {
time.Sleep(1)
glog.V(logger.Detail).Infof("missing peer test-0: %v (%v)", pp, s.Ids)
log.Trace(fmt.Sprintf("missing peer test-0: %v (%v)", pp, s.Ids))
}
// if !pp.Has(s.Ids[0]) {
// t.Fatalf("missing peer test-0: %v (%v)", pp, s.Ids)

7
p2p/simulations/examples/connectivity.go
View file

@ -1,16 +1,17 @@
package main
import (
"os"
"runtime"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/simulations"
)
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
glog.SetV(6)
glog.SetToStderr(true)
log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(false))))
c, quitc := simulations.NewSessionController(simulations.DefaultNet)
simulations.StartRestApiServer("8888", c)

11
p2p/simulations/journal.go
View file

@ -9,8 +9,7 @@ import (
"time"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/adapters"
)
@ -41,7 +40,7 @@ func NewJournal() *Journal {
// used for journalling history of a network
// the goroutine terminates when the journal is closed
func (self *Journal) Subscribe(eventer *event.TypeMux, types ...interface{}) {
glog.V(logger.Info).Infof("subscribe")
log.Info("subscribe")
sub := eventer.Subscribe(types...)
go func() {
defer sub.Unsubscribe()
@ -151,7 +150,7 @@ func (self *Journal) TimedRead(acc float64, f func(interface{}) bool) (read int)
panic("events not ordered")
}
interval := ev.Time.Sub(lastEvent)
glog.V(6).Infof("reset timer to interval %v", interval)
log.Trace(fmt.Sprintf("reset timer to interval %v", interval))
timer.Reset(time.Duration(acc) * interval)
lastEvent = ev.Time
data = ev.Data
@ -171,7 +170,7 @@ func (self *Journal) TimedRead(acc float64, f func(interface{}) bool) (read int)
}
read += n
if n == 0 || !f(data) {
glog.V(6).Infof("timed read ends (read %v entries)", read)
log.Trace(fmt.Sprintf("timed read ends (read %v entries)", read))
break
}
}
@ -192,7 +191,7 @@ func (self *Journal) reset(n int) {
if n >= length-1 {
n = length - 1
}
glog.V(6).Infof("cursor reset from %v to %v/%v (%v)", self.cursor, n, len(self.Events), self.counter)
log.Trace(fmt.Sprintf("cursor reset from %v to %v/%v (%v)", self.cursor, n, len(self.Events), self.counter))
self.Events = self.Events[self.cursor:]
self.cursor = 0
}

9
p2p/simulations/mocker.go
View file

@ -7,8 +7,7 @@ import (
"time"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/adapters"
)
@ -26,7 +25,7 @@ func NewMockersController(eventer *event.TypeMux, defaultMockerConfig *MockerCon
if len(conf.Id) == 0 {
conf.Id = fmt.Sprintf("%d", parent.id)
}
glog.V(logger.Detail).Infof("new mocker controller on %v", conf.Id)
log.Trace(fmt.Sprintf("new mocker controller on %v", conf.Id))
if parent != nil {
parent.SetResource(conf.Id, c)
parent.id++
@ -127,7 +126,7 @@ func MockEvents(eventer *event.TypeMux, ids []*adapters.NodeId, conf *MockerConf
rounds := 0
for _ = range conf.ticker.C {
glog.V(logger.Detail).Infof("rates: %v/%v, %v (%v/%v)", switchonRate, dropoutRate, newConnCount, connFailRate, disconnRate)
log.Trace(fmt.Sprintf("rates: %v/%v, %v (%v/%v)", switchonRate, dropoutRate, newConnCount, connFailRate, disconnRate))
// here switchon rate will depend
nodesUp := len(offNodes) / switchonRate
missing := nodesTarget - len(onNodes)
@ -149,7 +148,7 @@ func MockEvents(eventer *event.TypeMux, ids []*adapters.NodeId, conf *MockerConf
}
}
connsDown := len(onConns) / disconnRate
glog.V(logger.Detail).Infof("Nodes Up: %v, Down: %v [ON: %v/%v]\nConns Up: %v, Down: %v [ON: %v/%v(%v)]", nodesUp, nodesDown, len(onNodes), len(onNodes)+len(offNodes), connsUp, connsDown, len(onConns), len(conns)-len(onConns), len(conns))
log.Trace(fmt.Sprintf("Nodes Up: %v, Down: %v [ON: %v/%v]\nConns Up: %v, Down: %v [ON: %v/%v(%v)]", nodesUp, nodesDown, len(onNodes), len(onNodes)+len(offNodes), connsUp, connsDown, len(onConns), len(conns)-len(onConns), len(conns)))
for i := 0; len(onNodes) > 0 && i < nodesDown; i++ {
c := rand.Intn(len(onNodes))

29
p2p/simulations/network.go
View file

@ -32,8 +32,7 @@ import (
"sync"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/adapters"
"github.com/ethereum/go-ethereum/p2p/discover"
)
@ -81,7 +80,7 @@ func NewNetworkController(net NetworkControl, nodesController *ResourceControlle
// GET /<networkId>/
Retrieve: &ResourceHandler{
Handle: func(msg interface{}, parent *ResourceController) (interface{}, error) {
glog.V(logger.Detail).Infof("msg: %v", msg)
log.Trace(fmt.Sprintf("msg: %v", msg))
cyConfig, ok := msg.(*CyConfig)
if ok {
return UpdateCy(cyConfig, journal)
@ -213,7 +212,7 @@ func (self *Network) SetNaf(naf func(*NodeConfig) adapters.NodeAdapter) {
// and launches a goroutine that reads control events from an eventer Subsription channel
// and executes the events
func (self *Network) Subscribe(eventer *event.TypeMux, types ...interface{}) {
glog.V(logger.Info).Infof("subscribe")
log.Info("subscribe")
sub := eventer.Subscribe(types...)
go func() {
defer sub.Unsubscribe()
@ -229,38 +228,38 @@ func (self *Network) Subscribe(eventer *event.TypeMux, types ...interface{}) {
}
func (self *Network) execute(in *event.TypeMuxEvent) {
glog.V(logger.Detail).Infof("execute event %v", in)
log.Trace(fmt.Sprintf("execute event %v", in))
ev := in.Data
if ne, ok := ev.(*NodeEvent); ok {
if ne.Action == "up" {
err := self.NewNode(&NodeConfig{Id: ne.node.Id})
if err != nil {
glog.V(logger.Detail).Infof("error execute event %v: %v", ne, err)
log.Trace(fmt.Sprintf("error execute event %v: %v", ne, err))
}
err = self.Start(ne.node.Id)
if err != nil {
glog.V(logger.Detail).Infof("error execute event %v: %v", ne, err)
log.Trace(fmt.Sprintf("error execute event %v: %v", ne, err))
}
} else {
err := self.Stop(ne.node.Id)
if err != nil {
glog.V(logger.Detail).Infof("error execute event %v: %v", ne, err)
log.Trace(fmt.Sprintf("error execute event %v: %v", ne, err))
}
}
} else if ce, ok := ev.(*ConnEvent); ok {
if ce.Action == "up" {
err := self.Connect(ce.conn.One, ce.conn.Other)
if err != nil {
glog.V(logger.Detail).Infof("error execute event %v: %v", ne, err)
log.Trace(fmt.Sprintf("error execute event %v: %v", ne, err))
}
} else {
err := self.Disconnect(ce.conn.One, ce.conn.Other)
if err != nil {
glog.V(logger.Detail).Infof("error execute event %v: %v", ne, err)
log.Trace(fmt.Sprintf("error execute event %v: %v", ne, err))
}
}
} else {
glog.V(logger.Detail).Infof("event: %#v", ev)
log.Trace(fmt.Sprintf("event: %#v", ev))
panic("unhandled event")
}
}
@ -418,7 +417,7 @@ func (self *Network) NewNode(conf *NodeConfig) error {
na: na,
}
self.Nodes = append(self.Nodes, node)
glog.V(6).Infof("node %v created", id)
log.Trace(fmt.Sprintf("node %v created", id))
return nil
}
@ -469,7 +468,7 @@ func (self *Network) Start(id *adapters.NodeId) error {
if node.Up {
return fmt.Errorf("node %v already up", id)
}
glog.V(6).Infof("starting node %v: %v adapter %v", id, node.Up, node.Adapter())
log.Trace(fmt.Sprintf("starting node %v: %v adapter %v", id, node.Up, node.Adapter()))
sa, ok := node.Adapter().(adapters.StartAdapter)
if ok {
err := sa.Start()
@ -478,7 +477,7 @@ func (self *Network) Start(id *adapters.NodeId) error {
}
}
node.Up = true
glog.V(logger.Info).Infof("started node %v: %v", id, node.Up)
log.Info(fmt.Sprintf("started node %v: %v", id, node.Up))
self.events.Post(&NodeEvent{
Action: "up",
@ -505,7 +504,7 @@ func (self *Network) Stop(id *adapters.NodeId) error {
}
}
node.Up = false
glog.V(logger.Info).Infof("stop node %v: %v", id, node.Up)
log.Info(fmt.Sprintf("stop node %v: %v", id, node.Up))
self.events.Post(&NodeEvent{
Action: "down",

9
p2p/simulations/rest_api_server.go
View file

@ -7,8 +7,7 @@ import (
"strings"
"time"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
)
type Controller interface {
@ -25,16 +24,16 @@ func StartRestApiServer(port string, c Controller) {
})
fd, err := net.Listen("tcp", ":"+port)
if err != nil {
glog.Errorf("Can't listen on :%s: %v", port, err)
log.Error(fmt.Sprintf("Can't listen on :%s: %v", port, err))
return
}
go http.Serve(fd, serveMux)
glog.V(logger.Info).Infof("Swarm Network Controller HTTP server started on localhost:%s", port)
log.Info(fmt.Sprintf("Swarm Network Controller HTTP server started on localhost:%s", port))
}
func handle(w http.ResponseWriter, r *http.Request, c Controller) {
requestURL := r.URL
glog.V(logger.Debug).Infof("HTTP %s request URL: '%s', Host: '%s', Path: '%s', Referer: '%s', Accept: '%s'", r.Method, r.RequestURI, requestURL.Host, requestURL.Path, r.Referer(), r.Header.Get("Accept"))
log.Debug(fmt.Sprintf("HTTP %s request URL: '%s', Host: '%s', Path: '%s', Referer: '%s', Accept: '%s'", r.Method, r.RequestURI, requestURL.Host, requestURL.Path, r.Referer(), r.Header.Get("Accept")))
uri := requestURL.Path
w.Header().Set("Content-Type", "text/json")
w.Header().Set("Access-Control-Allow-Origin", "*")

7
p2p/simulations/session_controller.go
View file

@ -10,8 +10,7 @@ import (
"sync"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/adapters"
)
@ -98,7 +97,7 @@ func NewSessionController(nethook func(*NetworkConfig) (NetworkControl, *Resourc
Handle: func(msg interface{}, parent *ResourceController) (interface{}, error) {
conf := msg.(*NetworkConfig)
netC, nodesC := nethook(conf)
glog.V(logger.Info).Infof("new network controller on %v", conf.Id)
log.Info(fmt.Sprintf("new network controller on %v", conf.Id))
m := NewNetworkController(netC, nodesC)
if parent != nil {
parent.SetResource(conf.Id, m)
@ -110,7 +109,7 @@ func NewSessionController(nethook func(*NetworkConfig) (NetworkControl, *Resourc
Destroy: &ResourceHandler{
Handle: func(msg interface{}, parent *ResourceController) (interface{}, error) {
glog.V(logger.Debug).Infof("destroy handler called")
log.Debug("destroy handler called")
// this can quit the entire app (shut down the backend server)
quitc <- true
return empty, nil

11
p2p/simulations/session_controller_test.go
View file

@ -7,11 +7,12 @@ import (
"io"
"io/ioutil"
"net/http"
"os"
"testing"
"time"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/adapters"
)
@ -27,8 +28,8 @@ var quitc chan bool
var controller *ResourceController
func init() {
glog.SetV(0)
glog.SetToStderr(true)
log.Root().SetHandler(log.LvlFilterHandler(log.LvlError, log.StreamHandler(os.Stderr, log.TerminalFormat(false))))
controller, quitc = NewSessionController(DefaultNet)
StartRestApiServer(port, controller)
}
@ -160,9 +161,9 @@ func TestUpdate(t *testing.T) {
}
func mockNewNodes(eventer *event.TypeMux, ids []*adapters.NodeId) {
glog.V(6).Infof("mock starting")
log.Trace("mock starting")
for _, id := range ids {
glog.V(6).Infof("mock adding node %v", id)
log.Trace(fmt.Sprintf("mock adding node %v", id))
eventer.Post(&NodeEvent{
Action: "up",
Type: "node",

7
p2p/testing/peerpool.go
View file

@ -1,11 +1,10 @@
package testing
import (
"fmt"
"sync"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/adapters"
"github.com/ethereum/go-ethereum/p2p/discover"
)
@ -28,7 +27,7 @@ func NewTestPeerPool() *TestPeerPool {
func (self *TestPeerPool) Add(p TestPeer) {
self.lock.Lock()
defer self.lock.Unlock()
glog.V(logger.Detail).Infof("pp add peer %v", p.ID())
log.Trace(fmt.Sprintf("pp add peer %v", p.ID()))
self.peers[p.ID()] = p
}

15
p2p/testing/protocolsession.go
View file

@ -5,8 +5,7 @@ import (
"sync"
"time"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/adapters"
)
@ -78,9 +77,9 @@ func (self *ProtocolSession) trigger(trig Trigger) error {
errc := make(chan error)
go func() {
glog.V(logger.Detail).Infof("trigger %v (%v)....", trig.Msg, trig.Code)
log.Trace(fmt.Sprintf("trigger %v (%v)....", trig.Msg, trig.Code))
errc <- p2p.Send(peer, trig.Code, trig.Msg)
glog.V(logger.Detail).Infof("triggered %v (%v)", trig.Msg, trig.Code)
log.Trace(fmt.Sprintf("triggered %v (%v)", trig.Msg, trig.Code))
}()
t := trig.Timeout
@ -111,7 +110,7 @@ func (self *ProtocolSession) expect(exp Expect) error {
errc := make(chan error)
go func() {
glog.V(logger.Detail).Infof("waiting for msg, %v", exp.Msg)
log.Trace(fmt.Sprintf("waiting for msg, %v", exp.Msg))
errc <- p2p.ExpectMsg(peer, exp.Code, exp.Msg)
}()
@ -122,7 +121,7 @@ func (self *ProtocolSession) expect(exp Expect) error {
alarm := time.NewTimer(t)
select {
case err := <-errc:
glog.V(logger.Detail).Infof("expected msg arrives with error %v", err)
log.Trace(fmt.Sprintf("expected msg arrives with error %v", err))
return err
case <-alarm.C:
return fmt.Errorf("timout expecting %v sent to peer %v", exp.Msg, exp.Peer)
@ -158,7 +157,7 @@ func (self *ProtocolSession) TestExchanges(exchanges ...Exchange) error {
defer wg.Done()
err := self.expect(exp)
if err != nil {
glog.V(logger.Detail).Infof("expect msg fails %v", err)
log.Trace(fmt.Sprintf("expect msg fails %v", err))
errc <- err
}
}(ex)
@ -178,7 +177,7 @@ func (self *ProtocolSession) TestExchanges(exchanges ...Exchange) error {
if err != nil {
return fmt.Errorf("exchange failed with: %v", err)
} else {
glog.V(logger.Detail).Infof("exchange %v: '%v' run successfully", i, e.Label)
log.Trace(fmt.Sprintf("exchange %v: '%v' run successfully", i, e.Label))
}
case <-alarm.C:
return fmt.Errorf("exchange %v: '%v' timed out", i, e.Label)

18
p2p/testing/protocoltester.go
View file

@ -1,10 +1,10 @@
package testing
import (
"fmt"
"testing"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/adapters"
"github.com/ethereum/go-ethereum/p2p/simulations"
)
@ -21,7 +21,7 @@ func NewProtocolTester(t *testing.T, id *adapters.NodeId, n int, run adapters.Pr
naf := func(conf *simulations.NodeConfig) adapters.NodeAdapter {
na := adapters.NewSimNode(conf.Id, net)
if conf.Id.NodeID == id.NodeID {
glog.V(logger.Detail).Infof("adapter run function set to protocol for node %v (=%v)", conf.Id, id)
log.Trace(fmt.Sprintf("adapter run function set to protocol for node %v (=%v)", conf.Id, id))
na.Run = run
}
return na
@ -56,11 +56,11 @@ func (self *ProtocolTester) Start(id *adapters.NodeId) error {
}
node := self.network.GetNode(id)
if node == nil {
glog.V(logger.Detail).Infof("node for peer %v not found", id)
log.Trace(fmt.Sprintf("node for peer %v not found", id))
return nil
}
if node.Adapter() == nil {
glog.V(logger.Detail).Infof("node adapter for peer %v not found", id)
log.Trace(fmt.Sprintf("node adapter for peer %v not found", id))
return nil
}
return nil
@ -68,15 +68,15 @@ func (self *ProtocolTester) Start(id *adapters.NodeId) error {
func (self *ProtocolTester) Connect(ids ...*adapters.NodeId) {
for _, id := range ids {
glog.V(logger.Detail).Infof("start node %v", id)
log.Trace(fmt.Sprintf("start node %v", id))
err := self.Start(id)
if err != nil {
glog.V(logger.Detail).Infof("error starting peer %v: %v", id, err)
log.Trace(fmt.Sprintf("error starting peer %v: %v", id, err))
}
glog.V(logger.Detail).Infof("connect to %v", id)
log.Trace(fmt.Sprintf("connect to %v", id))
err = self.na.Connect(id.Bytes())
if err != nil {
glog.V(logger.Detail).Infof("error connecting to peer %v: %v", id, err)
log.Trace(fmt.Sprintf("error connecting to peer %v: %v", id, err))
}
}

37
pot/pot_test.go
View file

@ -19,13 +19,13 @@ import (
"errors"
"fmt"
"math/rand"
"os"
"runtime"
"sync"
"testing"
"time"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
)
const (
@ -34,8 +34,7 @@ const (
)
func init() {
glog.SetV(0)
glog.SetToStderr(true)
log.Root().SetHandler(log.LvlFilterHandler(log.LvlError, log.StreamHandler(os.Stderr, log.TerminalFormat(false))))
}
type testBVAddr struct {
@ -303,7 +302,7 @@ func TestPotMergeOne(t *testing.T) {
pot1.Add(NewTestAddr("00", 0))
pot2 := NewPot(nil, 0)
pot2.Add(NewTestAddr("01", 0))
glog.V(logger.Debug).Infof("\n%v\n%v", pot2, pot1)
log.Debug(fmt.Sprintf("\n%v\n%v", pot2, pot1))
pot1.Merge(pot2)
count := 0
pot1.Each(func(val PotVal, i int) bool {
@ -326,7 +325,7 @@ func TestPotMergeCommon(t *testing.T) {
max1 := rand.Intn(mergeTestChoose) + 1
n0 := NewPot(nil, 0)
n1 := NewPot(nil, 0)
glog.V(3).Infof("round %v: %v - %v", i, max0, max1)
log.Trace(fmt.Sprintf("round %v: %v - %v", i, max0, max1))
m := make(map[string]bool)
for j := 0; j < max0; {
r := rand.Intn(max0)
@ -357,9 +356,9 @@ func TestPotMergeCommon(t *testing.T) {
continue
}
expSize := len(m)
glog.V(4).Infof("%v-0: pin: %v, size: %v", i, n0.Pin(), max0)
glog.V(4).Infof("%v-1: pin: %v, size: %v", i, n1.Pin(), max1)
glog.V(4).Infof("%v: merged tree size: %v, newly added: %v", i, expSize, expAdded)
log.Trace(fmt.Sprintf("%v-0: pin: %v, size: %v", i, n0.Pin(), max0))
log.Trace(fmt.Sprintf("%v-1: pin: %v, size: %v", i, n1.Pin(), max1))
log.Trace(fmt.Sprintf("%v: merged tree size: %v, newly added: %v", i, expSize, expAdded))
n, common := Union(n0, n1)
added := n1.Size() - common
size := n.Size()
@ -388,7 +387,7 @@ func TestPotMergeScale(t *testing.T) {
max1 := rand.Intn(maxEachNeighbour) + 1
n0 := NewPot(nil, 0)
n1 := NewPot(nil, 0)
glog.V(3).Infof("round %v: %v - %v", i, max0, max1)
log.Trace(fmt.Sprintf("round %v: %v - %v", i, max0, max1))
m := make(map[string]bool)
for j := 0; j < max0; {
v := randomTestBVAddr(keylen, j)
@ -418,9 +417,9 @@ func TestPotMergeScale(t *testing.T) {
continue
}
expSize := len(m)
glog.V(4).Infof("%v-0: pin: %v, size: %v", i, n0.Pin(), max0)
glog.V(4).Infof("%v-1: pin: %v, size: %v", i, n1.Pin(), max1)
glog.V(4).Infof("%v: merged tree size: %v, newly added: %v", i, expSize, expAdded)
log.Trace(fmt.Sprintf("%v-0: pin: %v, size: %v", i, n0.Pin(), max0))
log.Trace(fmt.Sprintf("%v-1: pin: %v, size: %v", i, n1.Pin(), max1))
log.Trace(fmt.Sprintf("%v: merged tree size: %v, newly added: %v", i, expSize, expAdded))
n, common := Union(n0, n1)
added := n1.Size() - common
size := n.Size()
@ -476,7 +475,7 @@ func TestPotEachNeighbourSync(t *testing.T) {
}
count := rand.Intn(size/2) + size/2
val := randomTestAddr(keylen, max+1)
glog.V(3).Infof("%v: pin: %v, size: %v, val: %v, count: %v", i, n.Pin(), size, val, count)
log.Trace(fmt.Sprintf("%v: pin: %v, size: %v, val: %v, count: %v", i, n.Pin(), size, val, count))
err := testPotEachNeighbour(n, val, count, checkPo(val), checkOrder(val), checkValues(m, val))
if err != nil {
t.Fatal(err)
@ -525,16 +524,16 @@ func TestPotEachNeighbourAsync(t *testing.T) {
mu := sync.Mutex{}
m := make(map[string]bool)
maxPos := rand.Intn(keylen)
glog.V(3).Infof("%v: pin: %v, size: %v, val: %v, count: %v, maxPos: %v", i, n.Pin(), size, val, count, maxPos)
log.Trace(fmt.Sprintf("%v: pin: %v, size: %v, val: %v, count: %v, maxPos: %v", i, n.Pin(), size, val, count, maxPos))
msize := 0
remember := func(v PotVal, po int) error {
// mu.Lock()
// defer mu.Unlock()
if po > maxPos {
// glog.V(4).Infof("NOT ADD %v", v)
// log.Trace(fmt.Sprintf("NOT ADD %v", v))
return errNoCount
}
// glog.V(4).Infof("ADD %v, %v", v, msize)
// log.Trace(fmt.Sprintf("ADD %v, %v", v, msize))
m[v.String()] = true
msize++
return nil
@ -544,14 +543,14 @@ func TestPotEachNeighbourAsync(t *testing.T) {
}
err := testPotEachNeighbour(n, val, count, remember)
if err != nil {
glog.V(6).Info(err)
log.Error(err.Error())
}
d := 0
forget := func(v PotVal, po int) {
mu.Lock()
defer mu.Unlock()
d++
// glog.V(4).Infof("DEL %v", v)
// log.Trace(fmt.Sprintf("DEL %v", v))
delete(m, v.String())
}

22
swarm/network/discovery.go
View file

@ -3,9 +3,7 @@ package network
import (
"fmt"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
// "github.com/ethereum/go-ethereum/p2p/discover"
"github.com/ethereum/go-ethereum/log"
)
// discovery bzz overlay extension doing peer relaying
@ -46,11 +44,11 @@ func NewDiscovery(p Peer, o Overlay) *discPeer {
// NotifyPeer notifies the receiver remote end of a peer p or PO po.
// callback for overlay driver
func (self *discPeer) NotifyPeer(p Peer, po uint8) error {
glog.V(logger.Warn).Infof("peers %v", self.peers)
log.Warn(fmt.Sprintf("peers %v", self.peers))
if po < self.proxLimit || self.seen(p) {
return nil
}
glog.V(logger.Warn).Infof("notification about %x", p.OverlayAddr())
log.Warn(fmt.Sprintf("notification about %x", p.OverlayAddr()))
resp := &peersMsg{
Peers: []*peerAddr{&peerAddr{OAddr: p.OverlayAddr(), UAddr: p.UnderlayAddr()}}, // perhaps the PeerAddr interface is unnecessary generalization
@ -125,7 +123,7 @@ func (self *discPeer) handleSubPeersMsg(msg interface{}) error {
peers = append(peers, &peerAddr{p.OverlayAddr(), p.UnderlayAddr()})
return true
})
glog.V(logger.Warn).Infof("found initial %v peers not farther than %v", len(peers), self.proxLimit)
log.Warn(fmt.Sprintf("found initial %v peers not farther than %v", len(peers), self.proxLimit))
if len(peers) > 0 {
self.Send(&peersMsg{Peers: peers})
}
@ -147,10 +145,10 @@ func (self *discPeer) handlePeersMsg(msg interface{}) error {
}
if len(nas) == 0 {
glog.V(logger.Debug).Infof("whoops, no peers in incoming peersMsg from %v", self)
log.Debug(fmt.Sprintf("whoops, no peers in incoming peersMsg from %v", self))
return nil
}
glog.V(logger.Debug).Infof("got peer addresses from %x, %v (%v)", self.OverlayAddr(), nas, len(nas))
log.Debug(fmt.Sprintf("got peer addresses from %x, %v (%v)", self.OverlayAddr(), nas, len(nas)))
return self.overlay.Register(nas...)
}
@ -172,10 +170,10 @@ func (self *discPeer) handleGetPeersMsg(msg interface{}) error {
return len(peers) < int(req.Max)
})
if len(peers) == 0 {
glog.V(logger.Debug).Infof("no peers found for %v", self)
log.Debug(fmt.Sprintf("no peers found for %v", self))
return nil
}
glog.V(logger.Debug).Infof("%v peers sent to %v", len(peers), self)
log.Debug(fmt.Sprintf("%v peers sent to %v", len(peers), self))
resp := &peersMsg{
Peers: peers,
}
@ -190,7 +188,7 @@ func RequestOrder(k Overlay, order, broadcastSize, maxPeers uint8) {
var i uint8
var err error
k.EachLivePeer(nil, 255, func(n Peer, po int) bool {
glog.V(logger.Detail).Infof("%T sent to %v", req, n.ID())
log.Trace(fmt.Sprintf("%T sent to %v", req, n.ID()))
err = n.Send(req)
if err == nil {
i++
@ -200,7 +198,7 @@ func RequestOrder(k Overlay, order, broadcastSize, maxPeers uint8) {
}
return true
})
glog.V(logger.Info).Infof("requesting bees of PO%03d from %v/%v (each max %v)", order, i, broadcastSize, maxPeers)
log.Info(fmt.Sprintf("requesting bees of PO%03d from %v/%v (each max %v)", order, i, broadcastSize, maxPeers))
}
func (self *discPeer) seen(p PeerAddr) bool {

6
swarm/network/discovery_test.go
View file

@ -1,10 +1,10 @@
package network
import (
"fmt"
"testing"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
p2ptest "github.com/ethereum/go-ethereum/p2p/testing"
)
@ -21,7 +21,7 @@ func TestDiscovery(t *testing.T) {
services := func(p Peer) error {
dp := NewDiscovery(p, to)
to.On(dp)
glog.V(logger.Detail).Infof("kademlia on %v", p)
log.Trace(fmt.Sprintf("kademlia on %v", p))
p.DisconnectHook(func(err error) {
to.Off(p)
})

32
swarm/network/hive.go
View file

@ -17,11 +17,11 @@
package network
import (
"fmt"
"sync"
"time"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/adapters"
"github.com/ethereum/go-ethereum/p2p/discover"
)
@ -97,7 +97,7 @@ func (self *Hive) Start(connectPeer func(string) error, af func() <-chan time.Ti
self.toggle = make(chan bool)
self.more = make(chan bool, 1)
self.quit = make(chan bool)
glog.V(logger.Debug).Infof("hive started")
log.Debug("hive started")
// this loop is doing bootstrapping and maintains a healthy table
go self.keepAlive(af)
go func() {
@ -108,17 +108,17 @@ func (self *Hive) Start(connectPeer func(string) error, af func() <-chan time.Ti
// to attempt to write to more (remove Peer when shutting down)
return
}
glog.V(logger.Detail).Infof("hive delegate to overlay driver: suggest addr to connect to")
log.Trace("hive delegate to overlay driver: suggest addr to connect to")
addr, order, want := self.SuggestPeer()
if addr != nil {
glog.V(logger.Info).Infof("========> connect to bee %v", addr)
log.Info(fmt.Sprintf("========> connect to bee %v", addr))
err := connectPeer(NodeId(addr).NodeID.String())
if err != nil {
glog.V(logger.Detail).Infof("===X====> connect to bee %v failed: %v", addr, err)
log.Error(fmt.Sprintf("===X====> connect to bee %v failed: %v", addr, err))
}
} else {
glog.V(logger.Detail).Infof("cannot suggest peers")
log.Trace("cannot suggest peers")
}
want = want && self.Discovery
@ -128,11 +128,11 @@ func (self *Hive) Start(connectPeer func(string) error, af func() <-chan time.Ti
select {
case self.toggle <- want:
glog.V(logger.Detail).Infof("keep hive alive: %v", want)
log.Trace(fmt.Sprintf("keep hive alive: %v", want))
case <-self.quit:
return
}
glog.V(logger.Info).Infof("%v", self)
log.Info(fmt.Sprintf("%v", self))
}
}()
return nil
@ -148,12 +148,12 @@ func (self *Hive) ticker() <-chan time.Time {
// wake state is toggled by writing to self.toggle
// it restarts if the table becomes non-full again due to disconnections
func (self *Hive) keepAlive(af func() <-chan time.Time) {
glog.V(logger.Detail).Infof("keep alive loop started")
log.Trace("keep alive loop started")
alarm := af()
for {
select {
case <-alarm:
glog.V(logger.Detail).Infof("wake up: make hive alive")
log.Trace("wake up: make hive alive")
self.wake()
case need := <-self.toggle:
if alarm == nil && need {
@ -174,17 +174,17 @@ func (self *Hive) keepAlive(af func() <-chan time.Time) {
func (self *Hive) Add(p Peer) error {
defer self.wake()
dp := NewDiscovery(p, self.Overlay)
glog.V(logger.Debug).Infof("to add new bee %v", p)
log.Debug(fmt.Sprintf("to add new bee %v", p))
self.On(dp)
self.String()
glog.V(logger.Warn).Infof("%v", self)
log.Debug(fmt.Sprintf("%v", self))
return nil
}
// Remove called after peer is disconnected
func (self *Hive) Remove(p Peer) {
defer self.wake()
glog.V(logger.Debug).Infof("remove bee %v", p)
log.Debug(fmt.Sprintf("remove bee %v", p))
self.Off(p)
}
@ -212,10 +212,10 @@ func (self *Hive) Stop() {
func (self *Hive) wake() {
select {
case self.more <- true:
glog.V(logger.Detail).Infof("hive woken up")
log.Trace("hive woken up")
case <-self.quit:
default:
glog.V(logger.Detail).Infof("hive already awake")
log.Trace("hive already awake")
}
}

37
swarm/network/kademlia.go
View file

@ -22,8 +22,7 @@ import (
"strings"
"time"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/pot"
)
@ -118,7 +117,7 @@ func NewKademlia(addr []byte, params *KadParams) *Kademlia {
func (self *Kademlia) Prune(c <-chan time.Time) {
go func() {
for _ = range c {
glog.V(logger.Debug).Infof("pruning...")
log.Debug("pruning...")
total := 0
self.peers.EachBin(self.addr, 0, func(po, size int, f func(func(pot.PotVal, int) bool) bool) bool {
extra := size - self.MinBinSize
@ -136,7 +135,7 @@ func (self *Kademlia) Prune(c <-chan time.Time) {
}
return true
})
glog.V(logger.Debug).Infof("pruned %v peers", total)
log.Debug(fmt.Sprintf("pruned %v peers", total))
}
}()
}
@ -166,25 +165,25 @@ func (self *Kademlia) callable(val pot.PotVal) *KadPeer {
kp := val.(*KadPeer)
// not callable if peer is live or exceeded maxRetries
if kp.Peer != nil || kp.retries > self.MaxRetries {
glog.V(logger.Detail).Infof("peer %v (%T) not callable", kp, kp.Peer)
log.Trace(fmt.Sprintf("peer %v (%T) not callable", kp, kp.Peer))
return nil
}
// calculate the allowed number of retries based on time lapsed since last seen
timeAgo := time.Since(kp.seenAt)
var retries int
for delta := int(timeAgo) / self.RetryInterval; delta > 0; delta /= self.RetryExponent {
glog.V(logger.Detail).Infof("delta: %v", delta)
log.Trace(fmt.Sprintf("delta: %v", delta))
retries++
}
// this is never called concurrently, so safe to increment
// peer can be retried again
if retries < kp.retries {
glog.V(logger.Detail).Infof("log time needed before retry %v, wait only warrants %v", kp.retries, retries)
log.Trace(fmt.Sprintf("log time needed before retry %v, wait only warrants %v", kp.retries, retries))
return nil
}
kp.retries++
glog.V(logger.Detail).Infof("peer %v is callable", kp)
log.Trace(fmt.Sprintf("peer %v is callable", kp))
return kp
}
@ -204,7 +203,7 @@ func (self *Kademlia) Register(nas ...PeerAddr) error {
np := pot.NewPot(nil, 0)
for _, na := range nas {
if bytes.Equal(na.OverlayAddr(), self.addr.OverlayAddr()) {
glog.V(logger.Warn).Infof("[%06s] add peers: %x is self.. skipped ", label, self.addr.OverlayAddr())
log.Warn(fmt.Sprintf("[%06s] add peers: %x is self.. skipped ", label, self.addr.OverlayAddr()))
continue
}
p := NewKadPeer(na)
@ -217,7 +216,7 @@ func (self *Kademlia) Register(nas ...PeerAddr) error {
self.peers.Each(func(val pot.PotVal, i int) bool {
_, found := m[val.String()]
// TODO: remove this check
// glog.V(logger.Debug).Infof("-> %v %v", val, i)
// log.Debug(fmt.Sprintf("-> %v %v", val, i))
if found {
panic("duplicate found")
}
@ -249,19 +248,19 @@ func (self *Kademlia) On(p Peer) {
vp, ok := kp.Peer.(KadDiscovery)
if !ok {
glog.V(logger.Detail).Infof("not discovery peer %T", kp)
log.Trace(fmt.Sprintf("not discovery peer %T", kp))
return
}
go vp.NotifyProx(uint8(prox))
f := func(val pot.PotVal, po int) {
dp := val.(*KadPeer).Peer.(KadDiscovery)
glog.V(logger.Debug).Infof("peer %v notified of %v (%v)", dp, kp, po)
log.Debug(fmt.Sprintf("peer %v notified of %v (%v)", dp, kp, po))
dp.NotifyPeer(kp.Peer, uint8(po))
if uint8(prox) != self.lastProxLimit {
self.lastProxLimit = uint8(prox)
dp.NotifyProx(uint8(prox))
}
glog.V(logger.Debug).Infof("peer notified")
log.Debug("peer notified")
}
self.conns.EachNeighbourAsync(kp, 1024, 255, f, false)
}
@ -349,7 +348,7 @@ func (self *Kademlia) SuggestPeer() (p PeerAddr, o int, want bool) {
proxLimit := self.proxLimit()
// if there is a callable neighbour within the current proxBin, connect
// this makes sure nearest neighbour set is fully connected
glog.V(logger.Detail).Infof("candidate prox peer checking above PO %v", proxLimit)
log.Trace(fmt.Sprintf("candidate prox peer checking above PO %v", proxLimit))
var ppo int
self.peers.EachNeighbour(self.addr, func(val pot.PotVal, po int) bool {
r := self.callable(val)
@ -361,15 +360,15 @@ func (self *Kademlia) SuggestPeer() (p PeerAddr, o int, want bool) {
return false
})
if p != nil {
glog.V(logger.Detail).Infof("candidate prox peer found: %v (%v), %v", p, ppo, p)
log.Trace(fmt.Sprintf("candidate prox peer found: %v (%v), %v", p, ppo, p))
return p, 0, false
}
glog.V(logger.Detail).Infof("no candidate prox peers to connect to (ProxLimit: %v, minProxSize: %v)", proxLimit, self.MinProxBinSize)
log.Trace(fmt.Sprintf("no candidate prox peers to connect to (ProxLimit: %v, minProxSize: %v)", proxLimit, self.MinProxBinSize))
var bpo []int
prev := -1
self.conns.EachBin(self.addr, 0, func(po, size int, f func(func(val pot.PotVal, i int) bool) bool) bool {
glog.V(logger.Detail).Infof("check PO%02d: ", po)
log.Trace(fmt.Sprintf("check PO%02d: ", po))
prev++
if po > prev {
size = 0
@ -395,7 +394,7 @@ func (self *Kademlia) SuggestPeer() (p PeerAddr, o int, want bool) {
// for each bin we find callable candidate peers
f(func(val pot.PotVal, i int) bool {
r := self.callable(val)
glog.V(logger.Detail).Infof("check PO%02d: ", po)
log.Trace(fmt.Sprintf("check PO%02d: ", po))
if r == nil {
return i < proxLimit
}
@ -472,7 +471,7 @@ func (self *Kademlia) String() string {
rowlen++
return rowlen < 4
})
// glog.V(logger.Debug).Infof("po: %v, peerrows length: %v, maxProxDisplay: %v", po, len(peersrows), self.MaxProxDisplay)
// log.Debug(fmt.Sprintf("po: %v, peerrows length: %v, maxProxDisplay: %v", po, len(peersrows), self.MaxProxDisplay))
// if po < self.MaxProxDisplay {
// peersrows[po] = strings.Join(row, " ")
// }

7
swarm/network/kademlia_test.go
View file

@ -21,8 +21,7 @@ import (
"testing"
"time"
// "github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/pot"
)
@ -111,7 +110,7 @@ func (k *testKademlia) newTestKadPeer(s string) Peer {
}
func overlayStr(a PeerAddr) string {
glog.V(6).Infof("PeerAddr: %v (%T)", a, a)
log.Error(fmt.Sprintf("PeerAddr: %v (%T)", a, a))
// if a == (*KadPeer)(nil) || a == (*testDiscPeer)(nil) || a == (*bzzPeer)(nil) || a == nil {
// return "<nil>"
// }
@ -122,7 +121,7 @@ func overlayStr(a PeerAddr) string {
// } else {
// p = a.(*testDiscPeer).Peer
// }
// glog.V(6).Infof("PeerAddr: %v (%T)", p, p)
// log.Error(fmt.Sprintf("PeerAddr: %v (%T)", p, p))
// if p == (Peer)(nil) || p == (*testDiscPeer)(nil) || p == (*bzzPeer)(nil) {
// return "<nil>"
// }

10
swarm/network/protocol.go
View file

@ -21,7 +21,7 @@ import (
"time"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/adapters"
"github.com/ethereum/go-ethereum/p2p/discover"
@ -87,7 +87,7 @@ func Bzz(oAddr, uAddr []byte, ct *protocols.CodeMap, services func(Peer) error,
// sets remote peer address
err := bee.bzzHandshake()
if err != nil {
glog.V(6).Infof("handshake error in peer %v: %v", bee.ID(), err)
log.Error(fmt.Sprintf("handshake error in peer %v: %v", bee.ID(), err))
return err
}
@ -95,7 +95,7 @@ func Bzz(oAddr, uAddr []byte, ct *protocols.CodeMap, services func(Peer) error,
if services != nil {
err = services(bee)
if err != nil {
glog.V(6).Infof("protocol service error for peer %v: %v", bee.ID(), err)
log.Error(fmt.Sprintf("protocol service error for peer %v: %v", bee.ID(), err))
return err
}
}
@ -183,7 +183,7 @@ func (self *bzzPeer) bzzHandshake() error {
hs, err := self.Handshake(lhs)
if err != nil {
glog.V(6).Infof("handshake failed: %v", err)
log.Error(fmt.Sprintf("handshake failed: %v", err))
return err
}
@ -191,7 +191,7 @@ func (self *bzzPeer) bzzHandshake() error {
self.peerAddr = rhs.Addr
err = checkBzzHandshake(rhs)
if err != nil {
glog.V(6).Infof("handshake between %v and %v failed: %v", self.localAddr, self.peerAddr, err)
log.Error(fmt.Sprintf("handshake between %v and %v failed: %v", self.localAddr, self.peerAddr, err))
return err
}

5
swarm/network/protocol_test.go
View file

@ -4,8 +4,7 @@ import (
"fmt"
"testing"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/adapters"
"github.com/ethereum/go-ethereum/p2p/protocols"
p2ptest "github.com/ethereum/go-ethereum/p2p/testing"
@ -166,7 +165,7 @@ func TestBzzPeerPoolAdd(t *testing.T) {
defer s.Stop()
id := s.Ids[0]
glog.V(logger.Detail).Infof("handshake with %v", id)
log.Trace(fmt.Sprintf("handshake with %v", id))
s.runHandshakes()
if !pp.Has(id) {

19
swarm/network/pss.go
View file

@ -1,30 +1,29 @@
package network
import (
"fmt"
"bytes"
"fmt"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
)
type Pss struct {
Overlay
LocalAddr []byte
C chan []byte
LocalAddr []byte
C chan []byte
}
func NewPss(k Overlay, addr []byte) *Pss {
return &Pss{
Overlay: k,
Overlay: k,
LocalAddr: addr,
C: make(chan []byte),
C: make(chan []byte),
}
}
type PssMsg struct {
To []byte
Data []byte
Data []byte
}
func (pm *PssMsg) String() string {
@ -35,7 +34,7 @@ func (ps *Pss) HandlePssMsg(msg interface{}) error {
pssmsg := msg.(*PssMsg)
to := pssmsg.To
if bytes.Equal(to, ps.LocalAddr) {
glog.V(logger.Detail).Infof("Pss to us, yay!", to)
log.Trace(fmt.Sprintf("Pss to us, yay! %v", to))
ps.C <- pssmsg.Data
return nil
}
@ -47,6 +46,6 @@ func (ps *Pss) HandlePssMsg(msg interface{}) error {
}
return false
})
return nil
}

2
swarm/network/pss_test.go
View file

@ -5,8 +5,6 @@ import (
"testing"
"time"
//"github.com/ethereum/go-ethereum/logger"
//"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/p2p/adapters"
"github.com/ethereum/go-ethereum/p2p/protocols"
"github.com/ethereum/go-ethereum/p2p/simulations"

17
swarm/network/simulations/overlay.go
View file

@ -6,13 +6,14 @@
package main
import (
"fmt"
"math/rand"
"os"
"reflect"
"runtime"
"time"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/adapters"
"github.com/ethereum/go-ethereum/p2p/simulations"
@ -79,7 +80,7 @@ func (self *Network) NewSimNode(conf *simulations.NodeConfig) adapters.NodeAdapt
services := func(p network.Peer) error {
dp := network.NewDiscovery(p, to)
pp.Add(dp)
glog.V(logger.Detail).Infof("kademlia on %v", dp)
log.Trace(fmt.Sprintf("kademlia on %v", dp))
p.DisconnectHook(func(err error) {
pp.Remove(dp)
})
@ -138,7 +139,7 @@ func nethook(conf *simulations.NetworkConfig) (simulations.NetworkControl, *simu
time.Sleep(time.Duration(n) * time.Millisecond)
net.NewNode(&simulations.NodeConfig{Id: id})
net.Start(id)
glog.V(logger.Debug).Infof("node %v starting up", id)
log.Debug(fmt.Sprintf("node %v starting up", id))
// time.Sleep(1000 * time.Millisecond)
// net.Stop(id)
}
@ -150,12 +151,12 @@ func nethook(conf *simulations.NetworkConfig) (simulations.NetworkControl, *simu
// // n := rand.Intn(5000)
// // n := 3000
// time.Sleep(time.Duration(n) * time.Millisecond)
// glog.V(logger.Debug).Infof("node %v shutting down", id)
// log.Debug(fmt.Sprintf("node %v shutting down", id))
// net.Stop(id)
// // n = rand.Intn(5000)
// n = 2000
// time.Sleep(time.Duration(n) * time.Millisecond)
// glog.V(logger.Debug).Infof("node %v starting up", id)
// log.Debug(fmt.Sprintf("node %v starting up", id))
// net.Start(id)
// n = 5000
// }
@ -178,8 +179,8 @@ func nethook(conf *simulations.NetworkConfig) (simulations.NetworkControl, *simu
// var server
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
glog.SetV(logger.Detail)
glog.SetToStderr(true)
log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(false))))
c, quitc := simulations.NewSessionController(nethook)

10
swarm/network/test_overlay.go
View file

@ -5,9 +5,7 @@ import (
"strings"
"sync"
// "github.com/ethereum/go-ethereum/p2p/adapters"
// "github.com/ethereum/go-ethereum/p2p/discover"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/log"
)
const orders = 8
@ -39,7 +37,7 @@ func (self *testOverlay) register(nas ...PeerAddr) error {
}
self.posMap[string(addr)] = tna
o := order(addr)
glog.V(6).Infof("PO: %v, orders: %v", o, orders)
log.Trace(fmt.Sprintf("PO: %v, orders: %v", o, orders))
self.pos[o] = append(self.pos[o], tna)
}
return nil
@ -60,7 +58,7 @@ func (self *testOverlay) On(n Peer) {
} else if na.Peer != nil {
return
}
glog.V(6).Infof("Online: %v", fmt.Sprintf("%x", addr[:4]))
log.Trace(fmt.Sprintf("Online: %x", addr[:4]))
na.Peer = n
return
}
@ -133,7 +131,7 @@ func (self *testOverlay) SuggestPeer() (PeerAddr, int, bool) {
if len(ons) < 2 {
offs := self.off(po)
if len(offs) > 0 {
glog.V(6).Infof("node %v is off", offs[0])
log.Trace(fmt.Sprintf("node %v is off", offs[0]))
return offs[0], i, true
}
}