github.com/number571/tendermint@v0.34.11-gost/test/e2e/generator/main.go (about)

     1  //nolint: gosec
     2  package main
     3  
     4  import (
     5  	"fmt"
     6  	"math"
     7  	"math/rand"
     8  	"os"
     9  	"path/filepath"
    10  
    11  	"github.com/spf13/cobra"
    12  
    13  	"github.com/number571/tendermint/libs/log"
    14  )
    15  
    16  const (
    17  	randomSeed int64 = 4827085738
    18  )
    19  
    20  var logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
    21  
    22  func main() {
    23  	NewCLI().Run()
    24  }
    25  
    26  // CLI is the Cobra-based command-line interface.
    27  type CLI struct {
    28  	root *cobra.Command
    29  }
    30  
    31  // NewCLI sets up the CLI.
    32  func NewCLI() *CLI {
    33  	cli := &CLI{}
    34  	cli.root = &cobra.Command{
    35  		Use:           "generator",
    36  		Short:         "End-to-end testnet generator",
    37  		SilenceUsage:  true,
    38  		SilenceErrors: true, // we'll output them ourselves in Run()
    39  		RunE: func(cmd *cobra.Command, args []string) error {
    40  			dir, err := cmd.Flags().GetString("dir")
    41  			if err != nil {
    42  				return err
    43  			}
    44  			groups, err := cmd.Flags().GetInt("groups")
    45  			if err != nil {
    46  				return err
    47  			}
    48  			p2pMode, err := cmd.Flags().GetString("p2p")
    49  			if err != nil {
    50  				return err
    51  			}
    52  			var opts Options
    53  			switch mode := P2PMode(p2pMode); mode {
    54  			case NewP2PMode, LegacyP2PMode, HybridP2PMode, MixedP2PMode:
    55  				opts = Options{P2P: mode}
    56  			default:
    57  				return fmt.Errorf("p2p mode must be either new, legacy, hybrid or mixed got %s", p2pMode)
    58  			}
    59  
    60  			return cli.generate(dir, groups, opts)
    61  		},
    62  	}
    63  
    64  	cli.root.PersistentFlags().StringP("dir", "d", "", "Output directory for manifests")
    65  	_ = cli.root.MarkPersistentFlagRequired("dir")
    66  	cli.root.PersistentFlags().IntP("groups", "g", 0, "Number of groups")
    67  	cli.root.PersistentFlags().StringP("p2p", "p", string(MixedP2PMode),
    68  		"P2P typology to be generated [\"new\", \"legacy\", \"hybrid\" or \"mixed\" ]")
    69  
    70  	return cli
    71  }
    72  
    73  // generate generates manifests in a directory.
    74  func (cli *CLI) generate(dir string, groups int, opts Options) error {
    75  	err := os.MkdirAll(dir, 0755)
    76  	if err != nil {
    77  		return err
    78  	}
    79  
    80  	manifests, err := Generate(rand.New(rand.NewSource(randomSeed)), opts)
    81  	if err != nil {
    82  		return err
    83  	}
    84  	if groups <= 0 {
    85  		for i, manifest := range manifests {
    86  			err = manifest.Save(filepath.Join(dir, fmt.Sprintf("gen-%04d.toml", i)))
    87  			if err != nil {
    88  				return err
    89  			}
    90  		}
    91  	} else {
    92  		groupSize := int(math.Ceil(float64(len(manifests)) / float64(groups)))
    93  		for g := 0; g < groups; g++ {
    94  			for i := 0; i < groupSize && g*groupSize+i < len(manifests); i++ {
    95  				manifest := manifests[g*groupSize+i]
    96  				err = manifest.Save(filepath.Join(dir, fmt.Sprintf("gen-group%02d-%04d.toml", g, i)))
    97  				if err != nil {
    98  					return err
    99  				}
   100  			}
   101  		}
   102  	}
   103  	return nil
   104  }
   105  
   106  // Run runs the CLI.
   107  func (cli *CLI) Run() {
   108  	if err := cli.root.Execute(); err != nil {
   109  		logger.Error(err.Error())
   110  		os.Exit(1)
   111  	}
   112  }