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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/* 
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

详见源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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上创建一个文件夹用于存储节点相关数据 

    1
    2
    3
    if err := n.openDataDir(); err != nil {
        return err
    }

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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)
    }

  • 启动服务

    1
    2
    3
    4
    5
    6
    7
    started := []reflect.Type{}
    for kind, service := range services {
        if err := service.Start(running); err != nil {
            ...
        }
        started = append(started, kind)
    }

  • 启动 RPC 接口

    1
    2
    3
    4
    5
    6
    7
    if err := n.startRPC(services); err != nil {
        for _, service := range services {
            service.Stop()
        }
        running.Stop()
        return err
    }
    • API 接口导入
      1
      2
      3
      4
      apis := n.apis()
      for _, service := range services {
          apis = append(apis, service.APIs()...)
      }
* 启动 InProc，用于进程内部的通信

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


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

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


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

1
2
3
4
if err := n.startHTTP(...); err != nil {
    ...
    return err
}


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

1
2
3
4
if err := n.startWS(...); err != nil {
    ...
    return err
}


* 为节点关闭创建 channel

1
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 {

通常，进行交易、查询的相关操作的API主要关注 ethapi\api.go 源码提供的接口。

——————————THE END——————————

本文文字和图片均属博主原创。未经授权，不得转载。

个人网站：https://jmy5945hh.github.io/