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
|
|
|
|
|
|
|
"github.com/ethereum/eth-go/ethchain"
|
|
|
|
"github.com/ethereum/eth-go/ethcrypto"
|
|
|
|
"github.com/ethereum/eth-go/ethlog"
|
2014-07-30 09:03:20 -07:00
|
|
|
"github.com/ethereum/eth-go/ethreact"
|
2014-07-26 02:24:44 -07:00
|
|
|
"github.com/ethereum/eth-go/ethrpc"
|
2014-09-13 15:13:23 -07:00
|
|
|
"github.com/ethereum/eth-go/ethstate"
|
2014-07-26 02:24:44 -07:00
|
|
|
"github.com/ethereum/eth-go/ethutil"
|
|
|
|
"github.com/ethereum/eth-go/ethwire"
|
2014-09-29 03:57:51 -07:00
|
|
|
"github.com/ethereum/eth-go/eventer"
|
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-09-22 07:28:49 -07:00
|
|
|
seedNodeAddress = "poc-6.ethdev.com:30303"
|
2014-07-29 14:33:59 -07:00
|
|
|
)
|
2014-07-11 07:04:09 -07:00
|
|
|
|
2014-06-23 04:54:10 -07:00
|
|
|
var ethlogger = ethlog.NewLogger("SERV")
|
|
|
|
|
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
|
|
|
|
stateManager *ethchain.StateManager
|
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-03-05 01:42:51 -08:00
|
|
|
txPool *ethchain.TxPool
|
|
|
|
// The canonical chain
|
|
|
|
blockChain *ethchain.BlockChain
|
2014-08-21 05:47:58 -07:00
|
|
|
// The block pool
|
|
|
|
blockPool *BlockPool
|
2014-09-29 03:57:51 -07:00
|
|
|
// Eventer
|
|
|
|
eventer *eventer.EventMachine
|
|
|
|
// 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-07-14 17:11:06 -07:00
|
|
|
reactor *ethreact.ReactorEngine
|
2014-05-02 04:35:25 -07:00
|
|
|
|
2014-05-05 06:15:14 -07:00
|
|
|
RpcServer *ethrpc.JsonRpcServer
|
2014-06-29 10:30:05 -07:00
|
|
|
|
|
|
|
keyManager *ethcrypto.KeyManager
|
2014-07-03 09:30:04 -07:00
|
|
|
|
|
|
|
clientIdentity ethwire.ClientIdentity
|
2014-07-17 13:01:13 -07:00
|
|
|
|
|
|
|
isUpToDate bool
|
2014-09-13 15:13:23 -07:00
|
|
|
|
|
|
|
filters map[int]*ethchain.Filter
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-07-03 09:30:04 -07:00
|
|
|
func New(db ethutil.Database, clientIdentity ethwire.ClientIdentity, keyManager *ethcrypto.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-06-23 04:54:10 -07:00
|
|
|
ethlogger.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-09-13 15:13:23 -07:00
|
|
|
filters: make(map[int]*ethchain.Filter),
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
2014-07-14 17:11:06 -07:00
|
|
|
ethereum.reactor = ethreact.New()
|
2014-09-29 03:57:51 -07:00
|
|
|
ethereum.eventer = eventer.New()
|
2014-03-10 03:53:02 -07:00
|
|
|
|
2014-08-21 05:47:58 -07:00
|
|
|
ethereum.blockPool = NewBlockPool(ethereum)
|
2014-03-05 01:42:51 -08:00
|
|
|
ethereum.txPool = ethchain.NewTxPool(ethereum)
|
|
|
|
ethereum.blockChain = ethchain.NewBlockChain(ethereum)
|
2014-03-05 01:57:32 -08:00
|
|
|
ethereum.stateManager = ethchain.NewStateManager(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-07-14 17:11:06 -07:00
|
|
|
func (s *Ethereum) Reactor() *ethreact.ReactorEngine {
|
2014-03-10 03:53:02 -07:00
|
|
|
return s.reactor
|
|
|
|
}
|
|
|
|
|
2014-06-29 10:30:05 -07:00
|
|
|
func (s *Ethereum) KeyManager() *ethcrypto.KeyManager {
|
|
|
|
return s.keyManager
|
|
|
|
}
|
|
|
|
|
2014-07-03 09:30:04 -07:00
|
|
|
func (s *Ethereum) ClientIdentity() ethwire.ClientIdentity {
|
|
|
|
return s.clientIdentity
|
|
|
|
}
|
|
|
|
|
2014-03-05 01:42:51 -08:00
|
|
|
func (s *Ethereum) BlockChain() *ethchain.BlockChain {
|
|
|
|
return s.blockChain
|
|
|
|
}
|
|
|
|
|
2014-03-05 01:57:32 -08:00
|
|
|
func (s *Ethereum) StateManager() *ethchain.StateManager {
|
|
|
|
return s.stateManager
|
2014-03-05 01:42:51 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) TxPool() *ethchain.TxPool {
|
|
|
|
return s.txPool
|
|
|
|
}
|
2014-09-24 10:56:21 -07:00
|
|
|
func (s *Ethereum) BlockPool() *BlockPool {
|
|
|
|
return s.blockPool
|
|
|
|
}
|
2014-09-29 03:57:51 -07:00
|
|
|
func (s *Ethereum) Eventer() *eventer.EventMachine {
|
|
|
|
return s.eventer
|
|
|
|
}
|
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-06-23 04:54:10 -07:00
|
|
|
ethlogger.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-06-23 04:54:10 -07:00
|
|
|
//ethlogger.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-02-01 16:39:06 -08:00
|
|
|
func (s *Ethereum) Broadcast(msgType ethwire.MsgType, data []interface{}) {
|
2014-01-23 13:32:50 -08:00
|
|
|
msg := ethwire.NewMessage(msgType, data)
|
2014-02-02 07:15:39 -08:00
|
|
|
s.BroadcastMsg(msg)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) BroadcastMsg(msg *ethwire.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)
|
|
|
|
|
|
|
|
s.reactor.Post("peerList", s.peers)
|
|
|
|
}
|
|
|
|
|
|
|
|
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-07-14 17:11:06 -07:00
|
|
|
s.reactor.Start()
|
2014-09-24 12:13:28 -07:00
|
|
|
s.blockPool.Start()
|
2014-09-29 03:57:51 -07:00
|
|
|
s.stateManager.Start()
|
|
|
|
|
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-06-26 08:37:56 -07:00
|
|
|
ethlogger.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-06-23 04:54:10 -07:00
|
|
|
ethlogger.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-06-26 02:43:02 -07:00
|
|
|
ethlogger.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-09-16 07:36:27 -07:00
|
|
|
ethlogger.Infoln("Connecting to previous peer ", ip)
|
|
|
|
s.ConnectToPeer(ip)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ethlogger.Debugln("Retrieving seed nodes")
|
|
|
|
|
|
|
|
// 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)
|
|
|
|
ethlogger.Debugln("Found DNS Go Peer:", node)
|
|
|
|
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)
|
|
|
|
ethlogger.Debugln("Found DNS Bootstrap Peer:", peer)
|
|
|
|
peers = append(peers, peer)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ethlogger.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-06-23 04:54:10 -07:00
|
|
|
ethlogger.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() {
|
|
|
|
// 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-03-05 01:57:32 -08:00
|
|
|
s.stateManager.Stop()
|
2014-07-14 17:11:06 -07:00
|
|
|
s.reactor.Flush()
|
|
|
|
s.reactor.Stop()
|
2014-09-24 10:56:21 -07:00
|
|
|
s.blockPool.Stop()
|
2014-02-08 12:02:09 -08:00
|
|
|
|
2014-06-26 02:43:02 -07:00
|
|
|
ethlogger.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-06-23 04:54:10 -07:00
|
|
|
ethlogger.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-06-23 04:54:10 -07:00
|
|
|
ethlogger.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-06-23 04:54:10 -07:00
|
|
|
ethlogger.Debugln("unable to remove UPnP port mapping:", err)
|
2014-02-02 10:22:39 -08:00
|
|
|
} else {
|
2014-06-23 04:54:10 -07:00
|
|
|
ethlogger.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 {
|
|
|
|
self.reactor.Post("chainSync", false)
|
|
|
|
self.isUpToDate = true
|
|
|
|
} else if !self.IsUpToDate() && self.isUpToDate {
|
|
|
|
self.reactor.Post("chainSync", true)
|
|
|
|
self.isUpToDate = false
|
|
|
|
}
|
|
|
|
case <-self.quit:
|
|
|
|
break out
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-08-22 02:34:59 -07:00
|
|
|
|
2014-09-13 15:13:23 -07:00
|
|
|
var filterId = 0
|
|
|
|
|
|
|
|
func (self *Ethereum) InstallFilter(object map[string]interface{}) (*ethchain.Filter, int) {
|
|
|
|
defer func() { filterId++ }()
|
|
|
|
|
|
|
|
filter := ethchain.NewFilterFromMap(object, self)
|
|
|
|
self.filters[filterId] = filter
|
|
|
|
|
|
|
|
return filter, filterId
|
|
|
|
}
|
|
|
|
|
|
|
|
func (self *Ethereum) UninstallFilter(id int) {
|
|
|
|
delete(self.filters, id)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (self *Ethereum) GetFilter(id int) *ethchain.Filter {
|
|
|
|
return self.filters[id]
|
|
|
|
}
|
|
|
|
|
|
|
|
func (self *Ethereum) filterLoop() {
|
|
|
|
blockChan := make(chan ethreact.Event, 5)
|
|
|
|
messageChan := make(chan ethreact.Event, 5)
|
|
|
|
// Subscribe to events
|
|
|
|
reactor := self.Reactor()
|
|
|
|
reactor.Subscribe("newBlock", blockChan)
|
|
|
|
reactor.Subscribe("messages", messageChan)
|
|
|
|
out:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-self.quit:
|
|
|
|
break out
|
|
|
|
case block := <-blockChan:
|
|
|
|
if block, ok := block.Resource.(*ethchain.Block); ok {
|
|
|
|
for _, filter := range self.filters {
|
|
|
|
if filter.BlockCallback != nil {
|
|
|
|
filter.BlockCallback(block)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case msg := <-messageChan:
|
|
|
|
if messages, ok := msg.Resource.(ethstate.Messages); ok {
|
|
|
|
for _, filter := range self.filters {
|
|
|
|
if filter.MessageCallback != nil {
|
|
|
|
msgs := filter.FilterMessages(messages)
|
|
|
|
if len(msgs) > 0 {
|
|
|
|
filter.MessageCallback(msgs)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
}
|