p2p: use cmn instead of .

p2p/addrbook.go

@@ -14,8 +14,8 @@ import (
 	"sync"
 	"time"
 
-	. "github.com/tendermint/tmlibs/common"
 	crypto "github.com/tendermint/go-crypto"
+	cmn "github.com/tendermint/tmlibs/common"
 )
 
 const (
@@ -80,7 +80,7 @@ const (
 
 // AddrBook - concurrency safe peer address manager.
 type AddrBook struct {
-	BaseService
+	cmn.BaseService
 
 	mtx               sync.Mutex
 	filePath          string
@@ -107,7 +107,7 @@ func NewAddrBook(filePath string, routabilityStrict bool) *AddrBook {
 		routabilityStrict: routabilityStrict,
 	}
 	am.init()
-	am.BaseService = *NewBaseService(log, "AddrBook", am)
+	am.BaseService = *cmn.NewBaseService(log, "AddrBook", am)
 	return am
 }
 
@@ -214,7 +214,7 @@ func (a *AddrBook) PickAddress(newBias int) *NetAddress {
 			}
 			randIndex--
 		}
-		PanicSanity("Should not happen")
+		cmn.PanicSanity("Should not happen")
 	} else {
 		// pick random New bucket.
 		var bucket map[string]*knownAddress = nil
@@ -229,7 +229,7 @@ func (a *AddrBook) PickAddress(newBias int) *NetAddress {
 			}
 			randIndex--
 		}
-		PanicSanity("Should not happen")
+		cmn.PanicSanity("Should not happen")
 	}
 	return nil
 }
@@ -293,10 +293,10 @@ func (a *AddrBook) GetSelection() []*NetAddress {
 		i++
 	}
 
-	numAddresses := MaxInt(
-		MinInt(minGetSelection, len(allAddr)),
+	numAddresses := cmn.MaxInt(
+		cmn.MinInt(minGetSelection, len(allAddr)),
 		len(allAddr)*getSelectionPercent/100)
-	numAddresses = MinInt(maxGetSelection, numAddresses)
+	numAddresses = cmn.MinInt(maxGetSelection, numAddresses)
 
 	// Fisher-Yates shuffle the array. We only need to do the first
 	// `numAddresses' since we are throwing the rest.
@@ -338,14 +338,14 @@ func (a *AddrBook) saveToFile(filePath string) {
 		log.Error("Failed to save AddrBook to file", "err", err)
 		return
 	}
-	err = WriteFileAtomic(filePath, jsonBytes, 0644)
+	err = cmn.WriteFileAtomic(filePath, jsonBytes, 0644)
 	if err != nil {
 		log.Error("Failed to save AddrBook to file", "file", filePath, "error", err)
 	}
 }
 
 // Returns false if file does not exist.
-// Panics if file is corrupt.
+// cmn.Panics if file is corrupt.
 func (a *AddrBook) loadFromFile(filePath string) bool {
 	// If doesn't exist, do nothing.
 	_, err := os.Stat(filePath)
@@ -356,14 +356,14 @@ func (a *AddrBook) loadFromFile(filePath string) bool {
 	// Load addrBookJSON{}
 	r, err := os.Open(filePath)
 	if err != nil {
-		PanicCrisis(Fmt("Error opening file %s: %v", filePath, err))
+		cmn.PanicCrisis(cmn.Fmt("Error opening file %s: %v", filePath, err))
 	}
 	defer r.Close()
 	aJSON := &addrBookJSON{}
 	dec := json.NewDecoder(r)
 	err = dec.Decode(aJSON)
 	if err != nil {
-		PanicCrisis(Fmt("Error reading file %s: %v", filePath, err))
+		cmn.PanicCrisis(cmn.Fmt("Error reading file %s: %v", filePath, err))
 	}
 
 	// Restore all the fields...
@@ -417,7 +417,7 @@ func (a *AddrBook) getBucket(bucketType byte, bucketIdx int) map[string]*knownAd
 	case bucketTypeOld:
 		return a.addrOld[bucketIdx]
 	default:
-		PanicSanity("Should not happen")
+		cmn.PanicSanity("Should not happen")
 		return nil
 	}
 }
