一，geth makefile 以及編譯邏輯

上篇提到用 make geth 來編譯geth客戶端。我們來看看make file做了什麼：

  geth:

  build/env.sh go run build/ci.go install ./cmd/geth

  @echo "Done building."

  @echo "Run \"$(GOBIN)/geth\" to launch geth."

執行了env.sh

# Create fake Go workspace if it doesn'texist yet.

workspace="$PWD/build/_workspace"

root="$PWD"

ethdir="$workspace/src/github.com/ethereum"

if [ ! -L "$ethdir/go-ethereum"]; then

   mkdir -p "$ethdir"

   cd "$ethdir"

   ln -s ../../../../../. go-ethereum

   cd "$root"

fi

# Set up the environment to use theworkspace.

GOPATH="$workspace"

export GOPATH

 

# Run the command inside the workspace.

cd "$ethdir/go-ethereum"

PWD="$ethdir/go-ethereum"
 

裡面做了兩件事情

1，ln -s命令在build/_workspace/ 目錄上生成了go-etherum的一個檔案映象，不佔用磁碟空間，與原始檔同步更新

2，把工作目錄 workspace加入GOPATH環境變數

跟蹤進ci.go 關鍵函式

 func doInstall(cmdline []string)

這個方法拼接了完整的geth 編譯命令：

go install -ldflags -X main.gitCommit=722bac84fa503199b9c485c1a2bfba03bc487d -v ./cmd/geth

二，geth 客戶端main函式以及geth的啟動入口

geth啟動命令：

build/bin/geth --datadir =./data/00 --networkid 1 --fast --cache = 1024 --etherbase“[yourpreferred account]”console >>geth.log
 

--datadir設定區塊鏈資料存放路徑

--networkid 網路設定啟動的區塊鏈網路預設值是1表示以太坊公司，0,2,3表示測試網路，大於4表示本地私有網路

--fast同步方式，預設為fast要選擇完全同步使用命令--syncmode full

--cache設定快取大小（最小16MB /資料庫強制）（預設值：128）

console表示啟動控制檯>>geth.log將控制檯顯示內容輸出到檔案geth.log中去

geth的原始碼入口main（）函式在/cmd/geth/main.go 

func main() {
	if err := app.Run(os.Args); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

// geth is the main entry point into the system if no special subcommand is ran.
// It creates a default node based on the command line arguments and runs it in
// blocking mode, waiting for it to be shut down.
func geth(ctx *cli.Context) error {
	node := makeFullNode(ctx)
	startNode(ctx, node)
	node.Wait()
	return nil
}
 

main.go/main() -> app.go/Run（） - > app.go/HandleAction（） - > main.go/geth（）

通過這幾個函式跳轉來到了GETH啟動入口。

 從啟動入口可以看到第一個啟動的模組是node模組，通過makeFullNode函式來建立一個節點物件（在ETH裡node可以認為是以太坊全網的一個節點，也可以認為是一個以太坊終端）。

func makeFullNode(ctx *cli.Context) *node.Node {
	stack, cfg := makeConfigNode(ctx)

	utils.RegisterEthService(stack, &cfg.Eth)

	if ctx.GlobalBool(utils.DashboardEnabledFlag.Name) {
		utils.RegisterDashboardService(stack, &cfg.Dashboard, gitCommit)
	}
	// Whisper must be explicitly enabled by specifying at least 1 whisper flag or in dev mode
	shhEnabled := enableWhisper(ctx)
	shhAutoEnabled := !ctx.GlobalIsSet(utils.WhisperEnabledFlag.Name) && ctx.GlobalIsSet(utils.DeveloperFlag.Name)
	if shhEnabled || shhAutoEnabled {
		if ctx.GlobalIsSet(utils.WhisperMaxMessageSizeFlag.Name) {
			cfg.Shh.MaxMessageSize = uint32(ctx.Int(utils.WhisperMaxMessageSizeFlag.Name))
		}
		if ctx.GlobalIsSet(utils.WhisperMinPOWFlag.Name) {
			cfg.Shh.MinimumAcceptedPOW = ctx.Float64(utils.WhisperMinPOWFlag.Name)
		}
		utils.RegisterShhService(stack, &cfg.Shh)
	}

	// Add the Ethereum Stats daemon if requested.
	if cfg.Ethstats.URL != "" {
		utils.RegisterEthStatsService(stack, cfg.Ethstats.URL)
	}
	return stack
}

進入 makeConfigNode()方法 

func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) {
	// Load defaults.
	cfg := gethConfig{
		Eth:       eth.DefaultConfig,
		Shh:       whisper.DefaultConfig,
		Node:      defaultNodeConfig(),
		Dashboard: dashboard.DefaultConfig,
	}

	// Load config file.
	if file := ctx.GlobalString(configFileFlag.Name); file != "" {
		if err := loadConfig(file, &cfg); err != nil {
			utils.Fatalf("%v", err)
		}
	}

	// Apply flags.
	utils.SetNodeConfig(ctx, &cfg.Node)
	stack, err := node.New(&cfg.Node)
	if err != nil {
		utils.Fatalf("Failed to create the protocol stack: %v", err)
	}
	utils.SetEthConfig(ctx, stack, &cfg.Eth)
	if ctx.GlobalIsSet(utils.EthStatsURLFlag.Name) {
		cfg.Ethstats.URL = ctx.GlobalString(utils.EthStatsURLFlag.Name)
	}

	utils.SetShhConfig(ctx, stack, &cfg.Shh)
	utils.SetDashboardConfig(ctx, &cfg.Dashboard)

	return stack, cfg
}

