// NewObject creates a new permanode and returns its Object wrapper.
func (h *Host) NewObject() (*Object, error) {
pn, err := h.upload(schema.NewUnsignedPermanode())
if err != nil {
return nil, err
}
// No need to do a describe query against it: we know it's
// empty (has no claims against it yet).
return &Object{h: h, pn: pn}, nil
}
func (ph *PublishHandler) bootstrapPermanode(jsonSign *JSONSignHandler) (err 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)
pn, err := ph.signUpload(jsonSign, "permanode", schema.NewUnsignedPermanode())
if err != nil {
return err
}
err = ph.setRootNode(jsonSign, pn)
return err
}
func (ph *PublishHandler) bootstrapPermanode(jsonSign *signhandler.Handler) (err error) {
result, err := ph.camliRootQuery()
if err == nil && len(result.Blobs) > 0 && result.Blobs[0].Blob.Valid() {
log.Printf("Publish root %q using existing permanode %s", ph.RootName, result.Blobs[0].Blob)
return nil
}
log.Printf("Publish root %q needs a permanode + claim", ph.RootName)
pn, err := ph.signUpload(jsonSign, "permanode", schema.NewUnsignedPermanode())
if err != nil {
return err
}
err = ph.setRootNode(jsonSign, pn)
return err
}
// ChildPathObject returns (creating if necessary) the child object
// from the permanode o, given by the "camliPath:xxxx" attribute,
// where xxx is the provided path.
func (o *Object) ChildPathObject(path string) (*Object, error) {
attrName := "camliPath:" + path
if v := o.Attr(attrName); v != "" {
br, ok := blob.Parse(v)
if ok {
return o.h.ObjectFromRef(br)
}
}
childBlobRef, err := o.h.upload(schema.NewUnsignedPermanode())
if err != nil {
return nil, err
}
if err := o.SetAttr(attrName, childBlobRef.String()); err != nil {
return nil, err
}
return &Object{
h: o.h,
pn: childBlobRef,
}, nil
}
func (c *Client) UploadNewPermanode() (*PutResult, error) {
unsigned := schema.NewUnsignedPermanode()
return c.UploadAndSignBlob(unsigned)
}
func (up *Uploader) UploadNewPermanode() (*client.PutResult, error) {
unsigned := schema.NewUnsignedPermanode()
return up.UploadAndSignBlob(unsigned)
}
// NewPermanode creates (& signs) a new permanode and adds it
// to the index, returning its blobref.
func (id *IndexDeps) NewPermanode() *blobref.BlobRef {
unsigned := schema.NewUnsignedPermanode()
return id.uploadAndSign(unsigned)
}
func (hl *handlerLoader) initPublisherRootNode(ah *app.Handler) error {
if !env.IsDev() {
return nil
}
h, err := hl.GetHandler("/my-search/")
if err != nil {
return err
}
sh := h.(*search.Handler)
camliRootQuery := func(camliRoot string) (*search.SearchResult, error) {
return sh.Query(&search.SearchQuery{
Limit: 1,
Constraint: &search.Constraint{
Permanode: &search.PermanodeConstraint{
Attr: "camliRoot",
Value: camliRoot,
},
},
})
}
appConfig := ah.AppConfig()
if appConfig == nil {
return errors.New("publisher app handler has no AppConfig")
}
camliRoot, ok := appConfig["camliRoot"].(string)
if !ok {
return fmt.Errorf("camliRoot in publisher app handler appConfig is %T, want string", appConfig["camliRoot"])
}
result, err := camliRootQuery(camliRoot)
if err == nil && len(result.Blobs) > 0 && result.Blobs[0].Blob.Valid() {
// root node found, nothing more to do.
log.Printf("Found %v camliRoot node for publisher: %v", camliRoot, result.Blobs[0].Blob.String())
return nil
}
log.Printf("No %v camliRoot node found, creating one from scratch now.", camliRoot)
bs, err := hl.GetStorage("/bs-recv/")
if err != nil {
return err
}
h, err = hl.GetHandler("/sighelper/")
if err != nil {
return err
}
sigh := h.(*signhandler.Handler)
signUpload := func(bb *schema.Builder) (blob.Ref, error) {
signed, err := sigh.Sign(bb)
if err != nil {
return blob.Ref{}, fmt.Errorf("could not sign blob: %v", err)
}
br := blob.SHA1FromString(signed)
if _, err := blobserver.Receive(bs, br, strings.NewReader(signed)); err != nil {
return blob.Ref{}, fmt.Errorf("could not upload %v: %v", br.String(), err)
}
return br, nil
}
pn, err := signUpload(schema.NewUnsignedPermanode())
if err != nil {
return fmt.Errorf("could not create new camliRoot node: %v", err)
}
if _, err := signUpload(schema.NewSetAttributeClaim(pn, "camliRoot", camliRoot)); err != nil {
return fmt.Errorf("could not set camliRoot on new node %v: %v", pn, err)
}
if _, err := signUpload(schema.NewSetAttributeClaim(pn, "title", "Publish root node for "+camliRoot)); err != nil {
return fmt.Errorf("could not set camliRoot on new node %v: %v", pn, err)
}
return nil
}