func main() {
defer Save()
jsonsign.AddFlags()
flag.Parse()
if flag.NArg() == 0 {
usage("No mode given.")
}
mode := flag.Arg(0)
cmd, ok := modeCommand[mode]
if !ok {
usage(fmt.Sprintf("Unknown mode %q", mode))
}
up := makeUploader()
cmdFlags := modeFlags[mode]
err := cmdFlags.Parse(flag.Args()[1:])
if err != nil {
err = ErrUsage
} else {
err = cmd.RunCommand(up, cmdFlags.Args())
}
if ue, isUsage := err.(UsageError); isUsage {
if isUsage {
errf("%s\n", ue)
}
cmd.Usage()
errf("\nGlobal options:\n")
flag.PrintDefaults()
if hasFlags(cmdFlags) {
errf("\nMode-specific options for mode %q:\n", mode)
cmdFlags.PrintDefaults()
}
os.Exit(1)
}
if *flagVerbose {
stats := up.Stats()
log.Printf("Client stats: %s", stats.String())
log.Printf(" #HTTP reqs: %d", up.transport.reqs)
}
if err != nil || wereErrors /* TODO: remove this part */ {
log.Printf("Error: %v", err)
Save()
os.Exit(2)
}
}
func main() {
jsonsign.AddFlags()
flag.Parse()
if *flagSplits {
showSplits()
return
}
nOpts := sumSet(flagFile, flagBlob, flagPermanode, flagInit, flagShare, flagRemove,
flagSetAttr, flagAddAttr)
if !(nOpts == 1 ||
(nOpts == 2 && *flagFile && *flagPermanode)) {
usage("Conflicting mode options.")
}
cc := client.NewOrFail()
if !*flagVerbose {
cc.SetLogger(nil)
}
up := &Uploader{
Client: cc,
entityFetcher: &jsonsign.CachingEntityFetcher{
Fetcher: &jsonsign.FileEntityFetcher{File: cc.SecretRingFile()},
},
}
switch {
case *flagInit:
doInit()
return
case *flagFile || *flagBlob:
var (
permaNode *client.PutResult
lastPut *client.PutResult
err os.Error
)
if n := flag.NArg(); *flagPermanode {
if n != 1 {
log.Fatalf("Options --permanode and --file can only be used together when there's exactly one argument")
}
permaNode, err = up.UploadNewPermanode()
if err != nil {
log.Fatalf("Error uploading permanode: %v", err)
}
}
for n := 0; n < flag.NArg(); n++ {
if *flagBlob {
lastPut, err = up.UploadFileBlob(flag.Arg(n))
handleResult("blob", lastPut, err)
} else {
lastPut, err = up.UploadFile(flag.Arg(n))
handleResult("file", lastPut, err)
}
}
if permaNode != nil {
put, err := up.UploadAndSignMap(schema.NewSetAttributeClaim(permaNode.BlobRef, "camliContent", lastPut.BlobRef.String()))
handleResult("claim-permanode-content", put, err)
if *flagName != "" {
put, err := up.UploadAndSignMap(schema.NewSetAttributeClaim(permaNode.BlobRef, "name", *flagName))
handleResult("claim-permanode-name", put, err)
}
handleResult("permanode", permaNode, nil)
}
case *flagPermanode:
if flag.NArg() > 0 {
log.Fatalf("--permanode doesn't take any additional arguments")
}
pr, err := up.UploadNewPermanode()
handleResult("permanode", pr, err)
if *flagName != "" {
put, err := up.UploadAndSignMap(schema.NewSetAttributeClaim(pr.BlobRef, "name", *flagName))
handleResult("permanode-name", put, err)
}
case *flagShare:
if flag.NArg() != 1 {
log.Fatalf("--share only supports one blobref")
}
br := blobref.Parse(flag.Arg(0))
if br == nil {
log.Fatalf("BlobRef is invalid: %q", flag.Arg(0))
}
pr, err := up.UploadShare(br, *flagTransitive)
handleResult("share", pr, err)
case *flagRemove:
if flag.NArg() == 0 {
log.Fatalf("--remove takes one or more blobrefs")
}
err := up.RemoveBlobs(blobref.ParseMulti(flag.Args()))
if err != nil {
log.Printf("Error removing blobs %s: %s", strings.Join(flag.Args(), ","), err)
wereErrors = true
}
case *flagAddAttr || *flagSetAttr:
if flag.NArg() != 3 {
log.Fatalf("--set-attr and --add-attr take 3 args: <permanode> <attr> <value>")
}
pn := blobref.Parse(flag.Arg(0))
if pn == nil {
log.Fatalf("Error parsing blobref %q", flag.Arg(0))
}
m := schema.NewSetAttributeClaim(pn, flag.Arg(1), flag.Arg(2))
if *flagAddAttr {
m = schema.NewAddAttributeClaim(pn, flag.Arg(1), flag.Arg(2))
}
put, err := up.UploadAndSignMap(m)
handleResult(m["claimType"].(string), put, err)
}
if *flagVerbose {
stats := up.Stats()
log.Printf("Client stats: %s", stats.String())
}
if wereErrors {
os.Exit(2)
}
}