func init() {
flag.BoolVar(&versionFlag, "version", false, "Print the version number and exit.")
flag.BoolVar(&versionFlag, "V", false, "Print the version number and exit (shorthand).")
flag.StringVar(&verboseFlag, "verbose", "", "Display debug information: choose between text or JSON.")
flag.StringVar(&verboseFlag, "v", "", "Display debug information: choose between text or JSON (shorthand).")
hostname, _ := os.Hostname()
flag.StringVar(&prefixFlag, "prefix", hostname, "Change series name prefix.")
flag.StringVar(&prefixFlag, "P", hostname, "Change series name prefix (shorthand).")
flag.StringVar(&hostFlag, "host", "localhost:8086", "Connect to host.")
flag.StringVar(&hostFlag, "h", "localhost:8086", "Connect to host (shorthand).")
flag.StringVar(&usernameFlag, "username", "root", "User for login.")
flag.StringVar(&usernameFlag, "u", "root", "User for login (shorthand).")
flag.StringVar(&passwordFlag, "password", "root", "Password to use when connecting to server.")
flag.StringVar(&passwordFlag, "p", "root", "Password to use when connecting to server (shorthand).")
flag.StringVar(&databaseFlag, "database", "", "Name of the database to use.")
flag.StringVar(&databaseFlag, "d", "", "Name of the database to use (shorthand).")
flag.StringVar(&collectFlag, "collect", "cpus,mem,swap,uptime,load,network,disks", "Chose which data to collect.")
flag.StringVar(&collectFlag, "c", "cpus,mem,swap,uptime,load,network,disks", "Chose which data to collect (shorthand).")
flag.BoolVar(&daemonFlag, "daemon", false, "Run in daemon mode.")
flag.BoolVar(&daemonFlag, "D", false, "Run in daemon mode (shorthand).")
flag.DurationVar(&daemonIntervalFlag, "interval", time.Second, "With daemon mode, change time between checks.")
flag.DurationVar(&daemonIntervalFlag, "i", time.Second, "With daemon mode, change time between checks (shorthand).")
}
func parseArgs() {
// set options
flag.DurationVar(&option.interval, "interval",
time.Second, "Measurement interval")
flag.BoolVar(&option.no_interval_backoff, "no-interval-backoff",
false, "Disable interval backoff")
flag.DurationVar(&option.timeout, "timeout",
time.Second*0, "Measurement timeout")
flag.DurationVar(&option.start_delay, "start-delay",
time.Second*0, "Wait time before measurement")
flag.StringVar(&option.output, "output",
"-", "Output file name")
flag.BoolVar(&option.no_cpu, "no-cpu",
false, "Do not record CPU usage")
flag.BoolVar(&option.no_disk, "no-disk",
false, "Do not record disk usage")
flag.BoolVar(&option.no_net, "no-net",
false, "Do not record net usage")
flag.BoolVar(&option.debug, "debug",
false, "Enable debug mode")
flag.BoolVar(&option.listDevices, "list-devices",
false, "List devices and exits")
flag.StringVar(&option.disks, "disks",
"", "Disk devices to be monitored")
flag.StringVar(&option.player_bin, "player-bin",
"", "Run perfmonger-player to show JSON output")
flag.Parse()
if option.player_bin == "" && terminal.IsTerminal(int(os.Stdout.Fd())) &&
option.output == "-" {
fmt.Fprintf(os.Stderr, "[recording to data.pgr]\n")
option.output = "data.pgr"
}
if option.disks == "" {
option.targetDisks = nil
} else {
option.targetDisks = new(map[string]bool)
*option.targetDisks = make(map[string]bool)
for _, dev := range strings.Split(option.disks, ",") {
(*option.targetDisks)[dev] = true
}
}
if option.debug {
os.Stderr.WriteString(
fmt.Sprintf(
`== option
- output : %s
- interval : %s
- debug : %t
- remainings: %s
`,
option.output,
option.interval.String(),
option.debug,
fmt.Sprint(flag.Args())))
}
}
func init() {
flag.BoolVar(&versionFlag, "version", false, "Print the version number and exit.")
flag.BoolVar(&versionFlag, "V", false, "Print the version number and exit (shorthand).")
flag.BoolVar(&verboseFlag, "verbose", false, "Display debug information: choose between text or JSON.")
flag.BoolVar(&verboseFlag, "v", false, "Display debug information: choose between text or JSON (shorthand).")
flag.BoolVar(&sslFlag, "ssl", false, "Enable SSL/TLS encryption.")
flag.BoolVar(&sslFlag, "S", false, "Enable SSL/TLS encryption (shorthand).")
flag.StringVar(&hostFlag, "host", "localhost:8086", "Connect to host.")
flag.StringVar(&hostFlag, "h", "localhost:8086", "Connect to host (shorthand).")
flag.StringVar(&usernameFlag, "username", "root", "User for login.")
flag.StringVar(&usernameFlag, "u", "root", "User for login (shorthand).")
flag.StringVar(&passwordFlag, "password", "root", "Password to use when connecting to server.")
flag.StringVar(&passwordFlag, "p", "root", "Password to use when connecting to server (shorthand).")
flag.StringVar(&secretFlag, "secret", "", "Absolute path to password file (shorthand). '-p' is ignored if specifed.")
flag.StringVar(&secretFlag, "s", "", "Absolute path to password file. '-p' is ignored if specifed.")
flag.StringVar(&databaseFlag, "database", "", "Name of the database to use.")
flag.StringVar(&databaseFlag, "d", "", "Name of the database to use (shorthand).")
flag.StringVar(&retentionPolicyFlag, "retentionpolicy", "", "Name of the retention policy to use.")
flag.StringVar(&retentionPolicyFlag, "rp", "", "Name of the retention policy to use (shorthand).")
flag.StringVar(&collectFlag, "collect", "cpu,cpus,mem,swap,uptime,load,network,disks,mounts", "Chose which data to collect.")
flag.StringVar(&collectFlag, "c", "cpu,cpus,mem,swap,uptime,load,network,disks,mounts", "Chose which data to collect (shorthand).")
flag.BoolVar(&daemonFlag, "daemon", false, "Run in daemon mode.")
flag.BoolVar(&daemonFlag, "D", false, "Run in daemon mode (shorthand).")
flag.DurationVar(&daemonIntervalFlag, "interval", time.Second, "With daemon mode, change time between checks.")
flag.DurationVar(&daemonIntervalFlag, "i", time.Second, "With daemon mode, change time between checks (shorthand).")
flag.DurationVar(&daemonConsistencyFlag, "consistency", time.Second, "With custom interval, duration to bring back collected values for data consistency (0s to disable).")
flag.DurationVar(&daemonConsistencyFlag, "C", time.Second, "With daemon mode, duration to bring back collected values for data consistency (shorthand).")
flag.StringVar(&pidFile, "pidfile", "", "the pid file")
}
func init() {
defaultDelay := time.Duration(1500 * time.Millisecond)
flag.DurationVar(&delayFlag, "d", defaultDelay, "")
flag.DurationVar(&delayFlag, "delay", defaultDelay, "")
flag.BoolVar(&kernelFlag, "k", false, "")
flag.BoolVar(&kernelFlag, "kernel", false, "")
flag.StringVar(&pidsFlag, "p", "", "")
flag.StringVar(&pidsFlag, "pids", "", "")
defaultSort := CPUPercentColumn.Title
flag.StringVar(&sortFlag, "s", defaultSort, "")
flag.StringVar(&sortFlag, "sort", defaultSort, "")
flag.BoolVar(&treeFlag, "t", false, "")
flag.BoolVar(&treeFlag, "tree", false, "")
flag.StringVar(&usersFlag, "u", "", "")
flag.StringVar(&usersFlag, "users", "", "")
flag.BoolVar(&verboseFlag, "verbose", false, "")
flag.Usage = func() {
fmt.Fprint(os.Stdout, usage)
}
}
func main() {
flag.StringVar(&emailAddr, "email", "*****@*****.**", "email recipient for notificiations")
flag.StringVar(&listenAddr, "listen", ":7700", "webserver listen address")
flag.IntVar(&failLimit, "failLimit", 4, "number failed ping attempts in a row to consider host down")
flag.DurationVar(&interval, "interval", 5*time.Second, "seconds between each ping")
flag.DurationVar(&ping.TimeOut, "timeOut", 5*time.Second, "seconds for single ping timeout")
flag.Parse()
// read non flag arguments as hosts to start monitoring
hosts := flag.Args()
var pool = &pingd.Pool{
Interval: interval,
FailLimit: failLimit,
Receive: http.NewReceiverFunc(listenAddr), // start/stop commands via HTTP
Notify: mail.NewNotifierFunc(emailAddr, sendMail), // notify up/down via email
Load: std.NewLoaderFunc(hosts), // load initial hosts from command line
}
pool.Start()
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c // Exit on interrupt
}
// Define a new Client via Flags. Note you must call client.Open() before using
// it.
func ClientFromFlag(name string) *Client {
c := &Client{}
hostname, _ := os.Hostname()
flag.StringVar(
&c.Host,
name+".host",
hostname,
"hostname for ganglia",
)
flag.StringVar(
&c.Spoof,
name+".spoof",
"",
"spoof hostname for ganglia",
)
flag.DurationVar(
&c.TickInterval,
name+".tick-interval",
time.Minute,
"tick interval for ganglia",
)
flag.DurationVar(
&c.Lifetime,
name+".lifetime",
time.Hour*24*30, // 30 days
"metrics lifetime for ganglia",
)
addrs.FlagManyVar(
&c.Addr,
name+".addrs",
"udp:127.0.0.1:8649",
"comma separated list of net:host:port triples of ganglia leaf nodes",
)
return c
}
func parseFlags() {
flag.DurationVar(&interval, "i", -1,
"set execution interval for command, e.g. 45s, 2m, 1h30m, default: 1/10 of timeout")
flag.DurationVar(&timeout, "t", 1*time.Minute,
"set execution timeout for command, e.g. 45s, 2m, 1h30m, default: 1m")
flag.BoolVar(&useSyslog, "s", false, "log via syslog")
flag.BoolVar(&pipeStderr, "e", true, "pipe stderr to log")
flag.BoolVar(&pipeStdout, "o", true, "pipe stdout to log")
flag.BoolVar(&killRunning, "k", false, "kill already running instance of command")
flag.Parse()
if flag.NArg() < 1 {
log.Fatal("FATAL: no command to execute")
}
command = flag.Arg(0)
if interval >= timeout {
log.Fatal("FATAL: interval >= timeout, no time left for actual command execution")
}
if interval == -1 {
interval = timeout / 10
}
}
func parseArguments() (string, *status_updater.EtcdConnectionParams, *status_updater.KeyUpdaterParameters) {
var unixSocketPath string
etcdParams := status_updater.EtcdConnectionParams{}
keyUpdaterParams := status_updater.KeyUpdaterParameters{}
// etcd connection params
flag.StringVar(&etcdParams.Endpoint, "etcd-endpoint", "http://127.0.0.1:4001,http://127.0.0.1:2379", "Coma separated etcd endpoints")
//
flag.StringVar(&etcdParams.CertFile, "etcd-cert-file", "", "identify HTTPS client using this SSL certificate file")
flag.StringVar(&etcdParams.KeyFile, "etcd-key-file", "", "identify HTTPS client using this SSL key file")
flag.StringVar(&etcdParams.CaFile, "etcd-ca-file", "", "verify certificates of HTTPS-enabled servers using this CA bundle")
flag.StringVar(&etcdParams.Username, "etcd-user", "", "Etcd auth user")
flag.StringVar(&etcdParams.Password, "etcd-password", "", "Etcd auth password")
flag.DurationVar(&etcdParams.ConnectionTimeout, "etcd-timeout", time.Second, "etcd connection timeout per request")
flag.DurationVar(&etcdParams.RequestTimeout, "etcd-request-timeout", 5*time.Second, "etcd requst timeout")
// Server socket path
flag.StringVar(&unixSocketPath, "socket", "/tmp/artd-status-updater.sock", "Path to unix socket liten on")
// Key updater parameters
flag.StringVar(&keyUpdaterParams.Key, "key", "/artifact-downloader/status", "Key where to push status")
flag.DurationVar(&keyUpdaterParams.KeyTTL, "key-ttl", 10*time.Second, "TTL for status key")
flag.DurationVar(&keyUpdaterParams.RetryFreq, "key-retry-freq", 1*time.Second, "Key update retry update freq")
flag.DurationVar(&keyUpdaterParams.UpdateFreq, "key-update-freq", 5*time.Second, "Key update freq")
flag.Parse()
return unixSocketPath, &etcdParams, &keyUpdaterParams
}
func main() {
log.SetFlags(log.LstdFlags | log.Lshortfile)
flag.IntVar(&cfg.Port, "port", 9033, "port to listen on")
flag.StringVar(&cfg.DataBasePath, "data", "/tmp/qrpc", "directory in which queue data is stored")
flag.Uint64Var(&cfg.MaxCacheSize, "cache", 1024*1024, "max. cache size (bytes) before an item is evicted.")
flag.DurationVar(&cfg.ClusterRequestTimeout, "timeout", 3*time.Second, "cluster request (gossip) timeout.")
flag.DurationVar(&cfg.ClusterWatchInterval, "interval", time.Second, "cluster watch timer interval.")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s [flags] [cluster peer(s) ...]\n", os.Args[0])
fmt.Fprintln(os.Stderr, "flags:")
flag.PrintDefaults()
os.Exit(2)
}
flag.Parse()
cfg.ClusterPeers = flag.Args()
s := qrpc.NewServer(&cfg)
errchan := s.Start()
// Handle SIGINT and SIGTERM.
sigchan := make(chan os.Signal, 1)
signal.Notify(sigchan, os.Interrupt, os.Kill)
select {
case sig := <-sigchan:
log.Printf("Signal %s received, shutting down...\n", sig)
s.Stop()
case err := <-errchan:
log.Fatalln(err)
}
}
func (c *ShuttleConfig) ParseFlags() {
flag.BoolVar(&c.PrintVersion, "version", false, "Print log-shuttle version.")
flag.BoolVar(&c.Verbose, "verbose", false, "Enable verbose debug info.")
flag.BoolVar(&c.SkipHeaders, "skip-headers", false, "Skip the prepending of rfc5424 headers.")
flag.BoolVar(&c.SkipVerify, "skip-verify", false, "Skip the verification of HTTPS server certificate.")
flag.StringVar(&c.Prival, "prival", "190", "The primary value of the rfc5424 header.")
flag.StringVar(&c.Version, "syslog-version", "1", "The version of syslog.")
flag.StringVar(&c.Procid, "procid", "shuttle", "The procid field for the syslog header.")
flag.StringVar(&c.Appname, "appname", "", "The app-name field for the syslog header.")
flag.StringVar(&c.Appname, "logplex-token", "", "Secret logplex token.")
flag.StringVar(&c.Hostname, "hostname", "shuttle", "The hostname field for the syslog header.")
flag.StringVar(&c.Msgid, "msgid", "- -", "The msgid field for the syslog header.")
flag.StringVar(&c.LogsURL, "logs-url", "", "The receiver of the log data.")
flag.StringVar(&c.StatsAddr, "stats-addr", DEFAULT_STATS_ADDR, "Where to expose stats.")
flag.StringVar(&c.StatsSource, "stats-source", DEFAULT_STATS_SOURCE, "When emitting stats, add source=<stats-source> to the stats.")
flag.DurationVar(&c.StatsInterval, "stats-interval", time.Duration(DEFAULT_STATS_INTERVAL), "How often to emit/reset stats.")
flag.IntVar(&c.MaxAttempts, "max-attempts", DEFAULT_MAX_ATTEMPTS, "Max number of retries.")
flag.IntVar(&c.InputFormat, "input-format", DEFAULT_INPUT_FORMAT, "0=raw (default), 1=rfc3164 (syslog(3))")
flag.IntVar(&c.NumBatchers, "num-batchers", 2, "The number of batchers to run.")
flag.IntVar(&c.NumOutlets, "num-outlets", 4, "The number of outlets to run.")
flag.DurationVar(&c.WaitDuration, "wait", time.Duration(DEFAULT_WAIT_DURATION), "Duration to wait to flush messages to logplex")
flag.IntVar(&c.BatchSize, "batch-size", 500, "Number of messages to pack into a logplex http request.")
flag.IntVar(&c.FrontBuff, "front-buff", DEFAULT_FRONT_BUFF, "Number of messages to buffer in log-shuttle's input chanel.")
flag.IntVar(&c.StatsBuff, "stats-buff", DEFAULT_STATS_BUFF, "Number of stats to buffer.")
flag.DurationVar(&c.Timeout, "timeout", time.Duration(DEFAULT_TIMEOUT), "Duration to wait for a response from Logplex.")
flag.BoolVar(&c.LogToSyslog, "log-to-syslog", false, "Log to syslog instead of stderr")
flag.Parse()
if c.MaxAttempts < 1 {
log.Fatalf("-max-attempts must be >= 1")
}
}
func init() {
flag.StringVar(&join, "join", "", "Member of SkyDNS cluster to join can be comma separated list")
flag.BoolVar(&discover, "discover", false, "Auto discover SkyDNS cluster. Performs an NS lookup on the -domain to find SkyDNS members")
flag.StringVar(&domain, "domain",
func() string {
if x := os.Getenv("SKYDNS_DOMAIN"); x != "" {
return x
}
return "skydns.local"
}(), "Domain to anchor requests to or env. var. SKYDNS_DOMAIN")
flag.StringVar(&ldns, "dns",
func() string {
if x := os.Getenv("SKYDNS_DNS"); x != "" {
return x
}
return "127.0.0.1:53"
}(), "IP:Port to bind to for DNS or env. var SKYDNS_DNS")
flag.StringVar(&lhttp, "http",
func() string {
if x := os.Getenv("SKYDNS"); x != "" {
// get rid of http or https
x1 := strings.TrimPrefix(x, "https://")
x1 = strings.TrimPrefix(x1, "http://")
return x1
}
return "127.0.0.1:8080"
}(), "IP:Port to bind to for HTTP or env. var. SKYDNS")
flag.StringVar(&dataDir, "data", "./data", "SkyDNS data directory")
flag.DurationVar(&rtimeout, "rtimeout", 2*time.Second, "Read timeout")
flag.DurationVar(&wtimeout, "wtimeout", 2*time.Second, "Write timeout")
flag.StringVar(&secret, "secret", "", "Shared secret for use with http api")
flag.StringVar(&nameserver, "nameserver", "", "Nameserver address to forward (non-local) queries to e.g. 8.8.8.8:53,8.8.4.4:53")
}
// Builds a conf data structure and connects
// the fields in the struct to flags.
// It is up to the caller to call flag.Parse()
func New() *D {
d := new(D)
flag.BoolVar(&d.PrintVersion, "version", false,
"Print l2met version and sha.")
flag.StringVar(&d.AppName, "app-name", "l2met",
"Prefix internal log messages with this value.")
flag.IntVar(&d.BufferSize, "buffer", 1024,
"Max number of items for all internal buffers.")
flag.IntVar(&d.Concurrency, "concurrency", 10,
"Number of running go routines for outlet or receiver.")
flag.IntVar(&d.Port, "port", 8080,
"HTTP server's bind port.")
flag.IntVar(&d.OutletRetries, "outlet-retry", 2,
"Number of attempts to outlet metrics to Librato.")
flag.Int64Var(&d.ReceiverDeadline, "recv-deadline", 2,
"Number of time units to pass before dropping incoming logs.")
flag.DurationVar(&d.OutletTtl, "outlet-ttl", time.Second*2,
"Timeout set on Librato HTTP requests.")
flag.Uint64Var(&d.MaxPartitions, "partitions", uint64(1),
"Number of partitions to use for outlets.")
flag.DurationVar(&d.FlushInterval, "flush-interval", time.Second,
"Time to wait before sending data to store or outlet. "+
"Example:60s 30s 1m")
flag.DurationVar(&d.OutletInterval, "outlet-interval", time.Second,
"Time to wait before outlets read buckets from the store. "+
"Example:60s 30s 1m")
flag.BoolVar(&d.UseOutlet, "outlet", false,
"Start the Librato outlet.")
flag.BoolVar(&d.UsingReciever, "receiver", false,
"Enable the Receiver.")
flag.BoolVar(&d.Verbose, "v", false,
"Enable verbose log output.")
d.RedisHost, d.RedisPass, _ = parseRedisUrl(env("REDIS_URL"))
d.Secrets = strings.Split(mustenv("SECRETS"), ":")
if len(env("METCHAN_URL")) > 0 {
url, err := url.Parse(env("METCHAN_URL"))
if err == nil {
d.MetchanUrl = url
}
}
return d
}
// TransportFlag - A Flag configured Transport instance.
func TransportFlag(name string) *Transport {
t := &Transport{TLSClientConfig: &tls.Config{}}
flag.BoolVar(
&t.TLSClientConfig.InsecureSkipVerify,
name+".insecure-tls",
false,
name+" skip tls certificate verification",
)
flag.BoolVar(
&t.DisableKeepAlives,
name+".disable-keepalive",
false,
name+" disable keep-alives",
)
flag.BoolVar(
&t.DisableCompression,
name+".disable-compression",
false,
name+" disable compression",
)
flag.IntVar(
&t.MaxIdleConnsPerHost,
name+".max-idle-conns-per-host",
http.DefaultMaxIdleConnsPerHost,
name+" max idle connections per host",
)
flag.DurationVar(
&t.DialTimeout,
name+".dial-timeout",
2*time.Second,
name+" dial timeout",
)
flag.DurationVar(
&t.DialKeepAlive,
name+".dial-keepalive",
0,
name+" dial keepalive connection",
)
flag.DurationVar(
&t.ResponseHeaderTimeout,
name+".response-header-timeout",
3*time.Second,
name+" response header timeout",
)
flag.DurationVar(
&t.RequestTimeout,
name+".request-timeout",
30*time.Second,
name+" request timeout",
)
flag.UintVar(
&t.MaxTries,
name+".max-tries",
0,
name+" max retries for known safe failures",
)
return t
}
func init() {
flag.StringVar(&carbon, "carbon", "localhost:2003", "address of carbon host")
flag.StringVar(&prefix, "prefix", "haggar", "prefix for metrics")
flag.DurationVar(&flushInterval, "flush-interval", 10*time.Second, "how often to flush metrics")
flag.DurationVar(&spawnInterval, "spawn-interval", 10*time.Second, "how often to gen new agents")
flag.IntVar(&metrics, "metrics", 10000, "number of metrics for each agent to hold")
flag.DurationVar(&jitter, "jitter", 10*time.Second, "max amount of jitter to introduce in between agent launches")
flag.IntVar(&agents, "agents", 100, "max number of agents to run concurrently")
}
func init() {
flag.IntVar(¶ms.port, "port", 8080, "Port to start app on")
flag.DurationVar(¶ms.checkexpire, "checkexpire", 5*time.Second, "How often to perform check expire boxes in seconds")
flag.IntVar(¶ms.freecapacity, "freecapacity", 5, "Max number of expired boxes to return to queue")
flag.DurationVar(¶ms.makefreeavailable, "makefreeavailable", 5*time.Second, "How often to perform makefreeavailable")
flag.StringVar(¶ms.mailboxes, "mailboxes", "vmailbox", "Postfix virtual map file")
flag.StringVar(¶ms.boxpath, "boxpath", "boxes", "Path to directory with stored boxes")
flag.Int64Var(¶ms.rentfor, "rentfor", 3600, "Mailbox rent time in seconds")
}
func init() {
flag.StringVar(&loadBatchTable, "load_batch_table", "load_batch", "Loads DB table for batches")
flag.StringVar(&pendingLoadTable, "pending_load_table", "pending_load", "Loads DB table for loads")
flag.DurationVar(&noWorkDelay, "no_work_delay", time.Minute, "Time to wait if there's no work to do")
flag.IntVar(&maxLoadRetryCount, "max_load_retry", 5, "Number of times to retry a load batch before giving up")
flag.IntVar(&dbRetryCount, "max_db_retry", 10, "Number of times to retry a transaction")
flag.DurationVar(&errorRetryDelay, "error_retry_delay", time.Minute*15, "Time to wait to retry a load that errors")
flag.DurationVar(&staleRetryDelay, "stale_retry_delay", time.Hour*3, "Time to wait before checking up on a load")
flag.DurationVar(&staleRecoverDelay, "stale_recover_delay", time.Minute*30, "Time to check out a stale load (lock duration)")
flag.DurationVar(&staleCheckInterval, "stale_check_interval", time.Minute, "How often to check for stale loads")
}
func main() {
addrString := flag.String("bind", ":0", "Listen [addr]:port")
flag.DurationVar(&acceptDelay, "accept-delay", 100*time.Millisecond, "")
flag.DurationVar(&responseDelay, "response-delay", 100*time.Millisecond, "")
flag.Parse()
listener, err := net.Listen("tcp", *addrString)
if err != nil {
log.Fatal("Listen:", err.Error())
}
log.Printf("Listen on http://%s/", listener.Addr())
server(listener, delayServe)
}
func main() {
var config LogClientConfig
flag.StringVar(&config.Name, "name", "log_client", "Log cilent name")
flag.StringVar(&config.Host, "server_host", "http://localhost", "Log server host")
flag.StringVar(&config.Port, "server_port", ":1734", "Log server listen port")
flag.StringVar(&config.Method, "method", "/upload", "Log client method")
flag.StringVar(&config.Dir, "dir", "/tmp/", "Upload Directory")
flag.StringVar(&config.ListenPort, "client_listen_port", ":1735", "Log client server listening port")
flag.DurationVar(&config.UploadInterval, "upload_interval", time.Duration(15)*time.Minute, "Upload file created before upload interval (better be smaller than keep_interval, has to be bigger than log file create interval)")
flag.DurationVar(&config.KeepInterval, "keep_interval", time.Duration(30)*time.Minute, "Log file kept time (better be bigger than sleep_interval and upload_interval)")
flag.DurationVar(&config.SleepInterval, "sleep_interval", time.Duration(10)*time.Minute, "Sleep time interval between every upload action (better smaller than keep_interval)")
flag.Parse()
// if config.KeepInterval < config.UploadInterval || config.KeepInterval < config.SleepInterval {
// if config.UploadInterval >= config.SleepInterval {
// config.KeepInterval = config.UploadInterval * 2
// // fmt.Printf("%v\n", config.KeepInterval)
// } else {
// config.KeepInterval = config.SleepInterval * 2
// // fmt.Printf("%v\n", config.KeepInterval)
// }
// }
if config.Dir[len(config.Dir)-1] != '/' {
config.Dir += "/"
}
glog.Infof("Log file will be kept for %v, log file will be uploaded %v after created, log client will run every %v", config.KeepInterval, config.UploadInterval, config.SleepInterval)
fmt.Printf("Log file will be kept for %v, log file will be uploaded %v after created, log client will run every %v\n", config.KeepInterval, config.UploadInterval, config.SleepInterval)
go func() {
for {
client.SendLog(config.Host+config.Port+config.Method, config.Dir, config.UploadInterval, config.KeepInterval)
time.Sleep(config.SleepInterval)
}
}()
app := ripple.NewApplication()
logclientcontroller, err := controller.NewLogClientController("logclientserver", config.Host+config.Port+config.Method, config.Dir)
if err != nil {
glog.Errorf("Log client controller init failed: %v", err)
}
app.RegisterController("logclient", logclientcontroller)
app.AddRoute(ripple.Route{Pattern: "sync", Controller: "logclient", Action: "Sync"})
app.AddRoute(ripple.Route{Pattern: "favicon.ico", Controller: "logclient", Action: "Favicon"})
app.AddRoute(ripple.Route{Pattern: "locallog", Controller: "logclient", Action: "LocalLogFile"})
app.SetBaseUrl("/")
http.HandleFunc("/", app.ServeHTTP)
glog.Infof("Starting log client server at ", config.ListenPort)
http.ListenAndServe(config.ListenPort, nil)
}
func init() {
flag.StringVar(&join, "join", "", "Member of SkyDNS cluster to join can be comma separated list")
flag.BoolVar(&discover, "discover", false, "Auto discover SkyDNS cluster. Performs an NS lookup on the -domain to find SkyDNS members")
flag.StringVar(&domain, "domain", "skydns.local", "Domain to anchor requests to")
flag.StringVar(&ldns, "dns", "127.0.0.1:53", "IP:Port to bind to for DNS")
flag.StringVar(&lhttp, "http", "127.0.0.1:8080", "IP:Port to bind to for HTTP")
flag.StringVar(&dataDir, "data", "./data", "SkyDNS data directory")
flag.DurationVar(&rtimeout, "rtimeout", 2*time.Second, "Read timeout")
flag.DurationVar(&wtimeout, "wtimeout", 2*time.Second, "Write timeout")
flag.BoolVar(&metricsToStdErr, "metricsToStdErr", false, "Write metrics to stderr periodically")
flag.StringVar(&graphiteServer, "graphiteServer", "", "Graphite Server connection string e.g. 127.0.0.1:2003")
flag.StringVar(&stathatUser, "stathatUser", "", "StatHat account for metrics")
flag.StringVar(&secret, "secret", "", "Shared secret for use with http api")
}
func init() {
flag.StringVar(&t.ListenNetwork, "listenNetwork", t.ListenNetwork, "Listen network")
flag.StringVar(&t.ListenAddr, "listenAddr", t.ListenAddr, "Listen address")
flag.StringVar(&t.DialNetwork, "dialNetwork", t.DialNetwork, "Dial network")
flag.StringVar(&t.DialAddr, "dialAddr", t.DialAddr, "Dial address")
flag.DurationVar(&t.DialTimeout, "dialTimeout", t.DialTimeout, "Dial timeout")
flag.DurationVar(&t.RetryTime, "retryTime", t.RetryTime, "Retry wait time")
flag.DurationVar(&t.PipeDeadLine, "pipeDeadLine", t.PipeDeadLine, "Pipe dead line wait time")
flag.IntVar(&t.MaxServerConnections, "maxServer", t.MaxServerConnections, "Max server connections")
flag.IntVar(&t.MaxClinetConnections, "maxClinet", t.MaxClinetConnections, "Max client connections")
flag.IntVar(&t.DebugLevel, "debug", t.DebugLevel, "debug level")
flag.BoolVar(&showVer, "version", showVer, "Show version")
flag.Parse()
}
func main() {
var ConfigPath string
var Port int
var ResponseCode int
var ResponseTime time.Duration
var ResponseBody string
var ResponseHeaders StringSlice
var Methods StringSlice
var IsRegex bool
var UseRequestURI bool
var HyjackPath string
var ProxyHost string
var ProxyPort int
var ProxyDelayTime time.Duration
flag.StringVar(&ConfigPath, "config", "", "json formatted conf file (see README at github.com/sethgrid/fakettp). If this flag is used, no other flags will be recognized.")
flag.IntVar(&Port, "port", 0, "set the port on which to listen")
flag.IntVar(&ResponseCode, "code", 0, "set the http status code with which to respond")
flag.DurationVar(&ResponseTime, "time", time.Millisecond*0, "set the response time, ex: 250ms or 1m5s")
flag.StringVar(&ResponseBody, "body", "", "set the response body")
flag.Var(&ResponseHeaders, "header", "headers, ex: 'Content-Type: application/json'. Multiple -header parameters allowed.")
flag.BoolVar(&IsRegex, "pattern_match", false, "set to true to match route patterns with Go regular expressions")
flag.BoolVar(&UseRequestURI, "request_uri", false, "set to true to match on raw query (including query params)")
flag.Var(&Methods, "method", "used with the -hyjack route to limit hyjacking to the given http verb. Multiple -method parameters allowed.")
flag.StringVar(&HyjackPath, "hyjack", "", "set the route you wish to hijack if using the reverse proxy host and port")
flag.StringVar(&ProxyHost, "proxy_host", "", "the host we will reverse proxy to (include protocol)")
flag.IntVar(&ProxyPort, "proxy_port", 0, "the proxy port")
flag.DurationVar(&ProxyDelayTime, "proxy_delay", time.Millisecond*0, "set the response time for proxied endpoints, ex: 250ms or 1m5s")
flag.Parse()
ConfigData := []byte{}
var err error
if ConfigPath != "" {
ConfigData, err = ioutil.ReadFile(ConfigPath)
if err != nil {
log.Fatalf("%s", string(ConfigData))
}
}
GlobalConfig = populateGlobalConfig(ConfigData, Port, ResponseCode, ResponseTime, ResponseBody, ResponseHeaders, Methods, HyjackPath, ProxyHost, ProxyPort, ProxyDelayTime, IsRegex, UseRequestURI)
log.Printf("starting on port :%d", GlobalConfig.Port)
startFakettp(GlobalConfig.Port)
}
func init() {
flag.StringVar(&options.IP, "ip", dns.DefaultIP, "IP to use")
flag.IntVar(&options.Port, "port", dns.DefaultPort, "Port to bind")
flag.Var(&options.Nameservers, "nameservers", "Nameservers to use")
flag.DurationVar(&options.Timeout, "timeout", dns.DefaultTimeout, "Timeout for external DNS queries")
flag.DurationVar(&options.TTL, "ttl", dns.DefaultTTL, "TTL")
flag.IntVar(&options.CacheSize, "cachesize", dns.DefaultCacheSize, "Cache size to use")
flag.BoolVar(&options.Debug, "debug", false, "Enable debugging")
flag.Parse()
}
func init() {
// step: setup some defaults
options.resources = new(VaultResources)
options.vaultAuthOptions = map[string]string{VaultAuth: "token"}
flag.StringVar(&options.vaultURL, "vault", getEnv("VAULT_ADDR", "https://127.0.0.1:8200"), "url the vault service or VAULT_ADDR")
flag.StringVar(&options.vaultAuthFile, "auth", "", "a configuration file in json or yaml containing authentication arguments")
flag.StringVar(&options.outputDir, "output", getEnv("VAULT_OUTPUT", "/etc/secrets"), "the full path to write resources or VAULT_OUTPUT")
flag.BoolVar(&options.dryRun, "dryrun", false, "perform a dry run, printing the content to screen")
flag.BoolVar(&options.tlsVerify, "tls-skip-verify", false, "whether to check and verify the vault service certificate")
flag.StringVar(&options.vaultCaFile, "ca-cert", "", "the path to the file container the CA used to verify the vault service")
flag.DurationVar(&options.statsInterval, "stats", time.Duration(1)*time.Hour, "the interval to produce statistics on the accessed resources")
flag.DurationVar(&options.execTimeout, "exec-timeout", time.Duration(60)*time.Second, "the timeout applied to commands on the exec option")
flag.Var(options.resources, "cn", "a resource to retrieve and monitor from vault")
}
// Registers Config fields as command line flags. If c is nil, DefaultConfig
// is used.
func RegisterFlags(c *Config) {
if c == nil {
c = DefaultConfig
}
flag.StringVar(&c.DHTRouters, "routers", c.DHTRouters,
"Comma separated addresses of DHT routers used to bootstrap the DHT network.")
flag.IntVar(&c.MaxNodes, "maxNodes", c.MaxNodes,
"Maximum number of nodes to store in the routing table, in memory. This is the primary configuration for how noisy or aggressive this node should be. When the node starts, it will try to reach d.config.MaxNodes/2 as quick as possible, to form a healthy routing table.")
flag.DurationVar(&c.CleanupPeriod, "cleanupPeriod", c.CleanupPeriod,
"How often to ping nodes in the network to see if they are reachable.")
flag.DurationVar(&c.SavePeriod, "savePeriod", c.SavePeriod,
"How often to save the routing table to disk.")
flag.Int64Var(&c.RateLimit, "rateLimit", c.RateLimit,
"Maximum packets per second to be processed. Beyond this limit they are silently dropped. Set to -1 to disable rate limiting.")
}
func init() {
flag.StringVar(&argAPIServerHostPort, "apiserver", "", "Kubernetes apiserver host:port")
flag.StringVar(&argVulcandURLString, "vulcand", "", "Vulcand Admin URL")
flag.DurationVar(&argResyncDuration, "resync", 30*time.Minute, "Resync period")
flag.DurationVar(&argVulcandTimeout, "vulcand-timeout", 10*time.Second, "Vulcand update timeout")
flag.Parse()
if argAPIServerHostPort == "" || argVulcandURLString == "" {
log.Fatal("Missing required properties. Usage: kubernetes-vulcand-router -apiserver '[kubernetes-server]' -vulcand '[vulcand-address]'")
}
// Only log the warning severity or above.
log.SetLevel(log.DebugLevel)
}
func main() {
hostname, _ := os.Hostname()
client := gmetric.ClientFromFlag("ganglia")
value := flag.String("value", "", "Value of the metric")
groups := flag.String("group", "", "Group(s) of the metric (comma-separated)")
metric := &gmetric.Metric{}
flag.StringVar(&metric.Name, "name", "", "Name of the metric")
flag.StringVar(&metric.Title, "title", "", "Title of the metric")
flag.StringVar(&metric.Host, "host", hostname, "Hostname")
flag.StringVar((*string)(&metric.ValueType), "type", "", "Either string|int8|uint8|int16|uint16|int32|uint32|float|double")
flag.StringVar(&metric.Units, "units", "", "Unit of measure for the value e.g. Kilobytes, Celcius")
flag.StringVar((*string)(&metric.Slope), "slope", "both", "Either zero|positive|negative|both")
flag.DurationVar(&metric.TickInterval, "tmax", 60*time.Second, "The maximum time between gmetric calls")
flag.DurationVar(&metric.Lifetime, "dmax", 0, "The lifetime in seconds of this metric")
flag.StringVar(&metric.Description, "desc", "", "Description of the metric")
flag.StringVar(&metric.Spoof, "spoof", "", "IP address and name of host/device (colon separated) we are spoofing")
flag.Parse()
if metric.Name == "" || metric.ValueType == "" || *value == "" {
fmt.Fprintln(os.Stderr, "name, type and value are required")
flag.Usage()
os.Exit(2)
}
if *groups != "" {
metric.Groups = strings.Split(*groups, ",")
}
if err := client.Open(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(2)
}
if err := client.WriteMeta(metric); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(2)
}
if err := client.WriteValue(metric, *value); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(2)
}
if err := client.Close(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(2)
}
}
func init() {
flag.StringVar(&config.Domain, "domain", env("SKYDNS_DOMAIN", "skydns.local."), "domain to anchor requests to (SKYDNS_DOMAIN)")
flag.StringVar(&config.DnsAddr, "addr", env("SKYDNS_ADDR", "127.0.0.1:53"), "ip:port to bind to (SKYDNS_ADDR)")
flag.StringVar(&nameserver, "nameservers", env("SKYDNS_NAMESERVERS", ""), "nameserver address(es) to forward (non-local) queries to e.g. 8.8.8.8:53,8.8.4.4:53")
flag.BoolVar(&config.NoRec, "no-rec", false, "do not provide a recursive service")
flag.StringVar(&machine, "machines", env("ETCD_MACHINES", ""), "machine address(es) running etcd")
flag.StringVar(&config.DNSSEC, "dnssec", "", "basename of DNSSEC key file e.q. Kskydns.local.+005+38250")
flag.StringVar(&config.Local, "local", "", "optional unique value for this skydns instance")
flag.StringVar(&tlskey, "tls-key", env("ETCD_TLSKEY", ""), "TLS Private Key path")
flag.StringVar(&tlspem, "tls-pem", env("ETCD_TLSPEM", ""), "X509 Certificate")
flag.StringVar(&cacert, "ca-cert", env("ETCD_CACERT", ""), "CA Certificate")
flag.DurationVar(&config.ReadTimeout, "rtimeout", 2*time.Second, "read timeout")
flag.BoolVar(&config.RoundRobin, "round-robin", true, "round robin A/AAAA replies")
flag.BoolVar(&discover, "discover", false, "discover new machines by watching /v2/_etcd/machines")
flag.BoolVar(&stub, "stubzones", false, "support stub zones")
flag.BoolVar(&config.Verbose, "verbose", false, "log queries")
flag.BoolVar(&config.Systemd, "systemd", false, "bind to socket(s) activated by systemd (ignore -addr)")
// TTl
// Minttl
flag.StringVar(&config.Hostmaster, "hostmaster", "[email protected].", "hostmaster email address to use")
flag.IntVar(&config.SCache, "scache", server.SCacheCapacity, "capacity of the signature cache")
flag.IntVar(&config.RCache, "rcache", 0, "capacity of the response cache") // default to 0 for now
flag.IntVar(&config.RCacheTtl, "rcache-ttl", server.RCacheTtl, "TTL of the response cache")
flag.StringVar(&msg.PathPrefix, "path-prefix", env("SKYDNS_PATH_PREFIX", "skydns"), "backend(etcd) path prefix, default: skydns")
}
func init() {
flag.StringVar(&config.Domain, "domain",
func() string {
if x := os.Getenv("SKYDNS_DOMAIN"); x != "" {
return x
}
return "skydns.local."
}(), "domain to anchor requests to (SKYDNS_DOMAIN)")
flag.StringVar(&config.DnsAddr, "addr",
func() string {
if x := os.Getenv("SKYDNS_ADDR"); x != "" {
return x
}
return "127.0.0.1:53"
}(), "ip:port to bind to (SKYDNS_ADDR)")
flag.StringVar(&nameserver, "nameserver", "", "nameserver address(es) to forward (non-local) queries to e.g. 8.8.8.8:53,8.8.4.4:53")
flag.StringVar(&machine, "machines", "http://127.0.0.1:4001", "machine address(es) running etcd")
flag.StringVar(&config.DNSSEC, "dnssec", "", "basename of DNSSEC key file e.q. Kskydns.local.+005+38250")
flag.StringVar(&tlskey, "tls-key", "", "TLS Private Key path")
flag.StringVar(&tlspem, "tls-pem", "", "X509 Certificate")
flag.DurationVar(&config.ReadTimeout, "rtimeout", 2*time.Second, "read timeout")
flag.BoolVar(&config.RoundRobin, "round-robin", true, "round robin A/AAAA replies")
// TTl
// Minttl
flag.StringVar(&config.Hostmaster, "hostmaster", "[email protected].", "hostmaster email address to use")
}
func main() {
hostname, err := os.Hostname()
if err != nil {
hostname = "unknown"
}
flag.StringVar(&prefix, "p", fmt.Sprintf("bucky-pickle-relay.%s", hostname),
"Prefix for internally generated metrics.")
flag.StringVar(&bindTo, "b", ":2004",
"Address to bind to for incoming connections.")
flag.BoolVar(&debug, "d", false,
"Debug mode.")
flag.IntVar(&pickleTimeout, "t", 300,
"Timeout in seconds on incoming pickle protocol TCP connections.")
flag.IntVar(&sendTimeout, "s", 30,
"TCP timeout in seconds for outgoing line protocol connections.")
flag.IntVar(&maxPickleSize, "x", 1*1024*1024,
"Maximum pickle size accepted.")
flag.IntVar(&pickleQueueSize, "q", 0,
"Internal buffer sizes.")
flag.DurationVar(&metricInterval, "i", 60,
"Interval in seconds between reporting of internal metrics.")
flag.Parse()
if flag.NArg() != 1 {
usage()
}
log.Printf("bucky-pickle-relay Copyright 2015 42 Lines, Inc.")
carbonRelay = flag.Arg(0)
log.Printf("Sending line protocol data to %s", carbonRelay)
log.Printf("Reporting internal metrics under %s", prefix)
metrics := serveForever()
plainTextOut(metrics)
}
func main() {
// parse command line flags
flag.StringVar(&path, "path", "", "")
flag.StringVar(&port, "port", ":8080", "")
flag.StringVar(&driver, "driver", "sqlite3", "")
flag.StringVar(&datasource, "datasource", "drone.sqlite", "")
flag.StringVar(&sslcert, "sslcert", "", "")
flag.StringVar(&sslkey, "sslkey", "", "")
flag.DurationVar(&timeout, "timeout", 300*time.Minute, "")
flag.Parse()
// validate the TLS arguments
checkTLSFlags()
// setup database and handlers
setupDatabase()
setupStatic()
setupHandlers()
// debug
log.Printf("starting drone version %s on port %s\n", version, port)
// start webserver using HTTPS or HTTP
if sslcert != "" && sslkey != "" {
panic(http.ListenAndServeTLS(port, sslcert, sslkey, nil))
} else {
panic(http.ListenAndServe(port, nil))
}
}
