plugeth/ethereum.go

645 lines
14 KiB
Go
Raw Normal View History

2014-01-23 19:14:01 +00:00
package eth
import (
"container/list"
2014-09-16 14:36:27 +00:00
"encoding/json"
"fmt"
2014-09-24 09:39:17 +00:00
"math/big"
"math/rand"
2014-01-23 19:14:01 +00:00
"net"
2014-09-16 14:36:27 +00:00
"path"
2014-02-02 18:22:39 +00:00
"strconv"
"strings"
2014-02-02 15:15:39 +00:00
"sync"
2014-01-23 19:14:01 +00:00
"sync/atomic"
"time"
2014-07-26 09:24:44 +00:00
"github.com/ethereum/eth-go/ethchain"
"github.com/ethereum/eth-go/ethcrypto"
"github.com/ethereum/eth-go/ethlog"
2014-07-30 16:03:20 +00:00
"github.com/ethereum/eth-go/ethreact"
2014-07-26 09:24:44 +00:00
"github.com/ethereum/eth-go/ethrpc"
2014-09-13 22:13:23 +00:00
"github.com/ethereum/eth-go/ethstate"
2014-07-26 09:24:44 +00:00
"github.com/ethereum/eth-go/ethutil"
"github.com/ethereum/eth-go/ethwire"
2014-01-23 19:14:01 +00:00
)
2014-07-29 21:33:59 +00:00
const (
seedTextFileUri string = "http://www.ethereum.org/servers.poc3.txt"
2014-09-22 14:28:49 +00:00
seedNodeAddress = "poc-6.ethdev.com:30303"
2014-07-29 21:33:59 +00:00
)
2014-07-11 14:04:09 +00:00
var ethlogger = ethlog.NewLogger("SERV")
2014-01-23 19:14:01 +00: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 14:36:27 +00:00
callback(e.Value.(*Peer), e)
2014-01-23 19:14:01 +00:00
}
}
const (
processReapingTimeout = 60 // TODO increase
)
type Ethereum struct {
// Channel for shutting down the ethereum
shutdownChan chan bool
2014-02-02 18:22:39 +00:00
quit chan bool
2014-08-11 14:23:38 +00:00
2014-01-23 19:14:01 +00:00
// DB interface
db ethutil.Database
2014-03-05 09:57:32 +00:00
// State manager for processing new blocks and managing the over all states
stateManager *ethchain.StateManager
2014-01-23 19:14:01 +00:00
// The transaction pool. Transaction can be pushed on this pool
// for later including in the blocks
txPool *ethchain.TxPool
// The canonical chain
blockChain *ethchain.BlockChain
// The block pool
blockPool *BlockPool
2014-01-23 19:14:01 +00:00
// Peers (NYI)
peers *list.List
// Nonce
Nonce uint64
2014-02-01 20:30:54 +00:00
Addr net.Addr
Port string
2014-02-01 20:30:54 +00:00
2014-02-02 15:15:39 +00:00
peerMut sync.Mutex
// Capabilities for outgoing peers
serverCaps Caps
2014-02-02 18:22:39 +00:00
nat NAT
// Specifies the desired amount of maximum peers
MaxPeers int
2014-03-10 10:53:02 +00:00
Mining bool
listening bool
reactor *ethreact.ReactorEngine
2014-05-02 11:35:25 +00:00
2014-05-05 13:15:14 +00:00
RpcServer *ethrpc.JsonRpcServer
keyManager *ethcrypto.KeyManager
clientIdentity ethwire.ClientIdentity
2014-07-17 20:01:13 +00:00
isUpToDate bool
2014-09-13 22:13:23 +00:00
filters map[int]*ethchain.Filter
2014-01-23 19:14:01 +00:00
}
func New(db ethutil.Database, clientIdentity ethwire.ClientIdentity, keyManager *ethcrypto.KeyManager, caps Caps, usePnp bool) (*Ethereum, error) {
var err error
2014-02-02 18:44:47 +00:00
var nat NAT
2014-02-02 18:44:47 +00:00
if usePnp {
nat, err = Discover()
if err != nil {
ethlogger.Debugln("UPnP failed", err)
2014-02-02 18:44:47 +00:00
}
2014-02-02 18:22:39 +00:00
}
bootstrapDb(db)
2014-01-23 19:14:01 +00:00
ethutil.Config.Db = db
nonce, _ := ethutil.RandomUint64()
ethereum := &Ethereum{
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 20:01:13 +00:00
isUpToDate: true,
2014-09-13 22:13:23 +00:00
filters: make(map[int]*ethchain.Filter),
2014-01-23 19:14:01 +00:00
}
ethereum.reactor = ethreact.New()
2014-03-10 10:53:02 +00:00
ethereum.blockPool = NewBlockPool(ethereum)
ethereum.txPool = ethchain.NewTxPool(ethereum)
ethereum.blockChain = ethchain.NewBlockChain(ethereum)
2014-03-05 09:57:32 +00:00
ethereum.stateManager = ethchain.NewStateManager(ethereum)
2014-01-23 19:14:01 +00:00
// Start the tx pool
ethereum.txPool.Start()
2014-01-23 19:14:01 +00:00
return ethereum, nil
}
func (s *Ethereum) Reactor() *ethreact.ReactorEngine {
2014-03-10 10:53:02 +00:00
return s.reactor
}
func (s *Ethereum) KeyManager() *ethcrypto.KeyManager {
return s.keyManager
}
func (s *Ethereum) ClientIdentity() ethwire.ClientIdentity {
return s.clientIdentity
}
func (s *Ethereum) BlockChain() *ethchain.BlockChain {
return s.blockChain
}
2014-03-05 09:57:32 +00:00
func (s *Ethereum) StateManager() *ethchain.StateManager {
return s.stateManager
}
func (s *Ethereum) TxPool() *ethchain.TxPool {
return s.txPool
}
2014-08-11 14:23:38 +00:00
func (self *Ethereum) Db() ethutil.Database {
return self.db
}
func (s *Ethereum) ServerCaps() Caps {
return s.serverCaps
}
func (s *Ethereum) IsMining() bool {
return s.Mining
}
func (s *Ethereum) PeerCount() int {
return s.peers.Len()
}
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 09:57:44 +00:00
if peer.catchingUp == true && peer.versionKnown {
upToDate = false
}
}
})
return upToDate
}
func (s *Ethereum) PushPeer(peer *Peer) {
s.peers.PushBack(peer)
}
func (s *Ethereum) IsListening() bool {
return s.listening
}
2014-09-24 09:39:17 +00: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-01-23 19:14:01 +00:00
func (s *Ethereum) AddPeer(conn net.Conn) {
peer := NewPeer(conn, s, true)
if peer != nil {
if s.peers.Len() < s.MaxPeers {
peer.Start()
} else {
ethlogger.Debugf("Max connected peers reached. Not adding incoming peer.")
}
2014-01-23 19:14:01 +00: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-18 00:34:06 +00:00
if s.peers.Len() < s.MaxPeers {
var alreadyConnected bool
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-18 00:34:06 +00:00
eachPeer(s.peers, func(p *Peer, v *list.Element) {
if p.conn == nil {
return
}
phost, _, _ := net.SplitHostPort(p.conn.RemoteAddr().String())
if phost == chost {
2014-02-18 00:34:06 +00:00
alreadyConnected = true
//ethlogger.Debugf("Peer %s already added.\n", chost)
2014-02-18 00:34:06 +00:00
return
}
})
if alreadyConnected {
return nil
}
NewOutboundPeer(addr, s, s.serverCaps)
2014-02-18 00:34:06 +00:00
}
2014-01-23 19:14:01 +00: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 10:18:10 +00:00
if !p.inbound && p.conn != nil {
2014-01-23 19:14:01 +00: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]
}
func (s *Ethereum) InOutPeers() []*Peer {
2014-02-02 15:15:39 +00:00
// Reap the dead peers first
s.reapPeers()
// 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 15:15:39 +00:00
// Only return peers with an actual ip
if len(p.host) > 0 {
inboundPeers[length] = p
length++
}
})
return inboundPeers[:length]
}
2014-02-02 00:39:06 +00:00
func (s *Ethereum) Broadcast(msgType ethwire.MsgType, data []interface{}) {
msg := ethwire.NewMessage(msgType, data)
2014-02-02 15:15:39 +00:00
s.BroadcastMsg(msg)
}
func (s *Ethereum) BroadcastMsg(msg *ethwire.Msg) {
2014-01-23 19:14:01 +00:00
eachPeer(s.peers, func(p *Peer, e *list.Element) {
p.QueueMessage(msg)
2014-01-23 19:14:01 +00:00
})
}
func (s *Ethereum) Peers() *list.List {
return s.peers
}
2014-02-02 15:15:39 +00:00
func (s *Ethereum) reapPeers() {
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 15:15:39 +00:00
s.peerMut.Lock()
defer s.peerMut.Unlock()
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 15:15:39 +00:00
}
})
}
2014-01-23 19:14:01 +00:00
2014-02-02 15:15:39 +00:00
func (s *Ethereum) ReapDeadPeerHandler() {
reapTimer := time.NewTicker(processReapingTimeout * time.Second)
for {
select {
case <-reapTimer.C:
s.reapPeers()
}
2014-01-23 19:14:01 +00:00
}
}
// Start the ethereum
2014-05-09 14:09:28 +00:00
func (s *Ethereum) Start(seed bool) {
s.reactor.Start()
2014-01-27 21:13:46 +00:00
// Bind to addr and port
ln, err := net.Listen("tcp", ":"+s.Port)
2014-01-23 19:14:01 +00:00
if err != nil {
ethlogger.Warnf("Port %s in use. Connection listening disabled. Acting as client", s.Port)
s.listening = false
2014-01-23 19:14:01 +00:00
} else {
s.listening = true
2014-01-23 19:14:01 +00:00
// Starting accepting connections
ethlogger.Infoln("Ready and accepting connections")
2014-02-02 15:15:39 +00:00
// Start the peer handler
go s.peerHandler(ln)
2014-01-23 19:14:01 +00:00
}
2014-02-02 18:44:47 +00:00
if s.nat != nil {
go s.upnpUpdateThread()
}
2014-02-02 18:22:39 +00:00
2014-01-23 19:14:01 +00:00
// Start the reaping processes
2014-02-02 15:15:39 +00:00
go s.ReapDeadPeerHandler()
2014-07-17 20:01:13 +00:00
go s.update()
2014-09-13 22:13:23 +00:00
go s.filterLoop()
2014-01-23 19:14:01 +00:00
2014-05-09 14:09:28 +00:00
if seed {
s.Seed()
}
ethlogger.Infoln("Server started")
2014-05-09 14:09:28 +00:00
}
func (s *Ethereum) Seed() {
2014-09-17 13:57:44 +00:00
ips := PastPeers()
2014-09-16 14:36:27 +00:00
if len(ips) > 0 {
for _, ip := range ips {
2014-09-16 14:36:27 +00: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-09-16 14:36:27 +00: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 09:37:37 +00:00
}
}
2014-09-16 14:36:27 +00:00
// Connect to Peer list
s.ProcessPeerList(peers)
2014-03-17 09:37:37 +00:00
}
2014-07-29 21:33:59 +00:00
2014-09-16 14:36:27 +00:00
// XXX tmp
s.ConnectToPeer(seedNodeAddress)
}
2014-01-23 19:14:01 +00:00
}
2014-02-02 15:15:39 +00:00
func (s *Ethereum) peerHandler(listener net.Listener) {
for {
conn, err := listener.Accept()
if err != nil {
ethlogger.Debugln(err)
2014-02-02 15:15:39 +00:00
continue
}
go s.AddPeer(conn)
}
}
2014-01-23 19:14:01 +00:00
func (s *Ethereum) Stop() {
// Close the database
defer s.db.Close()
2014-09-16 14:36:27 +00:00
var ips []string
eachPeer(s.peers, func(p *Peer, e *list.Element) {
ips = append(ips, p.conn.RemoteAddr().String())
})
2014-09-17 13:57:44 +00:00
if len(ips) > 0 {
d, _ := json.MarshalIndent(ips, "", " ")
ethutil.WriteFile(path.Join(ethutil.Config.ExecPath, "known_peers.json"), d)
}
2014-09-16 14:36:27 +00:00
2014-01-23 19:14:01 +00:00
eachPeer(s.peers, func(p *Peer, e *list.Element) {
p.Stop()
})
2014-02-02 18:22:39 +00:00
close(s.quit)
if s.RpcServer != nil {
s.RpcServer.Stop()
}
s.txPool.Stop()
2014-03-05 09:57:32 +00:00
s.stateManager.Stop()
s.reactor.Flush()
s.reactor.Stop()
ethlogger.Infoln("Server stopped")
2014-02-28 15:45:29 +00:00
close(s.shutdownChan)
2014-01-23 19:14:01 +00:00
}
// This function will wait for a shutdown and resumes main thread execution
func (s *Ethereum) WaitForShutdown() {
<-s.shutdownChan
}
2014-02-02 18:22:39 +00:00
func (s *Ethereum) upnpUpdateThread() {
// Go off immediately to prevent code duplication, thereafter we renew
// lease every 15 minutes.
2014-05-01 20:14:20 +00:00
timer := time.NewTimer(5 * time.Minute)
lport, _ := strconv.ParseInt(s.Port, 10, 16)
2014-02-02 18:22:39 +00:00
first := true
out:
for {
select {
case <-timer.C:
2014-02-02 18:44:47 +00:00
var err error
_, err = s.nat.AddPortMapping("TCP", int(lport), int(lport), "eth listen port", 20*60)
2014-02-02 18:22:39 +00:00
if err != nil {
ethlogger.Debugln("can't add UPnP port mapping:", err)
2014-02-02 18:22:39 +00:00
break out
}
if first && err == nil {
2014-02-02 18:44:47 +00:00
_, err = s.nat.GetExternalAddress()
2014-02-02 18:22:39 +00:00
if err != nil {
ethlogger.Debugln("UPnP can't get external address:", err)
2014-02-02 18:22:39 +00: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 {
ethlogger.Debugln("unable to remove UPnP port mapping:", err)
2014-02-02 18:22:39 +00:00
} else {
ethlogger.Debugln("succesfully disestablished UPnP port mapping")
2014-02-02 18:22:39 +00:00
}
}
2014-07-17 20:01:13 +00: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-09-13 22:13:23 +00: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)
}
}
}
}
}
}
}
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 13:57:44 +00: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
}