github.com/number571/tendermint@v0.34.11-gost/rpc/test/helpers.go (about)

     1  package rpctest
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"os"
     7  	"time"
     8  
     9  	abci "github.com/number571/tendermint/abci/types"
    10  	cfg "github.com/number571/tendermint/config"
    11  	"github.com/number571/tendermint/libs/log"
    12  	tmnet "github.com/number571/tendermint/libs/net"
    13  	"github.com/number571/tendermint/libs/service"
    14  	nm "github.com/number571/tendermint/node"
    15  	"github.com/number571/tendermint/proxy"
    16  	ctypes "github.com/number571/tendermint/rpc/core/types"
    17  	core_grpc "github.com/number571/tendermint/rpc/grpc"
    18  	rpcclient "github.com/number571/tendermint/rpc/jsonrpc/client"
    19  )
    20  
    21  // Options helps with specifying some parameters for our RPC testing for greater
    22  // control.
    23  type Options struct {
    24  	suppressStdout bool
    25  }
    26  
    27  func waitForRPC(ctx context.Context, conf *cfg.Config) {
    28  	laddr := conf.RPC.ListenAddress
    29  	client, err := rpcclient.New(laddr)
    30  	if err != nil {
    31  		panic(err)
    32  	}
    33  	result := new(ctypes.ResultStatus)
    34  	for {
    35  		_, err := client.Call(ctx, "status", map[string]interface{}{}, result)
    36  		if err == nil {
    37  			return
    38  		}
    39  
    40  		fmt.Println("error", err)
    41  		time.Sleep(time.Millisecond)
    42  	}
    43  }
    44  
    45  func waitForGRPC(ctx context.Context, conf *cfg.Config) {
    46  	client := GetGRPCClient(conf)
    47  	for {
    48  		_, err := client.Ping(ctx, &core_grpc.RequestPing{})
    49  		if err == nil {
    50  			return
    51  		}
    52  	}
    53  }
    54  
    55  func randPort() int {
    56  	port, err := tmnet.GetFreePort()
    57  	if err != nil {
    58  		panic(err)
    59  	}
    60  	return port
    61  }
    62  
    63  func makeAddrs() (string, string, string) {
    64  	return fmt.Sprintf("tcp://127.0.0.1:%d", randPort()),
    65  		fmt.Sprintf("tcp://127.0.0.1:%d", randPort()),
    66  		fmt.Sprintf("tcp://127.0.0.1:%d", randPort())
    67  }
    68  
    69  func CreateConfig(testName string) *cfg.Config {
    70  	c := cfg.ResetTestRoot(testName)
    71  
    72  	// and we use random ports to run in parallel
    73  	tm, rpc, grpc := makeAddrs()
    74  	c.P2P.ListenAddress = tm
    75  	c.RPC.ListenAddress = rpc
    76  	c.RPC.CORSAllowedOrigins = []string{"https://tendermint.com/"}
    77  	c.RPC.GRPCListenAddress = grpc
    78  	return c
    79  }
    80  
    81  func GetGRPCClient(conf *cfg.Config) core_grpc.BroadcastAPIClient {
    82  	grpcAddr := conf.RPC.GRPCListenAddress
    83  	return core_grpc.StartGRPCClient(grpcAddr)
    84  }
    85  
    86  type ServiceCloser func(context.Context) error
    87  
    88  func StartTendermint(ctx context.Context,
    89  	conf *cfg.Config,
    90  	app abci.Application,
    91  	opts ...func(*Options)) (service.Service, ServiceCloser, error) {
    92  
    93  	nodeOpts := &Options{}
    94  	for _, opt := range opts {
    95  		opt(nodeOpts)
    96  	}
    97  	var logger log.Logger
    98  	if nodeOpts.suppressStdout {
    99  		logger = log.NewNopLogger()
   100  	} else {
   101  		logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
   102  	}
   103  	papp := proxy.NewLocalClientCreator(app)
   104  	node, err := nm.New(conf, logger, papp, nil)
   105  	if err != nil {
   106  		return nil, func(_ context.Context) error { return nil }, err
   107  	}
   108  
   109  	err = node.Start()
   110  	if err != nil {
   111  		return nil, func(_ context.Context) error { return nil }, err
   112  	}
   113  
   114  	// wait for rpc
   115  	waitForRPC(ctx, conf)
   116  	waitForGRPC(ctx, conf)
   117  
   118  	if !nodeOpts.suppressStdout {
   119  		fmt.Println("Tendermint running!")
   120  	}
   121  
   122  	return node, func(ctx context.Context) error {
   123  		if err := node.Stop(); err != nil {
   124  			logger.Error("Error when trying to stop node", "err", err)
   125  		}
   126  		node.Wait()
   127  		os.RemoveAll(conf.RootDir)
   128  		return nil
   129  	}, nil
   130  }
   131  
   132  // SuppressStdout is an option that tries to make sure the RPC test Tendermint
   133  // node doesn't log anything to stdout.
   134  func SuppressStdout(o *Options) {
   135  	o.suppressStdout = true
   136  }