makeConfigNode做了兩件事1，函式獲取以太坊相關服務(Eth Node Shh DashBoard)的預設配置 2，通過Node的預設配置來建立一個Node。返回node物件和cfg

 makeFullNode把建立ethservice、建立DashBoard service、建立Shhservice以及建立ethStats service註冊到Node

從這裡我們可以看出來eth DashBoard Shh ethStats都是從node.Service介面派生出來的，它們的例項化物件需要實現node.Service所有介面，這在以後相關模組的分析中會遇到

type Service interface {
	// Protocols retrieves the P2P protocols the service wishes to start.
	Protocols() []p2p.Protocol

	// APIs retrieves the list of RPC descriptors the service provides
	APIs() []rpc.API

	// 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(server *p2p.Server) error

	// Stop terminates all goroutines belonging to the service, blocking until they
	// are all terminated.
	Stop() error
}

Protocols() 返回service要啟動的P2P 協議列表

APIs() 返回service提供的RPC介面

Start() 啟動已經初始化的service

Stop() 停止service所有的goroutines，並阻塞執行緒知道所有goroutines都終止

接下來呼叫startNode來啟動

// startNode boots up the system node and all registered protocols, after which
// it unlocks any requested accounts, and starts the RPC/IPC interfaces and the
// miner.
func startNode(ctx *cli.Context, stack *node.Node) {
	// Start up the node itself
	utils.StartNode(stack)

	// Unlock any account specifically requested
	ks := stack.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)

	passwords := utils.MakePasswordList(ctx)
	unlocks := strings.Split(ctx.GlobalString(utils.UnlockedAccountFlag.Name), ",")
	for i, account := range unlocks {
		if trimmed := strings.TrimSpace(account); trimmed != "" {
			unlockAccount(ctx, ks, trimmed, i, passwords)
		}
	}
	// Register wallet event handlers to open and auto-derive wallets
	events := make(chan accounts.WalletEvent, 16)
	stack.AccountManager().Subscribe(events)

	go func() {
		// Create an chain state reader for self-derivation
		rpcClient, err := stack.Attach()
		if err != nil {
			utils.Fatalf("Failed to attach to self: %v", err)
		}
		stateReader := ethclient.NewClient(rpcClient)

		// Open any wallets already attached
		for _, wallet := range stack.AccountManager().Wallets() {
			if err := wallet.Open(""); err != nil {
				log.Warn("Failed to open wallet", "url", wallet.URL(), "err", err)
			}
		}
		// Listen for wallet event till termination
		for event := range events {
			switch event.Kind {
			case accounts.WalletArrived:
				if err := event.Wallet.Open(""); err != nil {
					log.Warn("New wallet appeared, failed to open", "url", event.Wallet.URL(), "err", err)
				}
			case accounts.WalletOpened:
				status, _ := event.Wallet.Status()
				log.Info("New wallet appeared", "url", event.Wallet.URL(), "status", status)

				if event.Wallet.URL().Scheme == "ledger" {
					event.Wallet.SelfDerive(accounts.DefaultLedgerBaseDerivationPath, stateReader)
				} else {
					event.Wallet.SelfDerive(accounts.DefaultBaseDerivationPath, stateReader)
				}

			case accounts.WalletDropped:
				log.Info("Old wallet dropped", "url", event.Wallet.URL())
				event.Wallet.Close()
			}
		}
	}()
	// Start auxiliary services if enabled
	if ctx.GlobalBool(utils.MiningEnabledFlag.Name) || ctx.GlobalBool(utils.DeveloperFlag.Name) {
		// Mining only makes sense if a full Ethereum node is running
		if ctx.GlobalBool(utils.LightModeFlag.Name) || ctx.GlobalString(utils.SyncModeFlag.Name) == "light" {
			utils.Fatalf("Light clients do not support mining")
		}
		var ethereum *eth.Ethereum
		if err := stack.Service(ðereum); err != nil {
			utils.Fatalf("Ethereum service not running: %v", err)
		}
		// Use a reduced number of threads if requested
		if threads := ctx.GlobalInt(utils.MinerThreadsFlag.Name); threads > 0 {
			type threaded interface {
				SetThreads(threads int)
			}
			if th, ok := ethereum.Engine().(threaded); ok {
				th.SetThreads(threads)
			}
		}
		// Set the gas price to the limits from the CLI and start mining
		ethereum.TxPool().SetGasPrice(utils.GlobalBig(ctx, utils.GasPriceFlag.Name))
		if err := ethereum.StartMining(true); err != nil {
			utils.Fatalf("Failed to start mining: %v", err)
		}
	}
}

首先node start自己。node將之前註冊的所有service交給p2p.Server, 然後啟動p2p.Server物件，Server物件會逐個啟動每個Service。

解鎖賬號，並註冊錢包反饋事件。

啟動RPC。（RPC 提供一種能通過網路或者其他I/O連線訪問的能力，將在後續章節分析）

如果配置支援挖礦，則啟動挖礦。

node.Wait()阻塞住程式，直到nodestop。

三，小結

Node就好像一個組裝工廠，把以太坊相關功能裝配起來，連線了以太坊的前端和後端，啟動RPC供遠端呼叫，啟動了P2P server跟網路中的其他節點建立聯絡，開始了console 供命令列操作。

Node模組並沒有做任何跟區塊鏈實質相關的事情，甚至它都不直接建立以太坊相關模組，而讓它們封裝成一個個的service，每個service自身自滅。就好比一個賣場，各個商家都可以來賣東西，但我不關心你們的死活，你們的死活也不影響我。

這給我們擴充套件以太坊客戶端的功能提供一個思路，我們可以把擴充套件功能封裝成一個Service，塞給Node。