2014-01-23 11:14:01 -08:00
|
|
|
package eth
|
|
|
|
|
|
|
|
import (
|
|
|
|
"container/list"
|
|
|
|
"github.com/ethereum/ethchain-go"
|
|
|
|
"github.com/ethereum/ethdb-go"
|
|
|
|
"github.com/ethereum/ethutil-go"
|
|
|
|
"github.com/ethereum/ethwire-go"
|
|
|
|
"log"
|
|
|
|
"net"
|
2014-02-01 12:30:54 -08:00
|
|
|
"strconv"
|
2014-01-23 11:14:01 -08:00
|
|
|
"sync/atomic"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
|
|
|
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() {
|
|
|
|
if peer, ok := e.Value.(*Peer); ok {
|
|
|
|
callback(peer, e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const (
|
|
|
|
processReapingTimeout = 60 // TODO increase
|
|
|
|
)
|
|
|
|
|
|
|
|
type Ethereum struct {
|
|
|
|
// Channel for shutting down the ethereum
|
|
|
|
shutdownChan chan bool
|
|
|
|
// DB interface
|
|
|
|
//db *ethdb.LDBDatabase
|
|
|
|
db *ethdb.MemDatabase
|
|
|
|
// Block manager for processing new blocks and managing the block chain
|
|
|
|
BlockManager *ethchain.BlockManager
|
|
|
|
// The transaction pool. Transaction can be pushed on this pool
|
|
|
|
// for later including in the blocks
|
|
|
|
TxPool *ethchain.TxPool
|
|
|
|
// Peers (NYI)
|
|
|
|
peers *list.List
|
|
|
|
// Nonce
|
|
|
|
Nonce uint64
|
2014-02-01 12:30:54 -08:00
|
|
|
|
|
|
|
Addr net.Addr
|
|
|
|
|
|
|
|
nat NAT
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func New() (*Ethereum, error) {
|
|
|
|
//db, err := ethdb.NewLDBDatabase()
|
|
|
|
db, err := ethdb.NewMemDatabase()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
ethutil.Config.Db = db
|
|
|
|
|
2014-02-01 12:30:54 -08:00
|
|
|
/*
|
|
|
|
nat, err := Discover()
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("Can'them discover upnp: %v", err)
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
nonce, _ := ethutil.RandomUint64()
|
|
|
|
ethereum := &Ethereum{
|
|
|
|
shutdownChan: make(chan bool),
|
|
|
|
db: db,
|
|
|
|
peers: list.New(),
|
|
|
|
Nonce: nonce,
|
2014-02-01 12:30:54 -08:00
|
|
|
//nat: nat,
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
ethereum.TxPool = ethchain.NewTxPool()
|
|
|
|
ethereum.TxPool.Speaker = ethereum
|
2014-01-24 08:48:21 -08:00
|
|
|
ethereum.BlockManager = ethchain.NewBlockManager(ethereum)
|
2014-01-23 11:14:01 -08:00
|
|
|
|
|
|
|
ethereum.TxPool.BlockManager = ethereum.BlockManager
|
|
|
|
ethereum.BlockManager.TransactionPool = ethereum.TxPool
|
|
|
|
|
|
|
|
return ethereum, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) AddPeer(conn net.Conn) {
|
|
|
|
peer := NewPeer(conn, s, true)
|
|
|
|
|
|
|
|
if peer != nil {
|
2014-01-30 15:56:32 -08:00
|
|
|
if s.peers.Len() > 25 {
|
2014-01-30 14:48:52 -08:00
|
|
|
log.Println("SEED")
|
|
|
|
peer.Start(true)
|
|
|
|
} else {
|
|
|
|
s.peers.PushBack(peer)
|
|
|
|
peer.Start(false)
|
|
|
|
}
|
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-01-30 16:12:48 -08:00
|
|
|
var alreadyConnected bool
|
|
|
|
|
|
|
|
eachPeer(s.peers, func(p *Peer, v *list.Element) {
|
2014-01-31 02:18:10 -08:00
|
|
|
if p.conn == nil {
|
|
|
|
return
|
|
|
|
}
|
2014-01-30 16:12:48 -08:00
|
|
|
phost, _, _ := net.SplitHostPort(p.conn.RemoteAddr().String())
|
|
|
|
ahost, _, _ := net.SplitHostPort(addr)
|
|
|
|
|
|
|
|
if phost == ahost {
|
|
|
|
alreadyConnected = true
|
|
|
|
return
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
if alreadyConnected {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
peer := NewOutboundPeer(addr, s)
|
|
|
|
|
|
|
|
s.peers.PushBack(peer)
|
|
|
|
|
|
|
|
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 {
|
|
|
|
// 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) {
|
|
|
|
inboundPeers[length] = p
|
|
|
|
length++
|
|
|
|
})
|
|
|
|
|
|
|
|
return inboundPeers[:length]
|
|
|
|
}
|
|
|
|
|
2014-01-23 13:32:50 -08:00
|
|
|
func (s *Ethereum) Broadcast(msgType ethwire.MsgType, data interface{}) {
|
|
|
|
msg := ethwire.NewMessage(msgType, data)
|
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-01-23 11:14:01 -08:00
|
|
|
func (s *Ethereum) ReapDeadPeers() {
|
|
|
|
for {
|
|
|
|
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.peers.Remove(e)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
time.Sleep(processReapingTimeout * time.Second)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-01 12:30:54 -08:00
|
|
|
// FIXME
|
|
|
|
func (s *Ethereum) upnpUpdateThread() {
|
|
|
|
// Go off immediately to prevent code duplication, thereafter we renew
|
|
|
|
// lease every 15 minutes.
|
|
|
|
timer := time.NewTimer(0 * time.Second)
|
|
|
|
lport, _ := strconv.ParseInt("30303", 10, 16)
|
|
|
|
first := true
|
|
|
|
out:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-timer.C:
|
|
|
|
listenPort, err := s.nat.AddPortMapping("TCP", int(lport), int(lport), "eth listen port", 20*60)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("can't add UPnP port mapping: %v\n", err)
|
|
|
|
}
|
|
|
|
if first && err == nil {
|
|
|
|
externalip, err := s.nat.GetExternalAddress()
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("UPnP can't get external address: %v\n", err)
|
|
|
|
continue out
|
|
|
|
}
|
|
|
|
// externalip, listenport
|
|
|
|
log.Println("Successfully bound via UPnP to", externalip, listenPort)
|
|
|
|
first = false
|
|
|
|
}
|
|
|
|
timer.Reset(time.Minute * 15)
|
|
|
|
case <-s.shutdownChan:
|
|
|
|
break out
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
timer.Stop()
|
|
|
|
|
|
|
|
if err := s.nat.DeletePortMapping("tcp", int(lport), int(lport)); err != nil {
|
|
|
|
log.Printf("unable to remove UPnP port mapping: %v\n", err)
|
|
|
|
} else {
|
|
|
|
log.Printf("succesfully disestablished UPnP port mapping\n")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
// Start the ethereum
|
|
|
|
func (s *Ethereum) Start() {
|
2014-01-27 13:13:46 -08:00
|
|
|
// Bind to addr and port
|
|
|
|
ln, err := net.Listen("tcp", ":30303")
|
2014-01-23 11:14:01 -08:00
|
|
|
if err != nil {
|
|
|
|
// This is mainly for testing to create a "network"
|
2014-02-01 12:30:54 -08:00
|
|
|
//if ethutil.Config.Debug {
|
|
|
|
//log.Println("Connection listening disabled. Acting as client")
|
|
|
|
//} else {
|
|
|
|
log.Fatal(err)
|
|
|
|
//}
|
2014-01-23 11:14:01 -08:00
|
|
|
} else {
|
2014-02-01 12:30:54 -08:00
|
|
|
s.Addr = ln.Addr()
|
2014-01-23 11:14:01 -08:00
|
|
|
// Starting accepting connections
|
|
|
|
go func() {
|
2014-01-30 14:48:52 -08:00
|
|
|
log.Println("Ready and accepting connections")
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
for {
|
|
|
|
conn, err := ln.Accept()
|
|
|
|
if err != nil {
|
|
|
|
log.Println(err)
|
|
|
|
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
go s.AddPeer(conn)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Start the reaping processes
|
|
|
|
go s.ReapDeadPeers()
|
|
|
|
|
|
|
|
// Start the tx pool
|
|
|
|
s.TxPool.Start()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) Stop() {
|
|
|
|
// Close the database
|
|
|
|
defer s.db.Close()
|
|
|
|
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
|
|
|
p.Stop()
|
|
|
|
})
|
|
|
|
|
|
|
|
s.shutdownChan <- true
|
|
|
|
|
|
|
|
s.TxPool.Stop()
|
|
|
|
}
|
|
|
|
|
|
|
|
// This function will wait for a shutdown and resumes main thread execution
|
|
|
|
func (s *Ethereum) WaitForShutdown() {
|
|
|
|
<-s.shutdownChan
|
|
|
|
}
|