@@ -427,7 +427,7 @@ func (a *AddrBook) getBucket(bucketType byte, bucketIdx int) map[string]*knownAd
 func (a *AddrBook) addToNewBucket(ka *knownAddress, bucketIdx int) bool {
 	// Sanity check
 	if ka.isOld() {
-		log.Warn(Fmt("Cannot add address already in old bucket to a new bucket: %v", ka))
+		log.Warn(cmn.Fmt("Cannot add address already in old bucket to a new bucket: %v", ka))
 		return false
 	}
 
@@ -461,11 +461,11 @@ func (a *AddrBook) addToNewBucket(ka *knownAddress, bucketIdx int) bool {
 func (a *AddrBook) addToOldBucket(ka *knownAddress, bucketIdx int) bool {
 	// Sanity check
 	if ka.isNew() {
-		log.Warn(Fmt("Cannot add new address to old bucket: %v", ka))
+		log.Warn(cmn.Fmt("Cannot add new address to old bucket: %v", ka))
 		return false
 	}
 	if len(ka.Buckets) != 0 {
-		log.Warn(Fmt("Cannot add already old address to another old bucket: %v", ka))
+		log.Warn(cmn.Fmt("Cannot add already old address to another old bucket: %v", ka))
 		return false
 	}
 
@@ -496,7 +496,7 @@ func (a *AddrBook) addToOldBucket(ka *knownAddress, bucketIdx int) bool {
 
 func (a *AddrBook) removeFromBucket(ka *knownAddress, bucketType byte, bucketIdx int) {
 	if ka.BucketType != bucketType {
-		log.Warn(Fmt("Bucket type mismatch: %v", ka))
+		log.Warn(cmn.Fmt("Bucket type mismatch: %v", ka))
 		return
 	}
 	bucket := a.getBucket(bucketType, bucketIdx)
@@ -538,7 +538,7 @@ func (a *AddrBook) pickOldest(bucketType byte, bucketIdx int) *knownAddress {
 
 func (a *AddrBook) addAddress(addr, src *NetAddress) {
 	if a.routabilityStrict && !addr.Routable() {
-		log.Warn(Fmt("Cannot add non-routable address %v", addr))
+		log.Warn(cmn.Fmt("Cannot add non-routable address %v", addr))
 		return
 	}
 	if _, ok := a.ourAddrs[addr.String()]; ok {
@@ -578,7 +578,7 @@ func (a *AddrBook) expireNew(bucketIdx int) {
 	for addrStr, ka := range a.addrNew[bucketIdx] {
 		// If an entry is bad, throw it away
 		if ka.isBad() {
-			log.Notice(Fmt("expiring bad address %v", addrStr))
+			log.Notice(cmn.Fmt("expiring bad address %v", addrStr))
 			a.removeFromBucket(ka, bucketTypeNew, bucketIdx)
 			return
 		}
@@ -595,11 +595,11 @@ func (a *AddrBook) expireNew(bucketIdx int) {
 func (a *AddrBook) moveToOld(ka *knownAddress) {
 	// Sanity check
 	if ka.isOld() {
-		log.Warn(Fmt("Cannot promote address that is already old %v", ka))
+		log.Warn(cmn.Fmt("Cannot promote address that is already old %v", ka))
 		return
 	}
 	if len(ka.Buckets) == 0 {
-		log.Warn(Fmt("Cannot promote address that isn't in any new buckets %v", ka))
+		log.Warn(cmn.Fmt("Cannot promote address that isn't in any new buckets %v", ka))
 		return
 	}
 
@@ -624,13 +624,13 @@ func (a *AddrBook) moveToOld(ka *knownAddress) {
 		if !added {
 			added := a.addToNewBucket(oldest, freedBucket)
 			if !added {
-				log.Warn(Fmt("Could not migrate oldest %v to freedBucket %v", oldest, freedBucket))
+				log.Warn(cmn.Fmt("Could not migrate oldest %v to freedBucket %v", oldest, freedBucket))
 			}
 		}
 		// Finally, add to bucket again.
 		added = a.addToOldBucket(ka, oldBucketIdx)
 		if !added {
-			log.Warn(Fmt("Could not re-add ka %v to oldBucketIdx %v", ka, oldBucketIdx))
+			log.Warn(cmn.Fmt("Could not re-add ka %v to oldBucketIdx %v", ka, oldBucketIdx))
 		}
 	}
 }
@@ -778,7 +778,7 @@ func (ka *knownAddress) markGood() {
 func (ka *knownAddress) addBucketRef(bucketIdx int) int {
 	for _, bucket := range ka.Buckets {
 		if bucket == bucketIdx {
-			log.Warn(Fmt("Bucket already exists in ka.Buckets: %v", ka))
+			log.Warn(cmn.Fmt("Bucket already exists in ka.Buckets: %v", ka))
 			return -1
 		}
 	}
@@ -794,7 +794,7 @@ func (ka *knownAddress) removeBucketRef(bucketIdx int) int {
 		}
 	}
 	if len(buckets) != len(ka.Buckets)-1 {
-		log.Warn(Fmt("bucketIdx not found in ka.Buckets: %v", ka))
+		log.Warn(cmn.Fmt("bucketIdx not found in ka.Buckets: %v", ka))
 		return -1
 	}
 	ka.Buckets = buckets

p2p/listener.go

@@ -6,8 +6,8 @@ import (
 	"strconv"
 	"time"
 
-	. "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tendermint/p2p/upnp"
+	cmn "github.com/tendermint/tmlibs/common"
 )
 
 type Listener interface {
@@ -20,7 +20,7 @@ type Listener interface {
 
 // Implements Listener
 type DefaultListener struct {
-	BaseService
+	cmn.BaseService
 
 	listener    net.Listener
 	intAddr     *NetAddress
@@ -37,11 +37,11 @@ const (
 func splitHostPort(addr string) (host string, port int) {
 	host, portStr, err := net.SplitHostPort(addr)
 	if err != nil {
-		PanicSanity(err)
+		cmn.PanicSanity(err)
 	}
 	port, err = strconv.Atoi(portStr)
 	if err != nil {
-		PanicSanity(err)
+		cmn.PanicSanity(err)
 	}
 	return host, port
 }
@@ -63,7 +63,7 @@ func NewDefaultListener(protocol string, lAddr string, skipUPNP bool) Listener {
 		}
 	}
 	if err != nil {
-		PanicCrisis(err)
+		cmn.PanicCrisis(err)
 	}
 	// Actual listener local IP & port
 	listenerIP, listenerPort := splitHostPort(listener.Addr().String())
@@ -73,7 +73,7 @@ func NewDefaultListener(protocol string, lAddr string, skipUPNP bool) Listener {
 	var intAddr *NetAddress
 	intAddr, err = NewNetAddressString(lAddr)
 	if err != nil {
-		PanicCrisis(err)
+		cmn.PanicCrisis(err)
 	}
 
 	// Determine external address...
@@ -89,7 +89,7 @@ func NewDefaultListener(protocol string, lAddr string, skipUPNP bool) Listener {
 		extAddr = getNaiveExternalAddress(listenerPort)
 	}
 	if extAddr == nil {
-		PanicCrisis("Could not determine external address!")
+		cmn.PanicCrisis("Could not determine external address!")
 	}
 
 	dl := &DefaultListener{
@@ -98,7 +98,7 @@ func NewDefaultListener(protocol string, lAddr string, skipUPNP bool) Listener {
 		extAddr:     extAddr,
 		connections: make(chan net.Conn, numBufferedConnections),
 	}
-	dl.BaseService = *NewBaseService(log, "DefaultListener", dl)
+	dl.BaseService = *cmn.NewBaseService(log, "DefaultListener", dl)
 	dl.Start() // Started upon construction
 	return dl
 }
@@ -126,7 +126,7 @@ func (l *DefaultListener) listenRoutine() {
 		// listener wasn't stopped,
 		// yet we encountered an error.
 		if err != nil {
-			PanicCrisis(err)
+			cmn.PanicCrisis(err)
 		}
 
 		l.connections <- conn
@@ -199,7 +199,7 @@ func getUPNPExternalAddress(externalPort, internalPort int) *NetAddress {
 func getNaiveExternalAddress(port int) *NetAddress {
 	addrs, err := net.InterfaceAddrs()
 	if err != nil {
-		PanicCrisis(Fmt("Could not fetch interface addresses: %v", err))
+		cmn.PanicCrisis(cmn.Fmt("Could not fetch interface addresses: %v", err))
 	}
 
 	for _, a := range addrs {

p2p/peer_set_test.go

@@ -4,16 +4,16 @@ import (
 	"math/rand"
 	"testing"
 
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 )
 
 // Returns an empty dummy peer
 func randPeer() *Peer {
 	return &Peer{
-		Key: RandStr(12),
+		Key: cmn.RandStr(12),
 		NodeInfo: &NodeInfo{
-			RemoteAddr: Fmt("%v.%v.%v.%v:46656", rand.Int()%256, rand.Int()%256, rand.Int()%256, rand.Int()%256),
-			ListenAddr: Fmt("%v.%v.%v.%v:46656", rand.Int()%256, rand.Int()%256, rand.Int()%256, rand.Int()%256),
+			RemoteAddr: cmn.Fmt("%v.%v.%v.%v:46656", rand.Int()%256, rand.Int()%256, rand.Int()%256, rand.Int()%256),
+			ListenAddr: cmn.Fmt("%v.%v.%v.%v:46656", rand.Int()%256, rand.Int()%256, rand.Int()%256, rand.Int()%256),
 		},
 	}
 }

p2p/secret_connection.go

@@ -22,7 +22,7 @@ import (
 
 	"github.com/tendermint/go-crypto"
 	"github.com/tendermint/go-wire"
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 )
 
 // 2 + 1024 == 1026 total frame size
@@ -190,7 +190,7 @@ func genEphKeys() (ephPub, ephPriv *[32]byte) {
 	var err error
 	ephPub, ephPriv, err = box.GenerateKey(crand.Reader)
 	if err != nil {
-		PanicCrisis("Could not generate ephemeral keypairs")
+		cmn.PanicCrisis("Could not generate ephemeral keypairs")
 	}
 	return
 }
@@ -198,7 +198,7 @@ func genEphKeys() (ephPub, ephPriv *[32]byte) {
 func shareEphPubKey(conn io.ReadWriteCloser, locEphPub *[32]byte) (remEphPub *[32]byte, err error) {
 	var err1, err2 error
 
-	Parallel(
+	cmn.Parallel(
 		func() {
 			_, err1 = conn.Write(locEphPub[:])
 		},
@@ -268,7 +268,7 @@ func shareAuthSignature(sc *SecretConnection, pubKey crypto.PubKeyEd25519, signa
 	var recvMsg authSigMessage
 	var err1, err2 error
 
-	Parallel(
+	cmn.Parallel(
 		func() {
 			msgBytes := wire.BinaryBytes(authSigMessage{pubKey.Wrap(), signature.Wrap()})
 			_, err1 = sc.Write(msgBytes)

p2p/secret_connection_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	"github.com/tendermint/go-crypto"
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 )
 
 type dummyConn struct {
@@ -37,7 +37,7 @@ func makeSecretConnPair(tb testing.TB) (fooSecConn, barSecConn *SecretConnection
 	barPrvKey := crypto.GenPrivKeyEd25519()
 	barPubKey := barPrvKey.PubKey().Unwrap().(crypto.PubKeyEd25519)
 
-	Parallel(
+	cmn.Parallel(
 		func() {
 			var err error
 			fooSecConn, err = MakeSecretConnection(fooConn, fooPrvKey)
@@ -81,8 +81,8 @@ func TestSecretConnectionReadWrite(t *testing.T) {
 
 	// Pre-generate the things to write (for foo & bar)
 	for i := 0; i < 100; i++ {
-		fooWrites = append(fooWrites, RandStr((RandInt()%(dataMaxSize*5))+1))
-		barWrites = append(barWrites, RandStr((RandInt()%(dataMaxSize*5))+1))
+		fooWrites = append(fooWrites, cmn.RandStr((cmn.RandInt()%(dataMaxSize*5))+1))
+		barWrites = append(barWrites, cmn.RandStr((cmn.RandInt()%(dataMaxSize*5))+1))
 	}
 
 	// A helper that will run with (fooConn, fooWrites, fooReads) and vice versa
@@ -96,7 +96,7 @@ func TestSecretConnectionReadWrite(t *testing.T) {
 				return
 			}
 			// In parallel, handle reads and writes
-			Parallel(
+			cmn.Parallel(
 				func() {
 					// Node writes
 					for _, nodeWrite := range nodeWrites {
@@ -131,7 +131,7 @@ func TestSecretConnectionReadWrite(t *testing.T) {
 	}
 
 	// Run foo & bar in parallel
-	Parallel(
+	cmn.Parallel(
 		genNodeRunner(fooConn, fooWrites, &fooReads),
 		genNodeRunner(barConn, barWrites, &barReads),
 	)
@@ -174,7 +174,7 @@ func TestSecretConnectionReadWrite(t *testing.T) {
 func BenchmarkSecretConnection(b *testing.B) {
 	b.StopTimer()
 	fooSecConn, barSecConn := makeSecretConnPair(b)
-	fooWriteText := RandStr(dataMaxSize)
+	fooWriteText := cmn.RandStr(dataMaxSize)
 	// Consume reads from bar's reader
 	go func() {
 		readBuffer := make([]byte, dataMaxSize)

p2p/switch.go

@@ -9,7 +9,7 @@ import (
 
 	crypto "github.com/tendermint/go-crypto"
 	"github.com/tendermint/log15"
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 )
 
 const (
@@ -41,7 +41,7 @@ func NewDefaultConfig(rootDir string) *Config {
 }
 
 type Reactor interface {
-	Service // Start, Stop
+	cmn.Service // Start, Stop
 
 	SetSwitch(*Switch)
 	GetChannels() []*ChannelDescriptor
@@ -53,13 +53,13 @@ type Reactor interface {
 //--------------------------------------
 
 type BaseReactor struct {
-	BaseService // Provides Start, Stop, .Quit
-	Switch      *Switch
+	cmn.BaseService // Provides Start, Stop, .Quit
+	Switch          *Switch
 }
 
 func NewBaseReactor(log log15.Logger, name string, impl Reactor) *BaseReactor {
 	return &BaseReactor{
-		BaseService: *NewBaseService(log, name, impl),
+		BaseService: *cmn.NewBaseService(log, name, impl),
 		Switch:      nil,
 	}
 }
@@ -81,7 +81,7 @@ or more `Channels`.  So while sending outgoing messages is typically performed o
 incoming messages are received on the reactor.
 */
 type Switch struct {
-	BaseService
+	cmn.BaseService
 
 	config       *Config
 	listeners    []Listener
@@ -89,7 +89,7 @@ type Switch struct {
 	chDescs      []*ChannelDescriptor
 	reactorsByCh map[byte]Reactor
 	peers        *PeerSet
-	dialing      *CMap
+	dialing      *cmn.CMap
 	nodeInfo     *NodeInfo             // our node info
 	nodePrivKey  crypto.PrivKeyEd25519 // our node privkey
 
@@ -109,10 +109,10 @@ func NewSwitch(config *Config) *Switch {
 		chDescs:      make([]*ChannelDescriptor, 0),
 		reactorsByCh: make(map[byte]Reactor),
 		peers:        NewPeerSet(),
-		dialing:      NewCMap(),
+		dialing:      cmn.NewCMap(),
 		nodeInfo:     nil,
 	}
-	sw.BaseService = *NewBaseService(log, "P2P Switch", sw)
+	sw.BaseService = *cmn.NewBaseService(log, "P2P Switch", sw)
 	return sw
 }
 
@@ -124,7 +124,7 @@ func (sw *Switch) AddReactor(name string, reactor Reactor) Reactor {
 	for _, chDesc := range reactorChannels {
 		chID := chDesc.ID
 		if sw.reactorsByCh[chID] != nil {
-			PanicSanity(fmt.Sprintf("Channel %X has multiple reactors %v & %v", chID, sw.reactorsByCh[chID], reactor))
+			cmn.PanicSanity(fmt.Sprintf("Channel %X has multiple reactors %v & %v", chID, sw.reactorsByCh[chID], reactor))
 		}
 		sw.chDescs = append(sw.chDescs, chDesc)
 		sw.reactorsByCh[chID] = reactor
@@ -552,11 +552,11 @@ func makeSwitch(cfg *Config, i int, network, version string, initSwitch func(int
 	s := initSwitch(i, NewSwitch(cfg))
 	s.SetNodeInfo(&NodeInfo{
 		PubKey:     privKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
-		Moniker:    Fmt("switch%d", i),
+		Moniker:    cmn.Fmt("switch%d", i),
 		Network:    network,
 		Version:    version,
-		RemoteAddr: Fmt("%v:%v", network, rand.Intn(64512)+1023),
-		ListenAddr: Fmt("%v:%v", network, rand.Intn(64512)+1023),
+		RemoteAddr: cmn.Fmt("%v:%v", network, rand.Intn(64512)+1023),
+		ListenAddr: cmn.Fmt("%v:%v", network, rand.Intn(64512)+1023),
 	})
 	s.SetNodePrivKey(privKey)
 	return s

p2p/switch_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/stretchr/testify/require"
 	crypto "github.com/tendermint/go-crypto"
 	wire "github.com/tendermint/go-wire"
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 )
 
 var (
@@ -320,7 +320,7 @@ func BenchmarkSwitches(b *testing.B) {
 		}
 	}
 
-	log.Warn(Fmt("success: %v, failure: %v", numSuccess, numFailure))
+	log.Warn(cmn.Fmt("success: %v, failure: %v", numSuccess, numFailure))
 
 	// Allow everything to flush before stopping switches & closing connections.
 	b.StopTimer()

p2p/upnp/probe.go

@@ -6,7 +6,7 @@ import (
 	"net"
 	"time"
 
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 )
 
 type UPNPCapabilities struct {
@@ -19,19 +19,19 @@ func makeUPNPListener(intPort int, extPort int) (NAT, net.Listener, net.IP, erro
 	if err != nil {
 		return nil, nil, nil, errors.New(fmt.Sprintf("NAT upnp could not be discovered: %v", err))
 	}
-	log.Info(Fmt("ourIP: %v", nat.(*upnpNAT).ourIP))
+	log.Info(cmn.Fmt("ourIP: %v", nat.(*upnpNAT).ourIP))
 
 	ext, err := nat.GetExternalAddress()
 	if err != nil {
 		return nat, nil, nil, errors.New(fmt.Sprintf("External address error: %v", err))
 	}
-	log.Info(Fmt("External address: %v", ext))
+	log.Info(cmn.Fmt("External address: %v", ext))
 
 	port, err := nat.AddPortMapping("tcp", extPort, intPort, "Tendermint UPnP Probe", 0)
 	if err != nil {
 		return nat, nil, ext, errors.New(fmt.Sprintf("Port mapping error: %v", err))
 	}
-	log.Info(Fmt("Port mapping mapped: %v", port))
+	log.Info(cmn.Fmt("Port mapping mapped: %v", port))
 
 	// also run the listener, open for all remote addresses.
 	listener, err := net.Listen("tcp", fmt.Sprintf(":%v", intPort))
@@ -46,17 +46,17 @@ func testHairpin(listener net.Listener, extAddr string) (supportsHairpin bool) {
 	go func() {
 		inConn, err := listener.Accept()
 		if err != nil {
-			log.Notice(Fmt("Listener.Accept() error: %v", err))
+			log.Notice(cmn.Fmt("Listener.Accept() error: %v", err))
 			return
 		}
-		log.Info(Fmt("Accepted incoming connection: %v -> %v", inConn.LocalAddr(), inConn.RemoteAddr()))
+		log.Info(cmn.Fmt("Accepted incoming connection: %v -> %v", inConn.LocalAddr(), inConn.RemoteAddr()))
 		buf := make([]byte, 1024)
 		n, err := inConn.Read(buf)
 		if err != nil {
-			log.Notice(Fmt("Incoming connection read error: %v", err))
+			log.Notice(cmn.Fmt("Incoming connection read error: %v", err))
 			return
 		}
-		log.Info(Fmt("Incoming connection read %v bytes: %X", n, buf))
+		log.Info(cmn.Fmt("Incoming connection read %v bytes: %X", n, buf))
 		if string(buf) == "test data" {
 			supportsHairpin = true
 			return
@@ -66,16 +66,16 @@ func testHairpin(listener net.Listener, extAddr string) (supportsHairpin bool) {
 	// Establish outgoing
 	outConn, err := net.Dial("tcp", extAddr)
 	if err != nil {
-		log.Notice(Fmt("Outgoing connection dial error: %v", err))
+		log.Notice(cmn.Fmt("Outgoing connection dial error: %v", err))
 		return
 	}
 
 	n, err := outConn.Write([]byte("test data"))
 	if err != nil {
-		log.Notice(Fmt("Outgoing connection write error: %v", err))
+		log.Notice(cmn.Fmt("Outgoing connection write error: %v", err))
 		return
 	}
-	log.Info(Fmt("Outgoing connection wrote %v bytes", n))
+	log.Info(cmn.Fmt("Outgoing connection wrote %v bytes", n))
 
 	// Wait for data receipt
 	time.Sleep(1 * time.Second)
@@ -97,7 +97,7 @@ func Probe() (caps UPNPCapabilities, err error) {
 	defer func() {
 		err = nat.DeletePortMapping("tcp", intPort, extPort)
 		if err != nil {
-			log.Warn(Fmt("Port mapping delete error: %v", err))
+			log.Warn(cmn.Fmt("Port mapping delete error: %v", err))
 		}
 		listener.Close()
 	}()