2014-01-23 11:14:01 -08:00
|
|
|
package eth
|
|
|
|
|
|
|
|
import (
|
|
|
|
"container/list"
|
2014-09-16 07:36:27 -07:00
|
|
|
"encoding/json"
|
2014-05-12 06:08:21 -07:00
|
|
|
"fmt"
|
2014-09-24 02:39:17 -07:00
|
|
|
"math/big"
|
2014-05-12 06:08:21 -07:00
|
|
|
"math/rand"
|
2014-01-23 11:14:01 -08:00
|
|
|
"net"
|
2014-09-16 07:36:27 -07:00
|
|
|
"path"
|
2014-02-02 10:22:39 -08:00
|
|
|
"strconv"
|
2014-05-12 06:08:21 -07:00
|
|
|
"strings"
|
2014-02-02 07:15:39 -08:00
|
|
|
"sync"
|
2014-01-23 11:14:01 -08:00
|
|
|
"sync/atomic"
|
|
|
|
"time"
|
2014-07-26 02:24:44 -07:00
|
|
|
|
2014-10-31 02:59:17 -07:00
|
|
|
"github.com/ethereum/go-ethereum/chain"
|
2014-10-31 04:37:43 -07:00
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
2014-10-23 06:01:27 -07:00
|
|
|
"github.com/ethereum/go-ethereum/ethutil"
|
|
|
|
"github.com/ethereum/go-ethereum/event"
|
2014-10-31 04:56:05 -07:00
|
|
|
"github.com/ethereum/go-ethereum/logger"
|
2014-10-23 06:01:27 -07:00
|
|
|
"github.com/ethereum/go-ethereum/rpc"
|
2014-10-31 06:43:14 -07:00
|
|
|
"github.com/ethereum/go-ethereum/state"
|
2014-10-31 06:53:42 -07:00
|
|
|
"github.com/ethereum/go-ethereum/wire"
|
2014-01-23 11:14:01 -08:00
|
|
|
)
|
|
|
|
|
2014-07-29 14:33:59 -07:00
|
|
|
const (
|
|
|
|
seedTextFileUri string = "http://www.ethereum.org/servers.poc3.txt"
|
2014-10-21 04:25:31 -07:00
|
|
|
seedNodeAddress = "poc-7.ethdev.com:30303"
|
2014-07-29 14:33:59 -07:00
|
|
|
)
|
2014-07-11 07:04:09 -07:00
|
|
|
|
2014-10-31 04:56:05 -07:00
|
|
|
var loggerger = logger.NewLogger("SERV")
|
2014-06-23 04:54:10 -07:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
func eachPeer(peers *list.List, callback func(*Peer, *list.Element)) {
|
|
|
|
// Loop thru the peers and close them (if we had them)
|
|
|
|
for e := peers.Front(); e != nil; e = e.Next() {
|
2014-09-16 07:36:27 -07:00
|
|
|
callback(e.Value.(*Peer), e)
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const (
|
|
|
|
processReapingTimeout = 60 // TODO increase
|
|
|
|
)
|
|
|
|
|
|
|
|
type Ethereum struct {
|
|
|
|
// Channel for shutting down the ethereum
|
|
|
|
shutdownChan chan bool
|
2014-02-02 10:22:39 -08:00
|
|
|
quit chan bool
|
2014-08-11 07:23:38 -07:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
// DB interface
|
2014-02-08 12:02:09 -08:00
|
|
|
db ethutil.Database
|
2014-03-05 01:57:32 -08:00
|
|
|
// State manager for processing new blocks and managing the over all states
|
2014-11-04 01:57:02 -08:00
|
|
|
blockManager *chain.BlockManager
|
2014-01-23 11:14:01 -08:00
|
|
|
// The transaction pool. Transaction can be pushed on this pool
|
|
|
|
// for later including in the blocks
|
2014-10-31 02:59:17 -07:00
|
|
|
txPool *chain.TxPool
|
2014-03-05 01:42:51 -08:00
|
|
|
// The canonical chain
|
2014-10-31 02:59:17 -07:00
|
|
|
blockChain *chain.ChainManager
|
2014-08-21 05:47:58 -07:00
|
|
|
// The block pool
|
|
|
|
blockPool *BlockPool
|
2014-09-29 03:57:51 -07:00
|
|
|
// Eventer
|
2014-10-13 17:01:46 -07:00
|
|
|
eventMux event.TypeMux
|
2014-09-29 03:57:51 -07:00
|
|
|
// Peers
|
2014-01-23 11:14:01 -08:00
|
|
|
peers *list.List
|
|
|
|
// Nonce
|
|
|
|
Nonce uint64
|
2014-02-01 12:30:54 -08:00
|
|
|
|
|
|
|
Addr net.Addr
|
2014-02-22 16:57:45 -08:00
|
|
|
Port string
|
2014-02-01 12:30:54 -08:00
|
|
|
|
2014-10-02 08:03:48 -07:00
|
|
|
blacklist [][]byte
|
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
peerMut sync.Mutex
|
|
|
|
|
|
|
|
// Capabilities for outgoing peers
|
|
|
|
serverCaps Caps
|
2014-02-02 10:22:39 -08:00
|
|
|
|
|
|
|
nat NAT
|
2014-02-08 12:02:09 -08:00
|
|
|
|
|
|
|
// Specifies the desired amount of maximum peers
|
|
|
|
MaxPeers int
|
2014-03-10 03:53:02 -07:00
|
|
|
|
2014-05-13 05:43:29 -07:00
|
|
|
Mining bool
|
|
|
|
|
|
|
|
listening bool
|
|
|
|
|
2014-10-21 04:25:31 -07:00
|
|
|
RpcServer *rpc.JsonRpcServer
|
2014-06-29 10:30:05 -07:00
|
|
|
|
2014-10-31 04:37:43 -07:00
|
|
|
keyManager *crypto.KeyManager
|
2014-07-03 09:30:04 -07:00
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
clientIdentity wire.ClientIdentity
|
2014-07-17 13:01:13 -07:00
|
|
|
|
|
|
|
isUpToDate bool
|
2014-09-13 15:13:23 -07:00
|
|
|
|
2014-10-08 10:04:58 -07:00
|
|
|
filterMu sync.RWMutex
|
|
|
|
filterId int
|
2014-10-31 02:59:17 -07:00
|
|
|
filters map[int]*chain.Filter
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
func New(db ethutil.Database, clientIdentity wire.ClientIdentity, keyManager *crypto.KeyManager, caps Caps, usePnp bool) (*Ethereum, error) {
|
2014-06-29 10:30:05 -07:00
|
|
|
var err error
|
2014-02-02 10:44:47 -08:00
|
|
|
var nat NAT
|
2014-06-29 10:30:05 -07:00
|
|
|
|
2014-02-02 10:44:47 -08:00
|
|
|
if usePnp {
|
|
|
|
nat, err = Discover()
|
|
|
|
if err != nil {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln("UPnP failed", err)
|
2014-02-02 10:44:47 -08:00
|
|
|
}
|
2014-02-02 10:22:39 -08:00
|
|
|
}
|
|
|
|
|
2014-08-22 02:34:59 -07:00
|
|
|
bootstrapDb(db)
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
ethutil.Config.Db = db
|
|
|
|
|
|
|
|
nonce, _ := ethutil.RandomUint64()
|
|
|
|
ethereum := &Ethereum{
|
2014-07-03 09:30:04 -07:00
|
|
|
shutdownChan: make(chan bool),
|
|
|
|
quit: make(chan bool),
|
|
|
|
db: db,
|
|
|
|
peers: list.New(),
|
|
|
|
Nonce: nonce,
|
|
|
|
serverCaps: caps,
|
|
|
|
nat: nat,
|
|
|
|
keyManager: keyManager,
|
|
|
|
clientIdentity: clientIdentity,
|
2014-07-17 13:01:13 -07:00
|
|
|
isUpToDate: true,
|
2014-10-31 02:59:17 -07:00
|
|
|
filters: make(map[int]*chain.Filter),
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
2014-03-10 03:53:02 -07:00
|
|
|
|
2014-08-21 05:47:58 -07:00
|
|
|
ethereum.blockPool = NewBlockPool(ethereum)
|
2014-10-31 02:59:17 -07:00
|
|
|
ethereum.txPool = chain.NewTxPool(ethereum)
|
|
|
|
ethereum.blockChain = chain.NewChainManager(ethereum)
|
2014-11-04 01:57:02 -08:00
|
|
|
ethereum.blockManager = chain.NewBlockManager(ethereum)
|
2014-01-23 11:14:01 -08:00
|
|
|
|
2014-02-22 16:57:45 -08:00
|
|
|
// Start the tx pool
|
2014-03-05 01:42:51 -08:00
|
|
|
ethereum.txPool.Start()
|
2014-02-22 16:57:45 -08:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
return ethereum, nil
|
|
|
|
}
|
|
|
|
|
2014-10-31 04:37:43 -07:00
|
|
|
func (s *Ethereum) KeyManager() *crypto.KeyManager {
|
2014-06-29 10:30:05 -07:00
|
|
|
return s.keyManager
|
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
func (s *Ethereum) ClientIdentity() wire.ClientIdentity {
|
2014-07-03 09:30:04 -07:00
|
|
|
return s.clientIdentity
|
|
|
|
}
|
|
|
|
|
2014-10-31 02:59:17 -07:00
|
|
|
func (s *Ethereum) ChainManager() *chain.ChainManager {
|
2014-03-05 01:42:51 -08:00
|
|
|
return s.blockChain
|
|
|
|
}
|
|
|
|
|
2014-11-04 01:57:02 -08:00
|
|
|
func (s *Ethereum) BlockManager() *chain.BlockManager {
|
|
|
|
return s.blockManager
|
2014-03-05 01:42:51 -08:00
|
|
|
}
|
|
|
|
|
2014-10-31 02:59:17 -07:00
|
|
|
func (s *Ethereum) TxPool() *chain.TxPool {
|
2014-03-05 01:42:51 -08:00
|
|
|
return s.txPool
|
|
|
|
}
|
2014-09-24 10:56:21 -07:00
|
|
|
func (s *Ethereum) BlockPool() *BlockPool {
|
|
|
|
return s.blockPool
|
|
|
|
}
|
2014-10-13 16:58:31 -07:00
|
|
|
func (s *Ethereum) EventMux() *event.TypeMux {
|
2014-10-13 17:01:46 -07:00
|
|
|
return &s.eventMux
|
2014-09-29 03:57:51 -07:00
|
|
|
}
|
2014-08-11 07:23:38 -07:00
|
|
|
func (self *Ethereum) Db() ethutil.Database {
|
|
|
|
return self.db
|
|
|
|
}
|
2014-03-05 01:42:51 -08:00
|
|
|
|
2014-05-12 04:39:37 -07:00
|
|
|
func (s *Ethereum) ServerCaps() Caps {
|
|
|
|
return s.serverCaps
|
|
|
|
}
|
2014-05-13 05:43:29 -07:00
|
|
|
func (s *Ethereum) IsMining() bool {
|
|
|
|
return s.Mining
|
|
|
|
}
|
|
|
|
func (s *Ethereum) PeerCount() int {
|
|
|
|
return s.peers.Len()
|
|
|
|
}
|
2014-05-14 04:57:04 -07:00
|
|
|
func (s *Ethereum) IsUpToDate() bool {
|
|
|
|
upToDate := true
|
|
|
|
eachPeer(s.peers, func(peer *Peer, e *list.Element) {
|
|
|
|
if atomic.LoadInt32(&peer.connected) == 1 {
|
2014-07-18 02:57:44 -07:00
|
|
|
if peer.catchingUp == true && peer.versionKnown {
|
2014-05-14 04:57:04 -07:00
|
|
|
upToDate = false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
return upToDate
|
|
|
|
}
|
2014-06-18 04:06:48 -07:00
|
|
|
func (s *Ethereum) PushPeer(peer *Peer) {
|
|
|
|
s.peers.PushBack(peer)
|
|
|
|
}
|
2014-05-13 05:43:29 -07:00
|
|
|
func (s *Ethereum) IsListening() bool {
|
|
|
|
return s.listening
|
|
|
|
}
|
2014-05-12 04:39:37 -07:00
|
|
|
|
2014-09-24 02:39:17 -07:00
|
|
|
func (s *Ethereum) HighestTDPeer() (td *big.Int) {
|
|
|
|
td = big.NewInt(0)
|
|
|
|
|
|
|
|
eachPeer(s.peers, func(p *Peer, v *list.Element) {
|
|
|
|
if p.td.Cmp(td) > 0 {
|
|
|
|
td = p.td
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-10-02 08:03:48 -07:00
|
|
|
func (self *Ethereum) BlacklistPeer(peer *Peer) {
|
|
|
|
self.blacklist = append(self.blacklist, peer.pubkey)
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
func (s *Ethereum) AddPeer(conn net.Conn) {
|
|
|
|
peer := NewPeer(conn, s, true)
|
|
|
|
|
2014-05-12 07:36:14 -07:00
|
|
|
if peer != nil {
|
|
|
|
if s.peers.Len() < s.MaxPeers {
|
|
|
|
peer.Start()
|
|
|
|
} else {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugf("Max connected peers reached. Not adding incoming peer.")
|
2014-05-12 07:36:14 -07:00
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) ProcessPeerList(addrs []string) {
|
|
|
|
for _, addr := range addrs {
|
|
|
|
// TODO Probably requires some sanity checks
|
|
|
|
s.ConnectToPeer(addr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) ConnectToPeer(addr string) error {
|
2014-02-17 16:34:06 -08:00
|
|
|
if s.peers.Len() < s.MaxPeers {
|
|
|
|
var alreadyConnected bool
|
|
|
|
|
2014-05-12 06:08:21 -07:00
|
|
|
ahost, _, _ := net.SplitHostPort(addr)
|
|
|
|
var chost string
|
|
|
|
|
|
|
|
ips, err := net.LookupIP(ahost)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else {
|
|
|
|
// If more then one ip is available try stripping away the ipv6 ones
|
|
|
|
if len(ips) > 1 {
|
|
|
|
var ipsv4 []net.IP
|
|
|
|
// For now remove the ipv6 addresses
|
|
|
|
for _, ip := range ips {
|
|
|
|
if strings.Contains(ip.String(), "::") {
|
|
|
|
continue
|
|
|
|
} else {
|
|
|
|
ipsv4 = append(ipsv4, ip)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(ipsv4) == 0 {
|
|
|
|
return fmt.Errorf("[SERV] No IPV4 addresses available for hostname")
|
|
|
|
}
|
|
|
|
|
|
|
|
// Pick a random ipv4 address, simulating round-robin DNS.
|
|
|
|
rand.Seed(time.Now().UTC().UnixNano())
|
|
|
|
i := rand.Intn(len(ipsv4))
|
|
|
|
chost = ipsv4[i].String()
|
|
|
|
} else {
|
|
|
|
if len(ips) == 0 {
|
|
|
|
return fmt.Errorf("[SERV] No IPs resolved for the given hostname")
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
chost = ips[0].String()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-17 16:34:06 -08:00
|
|
|
eachPeer(s.peers, func(p *Peer, v *list.Element) {
|
|
|
|
if p.conn == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
phost, _, _ := net.SplitHostPort(p.conn.RemoteAddr().String())
|
|
|
|
|
2014-05-12 06:08:21 -07:00
|
|
|
if phost == chost {
|
2014-02-17 16:34:06 -08:00
|
|
|
alreadyConnected = true
|
2014-10-31 04:56:05 -07:00
|
|
|
//loggerger.Debugf("Peer %s already added.\n", chost)
|
2014-02-17 16:34:06 -08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
if alreadyConnected {
|
|
|
|
return nil
|
2014-01-30 16:12:48 -08:00
|
|
|
}
|
|
|
|
|
2014-06-18 04:06:48 -07:00
|
|
|
NewOutboundPeer(addr, s, s.serverCaps)
|
2014-02-17 16:34:06 -08:00
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) OutboundPeers() []*Peer {
|
|
|
|
// Create a new peer slice with at least the length of the total peers
|
|
|
|
outboundPeers := make([]*Peer, s.peers.Len())
|
|
|
|
length := 0
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
2014-01-31 02:18:10 -08:00
|
|
|
if !p.inbound && p.conn != nil {
|
2014-01-23 11:14:01 -08:00
|
|
|
outboundPeers[length] = p
|
|
|
|
length++
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
return outboundPeers[:length]
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) InboundPeers() []*Peer {
|
|
|
|
// Create a new peer slice with at least the length of the total peers
|
|
|
|
inboundPeers := make([]*Peer, s.peers.Len())
|
|
|
|
length := 0
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
|
|
|
if p.inbound {
|
|
|
|
inboundPeers[length] = p
|
|
|
|
length++
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
return inboundPeers[:length]
|
|
|
|
}
|
|
|
|
|
2014-01-31 02:57:56 -08:00
|
|
|
func (s *Ethereum) InOutPeers() []*Peer {
|
2014-02-02 07:15:39 -08:00
|
|
|
// Reap the dead peers first
|
|
|
|
s.reapPeers()
|
|
|
|
|
2014-01-31 02:57:56 -08:00
|
|
|
// Create a new peer slice with at least the length of the total peers
|
|
|
|
inboundPeers := make([]*Peer, s.peers.Len())
|
|
|
|
length := 0
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
2014-02-02 07:15:39 -08:00
|
|
|
// Only return peers with an actual ip
|
|
|
|
if len(p.host) > 0 {
|
|
|
|
inboundPeers[length] = p
|
|
|
|
length++
|
|
|
|
}
|
2014-01-31 02:57:56 -08:00
|
|
|
})
|
|
|
|
|
|
|
|
return inboundPeers[:length]
|
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
func (s *Ethereum) Broadcast(msgType wire.MsgType, data []interface{}) {
|
|
|
|
msg := wire.NewMessage(msgType, data)
|
2014-02-02 07:15:39 -08:00
|
|
|
s.BroadcastMsg(msg)
|
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
func (s *Ethereum) BroadcastMsg(msg *wire.Msg) {
|
2014-01-23 11:14:01 -08:00
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
2014-01-23 13:32:50 -08:00
|
|
|
p.QueueMessage(msg)
|
2014-01-23 11:14:01 -08:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2014-01-31 02:57:56 -08:00
|
|
|
func (s *Ethereum) Peers() *list.List {
|
|
|
|
return s.peers
|
|
|
|
}
|
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
func (s *Ethereum) reapPeers() {
|
2014-05-30 04:04:08 -07:00
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
|
|
|
if atomic.LoadInt32(&p.disconnect) == 1 || (p.inbound && (time.Now().Unix()-p.lastPong) > int64(5*time.Minute)) {
|
|
|
|
s.removePeerElement(e)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) removePeerElement(e *list.Element) {
|
2014-02-02 07:15:39 -08:00
|
|
|
s.peerMut.Lock()
|
|
|
|
defer s.peerMut.Unlock()
|
|
|
|
|
2014-05-30 04:04:08 -07:00
|
|
|
s.peers.Remove(e)
|
|
|
|
|
2014-10-13 16:58:31 -07:00
|
|
|
s.eventMux.Post(PeerListEvent{s.peers})
|
2014-05-30 04:04:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) RemovePeer(p *Peer) {
|
|
|
|
eachPeer(s.peers, func(peer *Peer, e *list.Element) {
|
|
|
|
if peer == p {
|
|
|
|
s.removePeerElement(e)
|
2014-02-02 07:15:39 -08:00
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
|
2014-10-08 03:29:49 -07:00
|
|
|
func (s *Ethereum) reapDeadPeerHandler() {
|
2014-02-02 07:15:39 -08:00
|
|
|
reapTimer := time.NewTicker(processReapingTimeout * time.Second)
|
|
|
|
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-reapTimer.C:
|
|
|
|
s.reapPeers()
|
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Start the ethereum
|
2014-05-09 07:09:28 -07:00
|
|
|
func (s *Ethereum) Start(seed bool) {
|
2014-09-24 12:13:28 -07:00
|
|
|
s.blockPool.Start()
|
2014-11-04 01:57:02 -08:00
|
|
|
s.blockManager.Start()
|
2014-09-29 03:57:51 -07:00
|
|
|
|
2014-01-27 13:13:46 -08:00
|
|
|
// Bind to addr and port
|
2014-02-22 16:57:45 -08:00
|
|
|
ln, err := net.Listen("tcp", ":"+s.Port)
|
2014-01-23 11:14:01 -08:00
|
|
|
if err != nil {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Warnf("Port %s in use. Connection listening disabled. Acting as client", s.Port)
|
2014-05-13 05:43:29 -07:00
|
|
|
s.listening = false
|
2014-01-23 11:14:01 -08:00
|
|
|
} else {
|
2014-05-13 05:43:29 -07:00
|
|
|
s.listening = true
|
2014-01-23 11:14:01 -08:00
|
|
|
// Starting accepting connections
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Infoln("Ready and accepting connections")
|
2014-02-02 07:15:39 -08:00
|
|
|
// Start the peer handler
|
|
|
|
go s.peerHandler(ln)
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-02-02 10:44:47 -08:00
|
|
|
if s.nat != nil {
|
|
|
|
go s.upnpUpdateThread()
|
|
|
|
}
|
2014-02-02 10:22:39 -08:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
// Start the reaping processes
|
2014-10-08 03:29:49 -07:00
|
|
|
go s.reapDeadPeerHandler()
|
2014-07-17 13:01:13 -07:00
|
|
|
go s.update()
|
2014-09-13 15:13:23 -07:00
|
|
|
go s.filterLoop()
|
2014-01-23 11:14:01 -08:00
|
|
|
|
2014-05-09 07:09:28 -07:00
|
|
|
if seed {
|
|
|
|
s.Seed()
|
|
|
|
}
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Infoln("Server started")
|
2014-05-09 07:09:28 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) Seed() {
|
2014-10-08 03:06:39 -07:00
|
|
|
// Sorry Py person. I must blacklist. you perform badly
|
|
|
|
s.blacklist = append(s.blacklist, ethutil.Hex2Bytes("64656330303561383532336435376331616537643864663236623336313863373537353163636634333530626263396330346237336262623931383064393031"))
|
2014-09-17 06:57:44 -07:00
|
|
|
ips := PastPeers()
|
2014-09-16 07:36:27 -07:00
|
|
|
if len(ips) > 0 {
|
2014-05-13 02:35:21 -07:00
|
|
|
for _, ip := range ips {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Infoln("Connecting to previous peer ", ip)
|
2014-09-16 07:36:27 -07:00
|
|
|
s.ConnectToPeer(ip)
|
|
|
|
}
|
|
|
|
} else {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln("Retrieving seed nodes")
|
2014-09-16 07:36:27 -07:00
|
|
|
|
|
|
|
// Eth-Go Bootstrapping
|
|
|
|
ips, er := net.LookupIP("seed.bysh.me")
|
|
|
|
if er == nil {
|
|
|
|
peers := []string{}
|
|
|
|
for _, ip := range ips {
|
|
|
|
node := fmt.Sprintf("%s:%d", ip.String(), 30303)
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln("Found DNS Go Peer:", node)
|
2014-09-16 07:36:27 -07:00
|
|
|
peers = append(peers, node)
|
|
|
|
}
|
|
|
|
s.ProcessPeerList(peers)
|
2014-05-13 02:35:21 -07:00
|
|
|
}
|
|
|
|
|
2014-09-16 07:36:27 -07:00
|
|
|
// Official DNS Bootstrapping
|
|
|
|
_, nodes, err := net.LookupSRV("eth", "tcp", "ethereum.org")
|
|
|
|
if err == nil {
|
|
|
|
peers := []string{}
|
|
|
|
// Iterate SRV nodes
|
|
|
|
for _, n := range nodes {
|
|
|
|
target := n.Target
|
|
|
|
port := strconv.Itoa(int(n.Port))
|
|
|
|
// Resolve target to ip (Go returns list, so may resolve to multiple ips?)
|
|
|
|
addr, err := net.LookupHost(target)
|
|
|
|
if err == nil {
|
|
|
|
for _, a := range addr {
|
|
|
|
// Build string out of SRV port and Resolved IP
|
|
|
|
peer := net.JoinHostPort(a, port)
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln("Found DNS Bootstrap Peer:", peer)
|
2014-09-16 07:36:27 -07:00
|
|
|
peers = append(peers, peer)
|
|
|
|
}
|
|
|
|
} else {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln("Couldn't resolve :", target)
|
2014-03-17 02:37:37 -07:00
|
|
|
}
|
|
|
|
}
|
2014-09-16 07:36:27 -07:00
|
|
|
// Connect to Peer list
|
|
|
|
s.ProcessPeerList(peers)
|
2014-03-17 02:37:37 -07:00
|
|
|
}
|
2014-07-29 14:33:59 -07:00
|
|
|
|
2014-09-16 07:36:27 -07:00
|
|
|
// XXX tmp
|
|
|
|
s.ConnectToPeer(seedNodeAddress)
|
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
func (s *Ethereum) peerHandler(listener net.Listener) {
|
|
|
|
for {
|
|
|
|
conn, err := listener.Accept()
|
|
|
|
if err != nil {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln(err)
|
2014-02-02 07:15:39 -08:00
|
|
|
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
go s.AddPeer(conn)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
func (s *Ethereum) Stop() {
|
2014-10-28 19:01:20 -07:00
|
|
|
// Stop eventMux first, it will close all subscriptions.
|
|
|
|
s.eventMux.Stop()
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
// Close the database
|
|
|
|
defer s.db.Close()
|
|
|
|
|
2014-09-16 07:36:27 -07:00
|
|
|
var ips []string
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
|
|
|
ips = append(ips, p.conn.RemoteAddr().String())
|
|
|
|
})
|
2014-09-17 06:57:44 -07:00
|
|
|
|
|
|
|
if len(ips) > 0 {
|
|
|
|
d, _ := json.MarshalIndent(ips, "", " ")
|
|
|
|
ethutil.WriteFile(path.Join(ethutil.Config.ExecPath, "known_peers.json"), d)
|
|
|
|
}
|
2014-09-16 07:36:27 -07:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
|
|
|
p.Stop()
|
|
|
|
})
|
|
|
|
|
2014-02-02 10:22:39 -08:00
|
|
|
close(s.quit)
|
|
|
|
|
2014-05-06 05:15:02 -07:00
|
|
|
if s.RpcServer != nil {
|
|
|
|
s.RpcServer.Stop()
|
|
|
|
}
|
2014-03-05 01:42:51 -08:00
|
|
|
s.txPool.Stop()
|
2014-11-04 01:57:02 -08:00
|
|
|
s.blockManager.Stop()
|
2014-09-24 10:56:21 -07:00
|
|
|
s.blockPool.Stop()
|
2014-02-08 12:02:09 -08:00
|
|
|
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Infoln("Server stopped")
|
2014-02-28 07:45:29 -08:00
|
|
|
close(s.shutdownChan)
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// This function will wait for a shutdown and resumes main thread execution
|
|
|
|
func (s *Ethereum) WaitForShutdown() {
|
|
|
|
<-s.shutdownChan
|
|
|
|
}
|
2014-02-02 10:22:39 -08:00
|
|
|
|
|
|
|
func (s *Ethereum) upnpUpdateThread() {
|
|
|
|
// Go off immediately to prevent code duplication, thereafter we renew
|
|
|
|
// lease every 15 minutes.
|
2014-05-01 13:14:20 -07:00
|
|
|
timer := time.NewTimer(5 * time.Minute)
|
2014-02-22 16:57:45 -08:00
|
|
|
lport, _ := strconv.ParseInt(s.Port, 10, 16)
|
2014-02-02 10:22:39 -08:00
|
|
|
first := true
|
|
|
|
out:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-timer.C:
|
2014-02-02 10:44:47 -08:00
|
|
|
var err error
|
|
|
|
_, err = s.nat.AddPortMapping("TCP", int(lport), int(lport), "eth listen port", 20*60)
|
2014-02-02 10:22:39 -08:00
|
|
|
if err != nil {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln("can't add UPnP port mapping:", err)
|
2014-02-02 10:22:39 -08:00
|
|
|
break out
|
|
|
|
}
|
|
|
|
if first && err == nil {
|
2014-02-02 10:44:47 -08:00
|
|
|
_, err = s.nat.GetExternalAddress()
|
2014-02-02 10:22:39 -08:00
|
|
|
if err != nil {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln("UPnP can't get external address:", err)
|
2014-02-02 10:22:39 -08:00
|
|
|
continue out
|
|
|
|
}
|
|
|
|
first = false
|
|
|
|
}
|
|
|
|
timer.Reset(time.Minute * 15)
|
|
|
|
case <-s.quit:
|
|
|
|
break out
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
timer.Stop()
|
|
|
|
|
|
|
|
if err := s.nat.DeletePortMapping("TCP", int(lport), int(lport)); err != nil {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln("unable to remove UPnP port mapping:", err)
|
2014-02-02 10:22:39 -08:00
|
|
|
} else {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Debugln("succesfully disestablished UPnP port mapping")
|
2014-02-02 10:22:39 -08:00
|
|
|
}
|
|
|
|
}
|
2014-07-17 13:01:13 -07:00
|
|
|
|
|
|
|
func (self *Ethereum) update() {
|
|
|
|
upToDateTimer := time.NewTicker(1 * time.Second)
|
|
|
|
|
|
|
|
out:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-upToDateTimer.C:
|
|
|
|
if self.IsUpToDate() && !self.isUpToDate {
|
2014-10-13 16:58:31 -07:00
|
|
|
self.eventMux.Post(ChainSyncEvent{false})
|
2014-07-17 13:01:13 -07:00
|
|
|
self.isUpToDate = true
|
|
|
|
} else if !self.IsUpToDate() && self.isUpToDate {
|
2014-10-13 16:58:31 -07:00
|
|
|
self.eventMux.Post(ChainSyncEvent{true})
|
2014-07-17 13:01:13 -07:00
|
|
|
self.isUpToDate = false
|
|
|
|
}
|
|
|
|
case <-self.quit:
|
|
|
|
break out
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-08-22 02:34:59 -07:00
|
|
|
|
2014-10-08 10:04:58 -07:00
|
|
|
// InstallFilter adds filter for blockchain events.
|
|
|
|
// The filter's callbacks will run for matching blocks and messages.
|
|
|
|
// The filter should not be modified after it has been installed.
|
2014-10-31 02:59:17 -07:00
|
|
|
func (self *Ethereum) InstallFilter(filter *chain.Filter) (id int) {
|
2014-10-08 10:04:58 -07:00
|
|
|
self.filterMu.Lock()
|
|
|
|
id = self.filterId
|
|
|
|
self.filters[id] = filter
|
|
|
|
self.filterId++
|
|
|
|
self.filterMu.Unlock()
|
|
|
|
return id
|
2014-09-13 15:13:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func (self *Ethereum) UninstallFilter(id int) {
|
2014-10-08 10:04:58 -07:00
|
|
|
self.filterMu.Lock()
|
2014-09-13 15:13:23 -07:00
|
|
|
delete(self.filters, id)
|
2014-10-08 10:04:58 -07:00
|
|
|
self.filterMu.Unlock()
|
2014-09-13 15:13:23 -07:00
|
|
|
}
|
|
|
|
|
2014-10-08 10:04:58 -07:00
|
|
|
// GetFilter retrieves a filter installed using InstallFilter.
|
|
|
|
// The filter may not be modified.
|
2014-10-31 02:59:17 -07:00
|
|
|
func (self *Ethereum) GetFilter(id int) *chain.Filter {
|
2014-10-08 10:04:58 -07:00
|
|
|
self.filterMu.RLock()
|
|
|
|
defer self.filterMu.RUnlock()
|
2014-09-13 15:13:23 -07:00
|
|
|
return self.filters[id]
|
|
|
|
}
|
|
|
|
|
|
|
|
func (self *Ethereum) filterLoop() {
|
|
|
|
// Subscribe to events
|
2014-10-31 06:43:14 -07:00
|
|
|
events := self.eventMux.Subscribe(chain.NewBlockEvent{}, state.Messages(nil))
|
2014-10-13 16:58:31 -07:00
|
|
|
for event := range events.Chan() {
|
|
|
|
switch event := event.(type) {
|
2014-10-31 02:59:17 -07:00
|
|
|
case chain.NewBlockEvent:
|
2014-10-13 16:58:31 -07:00
|
|
|
self.filterMu.RLock()
|
|
|
|
for _, filter := range self.filters {
|
|
|
|
if filter.BlockCallback != nil {
|
|
|
|
filter.BlockCallback(event.Block)
|
2014-09-13 15:13:23 -07:00
|
|
|
}
|
|
|
|
}
|
2014-10-13 16:58:31 -07:00
|
|
|
self.filterMu.RUnlock()
|
|
|
|
|
2014-10-31 06:43:14 -07:00
|
|
|
case state.Messages:
|
2014-10-13 16:58:31 -07:00
|
|
|
self.filterMu.RLock()
|
|
|
|
for _, filter := range self.filters {
|
|
|
|
if filter.MessageCallback != nil {
|
|
|
|
msgs := filter.FilterMessages(event)
|
|
|
|
if len(msgs) > 0 {
|
|
|
|
filter.MessageCallback(msgs)
|
2014-09-13 15:13:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-10-13 16:58:31 -07:00
|
|
|
self.filterMu.RUnlock()
|
2014-09-13 15:13:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-22 02:34:59 -07:00
|
|
|
func bootstrapDb(db ethutil.Database) {
|
|
|
|
d, _ := db.Get([]byte("ProtocolVersion"))
|
|
|
|
protov := ethutil.NewValue(d).Uint()
|
|
|
|
|
|
|
|
if protov == 0 {
|
|
|
|
db.Put([]byte("ProtocolVersion"), ethutil.NewValue(ProtocolVersion).Bytes())
|
|
|
|
}
|
|
|
|
}
|
2014-09-17 06:57:44 -07:00
|
|
|
|
|
|
|
func PastPeers() []string {
|
|
|
|
var ips []string
|
|
|
|
data, _ := ethutil.ReadAllFile(path.Join(ethutil.Config.ExecPath, "known_peers.json"))
|
|
|
|
json.Unmarshal([]byte(data), &ips)
|
|
|
|
|
|
|
|
return ips
|
|
|
|
}
|