MetzNet
/
graphvent
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixes and optimizations

master
noah metz 2024-03-28 19:28:07 -07:00
parent 3d28c703db
commit 1eff534e1a
15 changed files with 550 additions and 466 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

546
context.go
View File

File diff suppressed because it is too large Load Diff

34
db.go
Unescape Escape View File

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

4
extension.go
Unescape Escape View File

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

2
gql.go
Unescape Escape View File

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

71
gql_node.go
Unescape Escape View File

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

16
gql_test.go
Unescape Escape View File

@ -19,7 +19,7 @@ import (
func TestGQLSubscribe(t *testing.T) { func TestGQLSubscribe(t *testing.T) {
ctx := logTestContext(t, []string{"test", "gql"}) 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) fatalErr(t, err)
listener_ext := NewListenerExt(10) listener_ext := NewListenerExt(10)
@ -27,10 +27,10 @@ func TestGQLSubscribe(t *testing.T) {
gql_ext, err := NewGQLExt(ctx, ":0", nil, nil) gql_ext, err := NewGQLExt(ctx, ":0", nil, nil)
fatalErr(t, err) 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) 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", "GQL: %s", gql.ID)
ctx.Log.Logf("test", "Node: %s", n1.ID) ctx.Log.Logf("test", "Node: %s", n1.ID)
@ -129,14 +129,14 @@ func TestGQLQuery(t *testing.T) {
ctx := logTestContext(t, []string{"test", "lockable"}) ctx := logTestContext(t, []string{"test", "lockable"})
n1_listener := NewListenerExt(10) 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) fatalErr(t, err)
gql_listener := NewListenerExt(10) gql_listener := NewListenerExt(10)
gql_ext, err := NewGQLExt(ctx, ":0", nil, nil) gql_ext, err := NewGQLExt(ctx, ":0", nil, nil)
fatalErr(t, err) 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) fatalErr(t, err)
ctx.Log.Logf("test", "GQL: %s", gql.ID) 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) url := fmt.Sprintf("http://localhost:%d/gql", port)
req_1 := GQLPayload{ 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{}{ Variables: map[string]interface{}{
"id": n1.ID.String(), "id": n1.ID.String(),
}, },
} }
req_2 := GQLPayload{ 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 { SendGQL := func(payload GQLPayload) []byte {
@ -208,7 +208,7 @@ func TestGQLDB(t *testing.T) {
fatalErr(t, err) fatalErr(t, err)
listener_ext := NewListenerExt(10) 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) fatalErr(t, err)
ctx.Log.Logf("test", "GQL_ID: %s", gql.ID) ctx.Log.Logf("test", "GQL_ID: %s", gql.ID)

5
graph_test.go
Unescape Escape View File

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

2
listener.go
Unescape Escape View File

@ -60,7 +60,7 @@ func (ext *ListenerExt) Process(ctx *Context, node *Node, source NodeID, signal
} }
switch sig := signal.(type) { switch sig := signal.(type) {
case *StatusSignal: 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 return nil, nil
} }

27
lockable.go
Unescape Escape View File

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

24
lockable_test.go
Unescape Escape View File

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

94
node.go
Unescape Escape View File

@ -24,6 +24,10 @@ type NodeID uuid.UUID
func (id NodeID) MarshalBinary() ([]byte, error) { func (id NodeID) MarshalBinary() ([]byte, error) {
return (uuid.UUID)(id).MarshalBinary() return (uuid.UUID)(id).MarshalBinary()
} }
func (id *NodeID) UnmarshalBinary(data []byte) error {
return (*uuid.UUID)(id).UnmarshalBinary(data)
}
func (id NodeID) String() string { func (id NodeID) String() string {
return (uuid.UUID)(id).String() return (uuid.UUID)(id).String()
} }
@ -140,7 +144,13 @@ func SoonestSignal(signals []QueuedSignal) (*QueuedSignal, <-chan time.Time) {
} }
if soonest_signal != nil { if soonest_signal != nil {
if time.Now().Compare(soonest_time) == -1 {
return soonest_signal, time.After(time.Until(soonest_signal.Time)) 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 { } else {
return nil, nil return nil, nil
} }
@ -166,25 +176,23 @@ func (err StringError) MarshalBinary() ([]byte, error) {
return []byte(string(err)), nil return []byte(string(err)), nil
} }
func (node *Node) ReadFields(ctx *Context, reqs map[ExtType][]string)map[ExtType]map[string]any { func (node *Node) ReadFields(ctx *Context, fields []string)map[string]any {
ctx.Log.Logf("read_field", "Reading %+v on %+v", reqs, node.ID) ctx.Log.Logf("read_field", "Reading %+v on %+v", fields, node.ID)
exts := map[ExtType]map[string]any{} values := map[string]any{}
for ext_type, field_reqs := range(reqs) {
ext_info, ext_known := ctx.Extensions[ext_type] node_info := ctx.NodeTypes[node.Type]
if ext_known {
fields := map[string]any{} for _, field_name := range(fields) {
for _, req := range(field_reqs) { field_info, mapped := node_info.Fields[field_name]
ext, exists := node.Extensions[ext_type] if mapped {
if exists == false { ext := node.Extensions[field_info.Extension]
fields[req] = fmt.Errorf("%+v does not have %+v extension", node.ID, ext_type) values[field_name] = reflect.ValueOf(ext).Elem().FieldByIndex(field_info.Index).Interface()
} else { } else {
fields[req] = reflect.ValueOf(ext).Elem().FieldByIndex(ext_info.Fields[req].Index).Interface() values[field_name] = fmt.Errorf("NodeType %s has no field %s", node.Type, field_name)
}
} }
exts[ext_type] = fields
} }
}
return exts return values
} }
// Main Loop for nodes // 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", "Set %s active", node.ID)
} }
ctx.Log.Logf("node_ext", "Loading extensions for %s", node.ID)
for _, extension := range(node.Extensions) { 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) err := extension.Load(ctx, node)
if err != nil { 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) node.Active.Store(false)
ctx.Log.Logf("node", "Failed to load extension %s on node %s", reflect.TypeOf(extension), node.ID)
return err 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 started <- nil
run := true run := true
@ -212,10 +227,6 @@ func nodeLoop(ctx *Context, node *Node, started chan error) error {
var signal Signal var signal Signal
var source NodeID var source NodeID
select { select {
case msg := <- node.MsgChan:
signal = msg.Signal
source = msg.Source
case <-node.TimeoutChan: case <-node.TimeoutChan:
signal = node.NextSignal.Signal signal = node.NextSignal.Signal
source = node.ID source = node.ID
@ -244,13 +255,17 @@ func nodeLoop(ctx *Context, node *Node, started chan error) error {
} else { } else {
ctx.Log.Logf("node", "NODE_TIMEOUT(%s) - PROCESSING %+v@%s - NEXT_SIGNAL: %s@%s", node.ID, signal, t, node.NextSignal, node.NextSignal.Time) 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) ctx.Log.Logf("node", "NODE_SIGNAL_QUEUE[%s]: %+v", node.ID, node.SignalQueue)
switch sig := signal.(type) { switch sig := signal.(type) {
case *ReadSignal: case *ReadSignal:
result := node.ReadFields(ctx, sig.Extensions) result := node.ReadFields(ctx, sig.Fields)
msgs := []SendMsg{} msgs := []SendMsg{}
msgs = append(msgs, SendMsg{source, NewReadResultSignal(sig.ID(), node.ID, node.Type, result)}) msgs = append(msgs, SendMsg{source, NewReadResultSignal(sig.ID(), node.ID, node.Type, result)})
ctx.Send(node, msgs) 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 { func (node *Node) QueueChanges(ctx *Context, changes map[ExtType]Changes) error {
node.QueueSignal(time.Now(), NewStatusSignal(node.ID, changes)) 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 return nil
}
} }
func (node *Node) Process(ctx *Context, source NodeID, signal Signal) error { 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) write_err := WriteNodeChanges(ctx, node, changes)
if write_err != nil { if write_err != nil {
return write_err return write_err
} }
}
if len(changes) != 0 {
status_err := node.QueueChanges(ctx, changes) status_err := node.QueueChanges(ctx, changes)
if status_err != nil { if status_err != nil {
return status_err 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 // 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) { 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 { if known_type == false {
return nil, fmt.Errorf("%s is not a known node type", type_name) 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") 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 { 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] _, exists = ext_map[ext_type.ExtType]
if exists == true { 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 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] _, exists := ext_map[required_ext]
if exists == false { if exists == false {
return nil, fmt.Errorf(fmt.Sprintf("%+v requires %+v", node_type, required_ext)) 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{ node := &Node{
Key: key, Key: key,
ID: id, ID: id,
Type: node_type.NodeType, Type: node_type,
Extensions: ext_map, Extensions: ext_map,
MsgChan: make(chan RecvMsg, buffer_size), MsgChan: make(chan RecvMsg, buffer_size),
BufferSize: 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) ctx.AddNode(id, node)
started := make(chan error, 1) started := make(chan error, 1)
go runNode(ctx, node, started) go runNode(ctx, node, started)
err = <- started err = <- started
if err != nil { if err != nil {
return nil, err return nil, err

20
node_test.go
Unescape Escape View File

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

67
serialize.go
Unescape Escape View File

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

4
serialize_test.go
Unescape Escape View File

@ -144,7 +144,9 @@ func TestSerializeValues(t *testing.T) {
testSerializeCompare[*int](t, ctx, nil) testSerializeCompare[*int](t, ctx, nil)
testSerializeCompare(t, ctx, "string") 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) fatalErr(t, err)
testSerialize(t, ctx, node) testSerialize(t, ctx, node)
} }

28
signal.go
Unescape Escape View File

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