// LoadPinner loads a pinner and its keysets from the given datastore func LoadPinner(d ds.Datastore, dserv, internal mdag.DAGService) (Pinner, error) { p := new(pinner) rootKeyI, err := d.Get(pinDatastoreKey) if err != nil { return nil, fmt.Errorf("cannot load pin state: %v", err) } rootKeyBytes, ok := rootKeyI.([]byte) if !ok { return nil, fmt.Errorf("cannot load pin state: %s was not bytes", pinDatastoreKey) } rootCid, err := cid.Cast(rootKeyBytes) if err != nil { return nil, err } ctx, cancel := context.WithTimeout(context.TODO(), time.Second*5) defer cancel() root, err := internal.Get(ctx, rootCid) if err != nil { return nil, fmt.Errorf("cannot find pinning root object: %v", err) } rootpb, ok := root.(*mdag.ProtoNode) if !ok { return nil, mdag.ErrNotProtobuf } internalset := cid.NewSet() internalset.Add(rootCid) recordInternal := internalset.Add { // load recursive set recurseKeys, err := loadSet(ctx, internal, rootpb, linkRecursive, recordInternal) if err != nil { return nil, fmt.Errorf("cannot load recursive pins: %v", err) } p.recursePin = cidSetWithValues(recurseKeys) } { // load direct set directKeys, err := loadSet(ctx, internal, rootpb, linkDirect, recordInternal) if err != nil { return nil, fmt.Errorf("cannot load direct pins: %v", err) } p.directPin = cidSetWithValues(directKeys) } p.internalPin = internalset // assign services p.dserv = dserv p.dstore = d p.internal = internal return p, nil }
// LoadPinner loads a pinner and its keysets from the given datastore func LoadPinner(d ds.Datastore, dserv mdag.DAGService) (Pinner, error) { p := new(pinner) rootKeyI, err := d.Get(pinDatastoreKey) if err != nil { return nil, fmt.Errorf("cannot load pin state: %v", err) } rootKeyBytes, ok := rootKeyI.([]byte) if !ok { return nil, fmt.Errorf("cannot load pin state: %s was not bytes", pinDatastoreKey) } rootKey := key.Key(rootKeyBytes) ctx, cancel := context.WithTimeout(context.TODO(), time.Second*5) defer cancel() root, err := dserv.Get(ctx, rootKey) if err != nil { return nil, fmt.Errorf("cannot find pinning root object: %v", err) } internalPin := map[key.Key]struct{}{ rootKey: struct{}{}, } recordInternal := func(k key.Key) { internalPin[k] = struct{}{} } { // load recursive set recurseKeys, err := loadSet(ctx, dserv, root, linkRecursive, recordInternal) if err != nil { return nil, fmt.Errorf("cannot load recursive pins: %v", err) } p.recursePin = set.SimpleSetFromKeys(recurseKeys) } { // load direct set directKeys, err := loadSet(ctx, dserv, root, linkDirect, recordInternal) if err != nil { return nil, fmt.Errorf("cannot load direct pins: %v", err) } p.directPin = set.SimpleSetFromKeys(directKeys) } p.internalPin = internalPin // assign services p.dserv = dserv p.dstore = d return p, nil }
func ApplyChange(ctx context.Context, ds dag.DAGService, nd *dag.ProtoNode, cs []*Change) (*dag.ProtoNode, error) { e := NewDagEditor(nd, ds) for _, c := range cs { switch c.Type { case Add: child, err := ds.Get(ctx, c.After) if err != nil { return nil, err } childpb, ok := child.(*dag.ProtoNode) if !ok { return nil, dag.ErrNotProtobuf } err = e.InsertNodeAtPath(ctx, c.Path, childpb, nil) if err != nil { return nil, err } case Remove: err := e.RmLink(ctx, c.Path) if err != nil { return nil, err } case Mod: err := e.RmLink(ctx, c.Path) if err != nil { return nil, err } child, err := ds.Get(ctx, c.After) if err != nil { return nil, err } childpb, ok := child.(*dag.ProtoNode) if !ok { return nil, dag.ErrNotProtobuf } err = e.InsertNodeAtPath(ctx, c.Path, childpb, nil) if err != nil { return nil, err } } } return e.Finalize(ds) }
func Descendants(ctx context.Context, ds dag.DAGService, set key.KeySet, roots []key.Key, bestEffort bool) error { for _, k := range roots { set.Add(k) nd, err := ds.Get(ctx, k) if err != nil { return err } // EnumerateChildren recursively walks the dag and adds the keys to the given set err = dag.EnumerateChildren(ctx, ds, nd, set, bestEffort) if err != nil { return err } } return nil }
func Descendants(ds dag.DAGService, set key.KeySet, roots []key.Key) error { for _, k := range roots { set.Add(k) nd, err := ds.Get(context.Background(), k) if err != nil { return err } // EnumerateChildren recursively walks the dag and adds the keys to the given set err = dag.EnumerateChildren(context.Background(), ds, nd, set) if err != nil { return err } } return nil }
func addLink(ctx context.Context, ds dag.DAGService, root *dag.Node, childname string, childk key.Key) (*dag.Node, error) { ctx, cancel := context.WithTimeout(ctx, time.Second*30) childnd, err := ds.Get(ctx, childk) if err != nil { cancel() return nil, err } cancel() err = root.AddNodeLinkClean(childname, childnd) if err != nil { return nil, err } _, err = ds.Add(root) if err != nil { return nil, err } return root, nil }
func addLink(ctx context.Context, ds dag.DAGService, root *dag.Node, childname string, childk key.Key) (*dag.Node, error) { if childname == "" { return nil, errors.New("cannot create link with no name!") } childnd, err := ds.Get(ctx, childk) if err != nil { return nil, err } // ensure no link with that name already exists _ = root.RemoveNodeLink(childname) // ignore error, only option is ErrNotFound if err := root.AddNodeLinkClean(childname, childnd); err != nil { return nil, err } if _, err := ds.Add(root); err != nil { return nil, err } return root, nil }
func ApplyChange(ctx context.Context, ds dag.DAGService, nd *dag.Node, cs []*Change) (*dag.Node, error) { e := NewDagEditor(ds, nd) for _, c := range cs { switch c.Type { case Add: child, err := ds.Get(ctx, c.After) if err != nil { return nil, err } err = e.InsertNodeAtPath(ctx, c.Path, child, nil) if err != nil { return nil, err } case Remove: err := e.RmLink(ctx, c.Path) if err != nil { return nil, err } case Mod: err := e.RmLink(ctx, c.Path) if err != nil { return nil, err } child, err := ds.Get(ctx, c.After) if err != nil { return nil, err } err = e.InsertNodeAtPath(ctx, c.Path, child, nil) if err != nil { return nil, err } } } return e.GetNode(), nil }
func hasChild(ds mdag.DAGService, root *mdag.Node, child key.Key) (bool, error) { for _, lnk := range root.Links { k := key.Key(lnk.Hash) if k == child { return true, nil } nd, err := ds.Get(context.Background(), k) if err != nil { return false, err } has, err := hasChild(ds, nd, child) if err != nil { return false, err } if has { return has, nil } } return false, nil }