Fixes and optimizations

db.go

@@ -3,6 +3,7 @@ package graphvent
 import (
 	"encoding/binary"
 	"fmt"
+  "reflect"
 
 	badger "github.com/dgraph-io/badger/v3"
 )
@@ -59,11 +60,11 @@ func WriteNodeInit(ctx *Context, node *Node) error {
     for ext_type, ext := range(node.Extensions) {
       // Write each extension's current value
       ext_id := binary.BigEndian.AppendUint64(id_ser, uint64(ext_type))
-      ext_val, err := Serialize(ctx, ext)
+      ext_ser, err := SerializeValue(ctx, reflect.ValueOf(ext).Elem())
       if err != nil {
         return err
       }
-      err = tx.Set(ext_id, ext_val)
+      err = tx.Set(ext_id, ext_ser)
     }
     return nil
   })
@@ -74,7 +75,7 @@ func WriteNodeChanges(ctx *Context, node *Node, changes map[ExtType]Changes) err
     // Get the base key bytes
     id_ser, err := node.ID.MarshalBinary()
     if err != nil {
-      return err
+      return fmt.Errorf("Marshal ID error: %+w", err)
     }
 
     // Write the signal queue if it needs to be written
@@ -84,11 +85,11 @@ func WriteNodeChanges(ctx *Context, node *Node, changes map[ExtType]Changes) err
       sigqueue_id := append(id_ser, []byte(" - SIGQUEUE")...)
       sigqueue_val, err := Serialize(ctx, node.SignalQueue)
       if err != nil {
-        return err
+        return fmt.Errorf("SignalQueue Serialize Error: %+v, %w", node.SignalQueue, err)
       }
       err = tx.Set(sigqueue_id, sigqueue_val)
       if err != nil {
-        return err
+        return fmt.Errorf("SignalQueue set error: %+v, %w", node.SignalQueue, err)
       }
     }
 
@@ -100,14 +101,14 @@ func WriteNodeChanges(ctx *Context, node *Node, changes map[ExtType]Changes) err
         return fmt.Errorf("%s is not an extension in %s", ext_type, node.ID)
       }
       ext_id := binary.BigEndian.AppendUint64(id_ser, uint64(ext_type))
-      ext_ser, err := Serialize(ctx, ext)
+      ext_ser, err := SerializeValue(ctx, reflect.ValueOf(ext).Elem())
       if err != nil {
-        return err
+        return fmt.Errorf("Extension serialize err: %s, %w", reflect.TypeOf(ext), err)
       }
 
       err = tx.Set(ext_id, ext_ser)
       if err != nil {
-        return err
+        return fmt.Errorf("Extension set err: %s, %w", reflect.TypeOf(ext), err)
       }
     }
     return nil
@@ -173,10 +174,25 @@ func LoadNode(ctx *Context, id NodeID) (*Node, error) {
         return err
       }
 
+      ext_info, exists := ctx.Extensions[ext_type]
+      if exists == false {
+        return fmt.Errorf("Extension %s not in context", ext_type)
+      }
+
       var ext Extension
