github.com/n1ghtfa1l/go-vnt@v0.6.4-alpha.6/mobile/gvnt.go (about) 1 // Copyright 2016 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 // Contains all the wrappers from the node package to support client side node 18 // management on mobile platforms. 19 20 package gvnt 21 22 import ( 23 "encoding/json" 24 "fmt" 25 "path/filepath" 26 27 libp2p "github.com/libp2p/go-libp2p" 28 "github.com/vntchain/go-vnt/core" 29 "github.com/vntchain/go-vnt/internal/debug" 30 "github.com/vntchain/go-vnt/les" 31 "github.com/vntchain/go-vnt/node" 32 "github.com/vntchain/go-vnt/params" 33 "github.com/vntchain/go-vnt/vnt" 34 "github.com/vntchain/go-vnt/vnt/downloader" 35 "github.com/vntchain/go-vnt/vntclient" 36 "github.com/vntchain/go-vnt/vntp2p" 37 "github.com/vntchain/go-vnt/vntstats" 38 whisper "github.com/vntchain/go-vnt/whisper/whisperv6" 39 ) 40 41 // NodeConfig represents the collection of configuration values to fine tune the Gvnt 42 // node embedded into a mobile process. The available values are a subset of the 43 // entire API provided by go-ethereum to reduce the maintenance surface and dev 44 // complexity. 45 type NodeConfig struct { 46 // Bootstrap nodes used to establish connectivity with the rest of the network. 47 // BootstrapNodes *Enodes 48 49 // MaxPeers is the maximum number of peers that can be connected. If this is 50 // set to zero, then only the configured static and trusted peers can connect. 51 MaxPeers int 52 53 // VntEnabled specifies whether the node should run the VNT protocol. 54 VntEnabled bool 55 56 // HubbleNetworkID is the network identifier used by the VNT protocol to 57 // decide if remote peers should be accepted or not. 58 HubbleNetworkID int64 // uint64 in truth, but Java can't handle that... 59 60 // HubbleGenesis is the genesis JSON to use to seed the blockchain with. An 61 // empty genesis state is equivalent to using the mainnet's state. 62 HubbleGenesis string 63 64 // HubbleDatabaseCache is the system memory in MB to allocate for database caching. 65 // A minimum of 16MB is always reserved. 66 HubbleDatabaseCache int 67 68 // HubbleNetStats is a netstats connection string to use to report various 69 // chain, transaction and node stats to a monitoring server. 70 // 71 // It has the form "nodename:secret@host:port" 72 HubbleNetStats string 73 74 // WhisperEnabled specifies whether the node should run the Whisper protocol. 75 WhisperEnabled bool 76 77 // Listening address of pprof server. 78 PprofAddress string 79 } 80 81 // defaultNodeConfig contains the default node configuration values to use if all 82 // or some fields are missing from the user's specified list. 83 var defaultNodeConfig = &NodeConfig{ 84 // BootstrapNodes: FoundationBootnodes(), 85 MaxPeers: 25, 86 VntEnabled: true, 87 HubbleNetworkID: 1, 88 HubbleDatabaseCache: 16, 89 } 90 91 // NewNodeConfig creates a new node option set, initialized to the default values. 92 func NewNodeConfig() *NodeConfig { 93 config := *defaultNodeConfig 94 return &config 95 } 96 97 // Node represents a Gvnt VNT node instance. 98 type Node struct { 99 node *node.Node 100 } 101 102 // NewNode creates and configures a new Gvnt node. 103 func NewNode(datadir string, config *NodeConfig) (stack *Node, _ error) { 104 // If no or partial configurations were specified, use defaults 105 if config == nil { 106 config = NewNodeConfig() 107 } 108 if config.MaxPeers == 0 { 109 config.MaxPeers = defaultNodeConfig.MaxPeers 110 } 111 // if config.BootstrapNodes == nil || config.BootstrapNodes.Size() == 0 { 112 // config.BootstrapNodes = defaultNodeConfig.BootstrapNodes 113 // } 114 115 if config.PprofAddress != "" { 116 debug.StartPProf(config.PprofAddress) 117 } 118 119 // Create the empty networking stack 120 nodeConf := &node.Config{ 121 Name: clientIdentifier, 122 Version: params.Version, 123 DataDir: datadir, 124 KeyStoreDir: filepath.Join(datadir, "keystore"), // Mobile should never use internal keystores! 125 P2P: vntp2p.Config{ 126 NoDiscovery: true, 127 // DiscoveryV5: true, 128 // BootstrapNodesV5: config.BootstrapNodes.nodes, 129 ListenAddr: ":0", 130 // NAT: nat.Any(), 131 NAT: libp2p.NATPortMap(), 132 MaxPeers: config.MaxPeers, 133 }, 134 } 135 rawStack, err := node.New(nodeConf) 136 if err != nil { 137 return nil, err 138 } 139 140 debug.Memsize.Add("node", rawStack) 141 142 var genesis *core.Genesis 143 if config.HubbleGenesis != "" { 144 // Parse the user supplied genesis spec if not mainnet 145 genesis = new(core.Genesis) 146 if err := json.Unmarshal([]byte(config.HubbleGenesis), genesis); err != nil { 147 return nil, fmt.Errorf("invalid genesis spec: %v", err) 148 } 149 } 150 // Register the VNT protocol if requested 151 if config.VntEnabled { 152 vntConf := vnt.DefaultConfig 153 vntConf.Genesis = genesis 154 vntConf.SyncMode = downloader.LightSync 155 vntConf.NetworkId = uint64(config.HubbleNetworkID) 156 vntConf.DatabaseCache = config.HubbleDatabaseCache 157 if err := rawStack.Register(func(ctx *node.ServiceContext) (node.Service, error) { 158 return les.New(ctx, &vntConf) 159 }); err != nil { 160 return nil, fmt.Errorf("gvnt init: %v", err) 161 } 162 // If netstats reporting is requested, do it 163 if config.HubbleNetStats != "" { 164 if err := rawStack.Register(func(ctx *node.ServiceContext) (node.Service, error) { 165 var lesServ *les.LightVnt 166 ctx.Service(&lesServ) 167 168 return vntstats.New(config.HubbleNetStats, nil, lesServ) 169 }); err != nil { 170 return nil, fmt.Errorf("netstats init: %v", err) 171 } 172 } 173 } 174 // Register the Whisper protocol if requested 175 if config.WhisperEnabled { 176 if err := rawStack.Register(func(*node.ServiceContext) (node.Service, error) { 177 return whisper.New(&whisper.DefaultConfig), nil 178 }); err != nil { 179 return nil, fmt.Errorf("whisper init: %v", err) 180 } 181 } 182 return &Node{rawStack}, nil 183 } 184 185 // Start creates a live P2P node and starts running it. 186 func (n *Node) Start() error { 187 return n.node.Start() 188 } 189 190 // Stop terminates a running node along with all it's services. In the node was 191 // not started, an error is returned. 192 func (n *Node) Stop() error { 193 return n.node.Stop() 194 } 195 196 // GetVNTClient retrieves a client to access the VNT subsystem. 197 func (n *Node) GetVNTClient() (client *VNTClient, _ error) { 198 rpc, err := n.node.Attach() 199 if err != nil { 200 return nil, err 201 } 202 return &VNTClient{vntclient.NewClient(rpc)}, nil 203 } 204 205 // GetNodeInfo gathers and returns a collection of metadata known about the host. 206 func (n *Node) GetNodeInfo() *NodeInfo { 207 return &NodeInfo{n.node.Server().NodeInfo()} 208 } 209 210 // GetPeersInfo returns an array of metadata objects describing connected peers. 211 func (n *Node) GetPeersInfo() *PeerInfos { 212 return &PeerInfos{n.node.Server().PeersInfo()} 213 }