func init() {
id_message := versionString() + "\n\nUsage: c4 [mode] [flags] [files]\n\n" +
"# `id` mode \n\n" +
" c4 generates c4ids for all files and folders spacified.\n" +
" If no file is given c4 will read piped data.\n" +
" Output is in YAML format.\n\n" +
" flags:\n"
cp_message := "\n\n" +
"# `cp` mode (not yet implemented)\n\n" +
" cp mode acts as a drop in replacement for the unix cp command.\n" +
" It acts the same as the normal cp command, but ids files on the fly\n" +
" It also adds the ability to specify multiple copy targets with the -T flag.\n\n" +
" flags:\n"
flag.Usage = func() {
fmt.Fprintf(os.Stderr, id_message)
id_flags.PrintDefaults()
fmt.Fprintf(os.Stderr, cp_message)
cp_flags.PrintDefaults()
fmt.Fprintf(os.Stderr, "\n")
}
id_flags = flag.NewFlagSet("id", flag.ContinueOnError)
cp_flags = flag.NewFlagSet("cp", flag.ContinueOnError)
// id
// id_flags.BoolVarP(&version_flag, "version", "v", false, "Show version information.")
id_flags.BoolVarP(&recursive_flag, "recursive", "R", false, "Recursively identify all files for the given url.")
id_flags.BoolVarP(&absolute_flag, "absolute", "a", false, "Output absolute paths, instead of relative paths.")
// id_flags.BoolVarP(&arg_links, "arg_links", "H", false, "If the -R option is specified, symbolic links on the command line are followed.\n (Symbolic links encountered in the tree traversal are not followed by default.)")
id_flags.BoolVarP(&links_flag, "links", "L", false, "All symbolic links are followed.")
// id_flags.BoolVarP(&no_links, "no_links", "P", true, "If the -R option is specified, no symbolic links are followed. This is the default.")
id_flags.IntVarP(&depth, "depth", "d", 0, "Only output ids for files and folders 'depth' directories deep.")
id_flags.BoolVarP(&include_meta, "metadata", "m", false, "Include filesystem metadata.")
id_flags.StringVarP(&formatting_string, "formatting", "f", "id", "Output formatting options.\n \"id\": c4id oriented.\n \"path\": path oriented.")
// cp
cp_flags.BoolVarP(&archive_cp_flag, "archive", "a", false, "Same as -pPR options.")
cp_flags.BoolVarP(&force_cp_flag, "force", "f", false, "Force.")
cp_flags.BoolVarP(&follow_all_links_cp_flag, "follow_all_links", "H", false, "Follow all symbolic links.")
cp_flags.BoolVarP(&prompt_cp_flag, "prompt", "i", false, "Prompt before overwriting an existing file.")
cp_flags.BoolVarP(&follow_links_cp_flag, "follow_links", "L", false, "Follow links instead of copy with -R option.")
cp_flags.BoolVarP(&noclobber_cp_flag, "noclobber", "n", false, "Do not overwrite existing files.")
cp_flags.BoolVarP(©_links_cp_flag, "copy_links", "P", true, "Copy links with -R option (default).")
cp_flags.BoolVarP(&preserve_cp_flag, "preserve", "p", false, "Preserve attributes.")
cp_flags.BoolVarP(&recursive_cp_flag, "recursive", "R", false, "Copy recursively.")
cp_flags.BoolVarP(&verbose_cp_flag, "verbose", "v", false, "Verbose output.")
cp_flags.VarP(&target_cp_flag, "target", "T", "Specify additional target paths, can be used more than once.")
}
func NewCmd(l log15.Logger, server *Server, version string) *Cmd {
var (
flags = &flags{
FlagSet: pflag.NewFlagSet("", pflag.ExitOnError),
}
)
flags.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage:\n")
flags.PrintDefaults()
}
flags.StringVar(&flags.location, "location", "", "unix socket for http")
flags.StringVar(&flags.statedir, "statedir", "", "statedir location")
flags.BoolVarP(&flags.help, "help", "h", false, "show help")
flags.BoolVarP(&flags.version, "version", "v", false, "show version")
flags.BoolVar(&flags.verbose, "verbose", false, "verbose output")
return &Cmd{
Logger: l,
flags: flags,
Server: server,
version: version,
}
}
func (cmd *Download) parseFlags() (exitCode int, err error) {
var showUsage bool
fs := flag.NewFlagSet("conoha-ojs-download", flag.ContinueOnError)
fs.BoolVarP(&showUsage, "help", "h", false, "Print usage.")
err = fs.Parse(os.Args[2:])
if err != nil {
return ExitCodeParseFlagError, err
}
if showUsage {
return ExitCodeUsage, nil
}
if len(os.Args) < 3 {
return ExitCodeParseFlagError, errors.New("Not enough arguments.")
}
// 取得するオブジェクト名
cmd.objectName = os.Args[2]
// 保存先のパス
if len(os.Args) == 4 {
cmd.destPath = os.Args[3]
} else {
cmd.destPath = "."
}
return ExitCodeOK, nil
}
func FlagParse(args []string) (*CLI, error) {
fs := pflag.NewFlagSet(args[0], pflag.ContinueOnError)
cli := &CLI{}
fs.BoolVarP(&cli.Public, "private", "p", false, "make private")
err := fs.Parse(args[1:])
if err != nil {
return nil, err
}
cli.Public = !cli.Public
if len(fs.Args()) != 1 {
return nil, fmt.Errorf("file name is required")
}
cli.FileName = fs.Arg(0)
content, err := ioutil.ReadAll(os.Stdin)
if err != nil {
return nil, err
}
cli.FileContent = string(content)
return cli, nil
}
// コマンドライン引数を処理して、一覧表示するコンテナ名を返す
// 引数が省略された場合はルートを決め打ちする
func (cmd *List) parseFlags() (exitCode int, err error) {
var showUsage bool
fs := flag.NewFlagSet("conoha-ojs-list", flag.ContinueOnError)
fs.BoolVarP(&showUsage, "help", "h", false, "Print usage.")
err = fs.Parse(os.Args[2:])
if err != nil {
return ExitCodeParseFlagError, err
}
if showUsage {
return ExitCodeUsage, nil
}
if len(os.Args) == 2 {
// コンテナ名が指定されなかったときはルートを決め打ちする
cmd.containerName = "/"
} else if len(os.Args) < 2 {
return ExitCodeParseFlagError, errors.New("Not enough arguments.")
} else {
cmd.containerName = os.Args[2]
}
return ExitCodeOK, nil
}
func (cmd *Delete) parseFlags() (exitCode int, err error) {
var showUsage bool
fs := flag.NewFlagSet("conoha-ojs-delete", flag.ContinueOnError)
fs.BoolVarP(&showUsage, "help", "h", false, "Print usage.")
err = fs.Parse(os.Args[2:])
if err != nil {
return ExitCodeParseFlagError, err
}
if showUsage {
return ExitCodeUsage, nil
}
if fs.NArg() < 1 {
return ExitCodeParseFlagError, errors.New("Not enough arguments.")
}
// 削除するオブジェクト名
cmd.objectName = os.Args[2]
return ExitCodeOK, nil
}
// 引数-mでメタデータを指定する
// メタデータはコロン区切りの key:value の形式で渡す。
func (cmd *Post) parseFlags() (exitCode int, err error) {
// 初期化
cmd.metadatas = strmap{}
var showUsage bool
fs := flag.NewFlagSet("conoha-ojs-post", flag.ContinueOnError)
fs.BoolVarP(&showUsage, "help", "h", false, "Print usage.")
fs.VarP(&cmd.metadatas, "meta", "m", "Key and value of metadata.")
fs.StringVarP(&cmd.readAcl, "read-acl", "r", "_no_assign_", "Read ACL for containers.")
fs.StringVarP(&cmd.writeAcl, "write-acl", "w", "_no_assign_", "Write ACL for containers.")
err = fs.Parse(os.Args[2:])
if err != nil {
return ExitCodeParseFlagError, err
}
if showUsage {
return ExitCodeUsage, nil
}
// メタデータを操作するオブジェクト
cmd.objectName = fs.Arg(0)
if cmd.objectName == "" {
return ExitCodeParseFlagError, errors.New("Not enough arguments.")
}
return ExitCodeOK, nil
}
func readConfigsFromReader(r io.Reader, name string) ([]*Config, error) {
scanner := bufio.NewScanner(r)
lineNo := 0
var configs []*Config
for scanner.Scan() {
lineNo++
errorf := fmt.Sprintf("error on line %d of %s: %%s", lineNo, name)
c := &Config{}
flags := flag.NewFlagSet("", flag.ContinueOnError)
flags.SetOutput(ioutil.Discard)
c.registerFlags(flags)
parts, err := shellquote.Split(scanner.Text())
if err != nil {
return nil, fmt.Errorf(errorf, err)
}
// Skip empty lines and comments (lines starting with #).
if len(parts) == 0 || strings.HasPrefix(parts[0], "#") {
continue
}
if err := flags.Parse(parts); err != nil {
return nil, fmt.Errorf(errorf, err)
}
c.command = flags.Args()
c.source = fmt.Sprintf("%s, line %d", name, lineNo)
configs = append(configs, c)
}
if err := scanner.Err(); err != nil {
return nil, fmt.Errorf("error reading config from %s: %s", name, err)
}
return configs, nil
}
// Read configuration from both profile and flags. Flags override profile.
func config() (*flag.FlagSet, error) {
dir, err := getCfgDir(".boot2docker")
if err != nil {
return nil, fmt.Errorf("failed to get boot2docker directory: %s", err)
}
flags := flag.NewFlagSet(os.Args[0], flag.ContinueOnError)
flags.Usage = func() { usageLong(flags) }
flags.StringVar(&B2D.VM, "vm", "boot2docker-vm", "virtual machine name.")
flags.StringVarP(&B2D.Dir, "dir", "d", dir, "boot2docker config directory.")
flags.StringVar(&B2D.ISO, "iso", filepath.Join(dir, "boot2docker.iso"), "path to boot2docker ISO image.")
flags.StringVar(&B2D.VMDK, "basevmdk", "", "Path to VMDK to use as base for persistent partition")
vbm := "VBoxManage"
if p := os.Getenv("VBOX_INSTALL_PATH"); p != "" && runtime.GOOS == "windows" {
vbm = filepath.Join(p, "VBoxManage.exe")
}
flags.StringVar(&B2D.VBM, "vbm", vbm, "path to VirtualBox management utility.")
flags.BoolVarP(&B2D.Verbose, "verbose", "v", false, "display verbose command invocations.")
flags.StringVar(&B2D.SSH, "ssh", "ssh", "path to SSH client utility.")
flags.StringVar(&B2D.SSHGen, "ssh-keygen", "ssh-keygen", "path to ssh-keygen utility.")
sshdir, _ := getCfgDir(".ssh")
flags.StringVar(&B2D.SSHKey, "sshkey", filepath.Join(sshdir, "id_boot2docker"), "path to SSH key to use.")
flags.UintVarP(&B2D.DiskSize, "disksize", "s", 20000, "boot2docker disk image size (in MB).")
flags.UintVarP(&B2D.Memory, "memory", "m", 1024, "virtual machine memory size (in MB).")
flags.Uint16Var(&B2D.SSHPort, "sshport", 2022, "host SSH port (forward to port 22 in VM).")
flags.Uint16Var(&B2D.DockerPort, "dockerport", 4243, "host Docker port (forward to port 4243 in VM).")
flags.IPVar(&B2D.HostIP, "hostip", net.ParseIP("192.168.59.3"), "VirtualBox host-only network IP address.")
flags.IPMaskVar(&B2D.NetMask, "netmask", flag.ParseIPv4Mask("255.255.255.0"), "VirtualBox host-only network mask.")
flags.BoolVar(&B2D.DHCPEnabled, "dhcp", true, "enable VirtualBox host-only network DHCP.")
flags.IPVar(&B2D.DHCPIP, "dhcpip", net.ParseIP("192.168.59.99"), "VirtualBox host-only network DHCP server address.")
flags.IPVar(&B2D.LowerIP, "lowerip", net.ParseIP("192.168.59.103"), "VirtualBox host-only network DHCP lower bound.")
flags.IPVar(&B2D.UpperIP, "upperip", net.ParseIP("192.168.59.254"), "VirtualBox host-only network DHCP upper bound.")
// Set the defaults
if err := flags.Parse([]string{}); err != nil {
return nil, err
}
// Over-ride from the profile file
// TODO: should we really parse for and expand $ENVVARS before we process..?
filename := getCfgFilename(dir)
if _, err := toml.DecodeFile(filename, &B2D); err != nil {
return nil, err
}
// Command-line overrides profile config.
if err := flags.Parse(os.Args[1:]); err != nil {
return nil, err
}
// Name of VM is the second argument. Override the value set in flag.
if vm := flags.Arg(1); vm != "" {
B2D.VM = vm
}
vbx.Verbose = B2D.Verbose
vbx.VBM = B2D.VBM
return flags, nil
}
func parseCommandLine(cmdLine []string) (Args, error) {
var result Args
flags := pflag.NewFlagSet("Sarge", pflag.ContinueOnError)
flags.StringVarP(&result.ImageFile, "image", "i", "",
"The image file to load")
err := flags.Parse(cmdLine)
return result, err
}
func parseFlags(args []string) (*config.Config, error) {
var doHelp bool
var doVersion bool
var c = config.DefaultConfig()
flags := flag.NewFlagSet("mesos-consul", flag.ContinueOnError)
flags.Usage = func() {
fmt.Println(Help())
}
flags.BoolVar(&doHelp, "help", false, "")
flags.BoolVar(&doVersion, "version", false, "")
flags.StringVar(&c.LogLevel, "log-level", "WARN", "")
flags.DurationVar(&c.Refresh, "refresh", time.Minute, "")
flags.StringVar(&c.Zk, "zk", "zk://127.0.0.1:2181/mesos", "")
flags.StringVar(&c.MesosIpOrder, "mesos-ip-order", "netinfo,mesos,host", "")
flags.BoolVar(&c.Healthcheck, "healthcheck", false, "")
flags.StringVar(&c.HealthcheckIp, "healthcheck-ip", "127.0.0.1", "")
flags.StringVar(&c.HealthcheckPort, "healthcheck-port", "24476", "")
flags.Var((funcVar)(func(s string) error {
c.WhiteList = append(c.WhiteList, s)
return nil
}), "whitelist", "")
flags.StringVar(&c.ServiceName, "service-name", "mesos", "")
flags.StringVar(&c.ServiceTags, "service-tags", "", "")
consul.AddCmdFlags(flags)
if err := flags.Parse(args); err != nil {
return nil, err
}
args = flags.Args()
if len(args) > 0 {
return nil, fmt.Errorf("extra argument(s): %q", args)
}
if doVersion {
fmt.Printf("%s v%s\n", Name, Version)
os.Exit(0)
}
if doHelp {
flags.Usage()
os.Exit(0)
}
l, err := log.ParseLevel(strings.ToLower(c.LogLevel))
if err != nil {
log.SetLevel(log.WarnLevel)
log.Warnf("Invalid log level '%v'. Setting to WARN", c.LogLevel)
} else {
log.SetLevel(l)
}
return c, nil
}
// ParseCommandLine parses the standard command line interface for a squaddie
// plugin
func ParseCommandLine(cmdLine []string) (Args, error) {
var result Args
flags := pflag.NewFlagSet("Plugin API", pflag.ContinueOnError)
flags.StringVarP(&result.Network, "network", "n", "unix",
"The network type")
flags.StringVarP(&result.Path, "path", "p", "/var/sarge.sock",
"The RPC endpoint")
err := flags.Parse(cmdLine)
return result, err
}
func (c *CLI) Parse(args []string) error {
cmds := make(Commands, 0)
c.Commands = cmds
fset := pflag.NewFlagSet(args[0], pflag.ContinueOnError)
fset.VarP(&c.Commands, "command", "c", "command")
err := fset.Parse(args[1:])
c.Files = fset.Args()
return err
}
func RunServer(args []string) {
flags := flag.NewFlagSet("server", flag.ExitOnError)
addCommonOptions(flags)
flags.Parse(args)
// We start the transports in another goroutine, so our main routine can
// return (and wait for signals).
// Note: The startTransports function takes ownership (and closes) the
// tuntap device.
tt := getTuntap(false)
go startTransports(tt)
}
func httpHandle(args []string) {
set := pflag.NewFlagSet("http", pflag.ExitOnError)
addr := set.StringP("addr", "a", ":8080", "Listen address.")
set.Parse(args)
if addr == nil {
set.Usage()
os.Exit(1)
}
if err := ListenAndServe(*addr); err != nil {
log.Fatal(err)
}
}
func NewFlagSet(c *ConsulFlags) *flag.FlagSet {
consulFlags := flag.NewFlagSet("consulacl", flag.ContinueOnError)
consulFlags.StringVar(&c.consulAddr, "consul", "127.0.0.1:8500", "")
consulFlags.BoolVar(&c.sslEnabled, "ssl", false, "")
consulFlags.BoolVar(&c.sslVerify, "ssl-verify", true, "")
consulFlags.StringVar(&c.sslCert, "ssl-cert", "", "")
consulFlags.StringVar(&c.sslCaCert, "ssl-ca-cert", "", "")
consulFlags.StringVar(&c.token, "token", "", "")
c.auth = new(Auth)
consulFlags.Var((*Auth)(c.auth), "auth", "")
return consulFlags
}
func parseFlags(args []string) (*config.Config, error) {
var doHelp bool
var c = config.DefaultConfig()
flags := flag.NewFlagSet("mesos-consul", flag.ContinueOnError)
flags.Usage = func() {
fmt.Println(Help())
}
flags.BoolVar(&doHelp, "help", false, "")
flags.StringVar(&c.LogLevel, "log-level", "WARN", "")
flags.DurationVar(&c.Refresh, "refresh", time.Minute, "")
flags.StringVar(&c.RegistryPort, "registry-port", "8500", "")
flags.Var((*config.AuthVar)(c.RegistryAuth), "registry-auth", "")
flags.BoolVar(&c.RegistrySSL.Enabled, "registry-ssl", c.RegistrySSL.Enabled, "")
flags.BoolVar(&c.RegistrySSL.Verify, "registry-ssl-verify", c.RegistrySSL.Verify, "")
flags.StringVar(&c.RegistrySSL.Cert, "registry-ssl-cert", c.RegistrySSL.Cert, "")
flags.StringVar(&c.RegistrySSL.CaCert, "registry-ssl-cacert", c.RegistrySSL.CaCert, "")
flags.StringVar(&c.RegistryToken, "registry-token", c.RegistryToken, "")
flags.StringVar(&c.Zk, "zk", "zk://127.0.0.1:2181/mesos", "")
consul.AddCmdFlags(flags)
if err := flags.Parse(args); err != nil {
return nil, err
}
args = flags.Args()
if len(args) > 0 {
return nil, fmt.Errorf("extra argument(s): %q", args)
}
if doHelp {
flags.Usage()
os.Exit(0)
}
l, err := log.ParseLevel(c.LogLevel)
if err != nil {
log.SetLevel(log.WarnLevel)
log.Warnf("Invalid log level '%v'. Setting to WARN")
} else {
log.SetLevel(l)
}
return c, nil
}
func optionsSet() *pflag.FlagSet {
set := pflag.NewFlagSet("options", pflag.ExitOnError)
defaultMBox, _ := mailbox.DefaultMailboxPath()
set.StringVar(&fOptions.MyCall, `mycall`, ``, `Your callsign (winlink user).`)
set.StringVarP(&fOptions.Listen, "listen", "l", "", "Comma-separated list of methods to listen on (e.g. winmor,ardop,telnet,ax25).")
set.StringVar(&fOptions.MailboxPath, "mbox", defaultMBox, "Path to mailbox directory")
set.StringVar(&fOptions.ConfigPath, "config", fOptions.ConfigPath, "Path to config file")
set.StringVar(&fOptions.LogPath, "log", fOptions.LogPath, "Path to log file. The file is truncated on each startup.")
set.StringVar(&fOptions.EventLogPath, "event-log", fOptions.EventLogPath, "Path to event log file.")
set.BoolVarP(&fOptions.SendOnly, `send-only`, "s", false, `Download inbound messages later, send only.`)
set.BoolVarP(&fOptions.RobustWinmor, `robust-winmor`, "r", false, `Use robust winmor modes only. (Usefull to improve s/n-ratio at remote station.)`)
set.BoolVar(&fOptions.IgnoreBusy, "ignore-busy", false, "Don't wait for clear channel before connecting to a node.")
return set
}
func parseFlags(args []string) (*config.Config, error) {
var doHelp bool
var c = config.DefaultConfig()
flags := flag.NewFlagSet("mesos-consul", flag.ContinueOnError)
flags.Usage = func() {
fmt.Print(usage)
}
flags.BoolVar(&doHelp, "help", false, "")
flags.StringVar(&c.LogLevel, "log-level", "WARN", "")
flags.DurationVar(&c.Refresh, "refresh", time.Minute, "")
flags.StringVar(&c.RegistryPort, "registry-port", "8500", "")
flags.Var((*config.AuthVar)(c.RegistryAuth), "registry-auth", "")
flags.BoolVar(&c.RegistrySSL.Enabled, "registry-ssl", c.RegistrySSL.Enabled, "")
flags.BoolVar(&c.RegistrySSL.Verify, "registry-ssl-verify", c.RegistrySSL.Verify, "")
flags.StringVar(&c.RegistrySSL.Cert, "registry-ssl-cert", c.RegistrySSL.Cert, "")
flags.StringVar(&c.RegistrySSL.CaCert, "registry-ssl-cacert", c.RegistrySSL.CaCert, "")
flags.StringVar(&c.RegistryToken, "registry-token", c.RegistryToken, "")
flags.StringVar(&c.Zk, "zk", "zk://127.0.0.1:2181/mesos", "")
if err := flags.Parse(args); err != nil {
return nil, err
}
args = flags.Args()
if len(args) > 0 {
return nil, fmt.Errorf("extra argument(s): %q", args)
}
if doHelp {
flags.Usage()
os.Exit(0)
}
logging.Setup(&logging.Config{
Name: "mesos-consul",
Level: c.LogLevel,
Writer: os.Stderr,
})
return c, nil
}
func ParseFlag(args []string) ([]string, Commands, error) {
fset := pflag.NewFlagSet(args[0], pflag.ExitOnError)
globs := make(Strings, 0)
commands := make(Commands, 0)
fset.VarP(&globs, "glob", "g", "glob")
fset.VarP(&commands, "command", "c", "command")
fset.BoolVarP(&logger.debug, "debug", "d", false, "enable debug")
conf, err := LoadConfig()
if err != nil {
return nil, nil, err
}
a := append(conf, args[1:]...)
if err := fset.Parse(a); err != nil {
return nil, nil, err
}
return globs, commands, nil
}
func (m *Meta) FlagSet() *flag.FlagSet {
f := flag.NewFlagSet("consul-cli", flag.ContinueOnError)
f.StringVar(&m.consulAddr, "consul", "", "")
f.BoolVar(&m.sslEnabled, "ssl", false, "")
f.BoolVar(&m.sslVerify, "ssl-verify", true, "")
f.StringVar(&m.sslCert, "ssl-cert", "", "")
f.StringVar(&m.sslCaCert, "ssl-ca-cert", "", "")
f.StringVar(&m.token, "token", "", "")
if m.hasDc {
f.StringVar(&m.dc, "datacenter", "", "")
}
if m.hasWait {
f.Uint64Var(&m.waitIndex, "wait-index", 0, "")
}
m.auth = new(Auth)
f.Var((*Auth)(m.auth), "auth", "")
return f
}
func (cmd *Upload) parseFlags() (exitCode int, err error) {
var showUsage bool
fs := flag.NewFlagSet("conoha-ojs-upload", flag.ContinueOnError)
// コマンドライン引数の定義を追加
fs.BoolVarP(&showUsage, "help", "h", false, "Print usage.")
fs.StringVarP(&cmd.contentType, "content-type", "c", "", "Set Content-type")
err = fs.Parse(os.Args[2:])
if err != nil {
return ExitCodeParseFlagError, err
}
if showUsage {
return ExitCodeUsage, nil
}
if fs.NArg() < 2 {
return ExitCodeParseFlagError, errors.New("Not enough arguments.")
}
// アップロード先コンテナ
cmd.destContainer = fs.Arg(0)
// アップロードするファイル
for i := 1; i < fs.NArg(); i++ {
filename := fs.Arg(i)
_, err := os.Stat(filename)
if err != nil {
msg := fmt.Sprintf("File \"%s\" not found.", filename)
return ExitCodeError, errors.New(msg)
}
cmd.srcFiles = append(cmd.srcFiles, filename)
}
return ExitCodeOK, nil
}
func parseFlags(args []string) (*config.Config, error) {
var doHelp bool
var c = config.DefaultConfig()
flags := flag.NewFlagSet("mesos-consul", flag.ContinueOnError)
flags.Usage = func() {
fmt.Println(Help())
}
flags.BoolVar(&doHelp, "help", false, "")
flags.StringVar(&c.LogLevel, "log-level", "WARN", "")
flags.DurationVar(&c.Refresh, "refresh", time.Minute, "")
flags.StringVar(&c.Zk, "zk", "zk://127.0.0.1:2181/mesos", "")
flags.StringVar(&c.MesosIpOrder, "mesos-ip-order", "netinfo,mesos,host", "")
consul.AddCmdFlags(flags)
if err := flags.Parse(args); err != nil {
return nil, err
}
args = flags.Args()
if len(args) > 0 {
return nil, fmt.Errorf("extra argument(s): %q", args)
}
if doHelp {
flags.Usage()
os.Exit(0)
}
l, err := log.ParseLevel(strings.ToLower(c.LogLevel))
if err != nil {
log.SetLevel(log.WarnLevel)
log.Warnf("Invalid log level '%v'. Setting to WARN", c.LogLevel)
} else {
log.SetLevel(l)
}
return c, nil
}
func RunClient(args []string) {
flags := flag.NewFlagSet("client", flag.ExitOnError)
addCommonOptions(flags)
flags.StringVar(&method, "m", "all", "methods to try, as comma-seperated list (tcp/udp/icmp/dns/all)")
flags.StringVar(&server_addr, "server", "10.93.0.1", "ip address of the server")
flags.Parse(args)
cmd_args := flags.Args()
if len(cmd_args) < 1 {
fmt.Fprintf(os.Stderr, "No server address given!\n\n")
fmt.Fprintf(os.Stderr, "Usage:\n")
fmt.Fprintf(os.Stderr, " holepunch client [options] server_addr\n\n")
os.Exit(1)
} else {
// Use a different goroutine, so the main routine can wait for signals.
tt := getTuntap(true)
go startClient(tt, cmd_args[0])
}
}
func parseArgs() (arguments, error) {
var result arguments
flags := pflag.NewFlagSet("Impact", pflag.ContinueOnError)
flags.StringVarP(&result.packageName, "package", "p", "",
"The package to test. Paths in the patch file must be relative to this.")
flags.StringVarP(&result.packageListFile, "package-file", "f", "packages.txt",
"The file containing the list of packages to test")
flags.StringVarP(&result.patchFile, "delta", "d", "delta.patch",
"A patch describing the change to test")
flags.DurationVarP(&result.fetchTimeout, "timeout", "t", 60*time.Minute,
"How long to wait for the source code fetch befor giving up.")
flags.StringVarP(&result.reportFile, "report", "r", "report.txt",
"How long to wait for the source code frtch befor giving up.")
flags.IntVarP(&result.concurrency, "concurrency", "n", 8,
"How many tests to run simultaneously")
err := flags.Parse(os.Args[1:])
if err != nil {
return result, err
}
if result.packageName == "" {
return result, errors.New("Must specify a package to test")
}
result.packageListFile, err = filepath.Abs(result.packageListFile)
if err != nil {
return result, err
}
result.patchFile, err = filepath.Abs(result.patchFile)
if err != nil {
return result, err
}
result.reportFile, err = filepath.Abs(result.reportFile)
return result, err
}
func (cmd *Stat) parseFlags() (exitCode int, err error) {
var showUsage bool
fs := flag.NewFlagSet("conoha-ojs-post", flag.ContinueOnError)
fs.BoolVarP(&showUsage, "help", "h", false, "Print usage.")
err = fs.Parse(os.Args[2:])
if err != nil {
return ExitCodeParseFlagError, err
}
if showUsage {
return ExitCodeUsage, nil
}
cmd.objectName = fs.Arg(0)
if cmd.objectName == "" {
// オブジェクトが指定されなかった場合、一番上位のコンテナが指定されるのでそのまま進めて良い
}
return ExitCodeOK, nil
}
// コマンドライン引数を処理して返す
func (cmd *Auth) parseFlags() (exitCode int, err error) {
var showUsage bool
fs := flag.NewFlagSet("conoha-ojs-auth", flag.ContinueOnError)
// コマンドライン引数の定義を追加
fs.BoolVarP(&showUsage, "help", "h", false, "Print usage.")
fs.StringVarP(&cmd.username, "api-username", "u", "", "API Username")
fs.StringVarP(&cmd.password, "api-password", "p", "", "API Password")
fs.StringVarP(&cmd.authUrl, "auth-url", "a", "", "Auth URL")
fs.StringVarP(&cmd.tenantId, "tenant-id", "t", "", "Tenant ID")
err = fs.Parse(os.Args[2:])
if err != nil {
return ExitCodeParseFlagError, err
}
if showUsage {
return ExitCodeUsage, nil
}
// ユーザ名、パスワードを未指定の場合はUsageを表示して終了
if cmd.username == "" || cmd.password == "" || cmd.tenantId == "" {
return ExitCodeParseFlagError, errors.New("Not enough arguments.")
}
// 認証URLの指定がない場合はデフォルトを使用
if cmd.authUrl == "" {
cmd.authUrl = DEFAULT_AUTH_URL
}
// 末尾のURLを削除する
if strings.HasSuffix(cmd.authUrl, "/") {
cmd.authUrl = cmd.authUrl[0 : len(cmd.authUrl)-1]
}
return ExitCodeOK, nil
}
func rmsListHandle(args []string) {
set := pflag.NewFlagSet("rmslist", pflag.ExitOnError)
mode := set.StringP("mode", "m", "", "")
forceDownload := set.BoolP("force-download", "d", false, "")
set.Parse(args)
appDir, err := mailbox.DefaultAppDir()
if err != nil {
log.Fatal(err)
}
filePath := path.Join(appDir, "rmslist.json") // Should be moved to a tmp-folder, along with logfile.
var query string
if len(set.Args()) > 0 {
query = strings.ToUpper(set.Args()[0])
}
file, err := GetGatewayStatusCached(filePath, *forceDownload)
if err != nil {
log.Fatal(err)
}
defer file.Close()
var status GatewayStatus
err = json.NewDecoder(file).Decode(&status)
if err != nil {
log.Fatal(err)
}
*mode = strings.ToLower(*mode)
fmtStr := "%-9.9s [%-6.6s] %-15.15s %14.14s %14.14s\n"
// Print header
fmt.Printf(fmtStr, "callsign", "gridsq", "mode(s)", "dial freq", "center freq") //TODO: "center frequency" of packet is wrong...
// Print gateways (separated by blank line)
for _, gw := range status.Gateways {
switch {
case query != "" && !strings.HasPrefix(gw.Callsign, query):
continue
default:
}
var printed bool
for _, channel := range gw.Channels {
if mode != nil && !strings.Contains(strings.ToLower(channel.SupportedModes), *mode) {
continue
}
printed = true
freq := Frequency(channel.Frequency)
dial := freq.Dial(channel.SupportedModes)
fmt.Printf(fmtStr, gw.Callsign, channel.Gridsquare, channel.SupportedModes, dial, freq)
}
if printed {
fmt.Println("")
}
}
}
flag "github.com/ogier/pflag"
"gopkg.in/fsnotify.v1"
)
const defaultSubSymbol = "{}"
var (
reflexes []*Reflex
flagConf string
flagSequential bool
flagDecoration string
decoration Decoration
verbose bool
globalFlags = flag.NewFlagSet("", flag.ContinueOnError)
globalConfig = &Config{}
reflexID = 0
stdout = make(chan OutMsg, 1)
cleanupMu = &sync.Mutex{}
)
func usage() {
fmt.Fprintf(os.Stderr, `Usage: %s [OPTIONS] [COMMAND]
COMMAND is any command you'd like to run. Any instance of {} will be replaced
with the filename of the changed file. (The symbol may be changed with the
--substitute flag.)
// Read configuration from both profile and flags. Flags override profile.
func config() (*flag.FlagSet, error) {
dir, err := getCfgDir(".boot2kevoree")
if err != nil {
return nil, fmt.Errorf("failed to get boot2kevoree directory: %s", err)
}
flags := flag.NewFlagSet(os.Args[0], flag.ContinueOnError)
flags.Usage = func() { usageLong(flags) }
flags.StringVar(&B2D.VM, "vm", "boot2kevoree-vm", "virtual machine name.")
// removed for now, requires re-parsing a new config file which is too messy
//flags.StringVarP(&B2D.Dir, "dir", "d", dir, "boot2kevoree config directory.")
B2D.Dir = dir
flags.StringVar(&B2D.ISO, "iso", filepath.Join(dir, "boot2kevoree.iso"), "path to boot2kevoree ISO image.")
flags.StringVar(&B2D.VMDK, "basevmdk", "", "Path to VMDK to use as base for persistent partition")
vbm := "VBoxManage"
if p := os.Getenv("VBOX_INSTALL_PATH"); p != "" && runtime.GOOS == "windows" {
vbm = filepath.Join(p, "VBoxManage.exe")
}
flags.StringVar(&B2D.VBM, "vbm", vbm, "path to VirtualBox management utility.")
flags.BoolVarP(&B2D.Verbose, "verbose", "v", false, "display verbose command invocations.")
flags.StringVar(&B2D.SSH, "ssh", "ssh", "path to SSH client utility.")
flags.StringVar(&B2D.SSHGen, "ssh-keygen", "ssh-keygen", "path to ssh-keygen utility.")
sshdir, _ := getCfgDir(".ssh")
flags.StringVar(&B2D.SSHKey, "sshkey", filepath.Join(sshdir, "id_boot2kevoree"), "path to SSH key to use.")
flags.UintVarP(&B2D.DiskSize, "disksize", "s", 20000, "boot2kevoree disk image size (in MB).")
flags.UintVarP(&B2D.Memory, "memory", "m", 1024, "virtual machine memory size (in MB).")
flags.Uint16Var(&B2D.SSHPort, "sshport", 2022, "host SSH port (forward to port 22 in VM).")
flags.Uint16Var(&B2D.DockerPort, "dockerport", 4243, "host Docker port (forward to port 4243 in VM).")
flags.Uint16Var(&B2D.WebGuiPort, "kevguiport", 8080, "host KevoreeGui port (forward to port 8080 in VM).")
flags.Uint16Var(&B2D.GroupPort, "kevgroup", 9000, "host KevoreeGroup port (forward to port 9000 in VM).")
flags.Uint16Var(&B2D.EditorPort, "keveditorport", 3042, "host Kevoree Editor port (forward to port 3042 in VM).")
flags.IPVar(&B2D.HostIP, "hostip", net.ParseIP("192.168.59.3"), "VirtualBox host-only network IP address.")
flags.IPMaskVar(&B2D.NetMask, "netmask", flag.ParseIPv4Mask("255.255.255.0"), "VirtualBox host-only network mask.")
flags.BoolVar(&B2D.DHCPEnabled, "dhcp", true, "enable VirtualBox host-only network DHCP.")
flags.IPVar(&B2D.DHCPIP, "dhcpip", net.ParseIP("192.168.59.99"), "VirtualBox host-only network DHCP server address.")
flags.IPVar(&B2D.LowerIP, "lowerip", net.ParseIP("192.168.59.103"), "VirtualBox host-only network DHCP lower bound.")
flags.IPVar(&B2D.UpperIP, "upperip", net.ParseIP("192.168.59.254"), "VirtualBox host-only network DHCP upper bound.")
// Set the defaults
if err := flags.Parse([]string{}); err != nil {
return nil, err
}
// Over-ride from the profile file
filename := getCfgFilename(B2D.Dir)
if _, err := os.Lstat(filename); err == nil {
if _, err := toml.DecodeFile(filename, &B2D); err != nil {
return nil, err
}
}
// for cmd==ssh only:
// only pass the params up to and including the `ssh` command - after that,
// there might be other -flags that are destined for the ssh cmd
i := 1
for i < len(os.Args) && os.Args[i-1] != "ssh" {
i++
}
// Command-line overrides profile config.
if err := flags.Parse(os.Args[1:i]); err != nil {
return nil, err
}
vbx.Verbose = B2D.Verbose
vbx.VBM = B2D.VBM
return flags, nil
}