ppc: connect to node, gather some metricts

ppc_monitor.go

package main

import (
	"fmt"
	"github.com/mably/btcwire"
	"log"
	"net"
	"time"
)

const (
	appMajor           = 0
	appMinor           = 1
	appPatch           = 0
	maxProtocolVersion = 60004
	network            = btcwire.MainNet
)

var (
	userAgentName    = "ppc_monitor"
	userAgentVersion = fmt.Sprintf("%d.%d.%d", appMajor, appMinor, appPatch)
	serverNonce      = uint64(0)
	serverBlockNum   = int32(0)
)

func tryToTalkWithPeer() {
	hisAddr := &net.TCPAddr{
		IP: net.ParseIP("127.0.0.1"),
		//IP:   net.ParseIP("178.62.206.205"),
		//IP:   net.ParseIP("74.83.251.151"),
		Port: 9901}

	now := time.Now()
	conn, err := net.DialTCP("tcp4", nil, hisAddr)
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	log.Printf("conn in %v", time.Now().Sub(now))

	input := make(chan btcwire.Message, 100)

	go func() {
		for {
			msg, buf, err := btcwire.ReadMessage(conn, maxProtocolVersion, network)
			if msg != nil {
				log.Printf("RECV: msg: %v", msg.Command())
				input <- msg
			} else {
				log.Printf("RECV: err: %v", err)
				close(input)
			}
			_ = msg
			_ = buf
			_ = err
		}
	}()

	mineNa := btcwire.NewNetAddressIPPort(net.ParseIP("127.0.0.1"), uint16(9909), btcwire.SFNodeNetwork)
	hisNa := btcwire.NewNetAddressIPPort(hisAddr.IP, uint16(hisAddr.Port), btcwire.SFNodeNetwork)

	msg := btcwire.NewMsgVersion(mineNa, hisNa, serverNonce, serverBlockNum)
	msg.AddUserAgent(userAgentName, userAgentVersion)
	msg.AddrYou.Services = btcwire.SFNodeNetwork
	msg.Services = btcwire.SFNodeNetwork
	msg.ProtocolVersion = maxProtocolVersion

	now = time.Now()
	if err = btcwire.WriteMessage(conn, msg, maxProtocolVersion, network); err != nil {
		log.Fatal(err)
	}

	var ack *btcwire.MsgVerAck
	var hisVer *btcwire.MsgVersion
	for {
		m := <-input
		switch m.(type) {
		case *btcwire.MsgVersion:
			hisVer = m.(*btcwire.MsgVersion)
		case *btcwire.MsgVerAck:
			ack = m.(*btcwire.MsgVerAck)
		}
		if ack != nil && hisVer != nil {
			for len(input) > 0 {
				<-input
			}
			break
		}
	}
	log.Printf("versions in: %v %v", time.Now().Sub(now), hisVer.UserAgent)

	if err = btcwire.WriteMessage(conn, btcwire.NewMsgVerAck(), maxProtocolVersion, network); err != nil {
		log.Fatal(err)
	}

	now = time.Now()
	if err = btcwire.WriteMessage(conn, btcwire.NewMsgGetBlocks(&btcwire.ZeroSha), maxProtocolVersion, network); err != nil {
		log.Fatal(err)
	}

	log.Printf("input channel len: %v", len(input))
	var firstBlocks *btcwire.MsgInv
	for {
		m := <-input
		switch m.(type) {
		case *btcwire.MsgInv:
			inv := m.(*btcwire.MsgInv)
			log.Printf("inv with len: %v", len(inv.InvList))
			if len(inv.InvList) != 500 {
				log.Printf("invalid inv len: %v", len(inv.InvList))
			} else {
				firstBlocks = inv
			}
		}
		if firstBlocks != nil {
			for len(input) > 0 {
				<-input
			}
			break
		}
	}
	log.Printf("first blocks inv in %v", time.Now().Sub(now))

	gd := btcwire.NewMsgGetData()
	for _, inv := range firstBlocks.InvList {
		gd.AddInvVect(inv)
	}
	now = time.Now()
	if err = btcwire.WriteMessage(conn, gd, maxProtocolVersion, network); err != nil {
		log.Fatal(err)
	}
	blkCount, blkSize := 0, 0
	for blkCount != len(firstBlocks.InvList) {
		m := <-input
		switch m.(type) {
		case *btcwire.MsgBlock:
			b := m.(*btcwire.MsgBlock)
			blkCount++
			blkSize += b.SerializeSize()
		}
	}
	log.Printf("first %v blocks(%v) in %v", blkCount, float32(blkSize)/float32(1024*1024), time.Now().Sub(now))

	now = time.Now()
	if err = btcwire.WriteMessage(conn, btcwire.NewMsgGetAddr(), maxProtocolVersion, network); err != nil {
		log.Fatal(err)
	}
	addrs := make([]*btcwire.NetAddress, 0)
	for lastLen := 1000; lastLen == 1000; {
		m := <-input
		switch m.(type) {
		case *btcwire.MsgAddr:
			a := m.(*btcwire.MsgAddr)
			addrs = append(addrs, a.AddrList...)
			lastLen = len(a.AddrList)
		}
	}
	log.Printf("addresses %v in %v", len(addrs), time.Now().Sub(now))

	time.Sleep(time.Second)
}