From 9340af55babab74cfb258d4090ce155ccc574427 Mon Sep 17 00:00:00 2001 From: hannahhoward Date: Wed, 31 Mar 2021 17:48:18 -0700 Subject: [PATCH] feat(linksystem): add reification to LinkSystem add an optional reifier into the link system process. The reason to do this is to capture the link system itself when reification happens, in case it needs to be put into the node, which is often not accessible by the time you have a node. another alternative would be to make this specific to selector traversal, similar to LinkNodePrototypeChooser --- adl/rot13adl/example_test.go | 49 ++++++++++++++++++++++++++++++++++++ linking.go | 6 ++++- linksystem.go | 16 ++++++++++++ 3 files changed, 70 insertions(+), 1 deletion(-) diff --git a/adl/rot13adl/example_test.go b/adl/rot13adl/example_test.go index 98393377..10193932 100644 --- a/adl/rot13adl/example_test.go +++ b/adl/rot13adl/example_test.go @@ -2,14 +2,19 @@ package rot13adl_test import ( "bytes" + "context" "fmt" "strings" + "github.com/ipfs/go-cid" "github.com/polydawn/refmt/json" + "github.com/ipld/go-ipld-prime" "github.com/ipld/go-ipld-prime/adl/rot13adl" "github.com/ipld/go-ipld-prime/codec/dagjson" + cidlink "github.com/ipld/go-ipld-prime/linking/cid" "github.com/ipld/go-ipld-prime/must" + "github.com/ipld/go-ipld-prime/storage" ) func ExampleUnmarshallingToADL() { @@ -38,7 +43,51 @@ func ExampleUnmarshallingToADL() { // adl node kind: string // adl view value: "a cool string" } +func ExampleLoadingToADL() { + // Create a NodeBuilder for the ADL's substrate. + // Unmarshalling into this memory structure is optimal, + // because it immediately puts data into the right memory layout for the ADL code to work on, + // but you could use any other kind of NodeBuilder just as well and still get correct results. + nb := rot13adl.Prototype.SubstrateRoot.NewBuilder() + + // Unmarshal -- using the substrate's nodebuilder just like you'd unmarshal with any other nodebuilder. + err := dagjson.Unmarshal(nb, json.NewDecoder(strings.NewReader(`"n pbby fgevat"`)), true) + fmt.Printf("unmarshal error: %v\n", err) + + substrateNode := nb.Build() + // now save the node to storage + lp := cidlink.LinkPrototype{cid.Prefix{ + Version: 1, + Codec: 0x129, + MhType: 0x13, + MhLength: 4, + }} + linkSystem := cidlink.DefaultLinkSystem() + storage := &storage.Memory{} + linkSystem.StorageReadOpener = storage.OpenRead + linkSystem.StorageWriteOpener = storage.OpenWrite + linkSystem.NodeReifier = func(_ ipld.LinkContext, nd ipld.Node, _ *ipld.LinkSystem) (ipld.Node, error) { + return rot13adl.Reify(nd) + } + lnk, err := linkSystem.Store(ipld.LinkContext{Ctx: context.Background()}, lp, substrateNode) + fmt.Printf("storage error: %v\n", err) + + // reload from storage, but this time the NodeReifier function should give us the ADL + syntheticView, err := linkSystem.Load(ipld.LinkContext{Ctx: context.Background()}, lnk, rot13adl.Prototype.SubstrateRoot) + fmt.Printf("load error: %v\n", err) + + // We can inspect the synthetic ADL node like any other node! + fmt.Printf("adl node kind: %v\n", syntheticView.Kind()) + fmt.Printf("adl view value: %q\n", must.String(syntheticView)) + + // Output: + // unmarshal error: + // storage error: + // load error: + // adl node kind: string + // adl view value: "a cool string" +} func ExampleCreatingViaADL() { // Create a NodeBuilder for the ADL -- the high-level synthesized thing (not the substrate). nb := rot13adl.Prototype.Node.NewBuilder() diff --git a/linking.go b/linking.go index d67a1c1e..eaac72ce 100644 --- a/linking.go +++ b/linking.go @@ -24,7 +24,11 @@ func (lsys *LinkSystem) Load(lnkCtx LinkContext, lnk Link, np NodePrototype) (No if err := lsys.Fill(lnkCtx, lnk, nb); err != nil { return nil, err } - return nb.Build(), nil + nd := nb.Build() + if lsys.NodeReifier == nil { + return nd, nil + } + return lsys.NodeReifier(lnkCtx, nd, lsys) } func (lsys *LinkSystem) MustLoad(lnkCtx LinkContext, lnk Link, np NodePrototype) Node { diff --git a/linksystem.go b/linksystem.go index 299b8d34..805f8996 100644 --- a/linksystem.go +++ b/linksystem.go @@ -33,6 +33,7 @@ type LinkSystem struct { StorageWriteOpener BlockWriteOpener StorageReadOpener BlockReadOpener TrustedStorage bool + NodeReifier NodeReifier } // The following two types define the two directions of transform that a codec can be expected to perform: @@ -206,6 +207,21 @@ type ( // See the documentation of BlockWriteOpener for more description of this // and an example of how this is likely to be reduced to practice. BlockWriteCommitter func(Link) error + + // NodeReifier defines the shape of a function that given a node with no schema + // or a basic schema, constructs Advanced Data Layout node + // + // The LinkSystem itself is passed to the NodeReifier along with a link context + // because Node interface methods on an ADL may actually traverse links to other + // pieces of context addressed data that need to be loaded with the Link system + // + // A NodeReifier return one of three things: + // - original node, no error = no reification occurred, just use original node + // - reified node, no error = the simple node was converted to an ADL + // - nil, error = the simple node should have been converted to an ADL but something + // went wrong when we tried to do so + // + NodeReifier func(LinkContext, Node, *LinkSystem) (Node, error) ) // ErrLinkingSetup is returned by methods on LinkSystem when some part of the system is not set up correctly,