go ethreum eth之Ethereum

结构

LifeCycle：组件生命周期接口，其定义为

type Lifecycle interface {// Start is called after all services have been constructed and the networking// layer was also initialized to spawn any goroutines required by the service.Start() error// Stop terminates all goroutines belonging to the service, blocking until they// are all terminated.Stop() error
}

Ethereum

结构定义为

type Ethereum struct {// core protocol objectsconfig         *ethconfig.ConfigtxPool         *txpool.TxPoolblobTxPool     *blobpool.BlobPoollocalTxTracker *locals.TxTrackerblockchain     *core.BlockChainhandler *handlerdiscmix *enode.FairMixdropper *dropper// DB interfaceschainDb ethdb.Database // Block chain databaseeventMux       *event.TypeMuxengine         consensus.EngineaccountManager *accounts.ManagerfilterMaps      *filtermaps.FilterMapscloseFilterMaps chan chan struct{}APIBackend *EthAPIBackendminer    *miner.MinergasPrice *big.IntnetworkID     uint64netRPCService *ethapi.NetAPIp2pServer *p2p.Serverlock sync.RWMutex // Protects the variadic fields (e.g. gas price and etherbase)shutdownTracker *shutdowncheck.ShutdownTracker // Tracks if and when the node has shutdown ungracefully
}

关键成员有

• blockchain：类型为*core.BlockChain
• txPool ：类型为 *txpool.TxPool
• blobTxPool：类型为*blobpool.BlobPool
• engine：类型为consensus.Engine，共识引擎
• miner：类型为 *miner.Miner
• netRPCService：类型为*ethapi.NetAPI，rpc服务
• APIBackend：类型为 *EthAPIBackend，处理rpc请求

其实现了LifeCycle接口，同时与rpc.API和p2p.Protocol相关的接口有

func (s *Ethereum) APIs() []rpc.API
func (s *Ethereum) Protocols() []p2p.Protocol

在创建Ethereum时向Node注册eth服务时，会将rpc.API和p2p.Protocol以及向自己注册到node

stack.RegisterAPIs(eth.APIs())
stack.RegisterProtocols(eth.Protocols())
stack.RegisterLifecycle(eth)

在node.openEndpoint时会开启服务，启动p2p server
ethereum依赖EthAPIBackend

EthAPIBackend：实现了ethapi.Backend接口
在创建Ethereum时会注册rpc.API，主要包含有

• eth
  • NewEthereumAPI(apiBackend)
  • NewBlockChainAPI(apiBackend)
  • NewTransactionAPI(apiBackend, nonceLock)
  • NewEthereumAccountAPI(apiBackend.AccountManager())
  • downloader.NewDownloaderAPI(s.handler.downloader, s.blockchain, s.eventMux)
  • filters.NewFilterAPI(filterSystem)
• txpool
  • NewTxPoolAPI(apiBackend)
• debug
  • NewDebugAPI(apiBackend)
  • NewDebugAPI(s)
  • NewAPI(backend)
  • NewAPI(s)：s为Syncer
• miner
  • NewMinerAPI(s)
• admin
  • NewAdminAPI(s)
• net
  • s.netRPCService
• dev
  • newSimulatedBeaconAPI(sim)
• engine
  • NewConsensusAPI(backend)

代码为

eth.netRPCService = ethapi.NewNetAPI(eth.p2pServer, networkID)// Register the backend on the node
stack.RegisterAPIs(eth.APIs())func (s *Ethereum) APIs() []rpc.API {apis := ethapi.GetAPIs(s.APIBackend)// Append all the local APIs and returnreturn append(apis, []rpc.API{{Namespace: "miner",Service:   NewMinerAPI(s),}, {Namespace: "eth",Service:   downloader.NewDownloaderAPI(s.handler.downloader, s.blockchain, s.eventMux),}, {Namespace: "admin",Service:   NewAdminAPI(s),}, {Namespace: "debug",Service:   NewDebugAPI(s),}, {Namespace: "net",Service:   s.netRPCService,},}...)
}func GetAPIs(apiBackend Backend) []rpc.API {nonceLock := new(AddrLocker)return []rpc.API{{Namespace: "eth",Service:   NewEthereumAPI(apiBackend),}, {Namespace: "eth",Service:   NewBlockChainAPI(apiBackend),}, {Namespace: "eth",Service:   NewTransactionAPI(apiBackend, nonceLock),}, {Namespace: "txpool",Service:   NewTxPoolAPI(apiBackend),}, {Namespace: "debug",Service:   NewDebugAPI(apiBackend),}, {Namespace: "eth",Service:   NewEthereumAccountAPI(apiBackend.AccountManager()),},}
}stack.RegisterAPIs(tracers.APIs(backend.APIBackend))
func APIs(backend Backend) []rpc.API {// Append all the local APIs and returnreturn []rpc.API{{Namespace: "debug",Service:   NewAPI(backend),},}
}filterSystem := utils.RegisterFilterAPI(stack, backend, &cfg.Eth)
func RegisterFilterAPI(stack *node.Node, backend ethapi.Backend, ethcfg *ethconfig.Config) *filters.FilterSystem {filterSystem := filters.NewFilterSystem(backend, filters.Config{LogCacheSize: ethcfg.FilterLogCacheSize,})stack.RegisterAPIs([]rpc.API{{Namespace: "eth",Service:   filters.NewFilterAPI(filterSystem),}})return filterSystem
}

