github.com/linapex/ethereum-go-chinese@v0.0.0-20190316121929-f8b7a73c3fa1/swarm/network/simulations/overlay_test.go

//<developer>
//    <name>linapex 曹一峰</name>
//    <email>linapex@163.com</email>
//    <wx>superexc</wx>
//    <qqgroup>128148617</qqgroup>
//    <url>https://jsq.ink</url>
//    <role>pku engineer</role>
//    <date>2019-03-16 19:16:43</date>
//</624450115066662912>

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"net/url"
	"testing"
	"time"

	"github.com/ethereum/go-ethereum/p2p/enode"
	"github.com/ethereum/go-ethereum/p2p/simulations"
	"github.com/ethereum/go-ethereum/swarm/log"
)

var (
	nodeCount = 16
)

//此测试用于测试叠加模拟。
//由于模拟是通过主系统执行的，因此很容易错过更改。
//自动测试将阻止
//测试只是连接到模拟，启动网络，
//启动mocker，获取节点数，然后再次停止它。
//它还提供了前端所需步骤的文档
//使用模拟
func TestOverlaySim(t *testing.T) {
t.Skip("Test is flaky, see: https://github.com/ethersphere/go-ethereum/issues/592“）
//启动模拟
	log.Info("Start simulation backend")
//获取模拟网络；需要订阅up事件
	net := newSimulationNetwork()
//创建覆盖模拟
	sim := newOverlaySim(net)
//用它创建一个HTTP测试服务器
	srv := httptest.NewServer(sim)
	defer srv.Close()

	log.Debug("Http simulation server started. Start simulation network")
//启动仿真网络（仿真初始化）
	resp, err := http.Post(srv.URL+"/start", "application/json", nil)
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("Expected Status Code %d, got %d", http.StatusOK, resp.StatusCode)
	}

	log.Debug("Start mocker")
//启动mocker，需要一个节点计数和一个ID
	resp, err = http.PostForm(srv.URL+"/mocker/start",
		url.Values{
			"node-count":  {fmt.Sprintf("%d", nodeCount)},
			"mocker-type": {simulations.GetMockerList()[0]},
		})
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		reason, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			t.Fatal(err)
		}
		t.Fatalf("Expected Status Code %d, got %d, response body %s", http.StatusOK, resp.StatusCode, string(reason))
	}

//等待节点启动所需的变量
	var upCount int
	trigger := make(chan enode.ID)

//等待所有节点启动
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

//开始监视节点启动事件…
	go watchSimEvents(net, ctx, trigger)

//…并等待直到收到所有预期的向上事件（nodeCount）
LOOP:
	for {
		select {
		case <-trigger:
//接收到新节点向上事件，增加计数器
			upCount++
//接收到所有预期的节点向上事件
			if upCount == nodeCount {
				break LOOP
			}
		case <-ctx.Done():
			t.Fatalf("Timed out waiting for up events")
		}

	}

//此时，我们可以查询服务器
	log.Info("Get number of nodes")
//获取节点数
	resp, err = http.Get(srv.URL + "/nodes")
	if err != nil {
		t.Fatal(err)
	}

	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("err %s", resp.Status)
	}
	b, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		t.Fatal(err)
	}

//从JSON响应中取消标记节点数
	var nodesArr []simulations.Node
	err = json.Unmarshal(b, &nodesArr)
	if err != nil {
		t.Fatal(err)
	}

//检查接收的节点数是否与发送的节点数相同
	if len(nodesArr) != nodeCount {
		t.Fatal(fmt.Errorf("Expected %d number of nodes, got %d", nodeCount, len(nodesArr)))
	}

//需要让它运行一段时间，否则立即停止它会因运行节点而崩溃。
//希望连接到已停止的节点
	time.Sleep(1 * time.Second)

	log.Info("Stop the network")
//停止网络
	resp, err = http.Post(srv.URL+"/stop", "application/json", nil)
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("err %s", resp.Status)
	}

	log.Info("Reset the network")
//重置网络（删除所有节点和连接）
	resp, err = http.Post(srv.URL+"/reset", "application/json", nil)
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("err %s", resp.Status)
	}
}

//注意事件，以便我们知道所有节点何时启动
func watchSimEvents(net *simulations.Network, ctx context.Context, trigger chan enode.ID) {
	events := make(chan *simulations.Event)
	sub := net.Events().Subscribe(events)
	defer sub.Unsubscribe()

	for {
		select {
		case ev := <-events:
//仅捕获节点向上事件
			if ev.Type == simulations.EventTypeNode {
				if ev.Node.Up {
					log.Debug("got node up event", "event", ev, "node", ev.Node.Config.ID)
					select {
					case trigger <- ev.Node.Config.ID:
					case <-ctx.Done():
						return
					}
				}
			}
		case <-ctx.Done():
			return
		}
	}
}