github.com/daeglee/go-ethereum@v0.0.0-20190504220456-cad3e8d18e9b/cmd/geth/usage.go (about)

     1  // Copyright 2015 The go-ethereum Authors
     2  // This file is part of go-ethereum.
     3  //
     4  // go-ethereum is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // go-ethereum is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU General Public License
    15  // along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  // Contains the geth command usage template and generator.
    18  
    19  package main
    20  
    21  import (
    22  	"io"
    23  	"sort"
    24  
    25  	"strings"
    26  
    27  	"github.com/ethereum/go-ethereum/cmd/utils"
    28  	"github.com/ethereum/go-ethereum/internal/debug"
    29  	cli "gopkg.in/urfave/cli.v1"
    30  )
    31  
    32  // AppHelpTemplate is the test template for the default, global app help topic.
    33  var AppHelpTemplate = `NAME:
    34     {{.App.Name}} - {{.App.Usage}}
    35  
    36     Copyright 2013-2019 The go-ethereum Authors
    37  
    38  USAGE:
    39     {{.App.HelpName}} [options]{{if .App.Commands}} command [command options]{{end}} {{if .App.ArgsUsage}}{{.App.ArgsUsage}}{{else}}[arguments...]{{end}}
    40     {{if .App.Version}}
    41  VERSION:
    42     {{.App.Version}}
    43     {{end}}{{if len .App.Authors}}
    44  AUTHOR(S):
    45     {{range .App.Authors}}{{ . }}{{end}}
    46     {{end}}{{if .App.Commands}}
    47  COMMANDS:
    48     {{range .App.Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
    49     {{end}}{{end}}{{if .FlagGroups}}
    50  {{range .FlagGroups}}{{.Name}} OPTIONS:
    51    {{range .Flags}}{{.}}
    52    {{end}}
    53  {{end}}{{end}}{{if .App.Copyright }}
    54  COPYRIGHT:
    55     {{.App.Copyright}}
    56     {{end}}
    57  `
    58  
    59  // flagGroup is a collection of flags belonging to a single topic.
    60  type flagGroup struct {
    61  	Name  string
    62  	Flags []cli.Flag
    63  }
    64  
    65  // AppHelpFlagGroups is the application flags, grouped by functionality.
    66  var AppHelpFlagGroups = []flagGroup{
    67  	{
    68  		Name: "ETHEREUM",
    69  		Flags: []cli.Flag{
    70  			configFileFlag,
    71  			utils.DataDirFlag,
    72  			utils.KeyStoreDirFlag,
    73  			utils.NoUSBFlag,
    74  			utils.NetworkIdFlag,
    75  			utils.TestnetFlag,
    76  			utils.RinkebyFlag,
    77  			utils.GoerliFlag,
    78  			utils.SyncModeFlag,
    79  			utils.ExitWhenSyncedFlag,
    80  			utils.GCModeFlag,
    81  			utils.EthStatsURLFlag,
    82  			utils.IdentityFlag,
    83  			utils.LightServFlag,
    84  			utils.LightBandwidthInFlag,
    85  			utils.LightBandwidthOutFlag,
    86  			utils.LightPeersFlag,
    87  			utils.LightKDFFlag,
    88  			utils.WhitelistFlag,
    89  		},
    90  	},
    91  	{
    92  		Name: "DEVELOPER CHAIN",
    93  		Flags: []cli.Flag{
    94  			utils.DeveloperFlag,
    95  			utils.DeveloperPeriodFlag,
    96  		},
    97  	},
    98  	{
    99  		Name: "ETHASH",
   100  		Flags: []cli.Flag{
   101  			utils.EthashCacheDirFlag,
   102  			utils.EthashCachesInMemoryFlag,
   103  			utils.EthashCachesOnDiskFlag,
   104  			utils.EthashDatasetDirFlag,
   105  			utils.EthashDatasetsInMemoryFlag,
   106  			utils.EthashDatasetsOnDiskFlag,
   107  		},
   108  	},
   109  	//{
   110  	//	Name: "DASHBOARD",
   111  	//	Flags: []cli.Flag{
   112  	//		utils.DashboardEnabledFlag,
   113  	//		utils.DashboardAddrFlag,
   114  	//		utils.DashboardPortFlag,
   115  	//		utils.DashboardRefreshFlag,
   116  	//		utils.DashboardAssetsFlag,
   117  	//	},
   118  	//},
   119  	{
   120  		Name: "TRANSACTION POOL",
   121  		Flags: []cli.Flag{
   122  			utils.TxPoolLocalsFlag,
   123  			utils.TxPoolNoLocalsFlag,
   124  			utils.TxPoolJournalFlag,
   125  			utils.TxPoolRejournalFlag,
   126  			utils.TxPoolPriceLimitFlag,
   127  			utils.TxPoolPriceBumpFlag,
   128  			utils.TxPoolAccountSlotsFlag,
   129  			utils.TxPoolGlobalSlotsFlag,
   130  			utils.TxPoolAccountQueueFlag,
   131  			utils.TxPoolGlobalQueueFlag,
   132  			utils.TxPoolLifetimeFlag,
   133  		},
   134  	},
   135  	{
   136  		Name: "PERFORMANCE TUNING",
   137  		Flags: []cli.Flag{
   138  			utils.CacheFlag,
   139  			utils.CacheDatabaseFlag,
   140  			utils.CacheTrieFlag,
   141  			utils.CacheGCFlag,
   142  		},
   143  	},
   144  	{
   145  		Name: "ACCOUNT",
   146  		Flags: []cli.Flag{
   147  			utils.UnlockedAccountFlag,
   148  			utils.PasswordFileFlag,
   149  			utils.ExternalSignerFlag,
   150  		},
   151  	},
   152  	{
   153  		Name: "API AND CONSOLE",
   154  		Flags: []cli.Flag{
   155  			utils.RPCEnabledFlag,
   156  			utils.RPCListenAddrFlag,
   157  			utils.RPCPortFlag,
   158  			utils.RPCApiFlag,
   159  			utils.WSEnabledFlag,
   160  			utils.WSListenAddrFlag,
   161  			utils.WSPortFlag,
   162  			utils.WSApiFlag,
   163  			utils.WSAllowedOriginsFlag,
   164  			utils.IPCDisabledFlag,
   165  			utils.IPCPathFlag,
   166  			utils.RPCCORSDomainFlag,
   167  			utils.RPCVirtualHostsFlag,
   168  			utils.JSpathFlag,
   169  			utils.ExecFlag,
   170  			utils.PreloadJSFlag,
   171  		},
   172  	},
   173  	{
   174  		Name: "NETWORKING",
   175  		Flags: []cli.Flag{
   176  			utils.BootnodesFlag,
   177  			utils.BootnodesV4Flag,
   178  			utils.BootnodesV5Flag,
   179  			utils.ListenPortFlag,
   180  			utils.MaxPeersFlag,
   181  			utils.MaxPendingPeersFlag,
   182  			utils.NATFlag,
   183  			utils.NoDiscoverFlag,
   184  			utils.DiscoveryV5Flag,
   185  			utils.NetrestrictFlag,
   186  			utils.NodeKeyFileFlag,
   187  			utils.NodeKeyHexFlag,
   188  		},
   189  	},
   190  	{
   191  		Name: "MINER",
   192  		Flags: []cli.Flag{
   193  			utils.MiningEnabledFlag,
   194  			utils.MinerThreadsFlag,
   195  			utils.MinerNotifyFlag,
   196  			utils.MinerGasPriceFlag,
   197  			utils.MinerGasTargetFlag,
   198  			utils.MinerGasLimitFlag,
   199  			utils.MinerEtherbaseFlag,
   200  			utils.MinerExtraDataFlag,
   201  			utils.MinerRecommitIntervalFlag,
   202  			utils.MinerNoVerfiyFlag,
   203  		},
   204  	},
   205  	{
   206  		Name: "GAS PRICE ORACLE",
   207  		Flags: []cli.Flag{
   208  			utils.GpoBlocksFlag,
   209  			utils.GpoPercentileFlag,
   210  		},
   211  	},
   212  	{
   213  		Name: "VIRTUAL MACHINE",
   214  		Flags: []cli.Flag{
   215  			utils.VMEnableDebugFlag,
   216  			utils.EVMInterpreterFlag,
   217  			utils.EWASMInterpreterFlag,
   218  		},
   219  	},
   220  	{
   221  		Name: "LOGGING AND DEBUGGING",
   222  		Flags: append([]cli.Flag{
   223  			utils.FakePoWFlag,
   224  			utils.NoCompactionFlag,
   225  		}, debug.Flags...),
   226  	},
   227  	{
   228  		Name:  "METRICS AND STATS",
   229  		Flags: metricsFlags,
   230  	},
   231  	{
   232  		Name:  "WHISPER (EXPERIMENTAL)",
   233  		Flags: whisperFlags,
   234  	},
   235  	{
   236  		Name: "DEPRECATED",
   237  		Flags: []cli.Flag{
   238  			utils.MinerLegacyThreadsFlag,
   239  			utils.MinerLegacyGasTargetFlag,
   240  			utils.MinerLegacyGasPriceFlag,
   241  			utils.MinerLegacyEtherbaseFlag,
   242  			utils.MinerLegacyExtraDataFlag,
   243  		},
   244  	},
   245  	{
   246  		Name: "MISC",
   247  	},
   248  }
   249  
   250  // byCategory sorts an array of flagGroup by Name in the order
   251  // defined in AppHelpFlagGroups.
   252  type byCategory []flagGroup
   253  
   254  func (a byCategory) Len() int      { return len(a) }
   255  func (a byCategory) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
   256  func (a byCategory) Less(i, j int) bool {
   257  	iCat, jCat := a[i].Name, a[j].Name
   258  	iIdx, jIdx := len(AppHelpFlagGroups), len(AppHelpFlagGroups) // ensure non categorized flags come last
   259  
   260  	for i, group := range AppHelpFlagGroups {
   261  		if iCat == group.Name {
   262  			iIdx = i
   263  		}
   264  		if jCat == group.Name {
   265  			jIdx = i
   266  		}
   267  	}
   268  
   269  	return iIdx < jIdx
   270  }
   271  
   272  func flagCategory(flag cli.Flag) string {
   273  	for _, category := range AppHelpFlagGroups {
   274  		for _, flg := range category.Flags {
   275  			if flg.GetName() == flag.GetName() {
   276  				return category.Name
   277  			}
   278  		}
   279  	}
   280  	return "MISC"
   281  }
   282  
   283  func init() {
   284  	// Override the default app help template
   285  	cli.AppHelpTemplate = AppHelpTemplate
   286  
   287  	// Define a one shot struct to pass to the usage template
   288  	type helpData struct {
   289  		App        interface{}
   290  		FlagGroups []flagGroup
   291  	}
   292  
   293  	// Override the default app help printer, but only for the global app help
   294  	originalHelpPrinter := cli.HelpPrinter
   295  	cli.HelpPrinter = func(w io.Writer, tmpl string, data interface{}) {
   296  		if tmpl == AppHelpTemplate {
   297  			// Iterate over all the flags and add any uncategorized ones
   298  			categorized := make(map[string]struct{})
   299  			for _, group := range AppHelpFlagGroups {
   300  				for _, flag := range group.Flags {
   301  					categorized[flag.String()] = struct{}{}
   302  				}
   303  			}
   304  			var uncategorized []cli.Flag
   305  			for _, flag := range data.(*cli.App).Flags {
   306  				if _, ok := categorized[flag.String()]; !ok {
   307  					if strings.HasPrefix(flag.GetName(), "dashboard") {
   308  						continue
   309  					}
   310  					uncategorized = append(uncategorized, flag)
   311  				}
   312  			}
   313  			if len(uncategorized) > 0 {
   314  				// Append all ungategorized options to the misc group
   315  				miscs := len(AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags)
   316  				AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags = append(AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags, uncategorized...)
   317  
   318  				// Make sure they are removed afterwards
   319  				defer func() {
   320  					AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags = AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags[:miscs]
   321  				}()
   322  			}
   323  			// Render out custom usage screen
   324  			originalHelpPrinter(w, tmpl, helpData{data, AppHelpFlagGroups})
   325  		} else if tmpl == utils.CommandHelpTemplate {
   326  			// Iterate over all command specific flags and categorize them
   327  			categorized := make(map[string][]cli.Flag)
   328  			for _, flag := range data.(cli.Command).Flags {
   329  				if _, ok := categorized[flag.String()]; !ok {
   330  					categorized[flagCategory(flag)] = append(categorized[flagCategory(flag)], flag)
   331  				}
   332  			}
   333  
   334  			// sort to get a stable ordering
   335  			sorted := make([]flagGroup, 0, len(categorized))
   336  			for cat, flgs := range categorized {
   337  				sorted = append(sorted, flagGroup{cat, flgs})
   338  			}
   339  			sort.Sort(byCategory(sorted))
   340  
   341  			// add sorted array to data and render with default printer
   342  			originalHelpPrinter(w, tmpl, map[string]interface{}{
   343  				"cmd":              data,
   344  				"categorizedFlags": sorted,
   345  			})
   346  		} else {
   347  			originalHelpPrinter(w, tmpl, data)
   348  		}
   349  	}
   350  }