Ethereum 以太坊节点启动源码分析

作者: FinJmy | 来源:发表于2018-06-01 12:00 被阅读0次

Ethereum 以太坊节点启动源码分析
《对以太坊节点远程调用添加验证保护》
死磕以太坊源码分析之挖矿流程分析
go-ethereum源码解析-2018-06-27
Ethereum 以太坊智能合约部署源码分析
Ethereum 以太坊智能合约调用源码分析
go-ethereum以太坊源码解析完整版
以太坊源码分析（四节点发现）
以太坊常用网址
死磕以太坊源码分析之Ethash共识算法

title: Ethereum 以太坊节点启动源码分析
date: 2018-06-01 11:37:21
tags:
- 以太坊
categories:
- 区块链

0 前言

基于 Ethereum Coffice (v.1.8.8) 分析
需要区块链基础知识
有 C++/JAVA 基础就能理解文中 go 代码

1 定义

1.1 节点

在 Ethereum 区块链网络中，节点被定义为一个可以注册多种服务的容器。服务是一套独立的协议，可以基于P2P网络和PRC通信来提供具体的服务内容。节点对象的定义如下所示：

Node is a container on which services can be registered.

/* 
file:node/node.go
 */
type Node struct {
    eventmux *event.TypeMux // 服务之间的事件锁
    config   *Config
    accman   *accounts.Manager

    ephemeralKeystore string
    instanceDirLock   flock.Releaser
    
    // --- P2P 相关对象 -- Start
    serverConfig p2p.Config     
    server       *p2p.Server
    // --- P2P 相关对象 -- End

    // --- 服务相关对象 -- Start
    serviceFuncs []ServiceConstructor      
    services     map[reflect.Type]Service
    // --- 服务相关对象 -- End

    // --- RPC 相关对象 -- Start
    rpcAPIs       []rpc.API   // RPC 提供的 API
    inprocHandler *rpc.Server // RPC API 消息处理

    ipcEndpoint string       // IPC 端点
    ipcListener net.Listener // IPC API 服务监听
    ipcHandler  *rpc.Server  // IPC API 消息处理

    httpEndpoint  string       // HTTP 端点
    httpWhitelist []string     // HTTP 白名单
    httpListener  net.Listener // HTTP API 服务监听
    httpHandler   *rpc.Server  // HTTP API 消息处理

    wsEndpoint string       // Websocket 端点
    wsListener net.Listener // Websocket API 服务监听
    wsHandler  *rpc.Server  // Websocket API 消息处理
    // --- RPC 相关对象 -- End

    stop chan struct{} // 等待关闭通知的 通道
    lock sync.RWMutex

    log log.Logger  // 日志
}

1.2 默认值

node/defaults.go 源码中定义了关于节点的一系列默认值，包括：

HTTP RPC 端口默认 8545
WebSocket RPC 端口默认 8546
P2P 监听端口默认 30303
数据库文件夹
- Apple 系统 home\Library\Ethereum
- Windows 系统 home\AppData\Roaming\Ethereum
- 其他系统 home\.ethereum

详见源码

package node

import ...

const (
    DefaultHTTPHost = "localhost"
    DefaultHTTPPort = 8545 
    DefaultWSHost   = "localhost"
    DefaultWSPort   = 8546
)

var DefaultConfig = Config{
    DataDir:          DefaultDataDir(),
    HTTPPort:         DefaultHTTPPort,
    HTTPModules:      []string{"net", "web3"},
    HTTPVirtualHosts: []string{"localhost"},
    WSPort:           DefaultWSPort,
    WSModules:        []string{"net", "web3"},
    P2P: p2p.Config{
        ListenAddr: ":30303",
        MaxPeers:   25,
        NAT:        nat.Any(),
    },
}

func DefaultDataDir() string {
    home := homeDir()
    if home != "" {
        if runtime.GOOS == "darwin" {
            return filepath.Join(home, "Library", "Ethereum")
        } else if runtime.GOOS == "windows" {
            return filepath.Join(home, "AppData", "Roaming", "Ethereum")
        } else {
            return filepath.Join(home, ".ethereum")
        }
    }

    return ""
}

func homeDir() string {
    ...
}

2 启动

node/node.go 源码中的 Start() 函数描述了节点创建运行的过程。

openDataDir() 在FS上创建一个文件夹用于存储节点相关数据
```
if err := n.openDataDir(); err != nil {
    return err
}
```

创建 P2P 并导入服务的相关协议，启动 P2P

running := &p2p.Server{Config: n.serverConfig}

services := make(map[reflect.Type]Service)
for _, constructor := range n.serviceFuncs {
    ...
    services[kind] = service
}

for _, service := range services {
    running.Protocols = append(running.Protocols, service.Protocols()...)
}

if err := running.Start(); err != nil {
    return convertFileLockError(err)
}

启动服务

started := []reflect.Type{}
for kind, service := range services {
    if err := service.Start(running); err != nil {
        ...
    }
    started = append(started, kind)
}

启动 RPC 接口

if err := n.startRPC(services); err != nil {
    for _, service := range services {
        service.Stop()
    }
    running.Stop()
    return err
}

API 接口导入

apis := n.apis()
for _, service := range services {
    apis = append(apis, service.APIs()...)
}

启动 InProc，用于进程内部的通信

if err := n.startInProc(apis); err != nil {
    return err
}

启动 IPC，用于同系统内进程间的通信

if err := n.startIPC(apis); err != nil {
    ...
    return err
}

启动 HTTP，用于 HTTP 的交互通信

if err := n.startHTTP(...); err != nil {
    ...
    return err
}

启动 WebSocket，用于浏览器与服务器的 TCP 全双工通信

if err := n.startWS(...); err != nil {
    ...
    return err
}

为节点关闭创建 channel

n.stop = make(chan struct{})

3 API 交互

客户端通过 API 与 Ethereum 区块链网络进行交互，目前提供的服务有

backend.go
func (s *Ethereum) APIs() []rpc.API {
backend.go
func (s *LightEthereum) APIs() []rpc.API {
exec.go
func (s *snapshotService) APIs() []rpc.API {
ping-pong.go
func (p *pingPongService) APIs() []rpc.API {
swarm.go
func (self *Swarm) APIs() []rpc.API {
whisper.go
func (w *Whisper) APIs() []rpc.API {
whisper.go
func (whisper *Whisper) APIs() []rpc.API {