+      var ok bool
       err = ext_item.Value(func(val []byte) error {
-        ext, err = Deserialize[Extension](ctx, val)
-        return err
+        value, _, err := DeserializeValue(ctx, val, ext_info.Type)
+        if err != nil {
+          return err
+        }
+
+        ext, ok = value.Addr().Interface().(Extension)
+        if ok == false {
+          return fmt.Errorf("Parsed value %+v is not extension", value.Type())
+        }
+
+        return nil
       })
       if err != nil {
         return err

extension.go

@@ -1,7 +1,7 @@
 package graphvent
 
-type Change string
-type Changes []Change
+type Tag string
+type Changes []Tag
 
 // Extensions are data attached to nodes that process signals
 type Extension interface {

gql.go

@@ -501,7 +501,7 @@ type Field struct {
 type NodeResult struct {
   NodeID NodeID
   NodeType NodeType
-  Data map[ExtType]map[string]interface{}
+  Data map[string]interface{}
 }
 
 type ListField struct {

gql_node.go

@@ -30,33 +30,21 @@ type FieldIndex struct {
   Tag string
 }
 
-func GetFields(ctx *Context, node_type string, selection_set *ast.SelectionSet) []FieldIndex {
-  names := []FieldIndex{}
+func GetFields(selection_set *ast.SelectionSet) []string {
+  names := []string{}
   if selection_set == nil {
     return names
   }
 
-  node_info, mapped := ctx.NodeTypes[node_type]
-  if mapped == false {
-    return nil
-  }
-
   for _, sel := range(selection_set.Selections) {
     switch field := sel.(type) {
     case *ast.Field:
       if field.Name.Value == "ID" || field.Name.Value == "Type" {
         continue
       }
-
-      extension, mapped := node_info.Fields[field.Name.Value]
-      if mapped == false {
-        continue
-      }
-      names = append(names, FieldIndex{extension, field.Name.Value})
+      names = append(names, field.Name.Value)
     case *ast.InlineFragment:
-      names = append(names, GetFields(ctx, field.TypeCondition.Name.Value, field.SelectionSet)...)
-    default:
-      ctx.Log.Logf("gql", "Unknown selection type: %s", reflect.TypeOf(field))
+      names = append(names, GetFields(field.SelectionSet)...)
     }
   }
 
@@ -64,10 +52,10 @@ func GetFields(ctx *Context, node_type string, selection_set *ast.SelectionSet)
 }
 
 // Returns the fields that need to be resolved
-func GetResolveFields(id NodeID, ctx *ResolveContext, p graphql.ResolveParams) []FieldIndex {
-  fields := []FieldIndex{}
+func GetResolveFields(p graphql.ResolveParams) []string {
+  fields := []string{}
   for _, field := range(p.Info.FieldASTs) {
-    fields = append(fields, GetFields(ctx.Context, p.Info.ReturnType.Name(), field.SelectionSet)...)
+    fields = append(fields, GetFields(field.SelectionSet)...)
   }
 
   return fields
@@ -83,13 +71,10 @@ func ResolveNode(id NodeID, p graphql.ResolveParams) (NodeResult, error) {
   case *StatusSignal:
     cached_node, cached := ctx.NodeCache[source.Source]
     if cached {
-      for ext_type, ext_changes := range(source.Changes) {
-        cached_ext, cached := cached_node.Data[ext_type]
+      for _, field_name := range(source.Fields) {
+        _, cached := cached_node.Data[field_name]
         if cached {
-          for _, field := range(ext_changes) {
-            delete(cached_ext, string(field))
-          }
-          cached_node.Data[ext_type] = cached_ext
+          delete(cached_node.Data, field_name)
         }
       }
       ctx.NodeCache[source.Source] = cached_node
@@ -97,25 +82,22 @@ func ResolveNode(id NodeID, p graphql.ResolveParams) (NodeResult, error) {
   }
 
   cache, node_cached := ctx.NodeCache[id]
-  fields := GetResolveFields(id, ctx, p) 
-  not_cached := map[ExtType][]string{}
-  for _, field := range(fields) {
-    ext_fields, exists := not_cached[field.Extension]
-    if exists == false {
-      ext_fields = []string{}
-    }
-
-    if node_cached {
-      ext_cache, ext_cached := cache.Data[field.Extension]
-      if ext_cached {
-        _, field_cached := ext_cache[field.Tag]
+  fields := GetResolveFields(p) 
+  var not_cached []string
+  if node_cached {
+    not_cached = []string{}
+    for _, field := range(fields) {
+      if node_cached {
+        _, field_cached := cache.Data[field]
         if field_cached {
           continue
         }
       }
-    }
 
-    not_cached[field.Extension] = append(ext_fields, field.Tag)
+      not_cached = append(not_cached, field)
+    }
+  } else {
+    not_cached = fields
   }
 
   if (len(not_cached) == 0) && (node_cached == true) {
@@ -148,20 +130,11 @@ func ResolveNode(id NodeID, p graphql.ResolveParams) (NodeResult, error) {
         cache = NodeResult{
           NodeID: id,
           NodeType: response.NodeType,
-          Data: response.Extensions,
+          Data: response.Fields,
         }
       } else {
-        for ext_type, ext_data := range(response.Extensions) {
-          cached_ext, ext_cached := cache.Data[ext_type]
-          if ext_cached {
-            for field_name, field := range(ext_data) {
-              cache.Data[ext_type][field_name] = field
-            }
-          } else {
-            cache.Data[ext_type] = ext_data
-          }
-
-          cache.Data[ext_type] = cached_ext
+        for field_name, field_value := range(response.Fields) {
+          cache.Data[field_name] = field_value
         }
       }
 

gql_test.go

@@ -19,7 +19,7 @@ import (
 func TestGQLSubscribe(t *testing.T) {
   ctx := logTestContext(t, []string{"test", "gql"})
 
-  n1, err := NewNode(ctx, nil, "Lockable", 10, NewLockableExt(nil))
+  n1, err := NewNode(ctx, nil, "LockableNode", 10, NewLockableExt(nil))
   fatalErr(t, err)
 
   listener_ext := NewListenerExt(10)
@@ -27,10 +27,10 @@ func TestGQLSubscribe(t *testing.T) {
   gql_ext, err := NewGQLExt(ctx, ":0", nil, nil)
   fatalErr(t, err)
 
-  gql, err := NewNode(ctx, nil, "Lockable", 10, NewLockableExt([]NodeID{n1.ID}), gql_ext, listener_ext)
+  gql, err := NewNode(ctx, nil, "LockableNode", 10, NewLockableExt([]NodeID{n1.ID}), gql_ext, listener_ext)
   fatalErr(t, err)
 
-  query := "subscription { Self { ID, Type ... on Lockable { lockable_state } } }"
+  query := "subscription { Self { ID, Type ... on Lockable { LockableState } } }"
 
   ctx.Log.Logf("test", "GQL:  %s", gql.ID)
   ctx.Log.Logf("test", "Node: %s", n1.ID)
@@ -129,14 +129,14 @@ func TestGQLQuery(t *testing.T) {
   ctx := logTestContext(t, []string{"test", "lockable"})
 
   n1_listener := NewListenerExt(10)
-  n1, err := NewNode(ctx, nil, "Lockable", 10, NewLockableExt(nil), n1_listener)
+  n1, err := NewNode(ctx, nil, "LockableNode", 10, NewLockableExt(nil), n1_listener)
   fatalErr(t, err)
 
   gql_listener := NewListenerExt(10)
   gql_ext, err := NewGQLExt(ctx, ":0", nil, nil)
   fatalErr(t, err)
 
-  gql, err := NewNode(ctx, nil, "Lockable", 10, NewLockableExt([]NodeID{n1.ID}), gql_ext, gql_listener)
+  gql, err := NewNode(ctx, nil, "LockableNode", 10, NewLockableExt([]NodeID{n1.ID}), gql_ext, gql_listener)
   fatalErr(t, err)
 
   ctx.Log.Logf("test", "GQL:  %s", gql.ID)
@@ -150,14 +150,14 @@ func TestGQLQuery(t *testing.T) {
   url := fmt.Sprintf("http://localhost:%d/gql", port)
 
   req_1 := GQLPayload{
-    Query: "query Node($id:graphvent_NodeID) { Node(id:$id) { ID, Type, ... on Lockable { lockable_state } } }",
+    Query: "query Node($id:graphvent_NodeID) { Node(id:$id) { ID, Type, ... on Lockable { LockableState } } }",
     Variables: map[string]interface{}{
       "id": n1.ID.String(),
     },
   }
 
   req_2 := GQLPayload{
-    Query: "query Self { Self { ID, Type, ... on Lockable { lockable_state, requirements { Key { ID ... on Lockable { lockable_state } } } } } }",
+    Query: "query Self { Self { ID, Type, ... on Lockable { LockableState, Requirements { Key { ID ... on Lockable { LockableState } } } } } }",
   }
 
   SendGQL := func(payload GQLPayload) []byte {
@@ -208,7 +208,7 @@ func TestGQLDB(t *testing.T) {
   fatalErr(t, err)
   listener_ext := NewListenerExt(10)
 
-  gql, err := NewNode(ctx, nil, "Base", 10, gql_ext, listener_ext)
+  gql, err := NewNode(ctx, nil, "Node", 10, gql_ext, listener_ext)
   fatalErr(t, err)
   ctx.Log.Logf("test", "GQL_ID: %s", gql.ID)
   

graph_test.go

@@ -11,7 +11,7 @@ func NewSimpleListener(ctx *Context, buffer int) (*Node, *ListenerExt, error) {
   listener_extension := NewListenerExt(buffer)
   listener, err := NewNode(ctx,
                       nil,
-                      "LockableListener",
+                      "LockableNode",
                       10,
                       nil,
                       listener_extension,
@@ -29,9 +29,6 @@ func logTestContext(t * testing.T, components []string) *Context {
   ctx, err := NewContext(db, NewConsoleLogger(components))
   fatalErr(t, err)
 
-  err = RegisterNodeType(ctx, "LockableListener", []ExtType{ExtTypeFor[ListenerExt](), ExtTypeFor[LockableExt]()})
-  fatalErr(t, err)
-
   return ctx
 }
 

listener.go

@@ -60,7 +60,7 @@ func (ext *ListenerExt) Process(ctx *Context, node *Node, source NodeID, signal
   }
   switch sig := signal.(type) {
   case *StatusSignal:
-    ctx.Log.Logf("listener_status", "%s - %+v", sig.Source, sig.Changes)
+    ctx.Log.Logf("listener_status", "%s - %+v", sig.Source, sig.Fields)
   }
   return nil, nil
 }

lockable.go

@@ -31,7 +31,7 @@ func (state ReqState) String() string {
 }
 
 type LockableExt struct{
-  State ReqState `gv:"lockable_state"`
+  State ReqState `gv:"state"`
   ReqID *uuid.UUID `gv:"req_id"`
   Owner *NodeID `gv:"owner"`
   PendingOwner *NodeID `gv:"pending_owner"`
@@ -129,7 +129,7 @@ func (ext *LockableExt) HandleUnlockSignal(ctx *Context, node *Node, source Node
       messages = append(messages, SendMsg{source, NewErrorSignal(signal.Id, "not_owner")})
     } else {
       if len(ext.Requirements) == 0 {
-        changes = append(changes, "lockable_state", "owner", "pending_owner")
+        changes = append(changes, "state", "owner", "pending_owner")
 
         ext.Owner = nil
 
@@ -139,7 +139,7 @@ func (ext *LockableExt) HandleUnlockSignal(ctx *Context, node *Node, source Node
 
         messages = append(messages, SendMsg{source, NewSuccessSignal(signal.Id)})
       } else {
-        changes = append(changes, "lockable_state", "waiting", "requirements", "pending_owner")
+        changes = append(changes, "state", "waiting", "requirements", "pending_owner")
 
         ext.PendingOwner = nil
 
@@ -173,7 +173,7 @@ func (ext *LockableExt) HandleLockSignal(ctx *Context, node *Node, source NodeID
   switch ext.State {
   case Unlocked:
     if len(ext.Requirements) == 0 {
-      changes = append(changes, "lockable_state", "owner", "pending_owner")
+      changes = append(changes, "state", "owner", "pending_owner")
 
       ext.Owner = new(NodeID)
       *ext.Owner = source
@@ -184,7 +184,7 @@ func (ext *LockableExt) HandleLockSignal(ctx *Context, node *Node, source NodeID
       ext.State = Locked
       messages = append(messages, SendMsg{source, NewSuccessSignal(signal.Id)})
     } else {
-      changes = append(changes, "lockable_state", "requirements", "waiting", "pending_owner")
+      changes = append(changes, "state", "requirements", "waiting", "pending_owner")
 
       ext.PendingOwner = new(NodeID)
       *ext.PendingOwner = source
@@ -221,7 +221,7 @@ func (ext *LockableExt) HandleErrorSignal(ctx *Context, node *Node, source NodeI
 
     switch ext.State {
     case Locking:
-      changes = append(changes, "lockable_state", "requirements")
+      changes = append(changes, "state", "requirements")
 
       ext.Requirements[id] = Unlocked
 
@@ -242,11 +242,11 @@ func (ext *LockableExt) HandleErrorSignal(ctx *Context, node *Node, source NodeI
       }
 
       if unlocked == len(ext.Requirements) {
-        changes = append(changes, "owner", "lockable_state")
+        changes = append(changes, "owner", "state")
         ext.State = Unlocked
         ext.Owner = nil
       } else {
-        changes = append(changes, "lockable_state")
+        changes = append(changes, "state")
         ext.State = AbortingLock
       }
 
@@ -271,7 +271,7 @@ func (ext *LockableExt) HandleErrorSignal(ctx *Context, node *Node, source NodeI
         }
 
         if unlocked == len(ext.Requirements) {
-          changes = append(changes, "owner", "lockable_state")
+          changes = append(changes, "owner", "state")
           ext.State = Unlocked
           ext.Owner = nil
         }
@@ -309,7 +309,8 @@ func (ext *LockableExt) HandleSuccessSignal(ctx *Context, node *Node, source Nod
       }
 
       if locked == len(ext.Requirements) {
-        changes = append(changes, "lockable_state", "owner", "req_id")
+        ctx.Log.Logf("lockable", "%s FULL_LOCK: %d", node.ID, locked)
+        changes = append(changes, "state", "owner", "req_id")
         ext.State = Locked
 
         ext.Owner = new(NodeID)
@@ -317,6 +318,8 @@ func (ext *LockableExt) HandleSuccessSignal(ctx *Context, node *Node, source Nod
 
         messages = append(messages, SendMsg{*ext.Owner, NewSuccessSignal(*ext.ReqID)})
         ext.ReqID = nil
+      } else {
+        ctx.Log.Logf("lockable", "%s PARTIAL_LOCK: %d/%d", node.ID, locked, len(ext.Requirements))
       }
     case AbortingLock:
       req_state := ext.Requirements[id]
@@ -338,7 +341,7 @@ func (ext *LockableExt) HandleSuccessSignal(ctx *Context, node *Node, source Nod
         }
 
         if unlocked == len(ext.Requirements) {
-          changes = append(changes, "lockable_state", "pending_owner", "req_id")
+          changes = append(changes, "state", "pending_owner", "req_id")
 
           messages = append(messages, SendMsg{*ext.PendingOwner, NewErrorSignal(*ext.ReqID, "not_unlocked: %s", ext.State)})
           ext.State = Unlocked
@@ -359,7 +362,7 @@ func (ext *LockableExt) HandleSuccessSignal(ctx *Context, node *Node, source Nod
       }
 
       if unlocked == len(ext.Requirements) {
-        changes = append(changes, "lockable_state", "owner", "req_id")
+        changes = append(changes, "state", "owner", "req_id")
 
         messages = append(messages, SendMsg{*ext.Owner, NewSuccessSignal(*ext.ReqID)})
         ext.State = Unlocked

lockable_test.go

@@ -10,12 +10,12 @@ func TestLink(t *testing.T) {
 
 
   l2_listener := NewListenerExt(10)
-  l2, err := NewNode(ctx, nil, "Lockable", 10, l2_listener, NewLockableExt(nil))
+  l2, err := NewNode(ctx, nil, "LockableNode", 10, l2_listener, NewLockableExt(nil))
   fatalErr(t, err)
 
   l1_lockable := NewLockableExt(nil)
   l1_listener := NewListenerExt(10)
-  l1, err := NewNode(ctx, nil, "Lockable", 10, l1_listener, l1_lockable)
+  l1, err := NewNode(ctx, nil, "LockableNode", 10, l1_listener, l1_lockable)
   fatalErr(t, err)
 
   link_signal := NewLinkSignal("add", l2.ID)
@@ -42,24 +42,24 @@ func TestLink(t *testing.T) {
   fatalErr(t, err)
 }
 
-func Test1000Lock(t *testing.T) {
+func Test10000Lock(t *testing.T) {
   ctx := logTestContext(t, []string{"test"})
 
   NewLockable := func()(*Node) {
-    l, err := NewNode(ctx, nil, "Lockable", 10, NewLockableExt(nil))
+    l, err := NewNode(ctx, nil, "LockableNode", 10, NewLockableExt(nil))
     fatalErr(t, err)
     return l
   }
 
-  reqs := make([]NodeID, 1000)
+  reqs := make([]NodeID, 10000)
   for i := range(reqs) {
     new_lockable := NewLockable()
     reqs[i] = new_lockable.ID
   }
-  ctx.Log.Logf("test", "CREATED_1000")
+  ctx.Log.Logf("test", "CREATED_10000")
 
-  listener := NewListenerExt(5000)
-  node, err := NewNode(ctx, nil, "Lockable", 5000, listener, NewLockableExt(reqs))
+  listener := NewListenerExt(50000)
+  node, err := NewNode(ctx, nil, "LockableNode", 500000, listener, NewLockableExt(reqs))
   fatalErr(t, err)
   ctx.Log.Logf("test", "CREATED_LISTENER")
 
@@ -75,15 +75,15 @@ func Test1000Lock(t *testing.T) {
     t.Fatalf("Unexpected response to lock - %s", resp)
   }
 
-  ctx.Log.Logf("test", "LOCKED_1000")
+  ctx.Log.Logf("test", "LOCKED_10000")
 }
 
 func TestLock(t *testing.T) {
   ctx := logTestContext(t, []string{"test", "lockable"})
 
   NewLockable := func(reqs []NodeID)(*Node, *ListenerExt) {
-    listener := NewListenerExt(1000)
-    l, err := NewNode(ctx, nil, "Lockable", 10, listener, NewLockableExt(reqs))
+    listener := NewListenerExt(10000)
+    l, err := NewNode(ctx, nil, "LockableNode", 10, listener, NewLockableExt(reqs))
     fatalErr(t, err)
     return l, listener
   }
@@ -112,7 +112,7 @@ func TestLock(t *testing.T) {
   ctx.Log.Logf("test", "locking l1")
   id_2, err := LockLockable(ctx, l1)
   fatalErr(t, err)
-  response, _, err = WaitForResponse(l1_listener.Chan, time.Millisecond*1000, id_2)
+  response, _, err = WaitForResponse(l1_listener.Chan, time.Millisecond*10000, id_2)
   fatalErr(t, err)
   ctx.Log.Logf("test", "l1 lock: %+v", response)
 

node.go

@@ -24,6 +24,10 @@ type NodeID uuid.UUID
 func (id NodeID) MarshalBinary() ([]byte, error) {
   return (uuid.UUID)(id).MarshalBinary()
 }
+func (id *NodeID) UnmarshalBinary(data []byte) error {
+  return (*uuid.UUID)(id).UnmarshalBinary(data)
+}
+
 func (id NodeID) String() string {
   return (uuid.UUID)(id).String()
 }
@@ -140,7 +144,13 @@ func SoonestSignal(signals []QueuedSignal) (*QueuedSignal, <-chan time.Time) {
   }
 
   if soonest_signal != nil {
-    return soonest_signal, time.After(time.Until(soonest_signal.Time))
+    if time.Now().Compare(soonest_time) == -1 {
+      return soonest_signal, time.After(time.Until(soonest_signal.Time))
+    } else {
+      c := make(chan time.Time, 1)
+      c <- soonest_time
+      return soonest_signal, c
+    }
   } else {
     return nil, nil
   }
@@ -166,25 +176,23 @@ func (err StringError) MarshalBinary() ([]byte, error) {
   return []byte(string(err)), nil
 }
 
-func (node *Node) ReadFields(ctx *Context, reqs map[ExtType][]string)map[ExtType]map[string]any {
-  ctx.Log.Logf("read_field", "Reading %+v on %+v", reqs, node.ID)
-  exts := map[ExtType]map[string]any{}
-  for ext_type, field_reqs := range(reqs) {
-    ext_info, ext_known := ctx.Extensions[ext_type]
-    if ext_known { 
-      fields := map[string]any{}
-      for _, req := range(field_reqs) {
-        ext, exists := node.Extensions[ext_type]
-        if exists == false {
-          fields[req] = fmt.Errorf("%+v does not have %+v extension", node.ID, ext_type)
-        } else {
-          fields[req] = reflect.ValueOf(ext).Elem().FieldByIndex(ext_info.Fields[req].Index).Interface()
-        }
-      }
-      exts[ext_type] = fields
+func (node *Node) ReadFields(ctx *Context, fields []string)map[string]any {
+  ctx.Log.Logf("read_field", "Reading %+v on %+v", fields, node.ID)
+  values := map[string]any{}
+
+  node_info := ctx.NodeTypes[node.Type]
+
+  for _, field_name := range(fields) {
+    field_info, mapped := node_info.Fields[field_name]
+    if mapped {
+      ext := node.Extensions[field_info.Extension]
+      values[field_name] = reflect.ValueOf(ext).Elem().FieldByIndex(field_info.Index).Interface()
+    } else {
+      values[field_name] = fmt.Errorf("NodeType %s has no field %s", node.Type, field_name)
     }
   }
-  return exts
+
+  return values
 }
 
 // Main Loop for nodes
@@ -196,15 +204,22 @@ func nodeLoop(ctx *Context, node *Node, started chan error) error {
     ctx.Log.Logf("node", "Set %s active", node.ID)
   }
 
+  ctx.Log.Logf("node_ext", "Loading extensions for %s", node.ID)
+
   for _, extension := range(node.Extensions) {
+    ctx.Log.Logf("node_ext", "Loading extension %s for %s", reflect.TypeOf(extension), node.ID)
     err := extension.Load(ctx, node)
     if err != nil {
+      ctx.Log.Logf("node_ext", "Failed to load extension %s on node %s", reflect.TypeOf(extension), node.ID)
       node.Active.Store(false)
-      ctx.Log.Logf("node", "Failed to load extension %s on node %s", reflect.TypeOf(extension), node.ID)
       return err
+    } else {
+      ctx.Log.Logf("node_ext", "Loaded extension %s on node %s", reflect.TypeOf(extension), node.ID)
     }
   }
 
+  ctx.Log.Logf("node_ext", "Loaded extensions for %s", node.ID)
+
   started <- nil
 
   run := true
@@ -212,10 +227,6 @@ func nodeLoop(ctx *Context, node *Node, started chan error) error {
     var signal Signal
     var source NodeID
     select {
-    case msg := <- node.MsgChan:
-      signal = msg.Signal
-      source = msg.Source
-
     case <-node.TimeoutChan:
       signal = node.NextSignal.Signal
       source = node.ID
@@ -244,13 +255,17 @@ func nodeLoop(ctx *Context, node *Node, started chan error) error {
       } else {
         ctx.Log.Logf("node", "NODE_TIMEOUT(%s) - PROCESSING %+v@%s - NEXT_SIGNAL: %s@%s", node.ID, signal, t, node.NextSignal, node.NextSignal.Time)
       }
+    case msg := <- node.MsgChan:
+      signal = msg.Signal
+      source = msg.Source
+
     }
 
     ctx.Log.Logf("node", "NODE_SIGNAL_QUEUE[%s]: %+v", node.ID, node.SignalQueue)
 
     switch sig := signal.(type) {
     case *ReadSignal:
-      result := node.ReadFields(ctx, sig.Extensions)
+      result := node.ReadFields(ctx, sig.Fields)
       msgs := []SendMsg{}
       msgs = append(msgs, SendMsg{source, NewReadResultSignal(sig.ID(), node.ID, node.Type, result)})
       ctx.Send(node, msgs)
@@ -283,8 +298,25 @@ func (node *Node) Unload(ctx *Context) error {
 }
 
 func (node *Node) QueueChanges(ctx *Context, changes map[ExtType]Changes) error {
-  node.QueueSignal(time.Now(), NewStatusSignal(node.ID, changes))
-  return nil
+  node_info, exists := ctx.NodeTypes[node.Type]
+  if exists == false {
+    return fmt.Errorf("Node type not in context, can't map changes to field names")
+  } else {
+    fields := []string{}
+    for ext_type, ext_changes := range(changes) {
+      ext_map, ext_mapped := node_info.ReverseFields[ext_type]
+      if ext_mapped {
+        for _, ext_tag := range(ext_changes) {
+          field_name, tag_mapped := ext_map[ext_tag]
+          if tag_mapped {
+            fields = append(fields, field_name)
+          }
+        }
+      }
+    }
+    node.QueueSignal(time.Time{}, NewStatusSignal(node.ID, fields))
+    return nil
+  }
 }
 
 func (node *Node) Process(ctx *Context, source NodeID, signal Signal) error {
@@ -311,12 +343,14 @@ func (node *Node) Process(ctx *Context, source NodeID, signal Signal) error {
     }
   }
 
-  if len(changes) != 0 {
+  if (len(changes) != 0) || node.writeSignalQueue {
     write_err := WriteNodeChanges(ctx, node, changes)
     if write_err != nil {
       return write_err
     }
+  }
 
+  if len(changes) != 0 {
     status_err := node.QueueChanges(ctx, changes)
     if status_err != nil {
       return status_err
@@ -365,7 +399,8 @@ func KeyID(pub ed25519.PublicKey) NodeID {
 
 // Create a new node in memory and start it's event loop
 func NewNode(ctx *Context, key ed25519.PrivateKey, type_name string, buffer_size uint32, extensions ...Extension) (*Node, error) {
-  node_type, known_type := ctx.NodeTypes[type_name]
+  node_type := NodeTypeFor(type_name)
+  node_info, known_type := ctx.NodeTypes[node_type]
   if known_type == false {
     return nil, fmt.Errorf("%s is not a known node type", type_name)
   }
@@ -392,9 +427,9 @@ func NewNode(ctx *Context, key ed25519.PrivateKey, type_name string, buffer_size
       return nil, fmt.Errorf("Cannot create node with nil extension")
     }
 
-    ext_type, exists := ctx.ExtensionTypes[reflect.TypeOf(ext).Elem()]
+    ext_type, exists := ctx.Extensions[ExtTypeOf(reflect.TypeOf(ext))]
     if exists == false {
-      return nil, fmt.Errorf("%+v is not a known Extension", reflect.TypeOf(ext))
+      return nil, fmt.Errorf("%+v(%+v) is not a known Extension", reflect.TypeOf(ext), ExtTypeOf(reflect.TypeOf(ext)))
     }
     _, exists = ext_map[ext_type.ExtType]
     if exists == true {
@@ -403,7 +438,7 @@ func NewNode(ctx *Context, key ed25519.PrivateKey, type_name string, buffer_size
     ext_map[ext_type.ExtType] = ext
   }
 
-  for _, required_ext := range(node_type.Extensions) {
+  for _, required_ext := range(node_info.RequiredExtensions) {
     _, exists := ext_map[required_ext]
     if exists == false {
       return nil, fmt.Errorf(fmt.Sprintf("%+v requires %+v", node_type, required_ext))
@@ -413,7 +448,7 @@ func NewNode(ctx *Context, key ed25519.PrivateKey, type_name string, buffer_size
   node := &Node{
     Key: key,
     ID: id,
-    Type: node_type.NodeType,
+    Type: node_type,
     Extensions: ext_map,
     MsgChan: make(chan RecvMsg, buffer_size),
     BufferSize: buffer_size,
@@ -429,7 +464,6 @@ func NewNode(ctx *Context, key ed25519.PrivateKey, type_name string, buffer_size
   ctx.AddNode(id, node)
   started := make(chan error, 1)
   go runNode(ctx, node, started)
-
   err = <- started
   if err != nil {
     return nil, err

node_test.go

@@ -9,24 +9,20 @@ import (
 )
 
 func TestNodeDB(t *testing.T) {
-  ctx := logTestContext(t, []string{"node", "db"})
+  ctx := logTestContext(t, []string{"test", "node", "db"})
 
   node_listener := NewListenerExt(10)
-  node, err := NewNode(ctx, nil, "Base", 10, NewLockableExt(nil), node_listener)
+  node, err := NewNode(ctx, nil, "Node", 10, NewLockableExt(nil), node_listener)
   fatalErr(t, err)
 
   _, err = WaitForSignal(node_listener.Chan, 10*time.Millisecond, func(sig *StatusSignal) bool {
-    gql_changes, has_gql := sig.Changes[ExtTypeFor[GQLExt]()]
-    if has_gql == true {
-      return slices.Contains(gql_changes, "state") && sig.Source == node.ID
-    }
-    return false
+    return slices.Contains(sig.Fields, "state") && sig.Source == node.ID
   })
 
   err = ctx.Unload(node.ID)
   fatalErr(t, err)
 
-  ctx.nodeMap = map[NodeID]*Node{}
+  ctx.nodes = map[NodeID]*Node{}
   _, err = ctx.getNode(node.ID)
   fatalErr(t, err)
 }
@@ -46,15 +42,13 @@ func TestNodeRead(t *testing.T) {
   ctx.Log.Logf("test", "N2: %s", n2_id)
 
   n2_listener := NewListenerExt(10)
-  n2, err := NewNode(ctx, n2_key, "Base", 10, n2_listener)
+  n2, err := NewNode(ctx, n2_key, "Node", 10, n2_listener)
   fatalErr(t, err)
 
-  n1, err := NewNode(ctx, n1_key, "Base", 10, NewListenerExt(10)) 
+  n1, err := NewNode(ctx, n1_key, "Node", 10, NewListenerExt(10)) 
   fatalErr(t, err)
 
-  read_sig := NewReadSignal(map[ExtType][]string{
-    ExtTypeFor[ListenerExt](): {"buffer"},
-  })
+  read_sig := NewReadSignal([]string{"buffer"})
   msgs := []SendMsg{{n1.ID, read_sig}}
   err = ctx.Send(n2, msgs)
   fatalErr(t, err)

serialize.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"reflect"
   "math"
-	"slices"
 )
 
 type SerializedType uint64
@@ -39,14 +38,8 @@ func (t FieldTag) String() string {
   return fmt.Sprintf("0x%x", uint64(t))
 }
 
-func NodeTypeFor(extensions []ExtType) NodeType {
-  digest := []byte("GRAPHVENT_NODE - ")
-
-  slices.Sort(extensions)
-
-  for _, ext := range(extensions) {
-    digest = binary.BigEndian.AppendUint64(digest, uint64(ext))
-  }
+func NodeTypeFor(name string) NodeType {
+  digest := []byte("GRAPHVENT_NODE - " + name)
 
   hash := sha512.Sum512(digest)
   return NodeType(binary.BigEndian.Uint64(hash[0:8]))
@@ -66,6 +59,10 @@ func ExtTypeFor[E any, T interface { *E; Extension}]() ExtType {
   return ExtType(SerializedTypeFor[E]())
 }
 
+func ExtTypeOf(t reflect.Type) ExtType {
+  return ExtType(SerializeType(t.Elem()))
+}
+
 func SignalTypeFor[S Signal]() SignalType {
   return SignalType(SerializedTypeFor[S]())
 }
@@ -81,7 +78,7 @@ func GetFieldTag(tag string) FieldTag {
 }
 
 func TypeStack(ctx *Context, t reflect.Type) ([]byte, error) {
-  info, registered := ctx.TypeTypes[t]
+  info, registered := ctx.Types[t]
   if registered {
     return binary.BigEndian.AppendUint64(nil, uint64(info.Serialized)), nil
   } else {
@@ -131,7 +128,7 @@ func UnwrapStack(ctx *Context, stack []byte) (reflect.Type, []byte, error) {
   first_bytes, left := split(stack, 8)
   first := SerializedType(binary.BigEndian.Uint64(first_bytes))
 
-  info, registered := ctx.TypeMap[first]
+  info, registered := ctx.TypesReverse[first]
   if registered {
     return info.Reflect, left, nil
   } else {
@@ -177,13 +174,13 @@ func UnwrapStack(ctx *Context, stack []byte) (reflect.Type, []byte, error) {
 }
 
 func Serialize[T any](ctx *Context, value T) ([]byte, error) {
-  return serializeValue(ctx, reflect.ValueOf(&value).Elem())
+  return SerializeValue(ctx, reflect.ValueOf(&value).Elem())
 }
 
 func Deserialize[T any](ctx *Context, data []byte) (T, error) {
   reflect_type := reflect.TypeFor[T]()
   var zero T
-  value, left, err := deserializeValue(ctx, data, reflect_type)
+  value, left, err := DeserializeValue(ctx, data, reflect_type)
   if err != nil {
     return zero, err
   } else if len(left) != 0 {
@@ -195,10 +192,10 @@ func Deserialize[T any](ctx *Context, data []byte) (T, error) {
   return value.Interface().(T), nil
 }
 
-func serializeValue(ctx *Context, value reflect.Value) ([]byte, error) {
+func SerializeValue(ctx *Context, value reflect.Value) ([]byte, error) {
   var serialize SerializeFn = nil
 
-  info, registered := ctx.TypeTypes[value.Type()]
+  info, registered := ctx.Types[value.Type()]
   if registered {
     serialize = info.Serialize 
   }
@@ -248,7 +245,7 @@ func serializeValue(ctx *Context, value reflect.Value) ([]byte, error) {
       if value.IsNil() {
         return []byte{0x00}, nil
       } else {
-        elem, err := serializeValue(ctx, value.Elem())
+        elem, err := SerializeValue(ctx, value.Elem())
         if err != nil {
           return nil, err
         }
@@ -265,7 +262,7 @@ func serializeValue(ctx *Context, value reflect.Value) ([]byte, error) {
 
         data := []byte{}
         for i := 0; i < value.Len(); i++ {
-          elem, err := serializeValue(ctx, value.Index(i))
+          elem, err := SerializeValue(ctx, value.Index(i))
           if err != nil {
             return nil, err
           }
@@ -279,7 +276,7 @@ func serializeValue(ctx *Context, value reflect.Value) ([]byte, error) {
     case reflect.Array:
       data := []byte{}
       for i := 0; i < value.Len(); i++ {
-        elem, err := serializeValue(ctx, value.Index(i))
+        elem, err := SerializeValue(ctx, value.Index(i))
         if err != nil {
           return nil, err
         }
@@ -293,16 +290,20 @@ func serializeValue(ctx *Context, value reflect.Value) ([]byte, error) {
       binary.BigEndian.PutUint64(len_bytes, uint64(value.Len()))
 
       data := []byte{}
+      key := reflect.New(value.Type().Key()).Elem()
+      val := reflect.New(value.Type().Elem()).Elem()
       iter := value.MapRange()
       for iter.Next() {
-        k, err := serializeValue(ctx, iter.Key())
+        key.SetIterKey(iter)
+        val.SetIterValue(iter)
+
+        k, err := SerializeValue(ctx, key)
         if err != nil {
           return nil, err
         }
-
         data = append(data, k...)
 
-        v, err := serializeValue(ctx, iter.Value())
+        v, err := SerializeValue(ctx, val) 
         if err != nil {
           return nil, err
         }
@@ -319,7 +320,7 @@ func serializeValue(ctx *Context, value reflect.Value) ([]byte, error) {
 
         for field_tag, field_info := range(info.Fields) {
           data = append(data, binary.BigEndian.AppendUint64(nil, uint64(field_tag))...)
-          field_bytes, err := serializeValue(ctx, value.FieldByIndex(field_info.Index))
+          field_bytes, err := SerializeValue(ctx, value.FieldByIndex(field_info.Index))
           if err != nil {
             return nil, err
           }
@@ -332,7 +333,7 @@ func serializeValue(ctx *Context, value reflect.Value) ([]byte, error) {
     case reflect.Interface:
       data, err := TypeStack(ctx, value.Elem().Type())
 
-      val_data, err := serializeValue(ctx, value.Elem())
+      val_data, err := SerializeValue(ctx, value.Elem())
       if err != nil {
         return nil, err
       }
@@ -352,10 +353,10 @@ func split(data []byte, n int) ([]byte, []byte) {
   return data[:n], data[n:]
 }
 
-func deserializeValue(ctx *Context, data []byte, t reflect.Type) (reflect.Value, []byte, error) {
+func DeserializeValue(ctx *Context, data []byte, t reflect.Type) (reflect.Value, []byte, error) {
   var deserialize DeserializeFn = nil
 
-  info, registered := ctx.TypeTypes[t]
+  info, registered := ctx.Types[t]
   if registered {
     deserialize = info.Deserialize
   }
@@ -439,7 +440,7 @@ func deserializeValue(ctx *Context, data []byte, t reflect.Type) (reflect.Value,
         value.SetZero()
         return value, after_flags, nil
       } else {
-        elem_value, after_elem, err := deserializeValue(ctx, after_flags, t.Elem())
+        elem_value, after_elem, err := DeserializeValue(ctx, after_flags, t.Elem())
         if err != nil {
           return reflect.Value{}, nil, err
         }
@@ -454,7 +455,7 @@ func deserializeValue(ctx *Context, data []byte, t reflect.Type) (reflect.Value,
       for i := 0; i < length; i++ {
         var elem_value reflect.Value
         var err error
-        elem_value, left, err = deserializeValue(ctx, left, t.Elem())
+        elem_value, left, err = DeserializeValue(ctx, left, t.Elem())
         if err != nil {
           return reflect.Value{}, nil, err
         }
@@ -468,7 +469,7 @@ func deserializeValue(ctx *Context, data []byte, t reflect.Type) (reflect.Value,
       for i := 0; i < t.Len(); i++ {
         var elem_value reflect.Value
         var err error
-        elem_value, left, err = deserializeValue(ctx, left, t.Elem())
+        elem_value, left, err = DeserializeValue(ctx, left, t.Elem())
         if err != nil {
           return reflect.Value{}, nil, err
         }
@@ -487,12 +488,12 @@ func deserializeValue(ctx *Context, data []byte, t reflect.Type) (reflect.Value,
         var val_value reflect.Value
         var err error
 
-        key_value, left, err = deserializeValue(ctx, left, t.Key())        
+        key_value, left, err = DeserializeValue(ctx, left, t.Key())        
         if err != nil {
           return reflect.Value{}, nil, err
         }
 
-        val_value, left, err = deserializeValue(ctx, left, t.Elem())
+        val_value, left, err = DeserializeValue(ctx, left, t.Elem())
         if err != nil {
           return reflect.Value{}, nil, err
         }
@@ -503,7 +504,7 @@ func deserializeValue(ctx *Context, data []byte, t reflect.Type) (reflect.Value,
       return value, left, nil
 
     case reflect.Struct:
-      info, mapped := ctx.TypeTypes[t]
+      info, mapped := ctx.Types[t]
       if mapped {
         value := reflect.New(t).Elem()
 
@@ -520,7 +521,7 @@ func deserializeValue(ctx *Context, data []byte, t reflect.Type) (reflect.Value,
           if mapped {
             var field_val reflect.Value
             var err error
-            field_val, left, err = deserializeValue(ctx, left, field_info.Type)
+            field_val, left, err = DeserializeValue(ctx, left, field_info.Type)
             if err != nil {
               return reflect.Value{}, nil, err
             }
@@ -544,7 +545,7 @@ func deserializeValue(ctx *Context, data []byte, t reflect.Type) (reflect.Value,
         return reflect.Value{}, nil, err
       }
 
-      elem_val, left, err := deserializeValue(ctx, rest, elem_type)
+      elem_val, left, err := DeserializeValue(ctx, rest, elem_type)
       if err != nil {
         return reflect.Value{}, nil, err
       }

serialize_test.go

@@ -144,7 +144,9 @@ func TestSerializeValues(t *testing.T) {
   testSerializeCompare[*int](t, ctx, nil)
   testSerializeCompare(t, ctx, "string")
 
-  node, err := NewNode(ctx, nil, "Base", 100)
+  testSerialize(t, ctx, NewListenerExt(10))
+
+  node, err := NewNode(ctx, nil, "Node", 100)
   fatalErr(t, err)
   testSerialize(t, ctx, node)
 }

signal.go

@@ -30,7 +30,7 @@ func (signal SignalHeader) ID() uuid.UUID {
 }
 
 func (header SignalHeader) String() string {
-   return fmt.Sprintf("SignalHeader(%s)", header.Id)
+   return fmt.Sprintf("%s", header.Id)
 }
 
 type ResponseSignal interface {
@@ -48,7 +48,7 @@ func (header ResponseHeader) ResponseID() uuid.UUID {
 }
 
 func (header ResponseHeader) String() string {
-   return fmt.Sprintf("ResponseHeader(%s, %s)", header.Id, header.ReqID)
+   return fmt.Sprintf("%s for %s", header.Id, header.ReqID)
 }
 
 type Signal interface {
@@ -164,16 +164,16 @@ func NewACLTimeoutSignal(req_id uuid.UUID) *ACLTimeoutSignal {
 type StatusSignal struct {
   SignalHeader
   Source NodeID `gv:"source"`
-  Changes map[ExtType]Changes `gv:"changes"`
+  Fields []string `gv:"fields"`
 }
 func (signal StatusSignal) String() string {
-  return fmt.Sprintf("StatusSignal(%s: %+v)", signal.Source, signal.Changes)
+  return fmt.Sprintf("StatusSignal(%s: %+v)", signal.Source, signal.Fields)
 }
-func NewStatusSignal(source NodeID, changes map[ExtType]Changes) *StatusSignal {
+func NewStatusSignal(source NodeID, fields []string) *StatusSignal {
   return &StatusSignal{
     NewSignalHeader(),
     source,
-    changes,
+    fields,
   }
 }
 
@@ -225,17 +225,17 @@ func NewUnlockSignal() *UnlockSignal {
 
 type ReadSignal struct {
   SignalHeader
-  Extensions map[ExtType][]string `json:"extensions"`
+  Fields []string `json:"extensions"`
 }
 
 func (signal ReadSignal) String() string {
-  return fmt.Sprintf("ReadSignal(%s, %+v)", signal.SignalHeader, signal.Extensions)
+  return fmt.Sprintf("ReadSignal(%s, %+v)", signal.SignalHeader, signal.Fields)
 }
 
-func NewReadSignal(exts map[ExtType][]string) *ReadSignal {
+func NewReadSignal(fields []string) *ReadSignal {
   return &ReadSignal{
     NewSignalHeader(),
-    exts,
+    fields,
   }
 }
 
@@ -243,19 +243,19 @@ type ReadResultSignal struct {
   ResponseHeader
   NodeID NodeID
   NodeType NodeType
-  Extensions map[ExtType]map[string]any
+  Fields map[string]any
 }
 
 func (signal ReadResultSignal) String() string {
-  return fmt.Sprintf("ReadResultSignal(%s, %s, %+v)", signal.ResponseHeader, signal.NodeID, signal.Extensions)
+  return fmt.Sprintf("ReadResultSignal(%s, %s, %+v)", signal.ResponseHeader, signal.NodeID, signal.Fields)
 }
 
-func NewReadResultSignal(req_id uuid.UUID, node_id NodeID, node_type NodeType, exts map[ExtType]map[string]any) *ReadResultSignal {
+func NewReadResultSignal(req_id uuid.UUID, node_id NodeID, node_type NodeType, fields map[string]any) *ReadResultSignal {
   return &ReadResultSignal{
     NewResponseHeader(req_id),
     node_id,
     node_type,
-    exts,
+    fields,
   }
 }