github.com/10XDev/rclone@v1.52.3-0.20200626220027-16af9ab76b2a/fs/config/flags/flags.go (about)

     1  // Package flags contains enhanced versions of spf13/pflag flag
     2  // routines which will read from the environment also.
     3  package flags
     4  
     5  import (
     6  	"log"
     7  	"os"
     8  	"time"
     9  
    10  	"github.com/rclone/rclone/fs"
    11  	"github.com/spf13/pflag"
    12  )
    13  
    14  // setDefaultFromEnv constructs a name from the flag passed in and
    15  // sets the default from the environment if possible.
    16  func setDefaultFromEnv(flags *pflag.FlagSet, name string) {
    17  	key := fs.OptionToEnv(name)
    18  	newValue, found := os.LookupEnv(key)
    19  	if found {
    20  		flag := flags.Lookup(name)
    21  		if flag == nil {
    22  			log.Fatalf("Couldn't find flag %q", name)
    23  		}
    24  		err := flag.Value.Set(newValue)
    25  		if err != nil {
    26  			log.Fatalf("Invalid value for environment variable %q: %v", key, err)
    27  		}
    28  		fs.Debugf(nil, "Set default for %q from %q to %q (%v)", name, key, newValue, flag.Value)
    29  		flag.DefValue = newValue
    30  	}
    31  }
    32  
    33  // StringP defines a flag which can be overridden by an environment variable
    34  //
    35  // It is a thin wrapper around pflag.StringP
    36  func StringP(name, shorthand string, value string, usage string) (out *string) {
    37  	out = pflag.StringP(name, shorthand, value, usage)
    38  	setDefaultFromEnv(pflag.CommandLine, name)
    39  	return out
    40  }
    41  
    42  // StringVarP defines a flag which can be overridden by an environment variable
    43  //
    44  // It is a thin wrapper around pflag.StringVarP
    45  func StringVarP(flags *pflag.FlagSet, p *string, name, shorthand string, value string, usage string) {
    46  	flags.StringVarP(p, name, shorthand, value, usage)
    47  	setDefaultFromEnv(flags, name)
    48  }
    49  
    50  // BoolP defines a flag which can be overridden by an environment variable
    51  //
    52  // It is a thin wrapper around pflag.BoolP
    53  func BoolP(name, shorthand string, value bool, usage string) (out *bool) {
    54  	out = pflag.BoolP(name, shorthand, value, usage)
    55  	setDefaultFromEnv(pflag.CommandLine, name)
    56  	return out
    57  }
    58  
    59  // BoolVarP defines a flag which can be overridden by an environment variable
    60  //
    61  // It is a thin wrapper around pflag.BoolVarP
    62  func BoolVarP(flags *pflag.FlagSet, p *bool, name, shorthand string, value bool, usage string) {
    63  	flags.BoolVarP(p, name, shorthand, value, usage)
    64  	setDefaultFromEnv(flags, name)
    65  }
    66  
    67  // IntP defines a flag which can be overridden by an environment variable
    68  //
    69  // It is a thin wrapper around pflag.IntP
    70  func IntP(name, shorthand string, value int, usage string) (out *int) {
    71  	out = pflag.IntP(name, shorthand, value, usage)
    72  	setDefaultFromEnv(pflag.CommandLine, name)
    73  	return out
    74  }
    75  
    76  // Int64P defines a flag which can be overridden by an environment variable
    77  //
    78  // It is a thin wrapper around pflag.IntP
    79  func Int64P(name, shorthand string, value int64, usage string) (out *int64) {
    80  	out = pflag.Int64P(name, shorthand, value, usage)
    81  	setDefaultFromEnv(pflag.CommandLine, name)
    82  	return out
    83  }
    84  
    85  // Int64VarP defines a flag which can be overridden by an environment variable
    86  //
    87  // It is a thin wrapper around pflag.Int64VarP
    88  func Int64VarP(flags *pflag.FlagSet, p *int64, name, shorthand string, value int64, usage string) {
    89  	flags.Int64VarP(p, name, shorthand, value, usage)
    90  	setDefaultFromEnv(flags, name)
    91  }
    92  
    93  // IntVarP defines a flag which can be overridden by an environment variable
    94  //
    95  // It is a thin wrapper around pflag.IntVarP
    96  func IntVarP(flags *pflag.FlagSet, p *int, name, shorthand string, value int, usage string) {
    97  	flags.IntVarP(p, name, shorthand, value, usage)
    98  	setDefaultFromEnv(flags, name)
    99  }
   100  
   101  // Uint32VarP defines a flag which can be overridden by an environment variable
   102  //
   103  // It is a thin wrapper around pflag.Uint32VarP
   104  func Uint32VarP(flags *pflag.FlagSet, p *uint32, name, shorthand string, value uint32, usage string) {
   105  	flags.Uint32VarP(p, name, shorthand, value, usage)
   106  	setDefaultFromEnv(flags, name)
   107  }
   108  
   109  // Float64P defines a flag which can be overridden by an environment variable
   110  //
   111  // It is a thin wrapper around pflag.Float64P
   112  func Float64P(name, shorthand string, value float64, usage string) (out *float64) {
   113  	out = pflag.Float64P(name, shorthand, value, usage)
   114  	setDefaultFromEnv(pflag.CommandLine, name)
   115  	return out
   116  }
   117  
   118  // Float64VarP defines a flag which can be overridden by an environment variable
   119  //
   120  // It is a thin wrapper around pflag.Float64VarP
   121  func Float64VarP(flags *pflag.FlagSet, p *float64, name, shorthand string, value float64, usage string) {
   122  	flags.Float64VarP(p, name, shorthand, value, usage)
   123  	setDefaultFromEnv(flags, name)
   124  }
   125  
   126  // DurationP defines a flag which can be overridden by an environment variable
   127  //
   128  // It is a thin wrapper around pflag.DurationP
   129  func DurationP(name, shorthand string, value time.Duration, usage string) (out *time.Duration) {
   130  	out = pflag.DurationP(name, shorthand, value, usage)
   131  	setDefaultFromEnv(pflag.CommandLine, name)
   132  	return out
   133  }
   134  
   135  // DurationVarP defines a flag which can be overridden by an environment variable
   136  //
   137  // It is a thin wrapper around pflag.DurationVarP
   138  func DurationVarP(flags *pflag.FlagSet, p *time.Duration, name, shorthand string, value time.Duration, usage string) {
   139  	flags.DurationVarP(p, name, shorthand, value, usage)
   140  	setDefaultFromEnv(flags, name)
   141  }
   142  
   143  // VarP defines a flag which can be overridden by an environment variable
   144  //
   145  // It is a thin wrapper around pflag.VarP
   146  func VarP(value pflag.Value, name, shorthand, usage string) {
   147  	pflag.VarP(value, name, shorthand, usage)
   148  	setDefaultFromEnv(pflag.CommandLine, name)
   149  }
   150  
   151  // FVarP defines a flag which can be overridden by an environment variable
   152  //
   153  // It is a thin wrapper around pflag.VarP
   154  func FVarP(flags *pflag.FlagSet, value pflag.Value, name, shorthand, usage string) {
   155  	flags.VarP(value, name, shorthand, usage)
   156  	setDefaultFromEnv(flags, name)
   157  }
   158  
   159  // StringArrayP defines a flag which can be overridden by an environment variable
   160  //
   161  // It sets one value only - command line flags can be used to set more.
   162  //
   163  // It is a thin wrapper around pflag.StringArrayP
   164  func StringArrayP(name, shorthand string, value []string, usage string) (out *[]string) {
   165  	out = pflag.StringArrayP(name, shorthand, value, usage)
   166  	setDefaultFromEnv(pflag.CommandLine, name)
   167  	return out
   168  }
   169  
   170  // StringArrayVarP defines a flag which can be overridden by an environment variable
   171  //
   172  // It sets one value only - command line flags can be used to set more.
   173  //
   174  // It is a thin wrapper around pflag.StringArrayVarP
   175  func StringArrayVarP(flags *pflag.FlagSet, p *[]string, name, shorthand string, value []string, usage string) {
   176  	flags.StringArrayVarP(p, name, shorthand, value, usage)
   177  	setDefaultFromEnv(flags, name)
   178  }
   179  
   180  // CountP defines a flag which can be overridden by an environment variable
   181  //
   182  // It is a thin wrapper around pflag.CountP
   183  func CountP(name, shorthand string, usage string) (out *int) {
   184  	out = pflag.CountP(name, shorthand, usage)
   185  	setDefaultFromEnv(pflag.CommandLine, name)
   186  	return out
   187  }
   188  
   189  // CountVarP defines a flag which can be overridden by an environment variable
   190  //
   191  // It is a thin wrapper around pflag.CountVarP
   192  func CountVarP(flags *pflag.FlagSet, p *int, name, shorthand string, usage string) {
   193  	flags.CountVarP(p, name, shorthand, usage)
   194  	setDefaultFromEnv(flags, name)
   195  }