func main() {
flag.Parse()
if email == "" || password == "" {
fmt.Println("Invalid E-Mail or Password\n")
flag.Usage()
os.Exit(-1)
}
if flag.NArg()%2 == 0 {
flag.Usage()
os.Exit(-1)
}
imsi := flag.Arg(0)
tags := make([]map[string]string, (flag.NArg()-1)/2)
idx := 0
for i := 1; i < flag.NArg(); i += 2 {
k := flag.Arg(i)
v := flag.Arg(i + 1)
tag := map[string]string{"tagName": k, "tagValue": v}
tags[idx] = tag
idx++
}
fmt.Println(tags)
c, err := goracom.NewClient(email, password)
errToExit(err)
s := c.NewSubscriber()
sub, err := s.Tags(imsi, tags)
errToExit(err)
printSubscriber(*sub)
}
func main() {
// Scans the arg list and sets up flags
debug := flag.Bool("debug", false, "print debugging messages.")
latencies := flag.Bool("latencies", false, "record operation latencies.")
flag.Parse()
if flag.NArg() < 2 {
fmt.Fprintf(os.Stderr, "usage: %s MOUNTPOINT ZIP-FILE\n", os.Args[0])
os.Exit(2)
}
var fs fuse.NodeFileSystem
fs, err := zipfs.NewArchiveFileSystem(flag.Arg(1))
if err != nil {
fmt.Fprintf(os.Stderr, "NewArchiveFileSystem failed: %v\n", err)
os.Exit(1)
}
state, _, err := fuse.MountNodeFileSystem(flag.Arg(0), fs, nil)
if err != nil {
fmt.Printf("Mount fail: %v\n", err)
os.Exit(1)
}
state.SetRecordStatistics(*latencies)
state.Debug = *debug
state.Loop()
}
func main() {
var acctAlias = flag.String("a", "", "Account alias to use")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s [options] <HW Group UUID>\n", path.Base(os.Args[0]))
flag.PrintDefaults()
}
flag.Parse()
if flag.NArg() != 1 {
flag.Usage()
os.Exit(1)
}
client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
if err != nil {
exit.Fatal(err.Error())
} else if err := client.Logon("", ""); err != nil {
exit.Fatalf("Login failed: %s", err)
}
reqId, err := client.ArchiveHardwareGroup(flag.Arg(0), *acctAlias)
if err != nil {
exit.Fatalf("Failed to archive Hardware Group %s: %s", flag.Arg(0), err)
}
fmt.Println("Request ID for group archival:", reqId)
}
func main() {
flag.Parse()
if email == "" || password == "" {
fmt.Println("Invalid E-Mail or Password\n")
flag.Usage()
os.Exit(-1)
}
if flag.NArg() != 2 {
flag.Usage()
os.Exit(-1)
}
imsi := flag.Arg(0)
speed := flag.Arg(1)
c, err := goracom.NewClient(email, password)
errToExit(err)
s := c.NewSubscriber()
if sub, err := s.UpdateSpeedClass(imsi, speed); err == nil {
printSubscriber(*sub)
} else {
errToExit(err)
}
}
func main() {
flag.Parse()
root := flag.Arg(0)
bucket = flag.Arg(1)
conf = flag.Arg(2)
filepath.Walk(root, walkpath)
}
func main() {
var versionFlg bool
flag.BoolVar(&versionFlg, "v", false, "show version")
flag.Parse()
if versionFlg {
fmt.Println("openstack-ssh version:", Version)
return
}
if flag.Arg(0) == "" {
panic("please input username")
}
config, err := app.LoadConfig()
if err != nil {
app.ERR(err)
panic(err)
}
key, err := app.FetchPublicKey(flag.Arg(0), config)
if err != nil {
app.ERR(err)
panic(err)
}
fmt.Println(key.PublicKey)
}
func Project() (err error) {
path, err := os.Getwd()
if err != nil {
err = &FileError{
errors.Wrapf(err, "cmd: Failed to get working directory"),
}
return
}
proj := &project.Project{
Root: path,
}
err = proj.Init()
if err != nil {
return
}
cmd := flag.Arg(1)
switch cmd {
case "init":
err = proj.InitProject()
case "build":
err = proj.Build(flag.Arg(2))
case "repo":
err = proj.Repo(flag.Arg(2))
default:
err = &UnknownCommand{
errors.Newf("cmd: Unknown cmd '%s'", cmd),
}
}
return
}
func main() {
flag.Parse()
if email == "" || password == "" {
fmt.Println("Invalid E-Mail or Password\n")
flag.Usage()
os.Exit(-1)
}
if flag.NArg() != 2 {
flag.Usage()
os.Exit(-1)
}
imsi := flag.Arg(0)
tm, err := strconv.ParseInt(flag.Arg(1), 10, 64)
if err != nil {
fmt.Printf("%s\n\n", err.Error())
flag.Usage()
os.Exit(-1)
}
c, err := goracom.NewClient(email, password)
errToExit(err)
s := c.NewSubscriber()
if tm == 0 {
sub, err := s.UnsetExpiryTime(imsi)
errToExit(err)
printSubscriber(*sub)
} else {
sub, err := s.SetExpiryTime(imsi, tm)
errToExit(err)
printSubscriber(*sub)
}
}
func main() {
var pubFile, privFile string
var help, listen, stayOpen bool
flag.BoolVar(&help, "h", false, "display a short usage message")
flag.BoolVar(&stayOpen, "k", false, "keep listening after client disconnects")
flag.BoolVar(&listen, "l", false, "listen for incoming connections")
flag.StringVar(&privFile, "s", "", "path to signature key")
flag.StringVar(&pubFile, "v", "", "path to verification key")
flag.Parse()
if help {
usage()
os.Exit(1)
}
loadID(privFile, pubFile)
defer func() {
if idPriv != nil {
zero(idPriv[:], 0)
}
}()
if listen {
if flag.NArg() != 1 {
fmt.Println("A port is required (and should be the only argument) when listening.")
}
listener(stayOpen, flag.Arg(0))
return
}
if flag.NArg() != 2 {
fmt.Println("An address and port are required (and should be the only arguments).")
}
sender(flag.Arg(0) + ":" + flag.Arg(1))
}
func main() {
start := time.Now()
flag.Parse()
if *version {
fmt.Printf("inspectFile %d.%d.%d\n", Version[0], Version[1], Version[2])
return
}
if *flserve != "" {
fmt.Printf("Startinf server at %s. Use CTRL+C to quit.\n", *flserve)
listen(*flserve)
return
}
if *fltools != "" {
initTools(*fltools)
}
if *dir {
if flag.NArg() != 1 {
fmt.Println("You must pass a directory name!!!")
return
}
inspectdir(flag.Arg(0))
} else if flag.NArg() != 1 {
fmt.Println("You must pass a file name in parameter!!!")
return
} else {
output = inspectfile(flag.Arg(0), nil)
}
//output = inspectsfile("/media/sf_Temp/Benchmark.pptx", output)
fmt.Printf("Output: %s \n", output)
fmt.Printf("ToolsVersion: %s\n", ExportToolsVersion())
fmt.Printf("Took %v to run.\n", time.Since(start))
}
func main() {
var acctAlias = flag.String("a", "", "Account alias to use")
var snapName = flag.String("s", "", "The name of the Snapshot to delete")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s [options] <server-name>\n", path.Base(os.Args[0]))
flag.PrintDefaults()
}
flag.Parse()
if flag.NArg() != 1 || *snapName == "" {
flag.Usage()
os.Exit(1)
}
client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
if err != nil {
exit.Fatal(err.Error())
} else if err := client.Logon("", ""); err != nil {
exit.Fatalf("Login failed: %s", err)
}
err = client.DeleteSnapshot(*snapName, flag.Arg(0), *acctAlias)
if err != nil {
exit.Fatalf("Failed to delete snapshot on %s: %s", flag.Arg(0), err)
}
fmt.Printf("Successfully deleted snapshot %q from %s.\n", *snapName, flag.Arg(0))
}
func main() {
log.Trace("-m-", "Opening input file")
// Parse debug flags
flag.BoolVar(&log.LOG_TOKENS, "log-tokens", false, "Enable list of parsed tokens")
flag.BoolVar(&log.LOG_TRACE, "log-trace", false, "Enable trace logging of debug output")
flag.BoolVar(&log.EXTENSIONS, "extensions", false, "Enables parser extensions for additional features. See README for a list of these.")
flag.Parse()
// Init builtin functions
ast.InitBuiltins()
// Parse command line arguments
var file *os.File
var err error
if flag.NArg() == 0 {
log.Trace("-m-", "Reading from stdin")
file = os.Stdin
} else if flag.NArg() == 1 {
log.Trace("-m-", "Reading from file "+flag.Arg(0))
file, err = os.Open(flag.Arg(0))
} else {
panic("Must provide filename to read from or no filename at all")
}
if err != nil {
panic("File name provided does not exist")
}
log.Trace("-m-", "Beginning lex")
yyParse(NewLexer(file))
}
func main() {
flag.Parse()
if flag.NArg() != 2 {
topic = "many"
payload = proto.BytesPayload([]byte("hello"))
} else {
topic = flag.Arg(0)
payload = proto.BytesPayload([]byte(flag.Arg(1)))
}
if *conns == 0 {
*conns = -1
}
i := 0
for {
go client(i)
i++
*conns--
if *conns == 0 {
break
}
time.Sleep(time.Duration(*wait) * time.Millisecond)
}
// sleep forever
<-make(chan struct{})
}
// getFileHandles uses our arguments to set up our input and output files
func getFileHandles() (in, out *os.File, err error) {
// Input file should be our only command line argument
if len(flag.Args()) != 1 {
err = fmt.Errorf("Must have exactly one argument (input filename). Received: %v",
flag.Args())
return
}
in, err = os.Open(flag.Arg(0))
if err != nil {
err = fmt.Errorf("Error: Unable to open input file %v: %v", flag.Arg(0),
err)
return
}
// Output file
out = os.Stdout
if *output != "-" {
out, err = os.Create(*output)
if err != nil {
err = fmt.Errorf("Error: Unable to open output file %v: %v", *output,
err)
return
}
}
return
}
func main() {
search := flag.String("s", "", "search issues")
create := flag.Bool("C", false, "create issue")
comment := flag.Bool("c", false, "show comments")
flag.Usage = func() {
fmt.Fprint(os.Stderr, "Usage: goissue [-c ID | -s WORD]\n")
flag.PrintDefaults()
}
flag.Parse()
if flag.NArg() > 1 {
flag.Usage()
os.Exit(1)
}
config := getConfig()
auth := authLogin(config)
if *create {
createIssue(auth)
} else if len(*search) > 0 {
searchIssues(auth, *search)
} else if flag.NArg() == 0 {
showIssues(auth)
} else {
for i := 0; i < flag.NArg(); i++ {
showIssue(auth, flag.Arg(i))
if *comment {
showComments(auth, flag.Arg(i))
}
}
}
}
func main() {
flag.Parse()
c := client.NewHTTPClient(*address)
if err := c.WaitUntilReady(*waitDuration); err != nil {
log.Fatal(err)
}
serviceMethod, params := flag.Arg(0), json.RawMessage(flag.Arg(1))
if *legacyCall {
var resp json.RawMessage
if err := c.Call(serviceMethod, ¶ms, &resp); err != nil {
log.Fatal(err)
}
fmt.Println(string(resp))
} else {
rd := c.Stream(serviceMethod, ¶ms)
defer rd.Close()
for {
var resp json.RawMessage
if err := rd.NextResult(&resp); err == io.EOF {
break
} else if err != nil {
log.Fatal(err)
}
fmt.Println(string(resp))
}
}
}
func main() {
flag.Parse()
n, err := strconv.Atoi(flag.Arg(0))
if err != nil {
fmt.Printf("unknown number")
return
}
c, err := strconv.Atoi(flag.Arg(1))
if err != nil {
fmt.Printf("unknown concurrent")
return
}
ch_end := make(chan int, 100)
for i := 0; i < c; i++ {
go goroutine_gosched(n, ch_end)
}
for i := 0; i < c; i++ {
<-ch_end
}
return
}
func main() {
var acctAlias = flag.String("a", "", "Account alias to use")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s [options] <server-name>\n", path.Base(os.Args[0]))
flag.PrintDefaults()
}
flag.Parse()
if flag.NArg() != 1 {
flag.Usage()
os.Exit(1)
}
client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
if err != nil {
exit.Fatal(err.Error())
} else if err := client.Logon("", ""); err != nil {
exit.Fatalf("Login failed: %s", err)
}
credentials, err := client.GetServerCredentials(flag.Arg(0), *acctAlias)
if err != nil {
exit.Fatalf("Failed to obtain the credentials of server %q: %s", flag.Arg(0), err)
}
fmt.Printf("Credentials for %s:\n", flag.Arg(0))
fmt.Printf("User: %s\n", credentials.Username)
fmt.Printf("Password: '******'\n", credentials.Password)
}
func main() {
flag.Parse()
if flag.NArg() != 1 && flag.NArg() != 2 {
flag.Usage()
fmt.Fprintf(os.Stderr, "Usage: %s <remote> [<local>]\n", os.Args[0])
os.Exit(2)
}
handler := ext.FatalHandler(log15.CallerFileHandler(log15.StderrHandler))
if flagVeryVerbose {
handler = log15.LvlFilterHandler(log15.LvlDebug, handler)
} else if flagVerbose {
handler = log15.LvlFilterHandler(log15.LvlInfo, handler)
}
log15.Root().SetHandler(handler)
local := "."
if flag.NArg() == 2 {
local = flag.Arg(1)
}
m := sftpsync.SyncManager{
Local: local,
Remote: flag.Arg(0),
SkipFiles: skipFiles,
SkipDirs: skipDirs,
Append: flagAppend,
DryRun: flagDryRun,
}
err := m.Run()
if err != nil {
log.Crit("run error", "err", err)
return
}
}
func main() {
flag.Usage = usage
flag.Parse()
if flag.NArg() != 2 {
flag.Usage()
os.Exit(1)
}
serverAddr := flag.Arg(0)
recordFilename := flag.Arg(1)
recordInput, err := os.Open(recordFilename)
if err != nil {
log.Fatalf("Failed to open record file %q: %v", recordFilename, err)
}
defer recordInput.Close()
conn, err := net.Dial("tcp", serverAddr)
if err != nil {
log.Fatalf("Failed to connect to server %q: %v", serverAddr, err)
}
defer conn.Close()
replayer := record.NewReaderReplayer(recordInput, conn)
// Discard everything the server sends us.
go readAndDiscard(conn)
replayer.Replay()
}
func main() {
flag.Parse()
if flag.NArg() < 1 {
usage()
}
id := ""
if *iflag {
id = "__initdata"
}
fmt.Printf("/* automatically generated by bin2hex */\n")
fmt.Printf("static unsigned char %s[] %s =\n{\n\t", flag.Arg(0), id)
i := uint64(0)
for {
var b [8192]byte
n, err := os.Stdin.Read(b[:])
for j := 0; j < n; j++ {
c := b[j]
if i != 0 && i%10 == 0 {
fmt.Printf("\n\t")
}
i++
fmt.Printf("%#02x,", c)
}
if err != nil {
break
}
}
fmt.Printf("\n};\nstatic int %sLen = %d;\n", flag.Arg(0), i)
}
func main() {
flag.Usage = func() {
fmt.Fprintln(os.Stderr, usageMessage)
os.Exit(2)
}
flag.Parse()
// Usage information when no arguments.
if flag.NArg() != 2 {
flag.Usage()
}
programBinary = flag.Arg(0)
traceFile = flag.Arg(1)
ln, err := net.Listen("tcp", *httpFlag)
if err != nil {
dief("failed to create server socket: %v\n", err)
}
// Open browser.
if !startBrowser("http://" + ln.Addr().String()) {
fmt.Fprintf(os.Stderr, "Trace viewer is listening on http://%s\n", ln.Addr().String())
}
// Parse and symbolize trace asynchronously while browser opens.
go parseEvents()
// Start http server.
http.HandleFunc("/", httpMain)
err = http.Serve(ln, nil)
dief("failed to start http server: %v\n", err)
}
// TODO(rh): tame copy/paste code from cammount
func main() {
client.AddFlags()
flag.Parse()
cacheDir, err := ioutil.TempDir("", "camlicache")
if err != nil {
log.Fatalf("Error creating temp cache directory: %v", err)
}
defer os.RemoveAll(cacheDir)
diskcache, err := localdisk.New(cacheDir)
if err != nil {
log.Fatalf("Error setting up local disk cache: %v", err)
}
if flag.NArg() != 1 {
log.Fatal("usage: camwebdav <blobref>")
}
br := blobref.Parse(flag.Arg(0))
if br == nil {
log.Fatalf("%s was not a valid blobref.", flag.Arg(0))
}
client := client.NewOrFail()
fetcher := cacher.NewCachingFetcher(diskcache, client)
f = fs.NewCamliFileSystem(fetcher, br)
http.HandleFunc("/", webdav)
err = http.ListenAndServe(*davaddr, nil)
if err != nil {
log.Fatalf("Error starting WebDAV server: %v", err)
}
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage: %s <command> [command-opts]\n", os.Args[0])
fmt.Fprintln(os.Stderr, "Commands:")
for cmd, _ := range Commands {
fmt.Fprintf(os.Stderr, " %s\n", cmd)
}
}
flag.Parse()
if flag.NArg() < 1 {
flag.Usage()
os.Exit(1)
}
subcommand := flag.Arg(0)
if cmd, in := Commands[subcommand]; in {
flags := flag.NewFlagSet(Cmd_Repo, flag.ExitOnError)
cmd(os.Args[1:], flags)
os.Exit(0)
}
fmt.Fprintf(os.Stderr, "Subcommand not recognized: %s\n", flag.Arg(0))
flag.Usage()
os.Exit(1)
}
func main() {
// Get the name of the file.
flag.Parse()
fmt.Fprintf(os.Stdout, "Filename: %s\n", flag.Arg(0))
// Slurp the file into a string.
file, err := ioutil.ReadFile(flag.Arg(0))
if err != nil {
fmt.Fprintf(os.Stdout, "Error reading the file: %s", err.String())
os.Exit(1)
}
// Create the MD5 hash.
digest1 := md5.New()
_, err = digest1.Write(file)
if err != nil {
fmt.Fprintf(os.Stdout, "Error creating the first hash: %s\n", err.String())
os.Exit(1)
}
fmt.Fprintf(os.Stdout, "MD5: %x\n", digest1.Sum())
// Create the SHA-1 hash.
digest2 := sha1.New()
_, err = digest2.Write(file)
if err != nil {
fmt.Fprintf(os.Stdout, "Error creating the first hash: %s\n", err.String())
os.Exit(1)
}
fmt.Fprintf(os.Stdout, "SHA-1: %x\n", digest2.Sum())
}
func InitFindConfByFlag() gfind.FindConf {
var conf gfind.FindConf
if flag.Arg(0) != "" {
fmt.Println(flag.Arg(0))
conf.Dir = flag.Arg(0)
} else {
conf.Dir = *dir
}
conf.Stat = new(syscall.Stat_t)
conf.Maxdepth = *fmaxdepth
conf.Ctime = *fctime
conf.Cmin = *fcmin
conf.Mtime = *fmtime
conf.Mmin = *fmmin
conf.Atime = *fatime
conf.Amin = *famin
conf.ParseCMTime()
conf.RevTime = *frevtime
conf.Ftype = *fftype
conf.Name = *fname
conf.Ext = *fext
conf.Rootdir = *root
conf.SetRootdir()
if *frsynctemp {
conf.RsyncTemp = 1
}
conf.FlatSize = *fsize
conf.ParseSize()
return conf
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
var opt optionSet
flag.BoolVar(&opt.v, "V", false, "show version.")
flag.BoolVar(&opt.g, "g", false, "enable grep.")
flag.BoolVar(&opt.search_binary, "search-binary", false, "search binary files for matches on grep enable.")
flag.BoolVar(&opt.grep_only, "grep-only", false, "enable grep and disable file search.")
flag.StringVar(&opt.ignore, "ignore", "", "pattern is ignored.")
flag.BoolVar(&opt.hidden, "hidden", false, "search hidden files.")
flag.BoolVar(&opt.ignorecase, "ignorecase", false, "ignore case distinctions in pattern.")
flag.Parse()
if opt.v {
fmt.Printf("version: %s\n", version)
os.Exit(0)
}
if flag.NArg() < 1 {
usage()
}
pattern := flag.Arg(0)
fpath := "."
if flag.NArg() >= 2 {
fpath = strings.TrimRight(flag.Arg(1), separator)
}
g := newGorep(pattern, &opt)
chans := g.kick(fpath)
g.report(chans, verifyColor())
}
func main() {
flag.Parse()
imagick.Initialize()
defer imagick.Terminate()
mw := imagick.NewMagickWand()
defer mw.Destroy()
var err error
if flag.NArg() < 1 {
fmt.Println("Usage: imagick_profiles <imgfile> [<proftype>]\n")
os.Exit(1)
}
basename := flag.Arg(0)
err = mw.ReadImage(basename)
if err != nil {
fmt.Println("ReadImage Error:", err)
os.Exit(1)
}
if flag.NArg() == 1 {
profs := mw.GetImageProfiles("*")
fmt.Println(profs)
} else {
proftype := flag.Arg(1)
prof := mw.GetImageProfile(proftype)
fmt.Print(prof)
}
}
func main() {
flag.BoolVar(&fake, "n", false, "If true, don't actually do anything")
flag.BoolVar(&verbose, "v", false, "Provide verbose output")
flag.Var(&ignorePrefixes, "ignore", "Package prefix to ignore. Can be given multiple times.")
flag.Parse()
gopaths := filepath.SplitList(os.Getenv("GOPATH"))
if len(gopaths) == 0 {
log.Fatal("GOPATH must be set")
}
pkgName := flag.Arg(0)
if pkgName == "" {
log.Fatal("need a package name")
}
dest := flag.Arg(1)
if dest == "" {
log.Fatal("need a destination path")
}
ignorePrefixes = append(ignorePrefixes, pkgName)
ignorePrefixes = append(ignorePrefixes, dest)
rewrites = make(map[string]string)
visited = make(map[string]bool)
err := vendorize(pkgName, chooseGOPATH(gopaths, dest), dest)
if err != nil {
log.Fatal(err)
}
}
func main() {
log.SetFlags(0)
log.SetPrefix("power64map: ")
flag.Usage = usage
flag.Parse()
if flag.NArg() != 1 {
usage()
}
inputFile = flag.Arg(0)
var print func(*Prog)
switch *format {
default:
log.Fatalf("unknown output format %q", *format)
case "text":
print = printText
case "decoder":
print = printDecoder
}
p, err := readCSV(flag.Arg(0))
log.Printf("Parsed %d instruction forms.", len(p.Insts))
if err != nil {
log.Fatal(err)
}
print(p)
}