func (ph *PublishHandler) bootstrapPermanode(jsonSign *JSONSignHandler) (err os.Error) {
if pn, err := ph.Search.Index().PermanodeOfSignerAttrValue(ph.Search.Owner(), "camliRoot", ph.RootName); err == nil {
log.Printf("Publish root %q using existing permanode %s", ph.RootName, pn)
return nil
}
log.Printf("Publish root %q needs a permanode + claim", ph.RootName)
defer func() {
if perr := recover(); perr != nil {
err = perr.(os.Error)
}
}()
signUpload := func(name string, m map[string]interface{}) *blobref.BlobRef {
signed, err := jsonSign.SignMap(m)
if err != nil {
panic(fmt.Errorf("error signing %s: %v", name, err))
}
uh := client.NewUploadHandleFromString(signed)
_, err = ph.Storage.ReceiveBlob(uh.BlobRef, uh.Contents)
if err != nil {
panic(fmt.Errorf("error uploading %s: %v", name, err))
}
return uh.BlobRef
}
pn := signUpload("permanode", schema.NewUnsignedPermanode())
signUpload("set-attr camliRoot", schema.NewSetAttributeClaim(pn, "camliRoot", ph.RootName))
signUpload("set-attr title", schema.NewSetAttributeClaim(pn, "title", "Publish root node for "+ph.RootName))
return nil
}
func (up *Uploader) UploadAndSignMap(m map[string]interface{}) (*client.PutResult, os.Error) {
signed, err := up.SignMap(m)
if err != nil {
return nil, err
}
return up.Upload(client.NewUploadHandleFromString(signed))
}
func (up *Uploader) UploadShare(target *blobref.BlobRef, transitive bool) (*client.PutResult, os.Error) {
unsigned := schema.NewShareRef(schema.ShareHaveRef, target, transitive)
signed, err := up.SignMap(unsigned)
if err != nil {
return nil, err
}
return up.Upload(client.NewUploadHandleFromString(signed))
}
func (up *Uploader) UploadNewPermanode() (*client.PutResult, os.Error) {
unsigned := schema.NewUnsignedPermanode()
signed, err := up.SignMap(unsigned)
if err != nil {
return nil, err
}
return up.Upload(client.NewUploadHandleFromString(signed))
}
func (up *Uploader) UploadMap(m map[string]interface{}) (*client.PutResult, os.Error) {
json, err := schema.MapToCamliJson(m)
if err != nil {
return nil, err
}
if *flagVerbose {
fmt.Printf("json: %s\n", json)
}
return up.Upload(client.NewUploadHandleFromString(json))
}
func (up *Uploader) uploadString(s string) (*client.PutResult, os.Error) {
uh := client.NewUploadHandleFromString(s)
if c := up.haveCache; c != nil && c.BlobExists(uh.BlobRef) {
cachelog.Printf("HaveCache HIT for %s / %d", uh.BlobRef, uh.Size)
return &client.PutResult{BlobRef: uh.BlobRef, Size: uh.Size, Skipped: true}, nil
}
pr, err := up.Upload(uh)
if err == nil && up.haveCache != nil {
up.haveCache.NoteBlobExists(uh.BlobRef)
}
if pr == nil && err == nil {
log.Fatalf("Got nil/nil in uploadString while uploading %s", s)
}
return pr, err
}