func main() { laddr := flag.String("listen", ":8001", "listen address") baddr := flag.String("backend", "127.0.0.1:1234", "backend address") secret := flag.String("secret", "the answer to life, the universe and everything", "tunnel secret") tunnels := flag.Uint("tunnels", 1, "low level tunnel count, 0 if work as server") flag.Int64Var(&tunnel.Timeout, "timeout", 10, "tunnel read/write timeout") flag.UintVar(&tunnel.LogLevel, "log", 1, "log level") flag.Usage = usage flag.Parse() app := &tunnel.App{ Listen: *laddr, Backend: *baddr, Secret: *secret, Tunnels: *tunnels, } err := app.Start() if err != nil { fmt.Fprintf(os.Stderr, "start failed:%s\n", err.Error()) return } go handleSignal(app) app.Wait() }
func main() { var options Options flag.Var(&options.SourceDirs, "folder", "The folder to inspect for documents, can be provided multiple times") flag.StringVar(&options.Agency, "agency", "", "The agency to use if it's not available in the folder structure") flag.StringVar(&options.Component, "component", "", "The component to use if it's not available in the folder structure") flag.StringVar(&options.HtmlReport, "report", "report.html", "The file in which to store the HTML report") flag.StringVar(&options.PhpDataFile, "phpDataFile", "", "The file in which to store the file information as PHP data") flag.StringVar(&options.PhpVarName, "phpVarName", "$FILES", "The PHP variable to assign the file data to") flag.BoolVar(&options.WarnOnMissingAgency, "warnOnMissingAgency", false, "Should we warn if a agency is missing from folder structure?") flag.BoolVar(&options.WarnOnMissingComponent, "warnOnMissingComponent", false, "Should we warn if a component is missing from folder structure?") flag.Int64Var(&options.ErrorSingleFileSizeBytes, "errorSingleFileSizeBytes", 1024*500, "Display an error for any files larger than this size") flag.Int64Var(&options.WarnAverageFileSizeBytes, "warnAverageFileSizeBytes", 1024*384, "Display a warning if average size of files in the download exceeds this threshold") //options.SourceDirs.Set("C:\\Projects\\MAX-OGE\\docs-generator\\generated-files") options.Extensions = map[string]bool{".pdf": true} options.FieldsSeparator = ';' if options.validate() { var results Results results.Options = options results.walkSourceDirs() fmt.Println(results.LastFileIndex, "documents found in", len(results.DirsWalked), "folders.") results.createReport("HTML Report", htmlReportTemplate, options.HtmlReport) if len(options.PhpDataFile) > 0 { results.createReport("PHP Data", phpDataTemplate, options.PhpDataFile) } } }
func main() { flag.StringVar(&target.Address, "a", "", "address of sink") flag.Int64Var(&target.Counter, "c", 0, "initial packet counter") flag.Int64Var(&target.Next, "t", 0, "initial update timestamp") keyFile := flag.String("k", "decrypt.pub", "sink's decryption public key") flag.Parse() if target.Address == "" { fmt.Fprintf(os.Stderr, "[!] no address provided.\n") os.Exit(1) } in, err := ioutil.ReadFile(*keyFile) checkError(err) if len(in) != 32 { fmt.Fprintf(os.Stderr, "[!] invalid Curve25519 public key.\n") } target.Public = in buf := &bytes.Buffer{} out, err := json.Marshal(target) checkError(err) err = json.Indent(buf, out, "", "\t") checkError(err) fmt.Printf("%s\n", buf.Bytes()) }
func init() { flag.Int64Var(&first, "first", 0, "first uid") flag.Int64Var(&last, "last", 0, "last uid") flag.StringVar(&local_ip, "local_ip", "0.0.0.0", "local ip") flag.StringVar(&host, "host", "127.0.0.1", "host") flag.IntVar(&port, "port", 23000, "port") }
func main() { var ( S_SERVERS string S_LISTEN string S_ACCESS string timeout int max_entries int64 expire_interval int64 ) flag.StringVar(&S_SERVERS, "proxy", "127.0.0.1:53", "we proxy requests to those servers") flag.StringVar(&S_LISTEN, "listen", "[::1]:5353,127.0.0.1:5353", "listen on (both tcp and udp), [ipv6address]:port, ipv4address:port") flag.StringVar(&S_ACCESS, "access", "0.0.0.0/0", "allow those networks, use 0.0.0.0/0 to allow everything") flag.IntVar(&timeout, "timeout", 5, "timeout") flag.Int64Var(&expire_interval, "expire_interval", 300, "delete expired entries every N seconds") flag.BoolVar(&DEBUG, "debug", false, "enable/disable debug") flag.Int64Var(&max_entries, "max_cache_entries", 2000000, "max cache entries") flag.Parse() servers := strings.Split(S_SERVERS, ",") proxyer := ServerProxy{ giant: new(sync.RWMutex), ACCESS: make([]*net.IPNet, 0), SERVERS: servers, s_len: len(servers), NOW: time.Now().UTC().Unix(), entries: 0, timeout: time.Duration(timeout) * time.Second, max_entries: max_entries} for _, mask := range strings.Split(S_ACCESS, ",") { _, cidr, err := net.ParseCIDR(mask) if err != nil { panic(err) } _D("added access for %s\n", mask) proxyer.ACCESS = append(proxyer.ACCESS, cidr) } for _, addr := range strings.Split(S_LISTEN, ",") { _D("listening @ :%s\n", addr) go func() { if err := dns.ListenAndServe(addr, "udp", proxyer); err != nil { log.Fatal(err) } }() go func() { if err := dns.ListenAndServe(addr, "tcp", proxyer); err != nil { log.Fatal(err) } }() } for { proxyer.NOW = time.Now().UTC().Unix() time.Sleep(time.Duration(1) * time.Second) } }
func main() { dev := flag.String("d", "/dev/input/by-id/usb-0810_Twin_USB_Joystick-event-joystick", "The GH controller event device") flag.Int64Var(&baseNote, "b", 48, "The base midi note with no button pressed") flag.Int64Var(&vel, "v", 100, "Midi note velocity") flag.Int64Var(&midiChan, "c", 1, "Midi channel") flag.Parse() portmidi.Initialize() out, err := portmidi.NewOutputStream(portmidi.GetDefaultOutputDeviceId(), 32, 0) if err != nil { fmt.Println(err) return } c := make(chan *evdev.InputEvent) e := make(chan error) go ReadGuitar(c, e, *dev) for { select { case but := <-c: switch but.Code { case butGreen, butRed, butYellow, butBlue, butOrange: SetNote(butMap[but.Code], but.Value) if playing != -1 { SwapNote(out, baseNote+butState+octave, vel) } case butStrumbar: if but.Value == 255 || but.Value == 0 { NoteOn(out, baseNote+butState+octave, vel) } else if !hold { NoteOff(out, playing, vel) } case butSelect: if but.Value != 0 { hold = !hold if !hold { NoteOff(out, playing, vel) } } case butTilt: if but.Value == 1 { octave += 12 } else { octave -= 12 } if playing != -1 { SwapNote(out, baseNote+butState+octave, vel) } case butStart: AllNotesOff(out) } case err := <-e: fmt.Println(err) close(c) close(e) return default: } } }
func init() { flag.StringVar(&topic, "topic", "sangrenel", "Topic to publish to") flag.Int64Var(&msgSize, "size", 300, "Message size in bytes") flag.Int64Var(&msgRate, "rate", 100000000, "Apply a global message rate limit") flag.IntVar(&batchSize, "batch", 0, "Max messages per batch. Defaults to unlimited (0).") flag.StringVar(&compressionOpt, "compression", "none", "Message compression: none, gzip, snappy") flag.BoolVar(&noop, "noop", false, "Test message generation performance, do not transmit messages") flag.IntVar(&clients, "clients", 1, "Number of Kafka client workers") flag.IntVar(&producers, "producers", 5, "Number of producer instances per client") brokerString := flag.String("brokers", "localhost:9092", "Comma delimited list of Kafka brokers") flag.Parse() brokers = strings.Split(*brokerString, ",") switch compressionOpt { case "gzip": compression = kafka.CompressionGZIP case "snappy": compression = kafka.CompressionSnappy case "none": compression = kafka.CompressionNone default: fmt.Printf("Invalid compression option: %s\n", compressionOpt) os.Exit(1) } sentCntr <- 0 runtime.GOMAXPROCS(runtime.NumCPU()) }
func MakeConfigFromCmdline() *Config { tc := &Config{} flag.StringVar(&tc.ClientType, "client_type", "consul", "Type of client to connect with") flag.StringVar(&tc.BenchType, "bench_type", "read", "Type of test to run") flag.BoolVar(&tc.Setup, "setup", false, "Initialize the servers for test type") flag.Int64Var(&tc.Iterations, "iterations", 10, "Number of times to read") flag.Float64Var(&tc.ArrivalRate, "arrival_rate", 2, "Number of operations per second") flag.Int64Var(&tc.Seed, "seed", time.Now().UnixNano(), "Random number seed (defaults to current nanoseconds)") flag.BoolVar(&tc.Debug, "debug", false, "Enable verbose output") flag.StringVar(&tc.ServerHost, "server_host", "", "Override of server host:port") flag.Parse() if tc.ClientType != "consul" && tc.ClientType != "etcd" && tc.ClientType != "zookeeper" { fmt.Printf("Error: invalid client_type '%s'\n", tc.ClientType) } if tc.Debug { fmt.Printf("server_type = %s\n", tc.ClientType) fmt.Printf("server_host = %s\n", tc.ServerHost) fmt.Printf("setup = %t\n", tc.Setup) fmt.Printf("bench_type = %s\n", tc.BenchType) fmt.Printf("iterations = %d\n", tc.Iterations) fmt.Printf("arrival_rate = %f\n", tc.ArrivalRate) fmt.Printf("seed = %d\n", tc.Seed) fmt.Printf("debug = %t\n", tc.Debug) } return tc }
func init() { flag.StringVar(&username, "username", os.Getenv("HIVEKIT_USER"), "Hive Home web service username (usually an email address)") flag.StringVar(&password, "password", os.Getenv("HIVEKIT_PASS"), "Hive Home web service password") flag.StringVar(&pin, "pin", os.Getenv("HIVEKIT_PIN"), "The HomeKit accessory pin (8 numeric chars)") flag.BoolVar(&verbose, "verbose", false, "Enable verbose logging") flag.Int64Var(&boostDuration, "boost-duration", 60, "Duration (minutes) to boost heating") flag.Int64Var(&hotWaterDuration, "boost-water", 60, "Duration (minutes) to boost hot water") }
func init() { flag.Int64Var(&count, "count", 100, "files to generate") flag.Int64Var(&sizeMax, "size-max", 1024*100, "maximum file size in bytes") flag.Int64Var(&sizeMin, "size-min", 1024*5, "minimum file size in bytes") flag.IntVar(&resMax, "res-max", 1980, "maximum ephemeral resolution") flag.IntVar(&resMin, "res-min", 500, "minumum ephemeral resolution") flag.IntVar(&workers, "workers", 1, "concurrent workers") flag.StringVar(&dir, "dir", "", "working directory") }
func parseFlags() { flag.StringVar(&flagHTTPAddr, "http", flagHTTPAddr, "HTTP addr") flag.StringVar(&flagGitHubWebhookSecret, "github-webhook-secret", flagGitHubWebhookSecret, "GitHub webhook secret") flag.Int64Var(&flagGroupcache, "groupcache", flagGroupcache, "Groupcache") flag.StringVar(&flagGroupcacheSelf, "groupcache-self", flagGroupcacheSelf, "Groupcache self") flag.StringVar(&flagGroupcachePeers, "groupcache-peers", flagGroupcachePeers, "Groupcache peers") flag.Int64Var(&flagCacheMemory, "cache-memory", flagCacheMemory, "Cache memory") flag.Parse() }
func init() { flag.StringVar(&httpHost, "host", "0.0.0.0", "Host to bind HTTP server to") flag.StringVar(&httpPort, "port", "1080", "Port to bind HTTP server to") flag.Int64Var(&maxSize, "max-size", 0, "Maximum size of uploads in bytes") flag.StringVar(&dir, "dir", "./data", "Directory to store uploads in") flag.Int64Var(&storeSize, "store-size", 0, "Size of disk space allowed to storage") flag.StringVar(&basepath, "base-path", "/files/", "Basepath of the hTTP server") flag.Parse() }
func init() { flag.StringVar(&Mode, "mode", "client", "client/server, start as client or server mode") flag.StringVar(&ServerUrl, "server", "http://www.baidu.com", "client mode: assign server url to test") flag.Int64Var(&DurationSec, "ds", 1, "client mode: request duration (milli sec)") flag.Int64Var(&DurationMilliSec, "dms", 100, "client mode: request duration (sec), it will replace DurationMilliSec") flag.Int64Var(&IntervalMilliSec, "ims", 10, "client mode: request interval (milli sec)") flag.StringVar(&FileSize, "filesize", "10m", "file size when request \"/\" url, default 10MB, k/kb/m/mb/g/gb all accepted") flag.Parse() }
func main() { // // The purpose of this program is to demonstrate that when CloseWrite is called on a connection // opened across the loopback interface that received (but not acknowledged) packets will be // be acknowledged with an incorrect ack sequence number and so prevent the arrival of // packets sent after that time. // // The server waits for connections on the specified interface and port. // When it receives a connection it reads parameters from the connection. The parameters are: // * the number of bytes in each burst // * the number of milliseconds to delay between each burst // * the number of bursts to generate // // It then enters a loop and generates the specified number of bursts of specified number of characters, with a delay // of the specified amount between each burst. // // The client: // * connects to the server // * sends the parameters for the connection to the server // * creates a goroutine to copy the connections output to stdout and count the response bytes // * delays for a specified number of milliseconds, then issues a CloseWrite on the connection // * waits for the copying goroutine to finish // var role string var connection ConnectionParams var program Program var closeDelay int flag.StringVar(&role, "role", "client", "The role of this program - either client (default) or server") flag.StringVar(&connection.addr, "addr", "127.0.0.1:19622", "The connection address.") flag.Int64Var(&program.BurstSize, "burstSize", 5, "The number of bytes in each burst.") flag.Int64Var(&program.BurstDelay, "burstDelay", 1000, "The number of milliseconds between each burst.") flag.Int64Var(&program.InitialDelay, "initialDelay", 200, "The number of milliseconds to wait before the initial burst.") flag.Int64Var(&program.BurstCount, "burstCount", 2, "The number of bursts to issue before closing the connection.") flag.Int64Var(&program.PreambleSize, "preambleSize", 69, "The number of bytes of preamble to generate prior to the initial response burst.") flag.IntVar(&closeDelay, "closeDelay", 0, "The number of milliseconds delay before shutting down the write side of the client's socket.") flag.Parse() var exit int if role == "server" { // exit = server(connection) } else { exit = client(connection, program, closeDelay) } os.Exit(exit) }
func init() { flag.StringVar(&config_url, "url", "", "url to fetch (like https://www.mydomain.com/content/)") flag.StringVar(&config_cert, "cert", "", "x509 certificate file to use") flag.StringVar(&config_key, "key", "", "RSA key file to use") flag.Int64Var(&config_requests, "requests", 10, "Number of requests to perform") flag.Int64Var(&config_workers, "workers", 5, "Number of workers to use") flag.IntVar(&config_cpus, "cpus", runtime.NumCPU(), "Number of CPUs to use (defaults to all)") flag.BoolVar(&config_head_method, "head", false, "Whether to use HTTP HEAD (default is GET)") flag.BoolVar(&config_fail_quit, "fail", false, "Whether to exit on a non-OK response") flag.BoolVar(&config_quiet, "quiet", false, "do not print all responses") }
func init() { flag.Int64Var(&requests, "r", -1, "Number of requests per client") flag.IntVar(&clients, "c", 100, "Number of concurrent clients") flag.StringVar(&url, "u", "", "URL") flag.StringVar(&urlsFilePath, "f", "", "URL's file path (line seperated)") flag.BoolVar(&keepAlive, "k", true, "Do HTTP keep-alive") flag.StringVar(&postDataFilePath, "d", "", "HTTP POST data file path") flag.Int64Var(&period, "t", -1, "Period of time (in seconds)") flag.IntVar(&connectTimeout, "tc", 5000, "Connect timeout (in milliseconds)") flag.IntVar(&writeTimeout, "tw", 5000, "Write timeout (in milliseconds)") flag.IntVar(&readTimeout, "tr", 5000, "Read timeout (in milliseconds)") }
func init() { flag.StringVar(&streamName, "stream-name", "your_stream", "the kinesis stream to read from") flag.StringVar(&workerID, "id", "", "the unique id for this consumer") flag.StringVar(&consumerGroup, "consumer-group", "example", "the name for this consumer group") flag.StringVar(&iteratorType, "iterator-type", "LATEST", "valid options are LATEST or TRIM_HORIZON which is how this consumer group will initial start handling the kinesis stream") flag.BoolVar(&verbose, "v", false, "verbose mode") flag.Int64Var(&consumerExpirationSeconds, "consumer-expiration-seconds", 15, "amount of time until another consumer starts processing this shard") flag.IntVar(&totalToConsume, "consume-total", -1, "total number of records to count as consumed before closing consumer") flag.Int64Var(&numRecords, "num-records", 5000, "total number of records to consumer per iteration") flag.IntVar(&bufferSize, "buffer-size", 100000, "size of the internal buffer that holds records to process") flag.Var(queryFreq, "query-freq", "how frequently to query kinesis for records [default: 1s]") }
func FlagsParse() { flag.StringVar(&Port, "port", "50000", "node port") flag.StringVar(&Host, "host", "127.0.0.1", "node address") flag.Uint64Var(&MinWorkers, "minWorkers", 2, "min workers") flag.Uint64Var(&MinPartitionsPerWorker, "ppw", 1, "min partitions per worker") flag.Int64Var(&MessageThreshold, "mthresh", 1000, "message threshold") flag.Int64Var(&VertexThreshold, "vthresh", 1000, "vertex threshold") flag.StringVar(&LoadPath, "loadPath", "data", "data load path") flag.StringVar(&PersistPath, "persistPath", "persist", "data persist path") flag.Parse() }
func init() { flag.Int64Var(&rps, "rps", 500, "Set Request Per Second") flag.StringVar(&profileFile, "profile", "", "The path to the traffic profile") flag.Int64Var(&slowThreshold, "threshold", 200, "Set slowness standard (in millisecond)") flag.StringVar(&profileType, "type", "default", "Profile type (default|session|your session type)") flag.BoolVar(&debug, "debug", false, "debug flag (true|false)") flag.StringVar(&auth_method, "auth", "none", "Set authorization flag (oauth|simple(c|s)2s|none)") flag.IntVar(&sessionAmount, "size", 100, "session amount") flag.StringVar(&proxy, "proxy", "none", "Set HTTP proxy (need to specify scheme. e.g. http://127.0.0.1:8888)") simple_client.C2S_Secret = "----" simple_client.S2S_Secret = "----" }
func init() { flag.Int64Var(&count, "count", 10000, "files to generate") flag.Int64Var(&bulkSize, "bulk", 10000, "bulk size") flag.Int64Var(&sizeMax, "size-max", 1024*100, "maximum file size in bytes") flag.Int64Var(&sizeMin, "size-min", 1024*5, "minimum file size in bytes") flag.IntVar(&resMax, "res-max", 1980, "maximum ephemeral resolution") flag.IntVar(&resMin, "res-min", 500, "minumum ephemeral resolution") flag.BoolVar(&generate, "generate", false, "generate data") flag.BoolVar(&collect, "collect", true, "collect old files") flag.BoolVar(&onlyOpen, "only-open", false, "only open db") flag.BoolVar(&onlyMemory, "only-memory", false, "only load to memory") flag.BoolVar(&onlyMemory, "only-array", false, "only array of hashes") flag.StringVar(&dbpath, "dbfile", "db.bolt", "working directory") flag.IntVar(&cpus, "cpus", runtime.GOMAXPROCS(0), "cpu to use") }
func parse_args() (int64, int64, int64, *base_comp) { var length int64 var level int64 var nr int64 var p string // Process simple command line parameters: flag.Int64Var(&length, "l", 10000, "Length of the generated random sequence.") flag.Int64Var(&level, "e", 10, "Expression level.") flag.Int64Var(&nr, "n", 1000, "Number of transcripts.") flag.StringVar(&p, "p", "A:1.0, T:1.0, G:1.0, C:1.0", "Base composition.") flag.Parse() bc := parse_base_comp(p) return length, level, nr, bc }
func init() { flag.Int64Var(&rps, "rps", 500, "Set Request Per Second") flag.StringVar(&profileFile, "profile", "", "The path to the traffic profile") flag.Int64Var(&slowThreshold, "threshold", 200, "Set slowness standard (in millisecond)") flag.StringVar(&profileType, "type", "default", "Profile type (default|session|your session type)") flag.BoolVar(&debug, "debug", false, "debug flag (true|false)") flag.StringVar(&auth_method, "auth", "none", "Set authorization flag (oauth|gree(c|s)2s|none)") flag.StringVar(&auth_key, "key", "", "Set authorization key") flag.IntVar(&sessionAmount, "size", 100, "session amount") flag.StringVar(&sessionUrlPrefix, "url", "", "Session url prefix") flag.StringVar(&proxy, "proxy", "none", "Set HTTP proxy (need to specify scheme. e.g. http://127.0.0.1:8888)") flag.IntVar(&logIntv, "intv", 6, "Log interval in chart") flag.StringVar(&logType, "ltype", "default", "Log type (file|db)") }
func init() { log.SetFlags(log.Lshortfile | log.LstdFlags) flag.IntVar(&_Count, "n", 1, "连接数的大小,最大不能超过64511") flag.StringVar(&_Host, "h", "ws://127.0.0.1:1234/ws", "指定远端服务器WebSocket地址") flag.StringVar(&_LocalHost, "l", "127.0.0.1,192.168.2.10", "指定本地地址,逗号分隔多个") flag.IntVar(&_ConnPerSec, "cps", 0, "限制每秒创建连接,0为无限制") flag.DurationVar(&_SendInterval, "i", 30*time.Second, "设置发送的间隔(如:1s, 10us)") //flag.Int64Var(&_StartId, "s", 1, "设置id的初始值自动增加1") flag.Int64Var(&_StartId, "id", 1, "第一个客户端的id,多个客户端时自动累加") //flag.StringVar(&_ToId, "to_id", "", "发送到id,逗号\",\"符连接, 如: 2,3") flag.Int64Var(&_SpecifyTo, "to_sid", 0, "发往客户端的指定id,0或to_id中的一项") flag.StringVar(&_StatPort, "sh", ":30001", "设置服务器统计日志端口") //flag.StringVar(&_SN, "sn", "client1", "设置客户端sn") flag.Int64Var(&_SentCount, "sc", -1, "Sent msg count per client") }
func init() { flag.StringVar(&from_catrel_flag, "from-catrel", "unstable", "Actually, only unstable makes sense here.") flag.StringVar(&to_catrel_flag, "to-catrel", "bratislava", "The testing release.") flag.StringVar(&htmlReportDir, "html-report-path", "/home/maciej/public_html", "Full path to the file where the HTML report will be "+ "written. If the file already exists, it will be "+ "overwritten. ") flag.StringVar(&htmlReportTemplate, "html-report-template", "src/promote-packages/report-template.html", "HTML template used to generate the report.") flag.StringVar(&packageTimesFilename, "package-times-json-file", "/home/maciej/.checkpkg/package-times.json", "JSON file with package times state. This file is used "+ "for persistence: it remembers when each of the packages "+ "was last modified in the unstable catalog.") flag.Int64Var(&daysOldRequired, "required-age-in-days", 14, "Packages must be this number of days old before they can "+ "be integrated.") flag.StringVar(&logFile, "log-file", "-", "The log file contains rollback information.") }
func handleStart() error { id := stripArgument() if id == "" { return errors.New("No task id supplied to start") } var api string var timeout int64 flag.StringVar(&api, "api", "", "API host:port for advertizing.") flag.Int64Var(&timeout, "timeout", 30, "Timeout in seconds to wait until the task receives Running status.") ParseFlags("start") if err := resolveApi(api); err != nil { return err } request := framework.NewApiRequest(framework.Config.Api + "/api/start") request.PutString("id", id) request.PutInt("timeout", timeout) response := request.Get() fmt.Println(response.Message) return nil }
func parseFlags() { flag.StringVar(&flagHTTP, "http", flagHTTP, "HTTP") flag.Int64Var(&flagMemory, "memory", flagMemory, "Memory") flag.StringVar(&flagRedis, "redis", flagRedis, "Redis") flag.StringVar(&flagMemcache, "memcache", flagMemcache, "Memcache") flag.Parse() }
func init() { flag.StringVar(&hostname, "hostname", "localhost:9092", "host:port string for the kafka server") flag.StringVar(&topic, "topic", "test", "topic to read offsets from") flag.IntVar(&partition, "partition", 0, "partition to read offsets from") flag.UintVar(&offsets, "offsets", 1, "number of offsets returned") flag.Int64Var(&time, "time", -1, "timestamp of the offsets before that: time(ms)/-1(latest)/-2(earliest)") }
func init() { flag.StringVar(&address, "address", defaultAddress, addressUsage) flag.StringVar(&etcdUrls, "etcd-urls", "", etcdUrlsUsage) flag.BoolVar(&insecure, "insecure", false, insecureUsage) flag.BoolVar(&proxyPreserveHost, "proxy-preserve-host", false, proxyPreserveHostUsage) flag.StringVar(&etcdPrefix, "etcd-prefix", defaultEtcdPrefix, etcdPrefixUsage) flag.StringVar(&innkeeperUrl, "innkeeper-url", "", innkeeperUrlUsage) flag.Int64Var(&sourcePollTimeout, "source-poll-timeout", defaultSourcePollTimeout, sourcePollTimeoutUsage) flag.StringVar(&routesFile, "routes-file", "", routesFileUsage) flag.StringVar(&oauthUrl, "oauth-url", "", oauthUrlUsage) flag.StringVar(&oauthScope, "oauth-scope", "", oauthScopeUsage) flag.StringVar(&oauthCredentialsDir, "oauth-credentials-dir", "", oauthCredentialsDirUsage) flag.StringVar(&innkeeperAuthToken, "innkeeper-auth-token", "", innkeeperAuthTokenUsage) flag.StringVar(&innkeeperPreRouteFilters, "innkeeper-pre-route-filters", "", innkeeperPreRouteFiltersUsage) flag.StringVar(&innkeeperPostRouteFilters, "innkeeper-post-route-filters", "", innkeeperPostRouteFiltersUsage) flag.BoolVar(&devMode, "dev-mode", false, devModeUsage) flag.StringVar(&metricsListener, "metrics-listener", defaultMetricsListener, metricsListenerUsage) flag.StringVar(&metricsPrefix, "metrics-prefix", defaultMetricsPrefix, metricsPrefixUsage) flag.BoolVar(&debugGcMetrics, "debug-gc-metrics", false, debugGcMetricsUsage) flag.BoolVar(&runtimeMetrics, "runtime-metrics", defaultRuntimeMetrics, runtimeMetricsUsage) flag.StringVar(&applicationLog, "application-log", "", applicationLogUsage) flag.StringVar(&applicationLogPrefix, "application-log-prefix", defaultApplicationLogPrefix, applicationLogPrefixUsage) flag.StringVar(&accessLog, "access-log", "", accessLogUsage) flag.BoolVar(&accessLogDisabled, "access-log-disabled", false, accessLogDisabledUsage) flag.Parse() }
func main() { svc := dynamodb.New(session.New(&aws.Config{Region: aws.String("us-east-1")})) jar := &CookieManager{} var cookieCount int var sleepTime int64 flag.IntVar(&cookieCount, "count", 10, "collect this many cookies") flag.Int64Var(&sleepTime, "sleep", 2, "sleep this many between executions") flag.Parse() for i := 0; i <= cookieCount; i++ { jar.jar = make(map[string][]*http.Cookie) if resp, err := GetCookie(jar); err == nil { t, _ := time.Parse(timeLongForm, resp.Header["Date"][0]) time_string := strconv.FormatInt(t.Unix(), 10) body := resp.Body params := ProcessCookies(&InputItem{*jar, time_string, table_name, ScrapePage(&body)}) svc.PutItem(params) } else { fmt.Println("Failed to get a response body. Will retry after timeout.") } if i%5 == 0 && i != 0 { fmt.Printf("Got %d cookies.\n", i) } time.Sleep(time.Duration(sleepTime) * time.Second) // lets hold firm 2s for niceness } }
// Command line options parsing -------------------------------------------------- func ReadFlags(config *goDB.GeneralConf) error { flag.StringVar(&config.Iface, "i", "", "Interface for which the query should be performed (e.g. eth0, t4_33760, ...)") flag.StringVar(&config.Conditions, "c", "", "Logical conditions for the query") flag.StringVar(&config.BaseDir, "d", "/usr/local/goProbe/data/db", "Path to database directory. By default, /usr/local/goProbe/data/db is used") flag.BoolVar(&config.ListDB, "list", false, "lists on which interfaces data was captured and written to the DB") flag.StringVar(&config.Format, "e", "txt", "Output format: {txt|json|csv}") flag.BoolVar(&config.Help, "h", false, "Prints the help page") flag.BoolVar(&config.HelpAdmin, "help-admin", false, "Prints the advanced help page") flag.BoolVar(&config.WipeAdmin, "wipe", false, "wipes the entire database") flag.Int64Var(&config.CleanAdmin, "clean", 0, "cleans all entries before indicated timestamp") flag.BoolVar(&config.External, "x", false, "Mode for external calls, e.g. from portal") flag.BoolVar(&config.Sort, "p", false, "Sort results by accumulated packets instead of bytes") flag.BoolVar(&config.SortAscending, "a", false, "Sort results in ascending order") flag.BoolVar(&config.Incoming, "in", false, "Take into account incoming data only (received packets/bytes)") flag.BoolVar(&config.Outgoing, "out", false, "Take into account outgoing data only (sent packets/bytes)") flag.IntVar(&config.NumResults, "n", 10000, "Maximum number of final entries to show. Defaults to 95% of the overall data volume / number of packets (depending on the '-p' parameter)") flag.StringVar(&config.First, "f", "0", "Lower bound on flow timestamp") flag.StringVar(&config.Last, "l", "9999999999999999", "Upper bound on flow timestamp") flag.Parse() if flag.NArg() > 1 { return errors.New("Query type must be the last argument of the call") } config.QueryType = (flag.Arg(0)) return nil }