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

Added serialization for Tree and SerializedType. Changed policies to an array instead of a map

gql_cataclysm
noah metz 2023-09-20 19:14:28 -06:00
parent 0fc6215448
commit d4e0d855c7
9 changed files with 303 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
context.go
Unescape Escape View File

@ -942,6 +942,100 @@ func NewContext(db * badger.DB, log Logger) (*Context, error) {
} }
*/ */
err = ctx.RegisterType(reflect.TypeOf(Tree{}), TreeType, func(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value)(SerializedValue,error){
var data []byte
type_stack := []SerializedType{ctx_type}
if value == nil {
data = nil
} else if value.IsZero() {
data = []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
} else if value.Len() == 0 {
data = []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
} else {
data = make([]byte, 8)
map_size := 0
map_iter := value.MapRange()
for map_iter.Next() {
map_size += 1
key_reflect := map_iter.Key()
elem_reflect := map_iter.Value()
key_value, err := SerializeValue(ctx, key_reflect.Type(), &key_reflect)
if err != nil {
return SerializedValue{}, err
}
elem_value, err := SerializeValue(ctx, elem_reflect.Type(), &elem_reflect)
if err != nil {
return SerializedValue{}, err
}
data = append(data, key_value.Data...)
data = append(data, elem_value.Data...)
}
binary.BigEndian.PutUint64(data[0:8], uint64(map_size))
}
return SerializedValue{
type_stack,
data,
}, nil
},func(ctx *Context, value SerializedValue)(reflect.Type,*reflect.Value,SerializedValue,error){
if value.Data == nil {
return reflect.TypeOf(Tree{}), nil, value, nil
} else if len(value.Data) < 8 {
return nil, nil, value, fmt.Errorf("Not enough data to deserialize Tree")
} else {
var map_size_bytes []byte
var err error
map_size_bytes, value, err = value.PopData(8)
if err != nil {
return nil, nil, value, err
}
map_size := binary.BigEndian.Uint64(map_size_bytes)
ctx.Log.Logf("serialize", "Deserializing %d elements in Tree", map_size)
if map_size == 0xFFFFFFFFFFFFFFFF {
reflect_type := reflect.TypeOf(Tree{})
reflect_value := reflect.New(reflect_type).Elem()
return reflect_type, &reflect_value, value, nil
} else if map_size == 0x00 {
reflect_type := reflect.TypeOf(Tree{})
reflect_value := reflect.MakeMap(reflect_type)
return reflect_type, &reflect_value, value, nil
} else {
reflect_type := reflect.TypeOf(Tree{})
reflect_value := reflect.MakeMap(reflect_type)
tmp_value := value
for i := 0; i < int(map_size); i += 1 {
tmp_value.TypeStack = append([]SerializedType{SerializedTypeSerialized, TreeType}, value.TypeStack...)
var key_value, elem_value *reflect.Value
var err error
_, key_value, tmp_value, err = DeserializeValue(ctx, tmp_value)
if err != nil {
return nil, nil, value, err
}
_, elem_value, tmp_value, err = DeserializeValue(ctx, tmp_value)
if err != nil {
return nil, nil, value, err
}
reflect_value.SetMapIndex(*key_value, *elem_value)
}
return reflect_type, &reflect_value, tmp_value, nil
}
}
})
err = ctx.RegisterType(reflect.TypeOf(SerializedType(0)), SerializedTypeSerialized, SerializeUintN(8), DeserializeUintN[SerializedType](8))
if err != nil {
return nil, err
}
err = ctx.RegisterType(reflect.TypeOf(ExtType(0)), ExtTypeSerialized, SerializeUintN(8), DeserializeUintN[ExtType](8)) err = ctx.RegisterType(reflect.TypeOf(ExtType(0)), ExtTypeSerialized, SerializeUintN(8), DeserializeUintN[ExtType](8))
if err != nil { if err != nil {
return nil, err return nil, err
@ -1136,6 +1230,11 @@ func NewContext(db * badger.DB, log Logger) (*Context, error) {
return nil, err return nil, err
} }
err = ctx.RegisterSignal(reflect.TypeOf(SuccessSignal{}), SuccessSignalType)
if err != nil {
return nil, err
}
err = ctx.RegisterSignal(reflect.TypeOf(ReadResultSignal{}), ReadResultSignalType) err = ctx.RegisterSignal(reflect.TypeOf(ReadResultSignal{}), ReadResultSignalType)
if err != nil { if err != nil {
return nil, err return nil, err

11
gql_test.go
Unescape Escape View File

@ -65,16 +65,11 @@ func TestGQLServer(t *testing.T) {
fatalErr(t, err) fatalErr(t, err)
listener_ext := NewListenerExt(10) listener_ext := NewListenerExt(10)
n1, err := NewNode(ctx, nil, TestNodeType, 10, map[PolicyType]Policy{ n1, err := NewNode(ctx, nil, TestNodeType, 10, []Policy{user_policy_2, user_policy_1}, NewLockableExt(nil))
MemberOfPolicyType: &user_policy_2,
AllNodesPolicyType: &user_policy_1,
}, NewLockableExt(nil))
fatalErr(t, err) fatalErr(t, err)
gql, err := NewNode(ctx, gql_key, GQLNodeType, 10, map[PolicyType]Policy{ gql, err := NewNode(ctx, gql_key, GQLNodeType, 10, []Policy{group_policy_2, group_policy_1},
MemberOfPolicyType: &group_policy_2, NewLockableExt([]NodeID{n1.ID}), gql_ext, NewGroupExt(map[NodeID]string{
AllNodesPolicyType: &group_policy_1,
}, NewLockableExt([]NodeID{n1.ID}), gql_ext, NewGroupExt(map[NodeID]string{
n1.ID: "user", n1.ID: "user",
gql_id: "self", gql_id: "self",
}), listener_ext) }), listener_ext)

20
lockable_test.go
Unescape Escape View File

@ -28,10 +28,7 @@ func TestLink(t *testing.T) {
}) })
l2_listener := NewListenerExt(10) l2_listener := NewListenerExt(10)
l2, err := NewNode(ctx, nil, TestLockableType, 10, l2, err := NewNode(ctx, nil, TestLockableType, 10, []Policy{policy},
map[PolicyType]Policy{
PerNodePolicyType: &policy,
},
l2_listener, l2_listener,
NewLockableExt(nil), NewLockableExt(nil),
) )
@ -77,10 +74,7 @@ func Test10KLink(t *testing.T) {
}, },
}) })
NewLockable := func()(*Node) { NewLockable := func()(*Node) {
l, err := NewNode(ctx, nil, TestLockableType, 10, l, err := NewNode(ctx, nil, TestLockableType, 10, []Policy{child_policy},
map[PolicyType]Policy{
PerNodePolicyType: &child_policy,
},
NewLockableExt(nil), NewLockableExt(nil),
) )
fatalErr(t, err) fatalErr(t, err)
@ -98,10 +92,7 @@ func Test10KLink(t *testing.T) {
SerializedType(LockSignalType): nil, SerializedType(LockSignalType): nil,
}) })
listener := NewListenerExt(100000) listener := NewListenerExt(100000)
node, err := NewNode(ctx, listener_key, TestLockableType, 10000, node, err := NewNode(ctx, listener_key, TestLockableType, 10000, []Policy{l_policy},
map[PolicyType]Policy{
AllNodesPolicyType: &l_policy,
},
listener, listener,
NewLockableExt(reqs), NewLockableExt(reqs),
) )
@ -132,10 +123,7 @@ func TestLock(t *testing.T) {
NewLockable := func(reqs []NodeID)(*Node, *ListenerExt) { NewLockable := func(reqs []NodeID)(*Node, *ListenerExt) {
listener := NewListenerExt(100) listener := NewListenerExt(100)
l, err := NewNode(ctx, nil, TestLockableType, 10, l, err := NewNode(ctx, nil, TestLockableType, 10, []Policy{policy},
map[PolicyType]Policy{
AllNodesPolicyType: &policy,
},
listener, listener,
NewLockableExt(reqs), NewLockableExt(reqs),
) )

101
node.go
Unescape Escape View File

@ -14,16 +14,6 @@ import (
"crypto/rand" "crypto/rand"
) )
const (
// Magic first four bytes of serialized DB content, stored big endian
NODE_DB_MAGIC = 0x2491df14
// Total length of the node database header, has magic to verify and type_hash to map to load function
NODE_DB_HEADER_LEN = 32
EXTENSION_DB_HEADER_LEN = 16
QSIGNAL_DB_HEADER_LEN = 24
POLICY_DB_HEADER_LEN = 16
)
var ( var (
// Base NodeID, used as a special value // Base NodeID, used as a special value
ZeroUUID = uuid.UUID{} ZeroUUID = uuid.UUID{}
@ -84,7 +74,7 @@ type PendingACL struct {
} }
type PendingSignal struct { type PendingSignal struct {
Policy PolicyType Policy uuid.UUID
Found bool Found bool
ID uuid.UUID ID uuid.UUID
} }
@ -96,7 +86,7 @@ type Node struct {
ID NodeID ID NodeID
Type NodeType `gv:"type"` Type NodeType `gv:"type"`
Extensions map[ExtType]Extension `gv:"extensions"` Extensions map[ExtType]Extension `gv:"extensions"`
Policies map[PolicyType]Policy `gv:"policies"` Policies []Policy `gv:"policies"`
PendingACLs map[uuid.UUID]PendingACL `gv:"pending_acls"` PendingACLs map[uuid.UUID]PendingACL `gv:"pending_acls"`
PendingSignals map[uuid.UUID]PendingSignal `gv:"pending_signal"` PendingSignals map[uuid.UUID]PendingSignal `gv:"pending_signal"`
@ -134,14 +124,14 @@ const (
Pending Pending
) )
func (node *Node) Allows(ctx *Context, principal_id NodeID, action Tree)(map[PolicyType]Messages, RuleResult) { func (node *Node) Allows(ctx *Context, principal_id NodeID, action Tree)(map[uuid.UUID]Messages, RuleResult) {
pends := map[PolicyType]Messages{} pends := map[uuid.UUID]Messages{}
for policy_type, policy := range(node.Policies) { for _, policy := range(node.Policies) {
msgs, resp := policy.Allows(ctx, principal_id, action, node) msgs, resp := policy.Allows(ctx, principal_id, action, node)
if resp == Allow { if resp == Allow {
return nil, Allow return nil, Allow
} else if resp == Pending { } else if resp == Pending {
pends[policy_type] = msgs pends[policy.ID()] = msgs
} }
} }
if len(pends) != 0 { if len(pends) != 0 {
@ -370,33 +360,45 @@ func nodeLoop(ctx *Context, node *Node) error {
req_info.Counter -= 1 req_info.Counter -= 1
req_info.Responses = append(req_info.Responses, signal) req_info.Responses = append(req_info.Responses, signal)
allowed := node.Policies[info.Policy].ContinueAllows(ctx, req_info, signal) idx := -1
if allowed == Allow { for i, p := range(node.Policies) {
ctx.Log.Logf("policy", "DELAYED_POLICY_ALLOW: %s - %s", node.ID, req_info.Signal) if p.ID() == info.Policy {
signal = req_info.Signal idx = i
source = req_info.Source break
err := node.DequeueSignal(req_info.TimeoutID)
if err != nil {
panic("dequeued a passed signal")
}
delete(node.PendingACLs, info.ID)
} else if req_info.Counter == 0 {
ctx.Log.Logf("policy", "DELAYED_POLICY_DENY: %s - %s", node.ID, req_info.Signal)
// Send the denied response
msgs := Messages{}
msgs = msgs.Add(ctx, node.ID, node.Key, NewErrorSignal(req_info.Signal.Header().ID, "ACL_DENIED"), req_info.Source)
err := ctx.Send(msgs)
if err != nil {
ctx.Log.Logf("signal", "SEND_ERR: %s", err)
}
err = node.DequeueSignal(req_info.TimeoutID)
if err != nil {
panic("dequeued a passed signal")
} }
}
if idx == -1 {
ctx.Log.Logf("policy", "PENDING_FOR_NONEXISTENT_POLICY: %s - %s", node.ID, info.Policy)
delete(node.PendingACLs, info.ID) delete(node.PendingACLs, info.ID)
} else { } else {
node.PendingACLs[info.ID] = req_info allowed := node.Policies[idx].ContinueAllows(ctx, req_info, signal)
continue if allowed == Allow {
ctx.Log.Logf("policy", "DELAYED_POLICY_ALLOW: %s - %s", node.ID, req_info.Signal)
signal = req_info.Signal
source = req_info.Source
err := node.DequeueSignal(req_info.TimeoutID)
if err != nil {
panic("dequeued a passed signal")
}
delete(node.PendingACLs, info.ID)
} else if req_info.Counter == 0 {
ctx.Log.Logf("policy", "DELAYED_POLICY_DENY: %s - %s", node.ID, req_info.Signal)
// Send the denied response
msgs := Messages{}
msgs = msgs.Add(ctx, node.ID, node.Key, NewErrorSignal(req_info.Signal.Header().ID, "ACL_DENIED"), req_info.Source)
err := ctx.Send(msgs)
if err != nil {
ctx.Log.Logf("signal", "SEND_ERR: %s", err)
}
err = node.DequeueSignal(req_info.TimeoutID)
if err != nil {
panic("dequeued a passed signal")
}
delete(node.PendingACLs, info.ID)
} else {
node.PendingACLs[info.ID] = req_info
continue
}
} }
} }
} }
@ -544,7 +546,7 @@ 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, node_type NodeType, buffer_size uint32, policies map[PolicyType]Policy, extensions ...Extension) (*Node, error) { func NewNode(ctx *Context, key ed25519.PrivateKey, node_type NodeType, buffer_size uint32, policies []Policy, extensions ...Extension) (*Node, error) {
var err error var err error
var public ed25519.PublicKey var public ed25519.PublicKey
if key == nil { if key == nil {
@ -586,22 +588,7 @@ func NewNode(ctx *Context, key ed25519.PrivateKey, node_type NodeType, buffer_si
} }
} }
if policies == nil { policies = append(policies, DefaultPolicy)
policies = map[PolicyType]Policy{}
}
default_policy := NewAllNodesPolicy(Tree{
SerializedType(ErrorSignalType): nil,
SerializedType(ReadResultSignalType): nil,
SerializedType(StatusSignalType): nil,
})
all_nodes_policy, exists := policies[AllNodesPolicyType]
if exists == true {
policies[AllNodesPolicyType] = all_nodes_policy.Merge(&default_policy)
} else {
policies[AllNodesPolicyType] = &default_policy
}
node := &Node{ node := &Node{
Key: key, Key: key,

4
node_test.go
Unescape Escape View File

@ -63,9 +63,7 @@ func TestNodeRead(t *testing.T) {
n2, err := NewNode(ctx, n2_key, node_type, 10, nil, NewGroupExt(nil), n2_listener) n2, err := NewNode(ctx, n2_key, node_type, 10, nil, NewGroupExt(nil), n2_listener)
fatalErr(t, err) fatalErr(t, err)
n1, err := NewNode(ctx, n1_key, node_type, 10, map[PolicyType]Policy{ n1, err := NewNode(ctx, n1_key, node_type, 10, []Policy{n1_policy}, NewGroupExt(nil))
PerNodePolicyType: &n1_policy,
}, NewGroupExt(nil))
fatalErr(t, err) fatalErr(t, err)
read_sig := NewReadSignal(map[ExtType][]string{ read_sig := NewReadSignal(map[ExtType][]string{

110
policy.go
Unescape Escape View File

@ -1,15 +1,21 @@
package graphvent package graphvent
import ( import (
"github.com/google/uuid"
) )
type Policy interface { type Policy interface {
Allows(ctx *Context, principal_id NodeID, action Tree, node *Node)(Messages, RuleResult) Allows(ctx *Context, principal_id NodeID, action Tree, node *Node)(Messages, RuleResult)
ContinueAllows(ctx *Context, current PendingACL, signal Signal)RuleResult ContinueAllows(ctx *Context, current PendingACL, signal Signal)RuleResult
// Merge with another policy of the same underlying type ID() uuid.UUID
Merge(Policy) Policy }
// Make a copy of this policy
Copy() Policy type PolicyHeader struct {
UUID uuid.UUID `gv:"uuid"`
}
func (header PolicyHeader) ID() uuid.UUID {
return header.UUID
} }
func (policy AllNodesPolicy) Allows(ctx *Context, principal_id NodeID, action Tree, node *Node)(Messages, RuleResult) { func (policy AllNodesPolicy) Allows(ctx *Context, principal_id NodeID, action Tree, node *Node)(Messages, RuleResult) {
@ -38,10 +44,6 @@ type RequirementOfPolicy struct {
PerNodePolicy PerNodePolicy
} }
func (policy RequirementOfPolicy) Type() PolicyType {
return RequirementOfPolicyType
}
func NewRequirementOfPolicy(dep_rules map[NodeID]Tree) RequirementOfPolicy { func NewRequirementOfPolicy(dep_rules map[NodeID]Tree) RequirementOfPolicy {
return RequirementOfPolicy { return RequirementOfPolicy {
PerNodePolicy: NewPerNodePolicy(dep_rules), PerNodePolicy: NewPerNodePolicy(dep_rules),
@ -87,10 +89,6 @@ type MemberOfPolicy struct {
PerNodePolicy PerNodePolicy
} }
func (policy MemberOfPolicy) Type() PolicyType {
return MemberOfPolicyType
}
func NewMemberOfPolicy(group_rules map[NodeID]Tree) MemberOfPolicy { func NewMemberOfPolicy(group_rules map[NodeID]Tree) MemberOfPolicy {
return MemberOfPolicy{ return MemberOfPolicy{
PerNodePolicy: NewPerNodePolicy(group_rules), PerNodePolicy: NewPerNodePolicy(group_rules),
@ -156,19 +154,6 @@ func (policy MemberOfPolicy) Allows(ctx *Context, principal_id NodeID, action Tr
return msgs, Pending return msgs, Pending
} }
func (policy MemberOfPolicy) Merge(p Policy) Policy {
other := p.(*MemberOfPolicy)
policy.NodeRules = MergeNodeRules(policy.NodeRules, other.NodeRules)
return policy
}
func (policy MemberOfPolicy) Copy() Policy {
new_rules := CopyNodeRules(policy.NodeRules)
return &MemberOfPolicy{
PerNodePolicy: NewPerNodePolicy(new_rules),
}
}
func CopyTree(tree Tree) Tree { func CopyTree(tree Tree) Tree {
if tree == nil { if tree == nil {
return nil return nil
@ -199,56 +184,6 @@ func MergeTrees(first Tree, second Tree) Tree {
return ret return ret
} }
func CopyNodeRules(rules map[NodeID]Tree) map[NodeID]Tree {
ret := map[NodeID]Tree{}
for id, r := range(rules) {
ret[id] = r
}
return ret
}
func MergeNodeRules(first map[NodeID]Tree, second map[NodeID]Tree) map[NodeID]Tree {
merged := map[NodeID]Tree{}
for id, actions := range(first) {
merged[id] = actions
}
for id, actions := range(second) {
existing, exists := merged[id]
if exists {
merged[id] = MergeTrees(existing, actions)
} else {
merged[id] = actions
}
}
return merged
}
func (policy PerNodePolicy) Merge(p Policy) Policy {
other := p.(*PerNodePolicy)
policy.NodeRules = MergeNodeRules(policy.NodeRules, other.NodeRules)
return policy
}
func (policy PerNodePolicy) Copy() Policy {
new_rules := CopyNodeRules(policy.NodeRules)
return &PerNodePolicy{
NodeRules: new_rules,
}
}
func (policy AllNodesPolicy) Merge(p Policy) Policy {
other := p.(*AllNodesPolicy)
policy.Rules = MergeTrees(policy.Rules, other.Rules)
return policy
}
func (policy AllNodesPolicy) Copy() Policy {
new_rules := policy.Rules
return &AllNodesPolicy {
Rules: new_rules,
}
}
type Tree map[SerializedType]Tree type Tree map[SerializedType]Tree
func (rule Tree) Allows(action Tree) RuleResult { func (rule Tree) Allows(action Tree) RuleResult {
@ -278,39 +213,40 @@ func (rule Tree) Allows(action Tree) RuleResult {
} }
} }
func NewPolicyHeader() PolicyHeader {
return PolicyHeader{
UUID: uuid.New(),
}
}
func NewPerNodePolicy(node_actions map[NodeID]Tree) PerNodePolicy { func NewPerNodePolicy(node_actions map[NodeID]Tree) PerNodePolicy {
if node_actions == nil { if node_actions == nil {
node_actions = map[NodeID]Tree{} node_actions = map[NodeID]Tree{}
} }
return PerNodePolicy{ return PerNodePolicy{
PolicyHeader: NewPolicyHeader(),
NodeRules: node_actions, NodeRules: node_actions,
} }
} }
type PerNodePolicy struct { type PerNodePolicy struct {
NodeRules map[NodeID]Tree `json:"node_actions"` PolicyHeader
} NodeRules map[NodeID]Tree `gv:"node_rules"`
func (policy PerNodePolicy) Type() PolicyType {
return PerNodePolicyType
} }
func NewAllNodesPolicy(rules Tree) AllNodesPolicy { func NewAllNodesPolicy(rules Tree) AllNodesPolicy {
return AllNodesPolicy{ return AllNodesPolicy{
PolicyHeader: NewPolicyHeader(),
Rules: rules, Rules: rules,
} }
} }
type AllNodesPolicy struct { type AllNodesPolicy struct {
Rules Tree PolicyHeader
} Rules Tree `gv:"rules"`
func (policy AllNodesPolicy) Type() PolicyType {
return AllNodesPolicyType
} }
var DefaultPolicy = NewAllNodesPolicy(Tree{ var DefaultPolicy = NewAllNodesPolicy(Tree{
SerializedType(ErrorSignalType): nil, ResultType: nil,
SerializedType(ReadResultSignalType): nil,
}) })

175
serialize.go
Unescape Escape View File

@ -9,13 +9,13 @@ import (
) )
const ( const (
TagBase = "GraphventTag" TagBase = "GraphventTag"
ExtTypeBase = "ExtType" ExtTypeBase = "ExtType"
NodeTypeBase = "NodeType" NodeTypeBase = "NodeType"
SignalTypeBase = "SignalType" SignalTypeBase = "SignalType"
PolicyTypeBase = "PolicyType" PolicyTypeBase = "PolicyType"
SerializedTypeBase = "SerializedType" SerializedTypeBase = "SerializedType"
FieldNameBase = "FieldName" FieldNameBase = "FieldName"
) )
func Hash(base string, name string) SerializedType { func Hash(base string, name string) SerializedType {
@ -26,32 +26,37 @@ func Hash(base string, name string) SerializedType {
} }
type SerializedType uint64 type SerializedType uint64
func (t SerializedType) String() string { func (t SerializedType) String() string {
return fmt.Sprintf("0x%x", uint64(t)) return fmt.Sprintf("0x%x", uint64(t))
} }
type ExtType SerializedType type ExtType SerializedType
func (t ExtType) String() string { func (t ExtType) String() string {
return fmt.Sprintf("0x%x", uint64(t)) return fmt.Sprintf("0x%x", uint64(t))
} }
type NodeType SerializedType type NodeType SerializedType
func (t NodeType) String() string { func (t NodeType) String() string {
return fmt.Sprintf("0x%x", uint64(t)) return fmt.Sprintf("0x%x", uint64(t))
} }
type SignalType SerializedType type SignalType SerializedType
func (t SignalType) String() string { func (t SignalType) String() string {
return fmt.Sprintf("0x%x", uint64(t)) return fmt.Sprintf("0x%x", uint64(t))
} }
type PolicyType SerializedType type PolicyType SerializedType
func (t PolicyType) String() string { func (t PolicyType) String() string {
return fmt.Sprintf("0x%x", uint64(t)) return fmt.Sprintf("0x%x", uint64(t))
} }
type TypeSerialize func(*Context,SerializedType,reflect.Type,*reflect.Value) (SerializedValue, error) type TypeSerialize func(*Context, SerializedType, reflect.Type, *reflect.Value) (SerializedValue, error)
type TypeDeserialize func(*Context,SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) type TypeDeserialize func(*Context, SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error)
func NewExtType(name string) ExtType { func NewExtType(name string) ExtType {
return ExtType(Hash(ExtTypeBase, name)) return ExtType(Hash(ExtTypeBase, name))
@ -84,59 +89,63 @@ var (
StopSignalType = NewSignalType("STOP") StopSignalType = NewSignalType("STOP")
CreateSignalType = NewSignalType("CREATE") CreateSignalType = NewSignalType("CREATE")
StartSignalType = NewSignalType("START") StartSignalType = NewSignalType("START")
ErrorSignalType = NewSignalType("ERROR")
StatusSignalType = NewSignalType("STATUS") StatusSignalType = NewSignalType("STATUS")
LinkSignalType = NewSignalType("LINK") LinkSignalType = NewSignalType("LINK")
LockSignalType = NewSignalType("LOCK") LockSignalType = NewSignalType("LOCK")
ReadSignalType = NewSignalType("READ") ReadSignalType = NewSignalType("READ")
ReadResultSignalType = NewSignalType("READ_RESULT")
ACLTimeoutSignalType = NewSignalType("ACL_TIMEOUT") ACLTimeoutSignalType = NewSignalType("ACL_TIMEOUT")
ErrorSignalType = NewSignalType("ERROR")
SuccessSignalType = NewSignalType("SUCCESS")
ReadResultSignalType = NewSignalType("READ_RESULT")
MemberOfPolicyType = NewPolicyType("USER_OF") MemberOfPolicyType = NewPolicyType("USER_OF")
RequirementOfPolicyType = NewPolicyType("REQUIEMENT_OF") RequirementOfPolicyType = NewPolicyType("REQUIEMENT_OF")
PerNodePolicyType = NewPolicyType("PER_NODE") PerNodePolicyType = NewPolicyType("PER_NODE")
AllNodesPolicyType = NewPolicyType("ALL_NODES") AllNodesPolicyType = NewPolicyType("ALL_NODES")
ErrorType = NewSerializedType("ERROR") ErrorType = NewSerializedType("ERROR")
PointerType = NewSerializedType("POINTER") PointerType = NewSerializedType("POINTER")
SliceType = NewSerializedType("SLICE") SliceType = NewSerializedType("SLICE")
StructType = NewSerializedType("STRUCT") StructType = NewSerializedType("STRUCT")
IntType = NewSerializedType("INT") IntType = NewSerializedType("INT")
UIntType = NewSerializedType("UINT") UIntType = NewSerializedType("UINT")
BoolType = NewSerializedType("BOOL") BoolType = NewSerializedType("BOOL")
Float64Type = NewSerializedType("FLOAT64") Float64Type = NewSerializedType("FLOAT64")
Float32Type = NewSerializedType("FLOAT32") Float32Type = NewSerializedType("FLOAT32")
UInt8Type = NewSerializedType("UINT8") UInt8Type = NewSerializedType("UINT8")
UInt16Type = NewSerializedType("UINT16") UInt16Type = NewSerializedType("UINT16")
UInt32Type = NewSerializedType("UINT32") UInt32Type = NewSerializedType("UINT32")
UInt64Type = NewSerializedType("UINT64") UInt64Type = NewSerializedType("UINT64")
Int8Type = NewSerializedType("INT8") Int8Type = NewSerializedType("INT8")
Int16Type = NewSerializedType("INT16") Int16Type = NewSerializedType("INT16")
Int32Type = NewSerializedType("INT32") Int32Type = NewSerializedType("INT32")
Int64Type = NewSerializedType("INT64") Int64Type = NewSerializedType("INT64")
StringType = NewSerializedType("STRING") StringType = NewSerializedType("STRING")
ArrayType = NewSerializedType("ARRAY") ArrayType = NewSerializedType("ARRAY")
InterfaceType = NewSerializedType("INTERFACE") InterfaceType = NewSerializedType("INTERFACE")
MapType = NewSerializedType("MAP") MapType = NewSerializedType("MAP")
ReqStateType = NewSerializedType("REQ_STATE") ReqStateType = NewSerializedType("REQ_STATE")
SignalDirectionType = NewSerializedType("SIGNAL_DIRECTION") SignalDirectionType = NewSerializedType("SIGNAL_DIRECTION")
NodeStructType = NewSerializedType("NODE_STRUCT") NodeStructType = NewSerializedType("NODE_STRUCT")
QueuedSignalType = NewSerializedType("QUEUED_SIGNAL") QueuedSignalType = NewSerializedType("QUEUED_SIGNAL")
NodeTypeSerialized = NewSerializedType("NODE_TYPE") NodeTypeSerialized = NewSerializedType("NODE_TYPE")
ExtTypeSerialized = NewSerializedType("EXT_TYPE") ExtTypeSerialized = NewSerializedType("EXT_TYPE")
PolicyTypeSerialized = NewSerializedType("POLICY_TYPE") PolicyTypeSerialized = NewSerializedType("POLICY_TYPE")
ExtSerialized = NewSerializedType("EXTENSION") ExtSerialized = NewSerializedType("EXTENSION")
PolicySerialized = NewSerializedType("POLICY") PolicySerialized = NewSerializedType("POLICY")
SignalSerialized = NewSerializedType("SIGNAL") SignalSerialized = NewSerializedType("SIGNAL")
NodeIDType = NewSerializedType("NODE_ID") NodeIDType = NewSerializedType("NODE_ID")
UUIDType = NewSerializedType("UUID") UUIDType = NewSerializedType("UUID")
PendingACLType = NewSerializedType("PENDING_ACL") PendingACLType = NewSerializedType("PENDING_ACL")
PendingSignalType = NewSerializedType("PENDING_SIGNAL") PendingSignalType = NewSerializedType("PENDING_SIGNAL")
TimeType = NewSerializedType("TIME") TimeType = NewSerializedType("TIME")
ResultType = NewSerializedType("RESULT")
TreeType = NewSerializedType("TREE")
SerializedTypeSerialized = NewSerializedType("SERIALIZED_TYPE")
) )
func SerializeArray(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value)(SerializedValue,error){ func SerializeArray(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value) (SerializedValue, error) {
type_stack := []SerializedType{ctx_type} type_stack := []SerializedType{ctx_type}
if value == nil { if value == nil {
return SerializedValue{ return SerializedValue{
@ -164,7 +173,7 @@ func SerializeArray(ctx *Context, ctx_type SerializedType, reflect_type reflect.
} }
} }
func DeserializeArray[T any](ctx *Context)(func(ctx *Context, value SerializedValue)(reflect.Type,*reflect.Value,SerializedValue,error)){ func DeserializeArray[T any](ctx *Context) func(ctx *Context, value SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
var zero T var zero T
array_type := reflect.TypeOf(zero) array_type := reflect.TypeOf(zero)
array_size := array_type.Len() array_size := array_type.Len()
@ -173,7 +182,7 @@ func DeserializeArray[T any](ctx *Context)(func(ctx *Context, value SerializedVa
panic(err) panic(err)
} }
saved_type_stack := zero_value.TypeStack saved_type_stack := zero_value.TypeStack
return func(ctx *Context, value SerializedValue)(reflect.Type,*reflect.Value,SerializedValue,error){ return func(ctx *Context, value SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
if value.Data == nil { if value.Data == nil {
return array_type, nil, value, nil return array_type, nil, value, nil
} else { } else {
@ -198,7 +207,7 @@ func DeserializeArray[T any](ctx *Context)(func(ctx *Context, value SerializedVa
} }
} }
func SerializeUintN(size int)(func(*Context,SerializedType,reflect.Type,*reflect.Value)(SerializedValue,error)){ func SerializeUintN(size int) func(*Context, SerializedType, reflect.Type, *reflect.Value) (SerializedValue, error) {
var fill_data func([]byte, uint64) = nil var fill_data func([]byte, uint64) = nil
switch size { switch size {
case 1: case 1:
@ -220,7 +229,7 @@ func SerializeUintN(size int)(func(*Context,SerializedType,reflect.Type,*reflect
default: default:
panic(fmt.Sprintf("Cannot serialize uint of size %d", size)) panic(fmt.Sprintf("Cannot serialize uint of size %d", size))
} }
return func(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value)(SerializedValue,error){ return func(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value) (SerializedValue, error) {
var data []byte = nil var data []byte = nil
if value != nil { if value != nil {
data = make([]byte, size) data = make([]byte, size)
@ -233,7 +242,9 @@ func SerializeUintN(size int)(func(*Context,SerializedType,reflect.Type,*reflect
} }
} }
func DeserializeUintN[T interface{~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64}](size int)(func(ctx *Context, value SerializedValue)(reflect.Type,*reflect.Value,SerializedValue,error)){ func DeserializeUintN[T interface {
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}](size int) func(ctx *Context, value SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
var get_uint func([]byte) uint64 var get_uint func([]byte) uint64
switch size { switch size {
case 1: case 1:
@ -257,7 +268,7 @@ func DeserializeUintN[T interface{~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64}]
} }
var zero T var zero T
uint_type := reflect.TypeOf(zero) uint_type := reflect.TypeOf(zero)
return func(ctx *Context, value SerializedValue)(reflect.Type,*reflect.Value,SerializedValue,error){ return func(ctx *Context, value SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
if value.Data == nil { if value.Data == nil {
return uint_type, nil, value, nil return uint_type, nil, value, nil
} else { } else {
@ -274,7 +285,7 @@ func DeserializeUintN[T interface{~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64}]
} }
} }
func SerializeIntN(size int)(func(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value)(SerializedValue,error)){ func SerializeIntN(size int) func(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value) (SerializedValue, error) {
var fill_data func([]byte, int64) = nil var fill_data func([]byte, int64) = nil
switch size { switch size {
case 1: case 1:
@ -296,7 +307,7 @@ func SerializeIntN(size int)(func(ctx *Context, ctx_type SerializedType, reflect
default: default:
panic(fmt.Sprintf("Cannot serialize int of size %d", size)) panic(fmt.Sprintf("Cannot serialize int of size %d", size))
} }
return func(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value)(SerializedValue,error){ return func(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value) (SerializedValue, error) {
var data []byte = nil var data []byte = nil
if value != nil { if value != nil {
data = make([]byte, size) data = make([]byte, size)
@ -309,7 +320,9 @@ func SerializeIntN(size int)(func(ctx *Context, ctx_type SerializedType, reflect
} }
} }
func DeserializeIntN[T interface{~int | ~int8 | ~int16 | ~int32 | ~int64}](size int)(func(ctx *Context, value SerializedValue)(reflect.Type,*reflect.Value,SerializedValue,error)){ func DeserializeIntN[T interface {
~int | ~int8 | ~int16 | ~int32 | ~int64
}](size int) func(ctx *Context, value SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
var get_int func([]byte) int64 var get_int func([]byte) int64
switch size { switch size {
case 1: case 1:
@ -333,7 +346,7 @@ func DeserializeIntN[T interface{~int | ~int8 | ~int16 | ~int32 | ~int64}](size
} }
var zero T var zero T
int_type := reflect.TypeOf(zero) int_type := reflect.TypeOf(zero)
return func(ctx *Context, value SerializedValue)(reflect.Type,*reflect.Value,SerializedValue,error){ return func(ctx *Context, value SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
if value.Data == nil { if value.Data == nil {
return int_type, nil, value, nil return int_type, nil, value, nil
} else { } else {
@ -351,15 +364,15 @@ func DeserializeIntN[T interface{~int | ~int8 | ~int16 | ~int32 | ~int64}](size
} }
type FieldInfo struct { type FieldInfo struct {
Index []int Index []int
TypeStack []SerializedType TypeStack []SerializedType
} }
type StructInfo struct { type StructInfo struct {
Type reflect.Type Type reflect.Type
FieldOrder []SerializedType FieldOrder []SerializedType
FieldMap map[SerializedType]FieldInfo FieldMap map[SerializedType]FieldInfo
PostDeserialize bool PostDeserialize bool
PostDeserializeIdx int PostDeserializeIdx int
} }
@ -370,10 +383,10 @@ type Deserializable interface {
var deserializable_zero Deserializable = nil var deserializable_zero Deserializable = nil
var DeserializableType = reflect.TypeOf(&deserializable_zero).Elem() var DeserializableType = reflect.TypeOf(&deserializable_zero).Elem()
func structInfo(ctx *Context, struct_type reflect.Type)StructInfo{ func structInfo(ctx *Context, struct_type reflect.Type) StructInfo {
field_order := []SerializedType{} field_order := []SerializedType{}
field_map := map[SerializedType]FieldInfo{} field_map := map[SerializedType]FieldInfo{}
for _, field := range(reflect.VisibleFields(struct_type)) { for _, field := range reflect.VisibleFields(struct_type) {
gv_tag, tagged_gv := field.Tag.Lookup("gv") gv_tag, tagged_gv := field.Tag.Lookup("gv")
if tagged_gv == false { if tagged_gv == false {
continue continue
@ -396,7 +409,7 @@ func structInfo(ctx *Context, struct_type reflect.Type)StructInfo{
} }
} }
sort.Slice(field_order, func(i, j int)bool { sort.Slice(field_order, func(i, j int) bool {
return uint64(field_order[i]) < uint64(field_order[j]) return uint64(field_order[i]) < uint64(field_order[j])
}) })
@ -423,16 +436,16 @@ func structInfo(ctx *Context, struct_type reflect.Type)StructInfo{
} }
} }
func SerializeStruct(ctx *Context, struct_type reflect.Type)(func(*Context,SerializedType,reflect.Type,*reflect.Value)(SerializedValue,error)){ func SerializeStruct(ctx *Context, struct_type reflect.Type) func(*Context, SerializedType, reflect.Type, *reflect.Value) (SerializedValue, error) {
struct_info := structInfo(ctx, struct_type) struct_info := structInfo(ctx, struct_type)
return func(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value)(SerializedValue,error){ return func(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value) (SerializedValue, error) {
type_stack := []SerializedType{ctx_type} type_stack := []SerializedType{ctx_type}
var data []byte var data []byte
if value == nil { if value == nil {
data = nil data = nil
} else { } else {
data = make([]byte, 8) data = make([]byte, 8)
for _, field_hash := range(struct_info.FieldOrder) { for _, field_hash := range struct_info.FieldOrder {
field_hash_bytes := make([]byte, 8) field_hash_bytes := make([]byte, 8)
binary.BigEndian.PutUint64(field_hash_bytes, uint64(field_hash)) binary.BigEndian.PutUint64(field_hash_bytes, uint64(field_hash))
field_info := struct_info.FieldMap[field_hash] field_info := struct_info.FieldMap[field_hash]
@ -453,9 +466,9 @@ func SerializeStruct(ctx *Context, struct_type reflect.Type)(func(*Context,Seria
} }
} }
func DeserializeStruct(ctx *Context, struct_type reflect.Type)(func(*Context,SerializedValue)(reflect.Type,*reflect.Value,SerializedValue,error)){ func DeserializeStruct(ctx *Context, struct_type reflect.Type) func(*Context, SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
struct_info := structInfo(ctx, struct_type) struct_info := structInfo(ctx, struct_type)
return func(ctx *Context, value SerializedValue)(reflect.Type, *reflect.Value, SerializedValue, error) { return func(ctx *Context, value SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
if value.Data == nil { if value.Data == nil {
return struct_info.Type, nil, value, nil return struct_info.Type, nil, value, nil
} else { } else {
@ -511,7 +524,7 @@ func DeserializeStruct(ctx *Context, struct_type reflect.Type)(func(*Context,Ser
} }
} }
func SerializeInterface(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value)(SerializedValue,error){ func SerializeInterface(ctx *Context, ctx_type SerializedType, reflect_type reflect.Type, value *reflect.Value) (SerializedValue, error) {
var data []byte var data []byte
type_stack := []SerializedType{ctx_type} type_stack := []SerializedType{ctx_type}
if value == nil { if value == nil {
@ -537,8 +550,8 @@ func SerializeInterface(ctx *Context, ctx_type SerializedType, reflect_type refl
}, nil }, nil
} }
func DeserializeInterface[T any]()(func(*Context,SerializedValue)(reflect.Type,*reflect.Value,SerializedValue,error)){ func DeserializeInterface[T any]() func(*Context, SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
return func(ctx *Context, value SerializedValue)(reflect.Type, *reflect.Value, SerializedValue, error){ return func(ctx *Context, value SerializedValue) (reflect.Type, *reflect.Value, SerializedValue, error) {
var interface_zero T var interface_zero T
var interface_type = reflect.ValueOf(&interface_zero).Type().Elem() var interface_type = reflect.ValueOf(&interface_zero).Type().Elem()
if value.Data == nil { if value.Data == nil {
@ -573,7 +586,7 @@ func DeserializeInterface[T any]()(func(*Context,SerializedValue)(reflect.Type,*
type SerializedValue struct { type SerializedValue struct {
TypeStack []SerializedType TypeStack []SerializedType
Data []byte Data []byte
} }
func (value SerializedValue) PopType() (SerializedType, SerializedValue, error) { func (value SerializedValue) PopType() (SerializedType, SerializedValue, error) {
@ -627,7 +640,7 @@ func SerializeValue(ctx *Context, t reflect.Type, value *reflect.Value) (Seriali
serialize = kind_info.Serialize serialize = kind_info.Serialize
} }
serialized_value, err := serialize(ctx, ctx_type, t, value) serialized_value, err := serialize(ctx, ctx_type, t, value)
if err != nil { if err != nil {
return serialized_value, err return serialized_value, err
} }
@ -641,7 +654,7 @@ func ExtField(ctx *Context, ext Extension, field_name string) (reflect.Value, er
} }
ext_value := reflect.ValueOf(ext).Elem() ext_value := reflect.ValueOf(ext).Elem()
for _, field := range(reflect.VisibleFields(ext_value.Type())) { for _, field := range reflect.VisibleFields(ext_value.Type()) {
gv_tag, tagged := field.Tag.Lookup("gv") gv_tag, tagged := field.Tag.Lookup("gv")
if tagged == true && gv_tag == field_name { if tagged == true && gv_tag == field_name {
return ext_value.FieldByIndex(field.Index), nil return ext_value.FieldByIndex(field.Index), nil
@ -665,9 +678,9 @@ func (value SerializedValue) MarshalBinary() ([]byte, error) {
binary.BigEndian.PutUint64(data[0:8], uint64(len(value.TypeStack))) binary.BigEndian.PutUint64(data[0:8], uint64(len(value.TypeStack)))
binary.BigEndian.PutUint64(data[8:16], uint64(len(value.Data))) binary.BigEndian.PutUint64(data[8:16], uint64(len(value.Data)))
for i, t := range(value.TypeStack) { for i, t := range value.TypeStack {
type_start := (i+2)*8 type_start := (i + 2) * 8
type_end := (i+3)*8 type_end := (i + 3) * 8
binary.BigEndian.PutUint64(data[type_start:type_end], uint64(t)) binary.BigEndian.PutUint64(data[type_start:type_end], uint64(t))
} }
@ -686,12 +699,12 @@ func ParseSerializedValue(data []byte) (SerializedValue, []byte, error) {
data_size := int(binary.BigEndian.Uint64(data[8:16])) data_size := int(binary.BigEndian.Uint64(data[8:16]))
type_stack := make([]SerializedType, num_types) type_stack := make([]SerializedType, num_types)
for i := 0; i < num_types; i += 1 { for i := 0; i < num_types; i += 1 {
type_start := (i+2) * 8 type_start := (i + 2) * 8
type_end := (i+3) * 8 type_end := (i + 3) * 8
type_stack[i] = SerializedType(binary.BigEndian.Uint64(data[type_start:type_end])) type_stack[i] = SerializedType(binary.BigEndian.Uint64(data[type_start:type_end]))
} }
types_end := 8*(num_types + 2) types_end := 8 * (num_types + 2)
data_end := types_end + data_size data_end := types_end + data_size
return SerializedValue{ return SerializedValue{
type_stack, type_stack,

14
serialize_test.go
Unescape Escape View File

@ -7,7 +7,7 @@ import (
) )
func TestSerializeBasic(t *testing.T) { func TestSerializeBasic(t *testing.T) {
ctx := logTestContext(t, []string{"test"}) ctx := logTestContext(t, []string{"test", "serialize"})
testSerializeComparable[string](t, ctx, "test") testSerializeComparable[string](t, ctx, "test")
testSerializeComparable[bool](t, ctx, true) testSerializeComparable[bool](t, ctx, true)
testSerializeComparable[float32](t, ctx, 0.05) testSerializeComparable[float32](t, ctx, 0.05)
@ -59,6 +59,18 @@ func TestSerializeBasic(t *testing.T) {
12345, 12345,
"test_string", "test_string",
}) })
testSerialize(t, ctx, Tree{
TreeType: nil,
})
testSerialize(t, ctx, Tree{
TreeType: {
ErrorType: Tree{},
MapType: nil,
},
StringType: nil,
})
} }
type test struct { type test struct {

24
signal.go
Unescape Escape View File

@ -144,13 +144,31 @@ func NewStopSignal() *StopSignal {
} }
} }
type SuccessSignal struct {
SignalHeader
}
func (signal SuccessSignal) Permission() Tree {
return Tree{
ResultType: {
SerializedType(SuccessSignalType): nil,
},
}
}
func NewSuccessSignal(req_id uuid.UUID) Signal {
return &SuccessSignal{
NewRespHeader(req_id, Direct),
}
}
type ErrorSignal struct { type ErrorSignal struct {
SignalHeader SignalHeader
Error string Error string
} }
func (signal ErrorSignal) Permission() Tree { func (signal ErrorSignal) Permission() Tree {
return Tree{ return Tree{
SerializedType(ErrorSignalType): nil, ResultType: {
SerializedType(ErrorSignalType): nil,
},
} }
} }
func NewErrorSignal(req_id uuid.UUID, fmt_string string, args ...interface{}) Signal { func NewErrorSignal(req_id uuid.UUID, fmt_string string, args ...interface{}) Signal {
@ -275,7 +293,9 @@ type ReadResultSignal struct {
} }
func (signal ReadResultSignal) Permission() Tree { func (signal ReadResultSignal) Permission() Tree {
return Tree{ return Tree{
SerializedType(ReadResultSignalType): nil, ResultType: {
SerializedType(ReadResultSignalType): nil,
},
} }
} }
func NewReadResultSignal(req_id uuid.UUID, node_id NodeID, node_type NodeType, exts map[ExtType]map[string]SerializedValue) *ReadResultSignal { func NewReadResultSignal(req_id uuid.UUID, node_id NodeID, node_type NodeType, exts map[ExtType]map[string]SerializedValue) *ReadResultSignal {