func main() {
interval := flag.IntP("interval", "i", 60, "update interval in seconds")
ttl := flag.IntP("ttl", "t", 0, "heartbeat ttl in seconds")
eaddr := flag.StringP("etcd", "e", "http://localhost:4001", "address of etcd machine")
id := flag.StringP("id", "d", "", "hypervisor id")
logLevel := flag.StringP("log-level", "l", "info", "log level")
flag.Parse()
if err := logx.DefaultSetup(*logLevel); err != nil {
log.WithFields(log.Fields{
"error": err,
"func": "logx.DefaultSetup",
"level": logLevel,
}).Fatal("failed to set up logging")
}
if *ttl == 0 {
*ttl = 2 * (*interval)
}
e := etcd.NewClient([]string{*eaddr})
c := lochness.NewContext(e)
hn, err := lochness.SetHypervisorID(*id)
if err != nil {
log.WithFields(log.Fields{
"error": err,
"func": "lochness.SetHypervisorID",
"id": id,
}).Fatal("failed to set hypervisor id")
}
hv, err := c.Hypervisor(hn)
if err != nil {
log.WithFields(log.Fields{
"error": err,
"func": "context.Hypervisor",
"id": hn,
}).Fatal("failed to instantiate hypervisor")
}
for {
if err = hv.UpdateResources(); err != nil {
log.WithFields(log.Fields{
"error": err,
"func": "hv.UpdateResources",
}).Fatal("failed to update hypervisor resources")
}
if err = hv.Heartbeat(time.Duration(*ttl)); err != nil {
log.WithFields(log.Fields{
"error": err,
"func": "hv.Heartbeat",
"ttl": *ttl,
}).Fatal("failed to beat heart")
}
time.Sleep(time.Duration(*interval) * time.Second)
}
}
func main() {
dir, _ := os.Getwd()
port := flag.IntP("port", "p", 8080, "help message for flagname")
flag.Parse()
if flag.NArg() > 1 {
flag.Usage()
os.Exit(1)
} else if flag.NArg() == 1 {
dir = flag.Args()[0]
}
bindTo := fmt.Sprintf(":%d", *port)
fmt.Printf("Serving '%s' on %s...\n", dir, bindTo)
panic(http.ListenAndServe(bindTo, http.FileServer(http.Dir(dir))))
}
func main() {
// Basic user configuration variables
force := pflag.BoolP("force", "f", false, "Force output to terminal.")
count := pflag.StringP("count", "n", "+Inf", "Number of random bytes to generate.")
procs := pflag.IntP("procs", "p", runtime.NumCPU(), "Maximum number of concurrent workers.")
pflag.Parse()
if !(*force) && terminal.IsTerminal(int(os.Stdout.Fd())) {
fmt.Fprintf(os.Stderr, "Random data not written to terminal.\n\n")
pflag.Usage()
os.Exit(1)
}
cnt, err := strconv.ParsePrefix(*count, strconv.AutoParse)
if err != nil || math.IsNaN(cnt) {
fmt.Fprintf(os.Stderr, "Number of bytes to generate is invalid.\n\n")
pflag.Usage()
os.Exit(1)
}
if (*procs) < 1 {
fmt.Fprintf(os.Stderr, "Number of workers must be positive.\n\n")
pflag.Usage()
os.Exit(1)
}
runtime.GOMAXPROCS(*procs)
rand.SetNumRoutines(*procs)
// Copy random data to stdout
if int64(cnt) < 0 || math.IsInf(cnt, 0) {
_, err = io.Copy(os.Stdout, rand.Reader)
} else {
_, err = io.CopyN(os.Stdout, rand.Reader, int64(cnt))
}
if perr, ok := err.(*os.PathError); ok && perr.Err == syscall.EPIPE {
err = nil // Expected error is for the sink to close the pipe
} else if err != nil {
panic(err)
}
}
func main() {
var (
// general options
stateDir = pflag.String("statedir", "", "the server state directory")
help = pflag.BoolP("help", "h", false, "show this help")
// server options
server = pflag.BoolP("server", "s", false, "run the server in the foreground")
port = pflag.IntP("port", "p", 40000, "server port to listen on")
// client options
method = pflag.StringP("method", "X", "GET", "client method")
plugin = pflag.String("plugin", "", "client plugin")
data = pflag.StringP("data", "d", "", "client body")
headers = &repString{[]string{}}
verbose = pflag.BoolP("verbose", "v", false, "show full http response")
)
pflag.VarP(headers, "header", "H", "client request header")
pflag.Parse()
if *help {
os.Exit(runHelp())
}
if *server {
os.Exit(runServer(*port, *stateDir))
}
if pflag.NArg() < 1 {
fmt.Fprintln(os.Stderr, "must pass in path to make api call")
runHelp()
os.Exit(1)
}
os.Exit(runClient(*stateDir, *plugin, *method, pflag.Arg(0), *data, headers.strs, *verbose))
}
User twuser
Text string
Time string `json:"created_at"`
}
type twmeta struct {
RefreshUrl string `json:"refresh_url"`
}
type twitresp struct {
Statuses []twstatus
Meta twmeta `json:"search_metadata"`
}
const twSearchBase = "https://api.twitter.com/1.1/search/tweets.json"
var resnum = flag.IntP("number", "n", 20, "number of items to return")
var reverse = flag.BoolP("reverse", "r", false, "reverse order")
var retweets = flag.BoolP("retweets", "R", false, "include retweeets")
var follow = flag.BoolP("follow", "f", false, "follow mode")
var followDelay = flag.DurationP("followdelay", "F", time.Minute, "refresh delay in follow mode")
var fixes = strings.NewReplacer(
"\n", ` \n `, // spaces to make c&p easier
"‘", `'`,
"’", `'`,
"“", `"`,
"”", `"`,
"—", "-",
"&", "&",
"<", "<",
">", ">",
"log"
"os"
"os/exec"
"os/user"
"time"
"github.com/Unknwon/goconfig"
"github.com/howeyc/gopass"
"github.com/ogier/pflag"
)
// CLI flags
var _host = pflag.StringP("host", "h", "some.hostname.com", "The DRAC host (or IP)")
var _username = pflag.StringP("username", "u", "", "The DRAC username")
var _password = pflag.BoolP("password", "p", false, "Prompt for password (optional, will use 'calvin' if not present)")
var _version = pflag.IntP("version", "v", -1, "iDRAC version (6 or 7) (supermicro ikvm as 1)")
var _delay = pflag.IntP("delay", "d", 10, "Number of seconds to delay for javaws to start up & read jnlp before deleting it")
var _javaws = pflag.StringP("javaws", "j", DefaultJavaPath, "The path to javaws binary")
func promptPassword() string {
fmt.Print("Password: "******"root"
var password = "******"
// Parse the CLI flags
pflag.Parse()
`
Version = `
base64 (Go coreutils) 0.1
Copyright (C) 2015 Robert Deusser
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
`
)
var (
decode = flag.BoolP("decode", "d", false, "")
ignore = flag.BoolP("ignore-garbage", "i", false, "")
wrap = flag.IntP("wrap", "w", 76, "")
version = flag.BoolP("version", "v", false, "")
)
func base64Encode(src []byte) []byte {
return []byte(base64.StdEncoding.EncodeToString(src))
}
func base64Decode(src []byte) ([]byte, error) {
return base64.StdEncoding.DecodeString(string(src))
}
func readData(reader io.Reader) ([]byte, error) {
return ioutil.ReadAll(reader)
}
* reversing non-hexdump formats require -r<flag> (i.e. -rb, -ri, -rp).
-s, --seek start at <seek> bytes/bits in file. Byte/bit postfixes can be used.
* byte/bit postfix units are multiples of 1024.
* bits (kb, mb, etc.) will be rounded down to nearest byte.
-u, --uppercase use upper case hex letters.
-v, --version show version.`
Version = `xxd v2.0 2014-17-01 by Felix Geisendörfer and Eric Lagergren`
)
// cli flags
var (
autoskip = flag.BoolP("autoskip", "a", false, "toggle autoskip (* replaces nul lines")
bars = flag.BoolP("bars", "B", false, "print |ascii| instead of ascii")
binary = flag.BoolP("binary", "b", false, "binary dump, incompatible with -ps, -i, -r")
columns = flag.IntP("cols", "c", -1, "format <cols> octets per line")
ebcdic = flag.BoolP("ebcdic", "E", false, "use EBCDIC instead of ASCII")
group = flag.IntP("group", "g", -1, "num of octets per group")
cfmt = flag.BoolP("include", "i", false, "output in C include format")
length = flag.Int64P("len", "l", -1, "stop after len octets")
postscript = flag.BoolP("ps", "p", false, "output in postscript plain hd style")
reverse = flag.BoolP("reverse", "r", false, "convert hex to binary")
offset = flag.Int("off", 0, "revert with offset")
seek = flag.StringP("seek", "s", "", "start at seek bytes abs")
upper = flag.BoolP("uppercase", "u", false, "use uppercase hex letters")
version = flag.BoolP("version", "v", false, "print version")
)
// constants used in xxd()
const (
ebcdicOffset = 0x40
"os"
"strconv"
"unicode/utf8"
flag "github.com/ogier/pflag"
)
const programVersion = "0.0.1"
var (
ignore = flag.BoolP("ignore", "i", false, "ignore invalid numbers")
behead = flag.BoolP("behead", "b", false,
"remove the first line (head) from calculations. Useful to ignore column names")
separator = flag.StringP("separator", "s", " ",
"define the SEPARATOR to use instead of whitespace for column separator")
column = flag.IntP("column", "c", 1, "calculate stats based on the specified COLUMN")
version = flag.BoolP("version", "v", false, "print version information and exit")
)
func fail(format string, v ...interface{}) {
fmt.Fprintf(os.Stderr, format, v...)
os.Exit(1)
}
func calculate(s *Stats) {
if len(flag.Args()) == 0 {
parse("<stdin>", os.Stdin, s)
}
for _, filename := range flag.Args() {
if filename == "-" {
// Content-Type when serving pastes
contentType = "text/plain; charset=utf-8"
// Report usage stats how often
reportInterval = 1 * time.Minute
// HTTP response strings
invalidID = "invalid paste id"
unknownAction = "unsupported action"
)
var (
siteURL = pflag.StringP("url", "u", "http://localhost:8080", "URL of the site")
listen = pflag.StringP("listen", "l", ":8080", "Host and port to listen to")
lifeTime = pflag.DurationP("lifetime", "t", 24*time.Hour, "Lifetime of the pastes")
timeout = pflag.DurationP("timeout", "T", 5*time.Second, "Timeout of HTTP requests")
maxNumber = pflag.IntP("max-number", "m", 0, "Maximum number of pastes to store at once")
maxSize = 1 * bytesize.MB
maxStorage = 1 * bytesize.GB
)
func init() {
pflag.VarP(&maxSize, "max-size", "s", "Maximum size of pastes")
pflag.VarP(&maxStorage, "max-storage", "M", "Maximum storage size to use at once")
}
func getContentFromForm(r *http.Request) ([]byte, error) {
if value := r.FormValue(fieldName); len(value) > 0 {
return []byte(value), nil
}
if f, _, err := r.FormFile(fieldName); err == nil {
