github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/libs/cosmos-sdk/client/config.go (about)

     1  package client
     2  
     3  import (
     4  	"fmt"
     5  	"io"
     6  	"io/ioutil"
     7  	"os"
     8  	"path"
     9  	"strconv"
    10  
    11  	toml "github.com/pelletier/go-toml"
    12  	"github.com/spf13/cobra"
    13  	"github.com/spf13/viper"
    14  
    15  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/client/flags"
    16  )
    17  
    18  const (
    19  	flagGet = "get"
    20  )
    21  
    22  var configDefaults = map[string]string{
    23  	"chain-id":        "",
    24  	"keyring-backend": "os",
    25  	"output":          "text",
    26  	"node":            "tcp://localhost:26657",
    27  	"broadcast-mode":  "sync",
    28  }
    29  
    30  // ConfigCmd returns a CLI command to interactively create an application CLI
    31  // config file.
    32  func ConfigCmd(defaultCLIHome string) *cobra.Command {
    33  	cmd := &cobra.Command{
    34  		Use:   "config <key> [value]",
    35  		Short: "Create or query an application CLI configuration file",
    36  		RunE:  runConfigCmd,
    37  		Args:  cobra.RangeArgs(0, 2),
    38  	}
    39  
    40  	cmd.Flags().String(flags.FlagHome, defaultCLIHome,
    41  		"set client's home directory for configuration")
    42  	cmd.Flags().Bool(flagGet, false,
    43  		"print configuration value or its default if unset")
    44  	return cmd
    45  }
    46  
    47  func runConfigCmd(cmd *cobra.Command, args []string) error {
    48  	cfgFile, err := ensureConfFile(viper.GetString(flags.FlagHome))
    49  	if err != nil {
    50  		return err
    51  	}
    52  
    53  	getAction := viper.GetBool(flagGet)
    54  	if getAction && len(args) != 1 {
    55  		return fmt.Errorf("wrong number of arguments")
    56  	}
    57  
    58  	// load configuration
    59  	tree, err := loadConfigFile(cfgFile)
    60  	if err != nil {
    61  		return err
    62  	}
    63  
    64  	// print the config and exit
    65  	if len(args) == 0 {
    66  		s, err := tree.ToTomlString()
    67  		if err != nil {
    68  			return err
    69  		}
    70  		fmt.Print(s)
    71  		return nil
    72  	}
    73  
    74  	key := args[0]
    75  
    76  	// get config value for a given key
    77  	if getAction {
    78  		switch key {
    79  		case "trace", "trust-node", "indent":
    80  			fmt.Println(tree.GetDefault(key, false).(bool))
    81  
    82  		default:
    83  			if defaultValue, ok := configDefaults[key]; ok {
    84  				fmt.Println(tree.GetDefault(key, defaultValue).(string))
    85  				return nil
    86  			}
    87  
    88  			return errUnknownConfigKey(key)
    89  		}
    90  
    91  		return nil
    92  	}
    93  
    94  	if len(args) != 2 {
    95  		return fmt.Errorf("wrong number of arguments")
    96  	}
    97  
    98  	value := args[1]
    99  
   100  	// set config value for a given key
   101  	switch key {
   102  	case "chain-id", "output", "node", "broadcast-mode", "keyring-backend":
   103  		tree.Set(key, value)
   104  
   105  	case "trace", "trust-node", "indent":
   106  		boolVal, err := strconv.ParseBool(value)
   107  		if err != nil {
   108  			return err
   109  		}
   110  
   111  		tree.Set(key, boolVal)
   112  
   113  	default:
   114  		return errUnknownConfigKey(key)
   115  	}
   116  
   117  	// save configuration to disk
   118  	if err := saveConfigFile(cfgFile, tree); err != nil {
   119  		return err
   120  	}
   121  
   122  	fmt.Fprintf(os.Stderr, "configuration saved to %s\n", cfgFile)
   123  	return nil
   124  }
   125  
   126  func ensureConfFile(rootDir string) (string, error) {
   127  	cfgPath := path.Join(rootDir, "config")
   128  	if err := os.MkdirAll(cfgPath, os.ModePerm); err != nil {
   129  		return "", err
   130  	}
   131  
   132  	return path.Join(cfgPath, "config.toml"), nil
   133  }
   134  
   135  func loadConfigFile(cfgFile string) (*toml.Tree, error) {
   136  	if _, err := os.Stat(cfgFile); os.IsNotExist(err) {
   137  		fmt.Fprintf(os.Stderr, "%s does not exist\n", cfgFile)
   138  		return toml.Load(``)
   139  	}
   140  
   141  	bz, err := ioutil.ReadFile(cfgFile)
   142  	if err != nil {
   143  		return nil, err
   144  	}
   145  
   146  	tree, err := toml.LoadBytes(bz)
   147  	if err != nil {
   148  		return nil, err
   149  	}
   150  
   151  	return tree, nil
   152  }
   153  
   154  func saveConfigFile(cfgFile string, tree io.WriterTo) error {
   155  	fp, err := os.OpenFile(cfgFile, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0644)
   156  	if err != nil {
   157  		return err
   158  	}
   159  	defer fp.Close()
   160  
   161  	_, err = tree.WriteTo(fp)
   162  	return err
   163  }
   164  
   165  func errUnknownConfigKey(key string) error {
   166  	return fmt.Errorf("unknown configuration key: %q", key)
   167  }