func init() { fileloads = make(map[int64]string) flag.Var(&load_opts, "ld", ld_help_str) flag.Var(&load_zero, "ldz", ld_help_str) flag.Var(&load_file, "ldf", ld_help_str) }
func init() { flag.Var(&nsqdTCPAddrs, "nsqd-tcp-address", "nsqd TCP address (may be given multiple times)") flag.Var(&destNsqdTCPAddrs, "destination-nsqd-tcp-address", "destination nsqd TCP address (may be given multiple times)") flag.Var(&lookupdHTTPAddrs, "lookupd-http-address", "lookupd HTTP address (may be given multiple times)") flag.Var(&whitelistJSONFields, "whitelist-json-field", "for JSON messages: pass this field (may be given multiple times)") }
func init() { flag.BoolVar(&debug, "debug", false, "Run in debug mode") // The following flags need to be supported by stage1 according to // https://github.com/coreos/rkt/blob/master/Documentation/devel/stage1-implementors-guide.md // Most of them are ignored // These are ignored, but stage0 always passes them flag.Var(&discardNetlist, "net", "Setup networking") flag.StringVar(&discardString, "local-config", common.DefaultLocalConfigDir, "Local config path") // These are discarded with a warning // TODO either implement these, or stop passing them flag.Bool("interactive", true, "The pod is interactive (ignored, always true)") flag.Var(pkgflag.NewDiscardFlag("mds-token"), "mds-token", "MDS auth token (not implemented)") flag.Var(pkgflag.NewDiscardFlag("hostname"), "hostname", "Set hostname (not implemented)") flag.Bool("disable-capabilities-restriction", true, "ignored") flag.Bool("disable-paths", true, "ignored") flag.Bool("disable-seccomp", true, "ignored") dnsConfMode = pkgflag.MustNewPairList(map[string][]string{ "resolv": {"host", "stage0", "none", "default"}, "hosts": {"host", "stage0", "default"}, }, map[string]string{ "resolv": "default", "hosts": "default", }) flag.Var(dnsConfMode, "dns-conf-mode", "DNS config file modes") }
func main() { // do the actual parsing flag.Var(&listenersFlag, "l", "Which ports to listen on") flag.Var(&connectorsFlag, "c", "Which addresses to try to connect to") flag.BoolVar(&infoptr, "v", false, "Turn on verbose mode") flag.BoolVar(&debugptr, "vv", false, "Turn on extra verbose mode") retryPeriod = time.Duration(1000 * (*flag.Float64("rp", 5.0, "Retry rate for double connections"))) connPeriod = time.Duration(1000 * (*flag.Float64("cp", 0.5, "Retry rate for double connections, on success"))) flag.Parse() debug("Number of listeners: " + fmt.Sprint(len(listenersFlag))) debug("Number of connectors: " + fmt.Sprint(len(connectorsFlag))) // check a possibly temporary condition if len(listenersFlag)+len(connectorsFlag) != 2 { errmsg(1, "Strictly 2 connections allowed") } if len(listenersFlag) == 1 && len(connectorsFlag) == 1 { listenOne(normalizeAddr(listenersFlag[0]), normalizeAddr(connectorsFlag[0])) } if len(listenersFlag) == 2 && len(connectorsFlag) == 0 { listenTwo(normalizeAddr(listenersFlag[0]), normalizeAddr(listenersFlag[1])) } if len(listenersFlag) == 0 && len(connectorsFlag) == 2 { connectTwo(normalizeAddr(connectorsFlag[0]), normalizeAddr(connectorsFlag[1])) } }
func init() { flag.BoolVar(&debug, "debug", false, "Run in debug mode") flag.Var(&netList, "net", "Setup networking") flag.BoolVar(&interactive, "interactive", false, "The pod is interactive") flag.StringVar(&privateUsers, "private-users", "", "Run within user namespace. Can be set to [=UIDBASE[:NUIDS]]") flag.StringVar(&mdsToken, "mds-token", "", "MDS auth token") flag.StringVar(&localConfig, "local-config", common.DefaultLocalConfigDir, "Local config path") flag.StringVar(&hostname, "hostname", "", "Hostname of the pod") flag.BoolVar(&disableCapabilities, "disable-capabilities-restriction", false, "Disable capability restrictions") flag.BoolVar(&disablePaths, "disable-paths", false, "Disable paths restrictions") flag.BoolVar(&disableSeccomp, "disable-seccomp", false, "Disable seccomp restrictions") dnsConfMode = pkgflag.MustNewPairList(map[string][]string{ "resolv": {"host", "stage0", "none", "default"}, "hosts": {"host", "stage0", "default"}, }, map[string]string{ "resolv": "default", "hosts": "default", }) flag.Var(dnsConfMode, "dns-conf-mode", "DNS config file modes") flag.BoolVar(&mutable, "mutable", false, "Enable mutable operations on this pod, including starting an empty one") // this ensures that main runs only on main thread (thread group leader). // since namespace ops (unshare, setns) are done for a single thread, we // must ensure that the goroutine does not jump from OS thread to thread runtime.LockOSThread() localhostIP = net.ParseIP("127.0.0.1") if localhostIP == nil { panic("localhost IP failed to parse") } }
func init() { flag.StringVar(&FlagAddr, "mpi-addr", "", "address of the local running process") flag.Var(&FlagAllAddrs, "mpi-alladdr", "addresses of all of the processes as comma separated values") flag.Var(&FlagInitTimeout, "mpi-inittimeout", "duration to wait before timeout in init") flag.StringVar(&FlagProtocol, "mpi-protocol", "tcp", "communication protocol to use") flag.StringVar(&FlagPassword, "mpi-password", "", "value to use for salting the mpi connection") }
func parseFlags() *stage1commontypes.RuntimePod { rp := stage1commontypes.RuntimePod{} flag.BoolVar(&debug, "debug", false, "Run in debug mode") flag.BoolVar(&interactive, "interactive", false, "The pod is interactive") flag.StringVar(&localConfig, "local-config", common.DefaultLocalConfigDir, "Local config path") // These flags are persisted in the PodRuntime flag.BoolVar(&rp.Mutable, "mutable", false, "Enable mutable operations on this pod, including starting an empty one") flag.Var(&rp.NetList, "net", "Setup networking") flag.StringVar(&rp.PrivateUsers, "private-users", "", "Run within user namespace. Can be set to [=UIDBASE[:NUIDS]]") flag.StringVar(&rp.MDSToken, "mds-token", "", "MDS auth token") flag.StringVar(&rp.Hostname, "hostname", "", "Hostname of the pod") flag.BoolVar(&rp.InsecureOptions.DisableCapabilities, "disable-capabilities-restriction", false, "Disable capability restrictions") flag.BoolVar(&rp.InsecureOptions.DisablePaths, "disable-paths", false, "Disable paths restrictions") flag.BoolVar(&rp.InsecureOptions.DisableSeccomp, "disable-seccomp", false, "Disable seccomp restrictions") dnsConfMode := pkgflag.MustNewPairList(map[string][]string{ "resolv": {"host", "stage0", "none", "default"}, "hosts": {"host", "stage0", "default"}, }, map[string]string{ "resolv": "default", "hosts": "default", }) flag.Var(dnsConfMode, "dns-conf-mode", "DNS config file modes") flag.Parse() rp.Debug = debug rp.ResolvConfMode = dnsConfMode.Pairs["resolv"] rp.EtcHostsMode = dnsConfMode.Pairs["hosts"] return &rp }
func init() { flag.Var(&address, "address", "The IP address on to serve on (set to 0.0.0.0 for all interfaces)") flag.Var(&etcdServerList, "etcd_servers", "List of etcd servers to watch (http://ip:port), comma separated. Mutually exclusive with -etcd_config") flag.Var(&corsAllowedOriginList, "cors_allowed_origins", "List of allowed origins for CORS, comma separated. An allowed origin can be a regular expression to support subdomain matching. If this list is empty CORS will not be enabled.") flag.Var(&portalNet, "portal_net", "A CIDR notation IP range from which to assign portal IPs. This must not overlap with any IP ranges assigned to nodes for pods.") client.BindKubeletClientConfigFlags(flag.CommandLine, &kubeletConfig) }
func init() { flag.Var(&skips, "skip", "skip test case") flag.Var(&cases, "case", "run test case") flag.BoolVar(&Debug, "debug", false, "enter debug mode") log.SetFlags(log.Lshortfile | log.LstdFlags) }
func init() { var ( configureFile string printVersion bool ) flag.StringVar(&configureFile, "C", "", "configure file") flag.Var(&options.ChainNodes, "F", "forward address, can make a forward chain") flag.Var(&options.ServeNodes, "L", "listen address, can listen on multiple ports") flag.BoolVar(&printVersion, "V", false, "print version") flag.Parse() if err := loadConfigureFile(configureFile); err != nil { glog.Fatal(err) } if glog.V(5) { http2.VerboseLogs = true } if flag.NFlag() == 0 { flag.PrintDefaults() return } if printVersion { fmt.Fprintf(os.Stderr, "GOST %s (%s)\n", gost.Version, runtime.Version()) return } }
func init() { flag.Var(&in, "in", "comma separated pair of BAM files to be processed.") flag.StringVar(&ref, "ref", "", "fasta file of the genome to be processed.") flag.StringVar(&annot, "annot", "", "file name of a GFF file containing annotations.") flag.Var(&classes, "class", "comma separated set of annotation classes to analyse.") flag.StringVar(&out, "out", "", "outfile name.") flag.BoolVar(&pretty, "pretty", true, "outfile JSON data indented.") flag.BoolVar(&denest, "denest", false, "only consider denested reads for support count.") flag.IntVar(&minLength, "min", 20, "minimum length read considered.") flag.IntVar(&maxLength, "max", 35, "maximum length read considered.") flag.IntVar(&minId, "minid", 90, "minimum percentage identity for mapped bases.") flag.IntVar(&minQ, "minQ", 20, "minimum per-base sequence quality.") flag.IntVar(&filter, "f", 0, "filter on piwi type 0: no filter, 1: primary, 2: secondary.") flag.Float64Var(&minAvQ, "minAvQ", 30, "minimum average per-base sequence quality.") flag.IntVar(&mapQ, "mapQ", 0, "minimum mapping quality [0, 255).") flag.IntVar(&binLength, "bin", 1e7, "bin length.") help := flag.Bool("help", false, "output this usage message.") flag.Parse() mapQb = byte(mapQ) if *help { flag.Usage() os.Exit(0) } if in[0] == "" || in[1] == "" || out == "" || !annotOK(annot, classes) || mapQ < 0 || mapQ > 254 { flag.Usage() os.Exit(1) } }
func main() { flag.BoolVar(&fflag, "f", false, "unlink any already existing file, permitting the link to occur") flag.BoolVar(&hflag, "h", false, "if the target is a symlink to a directory, do not descend to it") flag.BoolVar(&hflag, "n", false, "alias for -h for compatibility") flag.BoolVar(&sflag, "s", false, "create a symbolic link") flag.Var(symFlag('L'), "L", "when creating a hard link and the source is a symbolic link, link to the fully resolved target of symbolic link") flag.Var(symFlag('P'), "P", "when creating a hardlink and the source is a symbolic link, link to the symbolic link itself") flag.Usage = usage flag.Parse() switch flag.NArg() { case 0: usage() case 1: ek(ln(flag.Arg(0), ".", true)) case 2: ek(ln(flag.Arg(0), flag.Arg(1), false)) default: sourceDir := flag.Arg(flag.NArg() - 1) fi, err := os.Stat(sourceDir) ck(err) if !fi.IsDir() { usage() } args := flag.Args() for _, name := range args[:len(args)-1] { ek(ln(name, sourceDir, true)) } } os.Exit(status) }
// Parses service options from the command line func parseOptions() (*serviceOptions, error) { options := &serviceOptions{} flag.StringVar(&options.codePath, "js", "", "Js code path") flag.StringVar(&options.backend, "b", "memory", "Backend type e.g. 'cassandra' or 'memory'") flag.StringVar(&options.loadBalancer, "lb", "random", "Loadbalancer algo, e.g. 'random'") flag.StringVar(&options.host, "h", "localhost", "Host to bind to") flag.IntVar(&options.httpPort, "p", 8080, "HTTP port to bind to") flag.StringVar(&options.pidPath, "pid", "", "pid file path") flag.Var(&options.cassandraServers, "csnode", "Cassandra nodes to connect to") flag.StringVar(&options.cassandraKeyspace, "cskeyspace", "", "Cassandra keyspace") flag.BoolVar(&options.cassandraCleanup, "cscleanup", false, "Whethere to perform periodic cassandra cleanups") flag.Var(&options.cassandraCleanupOptions, "cscleanuptime", "Cassandra cleanup utc time of day in form: HH:MM") flag.DurationVar(&options.cleanupPeriod, "logcleanup", time.Duration(24)*time.Hour, "How often should we remove unused golang logs (e.g. 24h, 1h, 7h)") flag.StringVar(&options.discovery, "discovery", "disabled", "Discovery Backend e.g. 'disabled', 'rackspace://${USERNAME}:${API_KEY}', or 'etcd") flag.Var(&options.etcdEndpoints, "etcd", "Etcd discovery service API endpoints") flag.StringVar(&options.sslCertFile, "sslcert", "", "File containing SSL Certificates") flag.StringVar(&options.sslKeyFile, "sslkey", "", "File containing SSL Private Key") flag.StringVar(&options.metricsOutput, "metrics", "console", "Comma seperated list of where to send metrics.") flag.StringVar(&options.cpuProfile, "cpuprofile", "", "Run with CPU Profiling enabled.") flag.Parse() return options, nil }
func init() { flag.Var(&Aliases, "D", "Replace text with some other text") flag.Var(&Headers, "H", "Request headers") flag.StringVar(&fileName, "filename", "", "File containing list of test rules") flag.Parse() }
func main() { templates := templateList{} flag.Var(&templates, "t", "Specify template and append optional destination after collons. Format: foo.tmpl:/etc/foo.conf") flag.Var(&keepEnvs, "e", fmt.Sprintf("Keep specified environment variables beside %s", strings.Join(keepEnvs, ","))) flag.Parse() if *root == "" { r, err := os.Getwd() if err != nil { log.Fatal("Not root (-r) specified and couldn't get working directory") } *root = r } args := flag.Args() if len(args) == 0 { log.Fatal("No command provided, exiting") } if err := templates.Render(*root); err != nil { log.Fatal(err) } path, err := exec.LookPath(args[0]) if err != nil { log.Fatal(err) } if *keepAllEnvs { execEnv = os.Environ() } else { execEnv = getFilteredEnv(keepEnvs) } if err := syscall.Exec(path, args, execEnv); err != nil { log.Fatal(err) } }
func init() { flag.Var(&postAddrs, "post", "HTTP address to make a POST request to. data will be in the body (may be given multiple times)") flag.Var(&getAddrs, "get", "HTTP address to make a GET request to. '%s' will be printf replaced with data (may be given multiple times)") flag.Var(&nsqdTCPAddrs, "nsqd-tcp-address", "nsqd TCP address (may be given multiple times)") flag.Var(&lookupdHTTPAddrs, "lookupd-http-address", "lookupd HTTP address (may be given multiple times)") }
func main() { now := time.Now() times[0] = syscall.Timespec{now.Unix(), int64(now.Nanosecond())} flag.Var(timeFlag('d'), "d", "parse date and use it instead of current time") flag.Var(timeFlag('t'), "t", "parse time and use it instead of current time") flag.Var(timeFlag('T'), "T", "parse as number of seconds since epoch") flag.Usage = usage flag.Parse() if flag.NArg() < 1 { usage() } if !*aflag && !*mflag { *aflag, *mflag = true, true } if *ref != "" { st, err := stat(*ref) ck(err) times[0] = st.Atim times[1] = st.Mtim } else { times[1] = times[0] } for _, name := range flag.Args() { touch(name) } os.Exit(status) }
func init() { flag.Var(&readerOpts, "reader-opt", "option to passthrough to nsq.Consumer (may be given multiple times)") flag.Var(&postAddrs, "post", "HTTP address to make a POST request to. data will be in the body (may be given multiple times)") flag.Var(&getAddrs, "get", "HTTP address to make a GET request to. '%s' will be printf replaced with data (may be given multiple times)") flag.Var(&nsqdTCPAddrs, "nsqd-tcp-address", "nsqd TCP address (may be given multiple times)") flag.Var(&lookupdHTTPAddrs, "lookupd-http-address", "lookupd HTTP address (may be given multiple times)") }
func main() { flag.BoolVar(&version, "version", false, "show version") flag.Var(&templatesFlag, "template", "Template (/template:/dest). Can be passed multiple times") flag.Var(&stdoutTailFlag, "stdout", "Tails a file to stdout. Can be passed multiple times") flag.Var(&stderrTailFlag, "stderr", "Tails a file to stderr. Can be passed multiple times") flag.StringVar(&delimsFlag, "delims", "", `template tag delimiters. default "{{":"}}" `) flag.Parse() if version { fmt.Println(buildVersion) return } //TODO: Not needed anymore for standalone mode //if flag.NArg() == 0 { // log.Fatalln("no command specified") //} if delimsFlag != "" { delims = strings.Split(delimsFlag, ":") if len(delims) != 2 { log.Fatalf("bad delimiters argument: %s. expected \"left:right\"", delimsFlag) } } for _, t := range templatesFlag { parts := strings.Split(t, ":") if len(parts) != 2 { log.Fatalf("bad template argument: %s. expected \"/template:/dest\"", t) } if flag.Arg(0) == "" { log.Println("Standalone mode, no app to start. Only template resolved") generateFile(parts[0], parts[1]) } else { log.Println("Resolve and Execute") generateFile(parts[0], parts[1]) // Setup context ctx, cancel = context.WithCancel(context.Background()) wg.Add(1) go runCmd(ctx, cancel, flag.Arg(0), flag.Args()[1:]...) for _, out := range stdoutTailFlag { wg.Add(1) go tailFile(ctx, out, os.Stdout) } for _, err := range stderrTailFlag { wg.Add(1) go tailFile(ctx, err, os.Stderr) } wg.Wait() } } }
func main() { flag.BoolVar(&version, "version", false, "show version") flag.Var(&templatesFlag, "template", "Template (/template:/dest). Can be passed multiple times") flag.Var(&stdoutTailFlag, "stdout", "Tails a file to stdout. Can be passed multiple times") flag.Var(&stderrTailFlag, "stderr", "Tails a file to stderr. Can be passed multiple times") flag.StringVar(&delimsFlag, "delims", "", `template tag delimiters. default "{{":"}}" `) flag.Usage = usage flag.Parse() if version { fmt.Println(buildVersion) return } if flag.NArg() == 0 && flag.NFlag() == 0 { usage() os.Exit(1) } if delimsFlag != "" { delims = strings.Split(delimsFlag, ":") if len(delims) != 2 { log.Fatalf("bad delimiters argument: %s. expected \"left:right\"", delimsFlag) } } for _, t := range templatesFlag { template, dest := t, "" if strings.Contains(t, ":") { parts := strings.Split(t, ":") if len(parts) != 2 { log.Fatalf("bad template argument: %s. expected \"/template:/dest\"", t) } template, dest = parts[0], parts[1] } generateFile(template, dest) } // Setup context ctx, cancel = context.WithCancel(context.Background()) if flag.NArg() > 0 { wg.Add(1) go runCmd(ctx, cancel, flag.Arg(0), flag.Args()[1:]...) } for _, out := range stdoutTailFlag { wg.Add(1) go tailFile(ctx, out, os.Stdout) } for _, err := range stderrTailFlag { wg.Add(1) go tailFile(ctx, err, os.Stderr) } wg.Wait() }
// initialize command-line options func init() { flag.Var(&optIncs, "inc", "word(s) to include in passphrase") flag.Var(&optLists, "list", "wordlist(s) to use (lower case L)") flag.IntVar(&optChars, "chars", optChars, "minimum number of characters") flag.IntVar(&optWords, "words", optWords, "minimum number of words") flag.BoolVar(&optCamel, "camel", optCamel, "use CamelCase") flag.StringVar(&optSep, "sep", optSep, "word separator") }
func init() { // TODO: remove, deprecated flag.Var(&consumerOpts, "reader-opt", "(deprecated) use --consumer-opt") flag.Var(&consumerOpts, "consumer-opt", "option to passthrough to nsq.Consumer (may be given multiple times, http://godoc.org/github.com/bitly/go-nsq#Config)") flag.Var(&nsqdTCPAddrs, "nsqd-tcp-address", "nsqd TCP address (may be given multiple times)") flag.Var(&lookupdHTTPAddrs, "lookupd-http-address", "lookupd HTTP address (may be given multiple times)") }
func init() { flag.BoolVar(&defaultConfig.Recursive, "r", false, "Watch directories recursively") flag.Var(&defaultConfig.IncludePattern, "include", "Process any events whose file name matches file name matches specified regular expression pattern (perl-style)") flag.Var(&defaultConfig.ExcludePattern, "exclude", "Do not process any events whose file name matches specified regular expression pattern (perl-style)") flag.DurationVar(&defaultConfig.Interval, "i", 100*time.Millisecond, "The interval limit the frequency of the command executions, if equal to 0, there is no limit (time unit: ns/us/ms/s/m/h)") flag.Var(&defaultConfig.Events, "e", "Listen for specific event(s) (comma separated list)") flag.Var((*stringSet)(&defaultConfig.Commands), "c", "Add arbitrary command (repeatable)") }
func init() { flag.Var(excludes, "e", "Packages will be excluded.") flag.Var(includes, "i", "Packages will be included.") pp.ColoringEnabled = false logger = log.New(os.Stderr, "", log.Lshortfile|log.LstdFlags) }
func init() { flag.Var(&packages, "pkgs", "Comma-separated list of packages to search for functions.") flag.Var(&arguments, "args", "Comma-separated list of argument types to match.") flag.Var(&returns, "rets", "Comma-separated list of return types to match.") flag.BoolVar(&and, "and", false, "Use AND instead of OR for matching functions.") flag.Parse() }
func init() { flag.Var(&readerOpts, "reader-opt", "option to passthrough to nsq.Consumer (may be given multiple times)") flag.Var(&nsqdTCPAddrs, "nsqd-tcp-address", "nsqd TCP address (may be given multiple times)") flag.Var(&destNsqdTCPAddrs, "destination-nsqd-tcp-address", "destination nsqd TCP address (may be given multiple times)") flag.Var(&lookupdHTTPAddrs, "lookupd-http-address", "lookupd HTTP address (may be given multiple times)") flag.Var(&whitelistJsonFields, "whitelist-json-field", "for JSON messages: pass this field (may be given multiple times)") }
func init() { flag.Var(&algorithm, "a", "select the digest algorithm (shorthand)") flag.Var(&algorithm, "algorithm", "select the digest algorithm") flag.BoolVar(&showVersion, "version", false, "show the version and exit") log.SetFlags(0) log.SetPrefix(os.Args[0] + ": ") }
func processCommandLine() (*UndertakerData, error) { var container_excludes_file string var image_excludes_file string var conserving_deadline_secs int64 var c_excludes MultiStringOption var i_excludes MultiStringOption var c_includes MultiStringOption var i_includes MultiStringOption flag.StringVar(&container_excludes_file, "filecexc", "", "read container excludes from file") flag.StringVar(&image_excludes_file, "fileiexc", "", "read image excludes from file") flag.Int64Var(&conserving_deadline_secs, "wait", int64(3600), "conserving deadline in seconds") flag.Var(&c_excludes, "cexc", "a single container exclude") flag.Var(&i_excludes, "iexc", "a single image exclude") flag.Var(&c_includes, "cinc", "a single container include") flag.Var(&i_includes, "iinc", "a single image incclude") flag.Parse() var resptr = NewUndertakerData() if len(container_excludes_file) > 0 { ptr, err := loadFile(container_excludes_file) if err != nil { return nil, err } resptr.ContainerExc = generateRegexp(ptr) } if len(image_excludes_file) > 0 { ptr, err := loadFile(image_excludes_file) if err != nil { return nil, err } resptr.ImageExc = generateRegexp(ptr) } if len(c_excludes) > 0 { *resptr.ContainerExc = append(*resptr.ContainerExc, *generateRegexp(&c_excludes)...) } if len(i_excludes) > 0 { *resptr.ImageExc = append(*resptr.ImageExc, *generateRegexp(&i_excludes)...) } if len(c_includes) > 0 { *resptr.ContainerInc = append(*resptr.ContainerInc, *generateRegexp(&c_includes)...) } if len(i_includes) > 0 { *resptr.ImageInc = append(*resptr.ImageInc, *generateRegexp(&i_includes)...) } return resptr, nil }
func main() { cfg := nsq.NewConfig() // TODO: remove, deprecated flag.Var(&nsq.ConfigFlag{cfg}, "reader-opt", "(deprecated) use --consumer-opt") flag.Var(&nsq.ConfigFlag{cfg}, "consumer-opt", "option to passthrough to nsq.Consumer (may be given multiple times, http://godoc.org/github.com/absolute8511/go-nsq#Config)") flag.Parse() if *showVersion { fmt.Printf("nsq_tail v%s\n", version.Binary) return } if *channel == "" { rand.Seed(time.Now().UnixNano()) *channel = fmt.Sprintf("tail%06d#ephemeral", rand.Int()%999999) } if *topic == "" { log.Fatal("--topic is required") } if len(lookupdHTTPAddrs) == 0 { log.Fatal("--nsqd-tcp-address or --lookupd-http-address required") } sigChan := make(chan os.Signal, 1) signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM) // Don't ask for more messages than we want if *totalMessages > 0 && *totalMessages < *maxInFlight { *maxInFlight = *totalMessages } cfg.UserAgent = fmt.Sprintf("nsq_tail/%s go-nsq/%s", version.Binary, nsq.VERSION) cfg.MaxInFlight = *maxInFlight consumer, err := nsq.NewPartitionConsumer(*topic, *partition, *channel, cfg) if err != nil { log.Fatal(err) } consumer.AddHandler(&TailHandler{totalMessages: *totalMessages}) err = consumer.ConnectToNSQLookupds(lookupdHTTPAddrs) if err != nil { log.Fatal(err) } for { select { case <-consumer.StopChan: return case <-sigChan: consumer.Stop() } } }
func main() { var kind string = "files" var ndirs, nfiles int var paths []string flag.Var(&_fthreshold, "ft", "file sizes <= threshhold will not be considered") flag.Var(&_dthreshold, "dt", "directory sizes <= threshhold will not be considered") //fmt.Printf("dedup\n") hf = aeshash.NewAES(0) flag.Parse() if *pat != "" { re, err := regexp.Compile(*pat) if err != nil { return } patre = re } if *dd != "" { re, err := regexp.Compile(*dd) if err != nil { return } ddre = re } fthreshold = int64(_fthreshold.V) dthreshold = int64(_dthreshold.V) //fmt.Printf("fthreshold=%d\n", fthreshold) //fmt.Printf("dthreshold=%d\n", dthreshold) if *dirf { kind = "dirs" } if len(flag.Args()) != 0 { for _, path := range flag.Args() { fi, err := os.Stat(path) if err != nil || fi == nil { fmt.Printf("fi=%#v, err=%v\n", fi, err) panic("bad") } if fi.Mode()&os.ModeDir == os.ModeDir { ndirs++ } else { nfiles++ } paths = append(paths, path) } } scan(paths, ndirs) if *s { asort() check2(kind, ndirs) } else { check(kind, ndirs) } }