在创建全节点时，会注册一些api,lifecycle以及handler,api的上面已经说过，还有api, lifecycle和handler
api的有

• RegisterSyncOverrideService
• RegisterSimulatedBeaconAPIs
• catalyst.Register

handler的有

• RegisterGraphQLService

lifecycle有

• RegisterEthStatsService
• RegisterSyncOverrideService
• stack.RegisterLifecycle(simBeacon)：其中simBeacon是通过catalyst.NewSimulatedBeacon创建
• stack.RegisterLifecycle(blsyncer)：其中blsyncer是通过blsync.NewClient创建

func RegisterGraphQLService(stack *node.Node, backend ethapi.Backend, filterSystem *filters.FilterSystem, cfg *node.Config) {err := graphql.New(stack, backend, filterSystem, cfg.GraphQLCors, cfg.GraphQLVirtualHosts)if err != nil {Fatalf("Failed to register the GraphQL service: %v", err)}
}func New(stack *node.Node, backend ethapi.Backend, filterSystem *filters.FilterSystem, cors, vhosts []string) error {_, err := newHandler(stack, backend, filterSystem, cors, vhosts)return err
}func newHandler(stack *node.Node, backend ethapi.Backend, filterSystem *filters.FilterSystem, cors, vhosts []string) (*handler, error) {q := Resolver{backend, filterSystem}s, err := graphql.ParseSchema(schema, &q, graphql.MaxDepth(maxQueryDepth))if err != nil {return nil, err}h := handler{Schema: s}handler := node.NewHTTPHandlerStack(h, cors, vhosts, nil)stack.RegisterHandler("GraphQL UI", "/graphql/ui", GraphiQL{})stack.RegisterHandler("GraphQL UI", "/graphql/ui/", GraphiQL{})stack.RegisterHandler("GraphQL", "/graphql", handler)stack.RegisterHandler("GraphQL", "/graphql/", handler)return &h, nil
}func RegisterEthStatsService(stack *node.Node, backend *eth.EthAPIBackend, url string) {if err := ethstats.New(stack, backend, backend.Engine(), url); err != nil {Fatalf("Failed to register the Ethereum Stats service: %v", err)}
}func New(node *node.Node, backend backend, engine consensus.Engine, url string) error {parts, err := parseEthstatsURL(url)if err != nil {return err}ethstats := &Service{backend: backend,engine:  engine,server:  node.Server(),node:    parts[0],pass:    parts[1],host:    parts[2],pongCh:  make(chan struct{}),histCh:  make(chan []uint64, 1),}node.RegisterLifecycle(ethstats)return nil
}func RegisterSyncOverrideService(stack *node.Node, eth *eth.Ethereum, target common.Hash, exitWhenSynced bool) {if target != (common.Hash{}) {log.Info("Registered sync override service", "hash", target, "exitWhenSynced", exitWhenSynced)} else {log.Info("Registered sync override service")}syncer.Register(stack, eth, target, exitWhenSynced)
}func Register(stack *node.Node, backend *eth.Ethereum, target common.Hash, exitWhenSynced bool) (*Syncer, error) {s := &Syncer{stack:          stack,backend:        backend,target:         target,request:        make(chan *syncReq),closed:         make(chan struct{}),exitWhenSynced: exitWhenSynced,}stack.RegisterAPIs(s.APIs())stack.RegisterLifecycle(s)return s, nil
}
func (s *Syncer) APIs() []rpc.API {return []rpc.API{{Namespace: "debug",Service:   NewAPI(s),},}
}catalyst.RegisterSimulatedBeaconAPIs(stack, simBeacon)
stack.RegisterLifecycle(simBeacon)func RegisterSimulatedBeaconAPIs(stack *node.Node, sim *SimulatedBeacon) {api := newSimulatedBeaconAPI(sim)stack.RegisterAPIs([]rpc.API{{Namespace: "dev",Service:   api,Version:   "1.0",},})
}blsyncer := blsync.NewClient(utils.MakeBeaconLightConfig(ctx))
blsyncer.SetEngineRPC(rpc.DialInProc(srv))
stack.RegisterLifecycle(blsyncer)func Register(stack *node.Node, backend *eth.Ethereum) error {log.Warn("Engine API enabled", "protocol", "eth")stack.RegisterAPIs([]rpc.API{{Namespace:     "engine",Service:       NewConsensusAPI(backend),Authenticated: true,},})return nil
}