graphvent

package module

Go to main page

Versions in this module

v0

v0.4.0

Aug 28, 2023

Changes in this version

+ const ACLTimeoutSignalType

+ const AbortingLock

+ const Locked

+ const Locking

+ const MemberOfPolicyType

+ const NewSignalType

+ const POLICY_DB_HEADER_LEN

+ const QSIGNAL_DB_HEADER_LEN

+ const Unlocked

+ const Unlocking

+ var DefaultPolicy = NewAllNodesPolicy(Tree{ ... })

+ var ECDH = ecdh.X25519()

+ func CopyNodeRules(rules map[NodeID]Tree) map[NodeID]Tree

+ func MergeNodeRules(first map[NodeID]Tree, second map[NodeID]Tree) map[NodeID]Tree

type AllNodesPolicy

+ Rules Tree

+ func (policy *AllNodesPolicy) ContinueAllows(current PendingACL, signal Signal) RuleResult

type BaseSignal

+ ReqUUID uuid.UUID

+ func NewRespSignal(id uuid.UUID, signal_type SignalType, direction SignalDirection) BaseSignal

+ func (signal *BaseSignal) ReqID() uuid.UUID

type Context

+ Policies map[uint64]PolicyInfo

type ECDHSignal

+ EDDSA ed25519.PublicKey

type ECDHSignalJSON

+ EDDSA []byte

type ErrorSignal

+ func (signal *ErrorSignal) String() string

type GQLExt

+ TLSCert []byte

+ TLSKey []byte

+ func (ext *GQLExt) FindResponseChannel(req_id uuid.UUID) chan Signal

type IDStringSignal

+ NodeID NodeID

type LockableExt

+ ReqID uuid.UUID

+ State ReqState

+ func (ext *LockableExt) HandleErrorSignal(log Logger, node *Node, source NodeID, signal *ErrorSignal) Messages

+ type MemberOfPolicy struct

+ func NewMemberOfPolicy(group_rules map[NodeID]Tree) MemberOfPolicy

+ func (policy *MemberOfPolicy) Allows(principal_id NodeID, action Tree, node *Node) (Messages, RuleResult)

+ func (policy *MemberOfPolicy) ContinueAllows(current PendingACL, signal Signal) RuleResult

+ func (policy *MemberOfPolicy) Copy() Policy

+ func (policy *MemberOfPolicy) Merge(p Policy) Policy

+ func (policy *MemberOfPolicy) Type() PolicyType

+ type Message struct

+ Dest NodeID

+ Principal ed25519.PublicKey

+ Signal Signal

+ Signature []byte

+ Source NodeID

+ func NewMessage(dest NodeID, source NodeID, principal ed25519.PrivateKey, signal Signal) (*Message, error)

+ type Messages []*Message

+ func (msgs Messages) Add(source NodeID, principal ed25519.PrivateKey, signal Signal, dest NodeID) Messages

type Node

+ PendingACLs map[uuid.UUID]PendingACL

+ PendingSignals map[uuid.UUID]PendingSignal

+ Policies map[PolicyType]Policy

+ func (node *Node) Allows(principal_id NodeID, action Tree) (map[PolicyType]Messages, RuleResult)

+ func (node *Node) DequeueSignal(id uuid.UUID) error

+ func (node *Node) ReadFields(reqs map[ExtType][]string) map[ExtType]map[string]interface{}

type NodeDB

+ Policies []PolicyDB

type NodeDBHeader

+ NumPolicies uint32

+ type PendingACL struct

+ Action Tree

+ Counter int

+ Messages Messages

+ Principal NodeID

+ Responses []Signal

+ Signal Signal

+ Source NodeID

+ TimeoutID uuid.UUID

+ type PendingSignal struct

+ Found bool

+ ID uuid.UUID

+ Policy PolicyType

type PerNodePolicy

+ NodeRules map[NodeID]Tree

+ func (policy *PerNodePolicy) ContinueAllows(current PendingACL, signal Signal) RuleResult

type Policy

+ ContinueAllows func(current PendingACL, signal Signal) RuleResult

+ type PolicyDB struct

+ Data []byte

+ Header PolicyDBHeader

+ func (policy PolicyDB) Serialize() []byte

+ type PolicyDBHeader struct

+ Length uint64

+ TypeHash uint64

+ func (header PolicyDBHeader) Serialize() []byte

type PolicyInfo

+ Type PolicyType

+ type QSignalDB struct

+ Data []byte

+ Header QSignalDBHeader

+ func (qsignal QSignalDB) Serialize() []byte

+ type QSignalDBHeader struct

+ Length uint64

+ Time time.Time

+ TypeHash uint64

+ func (header QSignalDBHeader) Serialize() []byte

type ReadResultSignal

+ NodeID NodeID

+ NodeType NodeType

type ReadSignal

+ func (signal *ReadSignal) Permission() Tree

type RequirementOfPolicy

+ func (policy *RequirementOfPolicy) ContinueAllows(current PendingACL, signal Signal) RuleResult

+ type RuleResult int

+ const Allow

+ const Deny

+ const Pending

type Signal

+ func NewACLTimeoutSignal(req_id uuid.UUID) Signal

+ func WaitForResponse(listener chan Signal, timeout time.Duration, req_id uuid.UUID) (Signal, error)

+ ReqID func() uuid.UUID

+ String func() string

type StringSignal

+ func (signal *StringSignal) String() string

+ type Tree map[string]Tree

+ func CopyTree(tree Tree) Tree

+ func MergeTrees(first Tree, second Tree) Tree

+ func (rule Tree) Allows(action Tree) RuleResult

v0.3.2

Aug 2, 2023

Changes in this version

+ const AuthorizedSignalType

+ var AuthorizedSignalAction = Action

+ var DefaultACLPolicies = []Policy

+ var ErrorSignalAction = Action

+ var ReadResultSignalAction = Action

+ var StartSignal = NewDirectSignal(StartSignalType)

+ func RegisterExtension(ctx *Context, data interface{}) error

+ func RegisterSignal(ctx *Context, signal_type SignalType) error

type ACLExt

+ func (ext *ACLExt) Deserialize(ctx *Context, data []byte) error

type ACLExtContext

+ Loads map[PolicyType]PolicyLoadFunc

type AllNodesPolicy

+ func (policy *AllNodesPolicy) Copy() Policy

+ func (policy *AllNodesPolicy) Deserialize(ctx *Context, data []byte) error

+ type AuthorizedSignal struct

+ Principal *ecdsa.PublicKey

+ Signal Signal

+ Signature []byte

+ func NewAuthorizedSignal(principal *ecdsa.PrivateKey, signal Signal) (AuthorizedSignal, error)

+ func (signal *AuthorizedSignal) Permission() Action

type BaseSignal

+ UUID uuid.UUID

+ func (signal *BaseSignal) Deserialize(ctx *Context, data []byte) error

type ECDHExt

+ func (ext *ECDHExt) Deserialize(ctx *Context, data []byte) error

type ErrorSignal

+ func (signal *ErrorSignal) Permission() Action

type Extension

+ func LoadExtension(ctx *Context, data []byte) (Extension, error)

type GQLExt

+ func (ext *GQLExt) Deserialize(ctx *Context, data []byte) error

+ func (ext *GQLExt) FreeResponseChannel(req_id uuid.UUID) chan Signal

+ func (ext *GQLExt) GetResponseChannel(req_id uuid.UUID) chan Signal

type GroupExt

+ func (ext *GroupExt) Deserialize(ctx *Context, data []byte) error

type ListenerExt

+ func (ext *ListenerExt) Deserialize(ctx *Context, data []byte) error

type LockableExt

+ func (ext *LockableExt) Deserialize(ctx *Context, data []byte) error

type NodeActions

+ func CopyNodeActions(actions NodeActions) NodeActions

type PerNodePolicy

+ func (policy *PerNodePolicy) Copy() Policy

+ func (policy *PerNodePolicy) Deserialize(ctx *Context, data []byte) error

type Policy

+ func LoadPolicy(ctx *Context, data []byte) (Policy, error)

+ Copy func() Policy

type ReadResultSignal

+ func (signal *ReadResultSignal) Permission() Action

type RequirementOfPolicy

+ func (policy *RequirementOfPolicy) Copy() Policy

type ResolveContext

+ Chans map[uuid.UUID]chan Signal

+ Key *ecdsa.PrivateKey

type Serializable

+ Deserialize func(*Context, []byte) error

type Signal

+ func LoadSignal(ctx *Context, data []byte) (Signal, error)

v0.3.1

Aug 1, 2023

Changes in this version

type BaseSignal

+ func (signal BaseSignal) ID() uuid.UUID

type Signal

+ func WaitForResult(listener chan Signal, timeout time.Duration, id uuid.UUID) (Signal, error)

+ ID func() uuid.UUID

v0.3.0

Jul 31, 2023

Changes in this version

+ const StartSignalType

v0.2.8

Jul 31, 2023

Changes in this version

+ const ErrorSignalType

+ type ErrorSignal struct

+ Error error

+ func NewErrorSignal(err error) ErrorSignal

type GQLExt

+ State string

+ type IDStringSignal struct

+ ID NodeID

+ Str string

+ func NewIDStringSignal(signal_type SignalType, direction SignalDirection, state string, id NodeID) IDStringSignal

+ func (signal IDStringSignal) Serialize() ([]byte, error)

+ func (signal IDStringSignal) String() string

+ type StringSignal struct

+ Str string

+ func (signal StringSignal) Permission() Action

+ func (signal StringSignal) Serialize() ([]byte, error)

v0.2.7

Jul 30, 2023

Changes in this version

type IDStateSignal

+ func NewIDStateSignal(signal_type SignalType, direction SignalDirection, state string, id NodeID) IDStateSignal

+ type LinkMap map[NodeID]LinkState

+ func (m LinkMap) MarshalJSON() ([]byte, error)

+ func (m LinkMap) UnmarshalJSON(data []byte) error

+ type LinkState struct

+ Initiator NodeID

+ Link string

+ Lock string

v0.2.6

Jul 30, 2023

Changes in this version

+ const DEFAULT_ECDH_WINDOW

+ const ECDHProxySignalType

+ const ECDHSignalType

+ const ECDHStateSignalType

+ const GQLStateSignalType

+ const GQL_RESOLVER_CHAN_SIZE

+ const LinkStartSignalType

+ const ReadResultSignalType

+ const ReadSignalType

+ const SIGNAL_SER_HEADER_LENGTH

+ const SIGNAL_SER_MAGIC

+ var MutationStop = NewField(func() *graphql.Field { ... })

+ var TypeSignal = NewSingleton(func() *graphql.Object { ... }, nil)

+ func GQLInterfaces(ctx *GQLExtContext, interface_names []string) ([]*graphql.Interface, error)

+ func GetFieldNames(ctx *Context, selection_set *ast.SelectionSet) []string

+ func GetResolveFields(ctx *Context, p graphql.ResolveParams) []string

+ func NodeInterfaceDefaultIsType(extensions []ExtType) func(graphql.IsTypeOfParams) bool

+ func NodeInterfaceResolveType(required_extensions []ExtType, default_type **graphql.Object) func(graphql.ResolveTypeParams) *graphql.Object

+ func ReadNodeFields(ctx *Context, self *Node, princ NodeID, reqs map[ExtType][]string) map[ExtType]map[string]interface

+ func RegisterField(ctx *GQLExtContext, gql_type graphql.Type, gql_name string, ext_type ExtType, ...) error

+ func ResolveFields(t T, name string, field_funcs map[string]func(T) interface{}) interface

+ func ResolveNodeID(p graphql.ResolveParams) (interface{}, error)

+ func ResolveNodeResult(p graphql.ResolveParams, ...) (interface{}, error)

+ func ResolveNodeTypeHash(p graphql.ResolveParams) (interface{}, error)

+ func SerializeSignal(signal Signal, block_size int) ([]byte, error)

+ func VerifyECDHSignal(now time.Time, sig ECDHSignal, window time.Duration) error

+ func WaitForSignal(ctx *Context, listener *ListenerExt, timeout time.Duration, ...) (S, error)

type ACLExt

+ func (ext *ACLExt) Field(name string) interface{}

type Action

+ func MakeAction(parts ...interface{}) Action

+ func (action Action) Allows(test Action) bool

type Context

+ ECDH ecdh.Curve

+ ECDSA elliptic.Curve

+ NodesLock sync.RWMutex

+ Signals map[uint64]SignalInfo

+ func (ctx *Context) AddNode(id NodeID, node *Node)

+ func (ctx *Context) Node(id NodeID) (*Node, bool)

+ func (ctx *Context) RegisterSignal(signal_type SignalType, load_fn SignalLoadFunc) error

type ECDHExt

+ ECDHStates ECDHMap

+ func NewECDHExt() *ECDHExt

+ func (ext *ECDHExt) Field(name string) interface{}

+ func (ext *ECDHExt) HandleECDHProxySignal(ctx *Context, source NodeID, node *Node, signal ECDHProxySignal)

+ func (ext *ECDHExt) HandleECDHSignal(ctx *Context, source NodeID, node *Node, signal ECDHSignal)

+ func (ext *ECDHExt) HandleStateSignal(ctx *Context, source NodeID, node *Node, signal StateSignal)

+ type ECDHMap map[NodeID]ECDHState

+ func (m ECDHMap) MarshalJSON() ([]byte, error)

+ type ECDHProxySignal struct

+ Data []byte

+ Dest NodeID

+ IV []byte

+ Source NodeID

+ func NewECDHProxySignal(source, dest NodeID, signal Signal, shared_secret []byte) (ECDHProxySignal, error)

+ type ECDHSignal struct

+ ECDH *ecdh.PublicKey

+ ECDSA *ecdsa.PublicKey

+ Signature []byte

+ Time time.Time

+ func NewECDHReqSignal(ctx *Context, node *Node) (ECDHSignal, *ecdh.PrivateKey, error)

+ func NewECDHRespSignal(ctx *Context, node *Node, req ECDHSignal) (ECDHSignal, []byte, error)

+ func (signal *ECDHSignal) MarshalJSON() ([]byte, error)

+ func (signal ECDHSignal) Serialize() ([]byte, error)

+ type ECDHSignalJSON struct

+ ECDH []byte

+ ECDSA []byte

+ Signature []byte

+ Time time.Time

+ type ECDHState struct

+ ECKey *ecdh.PrivateKey

+ SharedSecret []byte

+ func (state *ECDHState) MarshalJSON() ([]byte, error)

+ func (state *ECDHState) UnmarshalJSON(data []byte) error

+ type ECDHStateJSON struct

+ ECKey []byte

+ SharedSecret []byte

type ExtType

+ func GQLFields(ctx *GQLExtContext, field_names []string) (graphql.Fields, []ExtType, error)

type Extension

+ Field func(string) interface{}

+ type Field struct

+ Ext ExtType

+ Field *graphql.Field

+ Name string

type GQLExt

+ func (ext *GQLExt) Field(name string) interface{}

+ func (ext *GQLExt) StartGQLServer(ctx *Context, node *Node) error

+ func (ext *GQLExt) StopGQLServer() error

type GQLExtContext

+ Fields map[string]Field

+ func (ctx *GQLExtContext) GetACLFields(obj_name string, names []string) (map[ExtType][]string, error)

+ func (ctx *GQLExtContext) RegisterInterface(name string, default_name string, interfaces []string, fields []string, ...) error

type GroupExt

+ func (ext *GroupExt) Field(name string) interface{}

type IDSignal

+ func (signal IDSignal) Serialize() ([]byte, error)

+ type IDStateSignal struct

+ ID NodeID

+ State string

+ func (signal IDStateSignal) Serialize() ([]byte, error)

+ func (signal IDStateSignal) String() string

+ type Interface struct

+ Default *graphql.Object

+ Extensions []ExtType

+ Interface *graphql.Interface

+ List *graphql.List

+ type LinkStartSignal struct

+ LinkType string

+ func NewLinkStartSignal(link_type string, target NodeID) LinkStartSignal

+ type ListField struct

+ ACLName string

+ Extension ExtType

+ ResolveFn func(graphql.ResolveParams, interface{}) ([]NodeID, error)

type ListenerExt

+ func (ext *ListenerExt) Field(name string) interface{}

type LockableExt

+ func (ext *LockableExt) Field(name string) interface{}

+ func (ext *LockableExt) HandleLinkStartSignal(ctx *Context, source NodeID, node *Node, signal LinkStartSignal)

type Node

+ BufferSize uint32

+ Key *ecdsa.PrivateKey

type NodeActions

+ func (actions NodeActions) MarshalJSON() ([]byte, error)

+ func (actions NodeActions) UnmarshalJSON(data []byte) error

type NodeDB

+ KeyBytes []byte

type NodeDBHeader

+ BufferSize uint32

+ KeyLength uint32

type NodeID

+ func KeyID(pub *ecdsa.PublicKey) NodeID

+ type NodeResult struct

+ ID NodeID

+ Result *ReadResultSignal

+ func ResolveNodes(ctx *ResolveContext, p graphql.ResolveParams, ids []NodeID) ([]NodeResult, error)

+ type ReadResultSignal struct

+ Extensions map[ExtType]map[string]interface{}

+ func NewReadResultSignal(req_id uuid.UUID, node_type NodeType, exts map[ExtType]map[string]interface{}) ReadResultSignal

+ func WaitForReadResult(listener chan *ReadResultSignal, timeout time.Duration, id uuid.UUID) (*ReadResultSignal, error)

+ type ReadSignal struct

+ Extensions map[ExtType][]string

+ UUID uuid.UUID

+ func NewReadSignal(exts map[ExtType][]string) ReadSignal

+ func (signal ReadSignal) Serialize() ([]byte, error)

type ResolveContext

+ Chan chan *ReadResultSignal

+ ID uuid.UUID

+ type SelfField struct

+ ACLName string

+ Extension ExtType

+ ResolveFn func(graphql.ResolveParams, interface{}) (NodeID, error)

type Signal

+ func ParseECDHProxySignal(ctx *Context, signal *ECDHProxySignal, shared_secret []byte) (Signal, error)

+ func ParseSignal(ctx *Context, data []byte) (Signal, error)

+ type SignalHeader struct

+ Length uint64

+ Magic uint32

+ TypeHash uint64

+ type SignalInfo struct

+ Load SignalLoadFunc

+ Type SignalType

+ type SignalLoadFunc func(*Context, []byte) (Signal, error)

type SignalType

+ func (signal_type SignalType) Prefix() string

+ func (signal_type SignalType) String() string

type StateSignal

+ func (signal StateSignal) Permission() Action

type Type

+ List *graphql.List

+ Type *graphql.Object

+ type TypeName interface

+ Prefix func() string

+ String func() string

v0.2.5

Jul 28, 2023

Changes in this version

+ func MergeNodeActions(modified NodeActions, read NodeActions)

+ type Action string

type Actions

+ func MergeActions(first Actions, second Actions) Actions

type AllNodesPolicy

+ func (policy *AllNodesPolicy) Merge(p Policy) Policy

type BaseSignal

+ func (signal BaseSignal) Permission() Action

type PerNodePolicy

+ func (policy *PerNodePolicy) Merge(p Policy) Policy

type Policy

+ Merge func(Policy) Policy

type RequirementOfPolicy

+ func (policy *RequirementOfPolicy) Merge(p Policy) Policy

type Signal

+ Permission func() Action

v0.2.4

Jul 28, 2023

Changes in this version

+ func IDMap(m T) map[string]S

+ func LoadIDMap(m T) (map[NodeID]S, error)

+ type GroupExtJSON struct

+ Members map[string]string

+ type LockableExtJSON struct

+ Dependencies map[string]string

+ Owner *NodeID

+ PendingOwner *NodeID

+ Requirements map[string]ReqState

v0.2.3

Jul 28, 2023

Changes in this version

+ func Hash(t Type) uint64

type ExtType

+ func (ext ExtType) Prefix() string

+ func (ext ExtType) String() string

type NodeType

+ func (node NodeType) Prefix() string

+ func (node NodeType) String() string

type PolicyType

+ func (policy PolicyType) Prefix() string

+ func (policy PolicyType) String() string

+ type Type interface

+ Prefix func() string

+ String func() string

v0.2.2

Jul 28, 2023

v0.2.1

Jul 28, 2023

Changes in this version

+ func UnlockLockable(ctx *Context, node *Node) error

type Context

+ func (ctx *Context) Stop()

type LockableExt

+ PendingOwner *NodeID

+ type ReqState struct

+ Link string

+ Lock string

v0.2.0

Jul 28, 2023

Changes in this version

+ const ACLExtType

+ const AllNodesPolicyType

+ const ECDHExtType

+ const EXTENSION_DB_HEADER_LEN

+ const GQLExtType

+ const GQLNodeType

+ const GroupExtType

+ const LinkSignalType

+ const ListenerExtType

+ const LockSignalType

+ const LockableExtType

+ const NODE_MSG_CHAN_DEFAULT

+ const PerNodePolicyType

+ const RequirementOfPolicyType

+ const StatusSignalType

+ const StopSignalType

+ var GQLLockableInterfaces = append(GQLNodeInterfaces, GQLInterfaceLockable.Interface)

+ var GQLMutationStartChild = NewField(func() *graphql.Field { ... })

+ var GQLMutationStop = NewField(func() *graphql.Field { ... })

+ var GQLNodeInterfaces = []*graphql.Interface

+ var GQLQueryUser = &graphql.Field

+ var GQLTypeGQLNode = NewGQLNodeType(GQLNodeType, GQLNodeInterfaces, func(gql *GQLType) { ... })

+ var NodeNotFoundError = errors.New("Node not found in DB")

+ var StopSignal = NewDownSignal(StopSignalType)

+ var ZeroID = NodeID(ZeroUUID)

+ var ZeroUUID = uuid.UUID

+ func AddLockableFields(object *graphql.Object)

+ func AddLockableInterfaceFields(gql *GQLInterface)

+ func AddNodeFields(object *graphql.Object)

+ func AddNodeInterfaceFields(gql *GQLInterface)

+ func AllNodesPolicyLoad(init_fn func(Actions) (Policy, error)) func(*Context, []byte) (Policy, error)

+ func Allowed(ctx *Context, principal_id NodeID, action SignalType, node *Node) error

+ func AuthHandler(ctx *Context, server *Node, gql_ext *GQLExt) func(http.ResponseWriter, *http.Request)

+ func BuildSchema(ctx *GQLExtContext) (graphql.Schema, error)

+ func ExtractList(p graphql.ResolveParams, name string) ([]K, error)

+ func ExtractParam(p graphql.ResolveParams, name string) (K, error)

+ func GQLGroupMembers(p graphql.ResolveParams) (interface{}, error)

+ func GQLNodeHasExtensions(extensions []ExtType) func(graphql.IsTypeOfParams) bool

+ func GQLNodeListen(p graphql.ResolveParams) (interface{}, error)

+ func GQLNodeTypeHash(p graphql.ResolveParams) (interface{}, error)

+ func GQLThreadState(p graphql.ResolveParams) (interface{}, error)

+ func GetCtx(ctx *Context) (C, error)

+ func GetExt(node *Node) (T, error)

+ func LinkRequirement(ctx *Context, dependency *Node, requirement NodeID) error

+ func LockLockable(ctx *Context, node *Node) error

+ func NewField(init func() *graphql.Field) *graphql.Field

+ func NodeHasExtensions(node *Node, extensions []ExtType) bool

+ func NodeLoop(ctx *Context, node *Node) error

+ func NodeResolver(required_extensions []ExtType, default_type **graphql.Object) func(graphql.ResolveTypeParams) *graphql.Object

+ func ParseAuthRespJSON(resp AuthRespJSON, ecdsa_curve elliptic.Curve, ecdh_curve ecdh.Curve, ...) ([]byte, error)

+ func PerNodePolicyLoad(init_fn func(NodeActions) (Policy, error)) func(*Context, []byte) (Policy, error)

+ func PrepResolve(p graphql.ResolveParams) (*Node, *ResolveContext, error)

+ func RunNode(ctx *Context, node *Node)

+ func SaveNode(node *Node) string

+ func SaveNodeList(nodes NodeMap) []string

+ func SaveNodeMap(nodes NodeMap) map[string]string

+ func StartGQLServer(ctx *Context, node *Node, gql_ext *GQLExt) error

+ func StopGQLServer(gql_ext *GQLExt)

+ func ValidateStateContext(context *StateContext, Type string, Finished bool) error

+ func WriteNode(ctx *Context, node *Node) error

+ type ACLExt struct

+ Policies map[PolicyType]Policy

+ func NewACLExt(policies ...Policy) *ACLExt

+ func (ext *ACLExt) Allows(ctx *Context, principal_id NodeID, action SignalType, node *Node) error

+ func (ext *ACLExt) Process(ctx *Context, princ_id NodeID, node *Node, signal Signal)

+ func (ext *ACLExt) Serialize() ([]byte, error)

+ func (ext *ACLExt) Type() ExtType

+ type ACLExtContext struct

+ Types map[PolicyType]PolicyInfo

+ func NewACLExtContext() *ACLExtContext

+ type ACLInfo struct

+ Node *Node

+ Resources []string

+ type ACLMap map[NodeID]ACLInfo

+ func ACLList(list []*Node, resources []string) ACLMap

+ func ACLListM(m map[NodeID]*Node, resources []string) ACLMap

+ func NewACLInfo(node *Node, resources []string) ACLMap

+ func NewACLMap(requests ...ACLMap) ACLMap

+ type Actions []SignalType

+ func (actions Actions) Allows(action SignalType) error

+ type AllNodesPolicy struct

+ Actions Actions

+ func NewAllNodesPolicy(actions Actions) AllNodesPolicy

+ func (policy *AllNodesPolicy) Allows(principal_id NodeID, action SignalType, node *Node) error

+ func (policy *AllNodesPolicy) Serialize() ([]byte, error)

+ func (policy *AllNodesPolicy) Type() PolicyType

+ type AllNodesPolicyJSON struct

+ Actions Actions

+ type AuthReqJSON struct

+ ECDHPubkey []byte

+ Pubkey []byte

+ Signature []byte

+ Time time.Time

+ func NewAuthReqJSON(curve ecdh.Curve, id *ecdsa.PrivateKey) (AuthReqJSON, *ecdh.PrivateKey, error)

+ type AuthRespJSON struct

+ ECDHPubkey []byte

+ Granted time.Time

+ Signature []byte

+ func NewAuthRespJSON(gql_ext *GQLExt, req AuthReqJSON) (AuthRespJSON, *ecdsa.PublicKey, []byte, error)

type BaseSignal

+ SignalDirection SignalDirection

+ SignalType SignalType

+ func NewUpSignal(signal_type SignalType) BaseSignal

+ func (signal BaseSignal) Serialize() ([]byte, error)

type Context

+ Extensions map[uint64]ExtensionInfo

+ Nodes map[NodeID]*Node

+ func (ctx *Context) GetNode(id NodeID) (*Node, error)

+ func (ctx *Context) RegisterExtension(ext_type ExtType, load_fn ExtensionLoadFunc, data interface{}) error

+ func (ctx *Context) Send(source NodeID, dest NodeID, signal Signal) error

+ type ECDHExt struct

+ Granted time.Time

+ Pubkey *ecdsa.PublicKey

+ Shared []byte

+ func (ext *ECDHExt) Process(ctx *Context, princ_id NodeID, node *Node, signal Signal)

+ func (ext *ECDHExt) Serialize() ([]byte, error)

+ func (ext *ECDHExt) Type() ExtType

+ type ECDHExtJSON struct

+ Granted time.Time

+ Pubkey []byte

+ Shared []byte

+ type ExtMap map[uint64]Extension

+ type ExtType string

+ func (ext ExtType) Hash() uint64

+ type Extension interface

+ Process func(context *Context, source NodeID, node *Node, signal Signal)

+ func LoadACLExt(ctx *Context, data []byte) (Extension, error)

+ func LoadECDHExt(ctx *Context, data []byte) (Extension, error)

+ func LoadGQLExt(ctx *Context, data []byte) (Extension, error)

+ func LoadGroupExt(ctx *Context, data []byte) (Extension, error)

+ func LoadListenerExt(ctx *Context, data []byte) (Extension, error)

+ func LoadLockableExt(ctx *Context, data []byte) (Extension, error)

+ type ExtensionDB struct

+ Data []byte

+ Header ExtensionDBHeader

+ func (extension ExtensionDB) Serialize() []byte

+ type ExtensionDBHeader struct

+ Length uint64

+ TypeHash uint64

+ func (header ExtensionDBHeader) Serialize() []byte

+ type ExtensionInfo struct

+ Data interface{}

+ Load ExtensionLoadFunc

+ Type ExtType

+ type ExtensionLoadFunc func(*Context, []byte) (Extension, error)

+ type GQLExt struct

+ ECDH ecdh.Curve

+ Key *ecdsa.PrivateKey

+ Listen string

+ SubscribeListeners []chan Signal

+ SubscribeLock sync.Mutex

+ Users NodeMap

+ func NewGQLExt(listen string, ecdh_curve ecdh.Curve, key *ecdsa.PrivateKey, tls_cert []byte, ...) *GQLExt

+ func (ext *GQLExt) NewSubscriptionChannel(buffer int) chan Signal

+ func (ext *GQLExt) Process(context *Context, princ_id NodeID, node *Node, signal Signal)

+ func (ext *GQLExt) Serialize() ([]byte, error)

+ func (ext *GQLExt) Type() ExtType

+ type GQLExtContext struct

+ Interfaces []*GQLInterface

+ Mutation *graphql.Object

+ NodeTypes map[NodeType]*graphql.Object

+ Query *graphql.Object

+ Schema graphql.Schema

+ Subscription *graphql.Object

+ Types []graphql.Type

+ func NewGQLExtContext() *GQLExtContext

+ func (ctx *GQLExtContext) AddInterface(i *GQLInterface) error

+ func (ctx *GQLExtContext) RegisterNodeType(node_type NodeType, gql_type *graphql.Object) error

+ type GQLExtJSON struct

+ ECDH uint8

+ Key []byte

+ Listen string

+ TLSCert []byte

+ TLSKey []byte

+ type GQLInterface struct

+ Default *graphql.Object

+ Extensions []ExtType

+ Interface *graphql.Interface

+ List *graphql.List

+ func NewGQLInterface(if_name string, default_name string, interfaces []*graphql.Interface, ...) *GQLInterface

+ type GQLPayload struct

+ Data string

+ Extensions map[string]interface{}

+ OperationName string

+ Query string

+ Variables map[string]interface{}

+ type GQLType struct

+ List *graphql.List

+ Type *graphql.Object

+ func NewGQLNodeType(node_type NodeType, interfaces []*graphql.Interface, init func(*GQLType)) *GQLType

+ type GQLUnauthorized string

+ func (e GQLUnauthorized) Error() string

+ func (e GQLUnauthorized) Is(target error) bool

+ func (e GQLUnauthorized) MarshalJSON() ([]byte, error)

+ type GroupExt struct

+ Members NodeMap

+ func NewGroupExt(members NodeMap) *GroupExt

+ func (ext *GroupExt) Process(ctx *Context, princ_id NodeID, node *Node, signal Signal)

+ func (ext *GroupExt) Serialize() ([]byte, error)

+ func (ext *GroupExt) Type() ExtType

+ type IDSignal struct

+ ID NodeID

+ func NewIDSignal(signal_type SignalType, direction SignalDirection, id NodeID) IDSignal

+ func (signal IDSignal) String() string

+ type ListenerExt struct

+ Buffer int

+ Chan chan Signal

+ func NewListenerExt(buffer int) *ListenerExt

+ func (ext *ListenerExt) Process(ctx *Context, princ_id NodeID, node *Node, signal Signal)

+ func (ext *ListenerExt) Serialize() ([]byte, error)

+ func (listener *ListenerExt) Type() ExtType

+ type LockableExt struct

+ Dependencies map[NodeID]string

+ LockStates map[NodeID]string

+ LocksHeld map[NodeID]*NodeID

+ Owner *NodeID

+ Requirements map[NodeID]string

+ func NewLockableExt() *LockableExt

+ func (ext *LockableExt) HandleLinkSignal(ctx *Context, source NodeID, node *Node, signal StateSignal)

+ func (ext *LockableExt) HandleLockSignal(ctx *Context, source NodeID, node *Node, signal StateSignal)

+ func (ext *LockableExt) Process(ctx *Context, source NodeID, node *Node, signal Signal)

+ func (ext *LockableExt) RecordLock(node NodeID, last_owner *NodeID)

+ func (ext *LockableExt) RecordUnlock(node NodeID) *NodeID

+ func (ext *LockableExt) Serialize() ([]byte, error)

+ func (ext *LockableExt) Type() ExtType

+ type Msg struct

+ Signal Signal

+ Source NodeID

type Node

+ Active atomic.Bool

+ Extensions map[ExtType]Extension

+ MsgChan chan Msg

+ NextSignal *QueuedSignal

+ SignalQueue []QueuedSignal

+ TimeoutChan <-chan time.Time

+ func NewNode(ctx *Context, id NodeID, node_type NodeType, queued_signals []QueuedSignal, ...) *Node

+ func RestoreNode(ctx *Context, id_str string) (*Node, error)

+ func (node *Node) ClearSignalQueue()

+ func (node *Node) Process(ctx *Context, source NodeID, signal Signal)

+ func (node *Node) QueueSignal(time time.Time, signal Signal)

+ type NodeActions map[NodeID]Actions

+ type NodeDB struct

+ Extensions []ExtensionDB

+ Header NodeDBHeader

+ QueuedSignals []QueuedSignal

+ func NewNodeDB(data []byte) (NodeDB, error)

+ func (node NodeDB) Serialize() []byte

+ type NodeDBHeader struct

+ Magic uint32

+ NumExtensions uint32

+ NumQueuedSignals uint32

+ TypeHash uint64

+ func (header NodeDBHeader) Serialize() []byte

type NodeID

+ func ExtractID(p graphql.ResolveParams, name string) (NodeID, error)

+ func IDFromBytes(bytes [16]byte) NodeID

+ func ParseID(str string) (NodeID, error)

+ func (id *NodeID) UnmarshalJSON(bytes []byte) error

+ func (id NodeID) MarshalJSON() ([]byte, error)

+ func (id NodeID) String() string

+ type NodeInfo struct

+ Extensions []ExtType

+ Type NodeType

type NodeMap

+ func RestoreNodeList(ctx *Context, ids []string) (NodeMap, error)

+ func RestoreNodeMap(ctx *Context, ids map[string]string) (NodeMap, error)

+ type PerNodePolicy struct

+ NodeActions NodeActions

+ func NewPerNodePolicy(node_actions NodeActions) PerNodePolicy

+ func (policy *PerNodePolicy) Allows(principal_id NodeID, action SignalType, node *Node) error

+ func (policy *PerNodePolicy) Serialize() ([]byte, error)

+ func (policy *PerNodePolicy) Type() PolicyType

+ type Policy interface

+ Allows func(principal_id NodeID, action SignalType, node *Node) error

+ type PolicyInfo struct

+ Load PolicyLoadFunc

+ type PolicyLoadFunc func(*Context, []byte) (Policy, error)

+ type PolicyType string

+ func (policy PolicyType) Hash() uint64

+ type QueuedSignal struct

+ Signal Signal

+ Time time.Time

+ func SoonestSignal(signals []QueuedSignal) (*QueuedSignal, <-chan time.Time)

+ type RequirementOfPolicy struct

+ func NewRequirementOfPolicy(actions Actions) RequirementOfPolicy

+ func (policy *RequirementOfPolicy) Allows(principal_id NodeID, action SignalType, node *Node) error

+ func (policy *RequirementOfPolicy) Type() PolicyType

+ type ResolveContext struct

+ Context *Context

+ Ext *GQLExt

+ GQLContext *GQLExtContext

+ Server *Node

+ User *Node

+ func NewResolveContext(ctx *Context, server *Node, gql_ext *GQLExt, r *http.Request) (*ResolveContext, error)

+ type Serializable interface

+ Serialize func() ([]byte, error)

+ Type func() I

+ type Signal interface

+ Direction func() SignalDirection

+ type SignalType string

+ type Singleton struct

+ List *graphql.List

+ Type K

+ func NewSingleton(init func() K, post_init func(K, *graphql.List)) *Singleton[K]

+ type StartChildSignal struct

+ Action string

+ func NewStartChildSignal(child_id NodeID, action string) StartChildSignal

+ type StateContext struct

+ Finished bool

+ Graph *Context

+ Locked map[NodeID]*Node

+ Permissions map[NodeID]ACLMap

+ Started bool

+ Type string

+ func NewReadContext(ctx *Context) *StateContext

+ func NewWriteContext(ctx *Context) *StateContext

+ type StateFn func(*StateContext) error

+ type StateSignal struct

+ State string

+ func NewLinkSignal(state string) StateSignal

+ func NewLockSignal(state string) StateSignal

+ func (signal StateSignal) Serialize() ([]byte, error)

+ func (signal StateSignal) String() string

+ type StatusSignal struct

+ Status string

+ func NewStatusSignal(status string, source NodeID) StatusSignal

+ func (signal StatusSignal) String() string

v0.1.0

Jul 11, 2023

Changes in this version

+ const NODE_DB_HEADER_LEN

+ const NODE_DB_MAGIC

+ const THREAD_SIGNAL_BUFFER_SIZE

+ var BaseThreadActions = ThreadActions

+ var BaseThreadHandlers = ThreadHandlers

+ var ThreadDefaultRestore = func(ctx *Context, thread Thread) (string, error)

+ var ThreadDefaultStart = func(ctx *Context, thread Thread) (string, error)

+ var ThreadStart = func(ctx *Context, thread Thread) error

+ var ThreadWait = func(ctx *Context, thread Thread) (string, error)

+ func ChildGo(ctx *Context, thread Thread, child Thread, first_action string)

+ func GQLHandler(ctx *Context, server *GQLThread) func(http.ResponseWriter, *http.Request)

+ func GQLInterfaceLockable() *graphql.Interface

+ func GQLInterfaceNode() *graphql.Interface

+ func GQLInterfaceThread() *graphql.Interface

+ func GQLListLockable() *graphql.List

+ func GQLListThread() *graphql.List

+ func GQLLockableDependencies(p graphql.ResolveParams) (interface{}, error)

+ func GQLLockableName(p graphql.ResolveParams) (interface{}, error)

+ func GQLLockableOwner(p graphql.ResolveParams) (interface{}, error)

+ func GQLLockableRequirements(p graphql.ResolveParams) (interface{}, error)

+ func GQLMutationSendUpdate() *graphql.Field

+ func GQLNodeID(p graphql.ResolveParams) (interface{}, error)

+ func GQLQuerySelf() *graphql.Field

+ func GQLSignalDirection(p graphql.ResolveParams) (interface{}, error)

+ func GQLSignalFn(p graphql.ResolveParams, ...) (interface{}, error)

+ func GQLSignalSource(p graphql.ResolveParams) (interface{}, error)

+ func GQLSignalString(p graphql.ResolveParams) (interface{}, error)

+ func GQLSignalType(p graphql.ResolveParams) (interface{}, error)

+ func GQLSubscribeFn(p graphql.ResolveParams, send_nil bool, ...) (interface{}, error)

+ func GQLSubscribeSelf(p graphql.ResolveParams) (interface{}, error)

+ func GQLSubscribeSignal(p graphql.ResolveParams) (interface{}, error)

+ func GQLSubscriptionSelf() *graphql.Field

+ func GQLSubscriptionUpdate() *graphql.Field

+ func GQLThreadChildren(p graphql.ResolveParams) (interface{}, error)

+ func GQLThreadListen(p graphql.ResolveParams) (interface{}, error)

+ func GQLThreadParent(p graphql.ResolveParams) (interface{}, error)

+ func GQLTypeGQLThread() *graphql.Object

+ func GQLTypeGraphNode() *graphql.Object

+ func GQLTypeSignal() *graphql.Object

+ func GQLTypeSignalInput() *graphql.InputObject

+ func GQLTypeSimpleLockable() *graphql.Object

+ func GQLTypeSimpleThread() *graphql.Object

+ func GQLWSDo(ctx *Context, p graphql.Params) chan *graphql.Result

+ func GQLWSHandler(ctx *Context, server *GQLThread) func(http.ResponseWriter, *http.Request)

+ func GraphiQLHandler() func(http.ResponseWriter, *http.Request)

+ func LinkLockables(ctx *Context, lockable Lockable, requirements []Lockable, nodes NodeMap) error

+ func LinkThreads(ctx *Context, thread Thread, child Thread, info ThreadInfo, nodes NodeMap) error

+ func LockLockables(ctx *Context, to_lock []Lockable, new_owner Lockable, nodes NodeMap) error

+ func RestoreSimpleLockable(ctx *Context, lockable Lockable, j SimpleLockableJSON, nodes NodeMap) error

+ func RestoreSimpleThread(ctx *Context, thread Thread, j SimpleThreadJSON, nodes NodeMap) error

+ func ThreadAbort(ctx *Context, thread Thread, signal GraphSignal) (string, error)

+ func ThreadCancel(ctx *Context, thread Thread, signal GraphSignal) (string, error)

+ func ThreadLoop(ctx *Context, thread Thread, first_action string) error

+ func UnlinkLockables(ctx *Context, lockable Lockable, requirement Lockable) error

+ func UnlinkThreads(ctx *Context, thread Thread, child Thread) error

+ func UnlockLockables(ctx *Context, to_unlock []Lockable, old_owner Lockable, nodes NodeMap) error

+ func UpdateChannel(node Node, buffer int, id NodeID) chan GraphSignal

+ func UpdateMoreStates(ctx *Context, nodes []Node, locked_nodes NodeMap, nodes_fn NodesFn) error

+ func UpdateStates(ctx *Context, nodes []Node, nodes_fn NodesFn) error

+ func UseMoreStates(ctx *Context, new_nodes []Node, nodes NodeMap, nodes_fn NodesFn) error

+ func UseStates(ctx *Context, init_nodes []Node, nodes_fn NodesFn) error

+ func WriteNodes(ctx *Context, nodes NodeMap) error

+ type BaseSignal struct

+ FDirection SignalDirection

+ FSource NodeID

+ FType string

+ func AbortSignal(source Node) BaseSignal

+ func CancelSignal(source Node) BaseSignal

+ func NewBaseSignal(source Node, _type string, direction SignalDirection) BaseSignal

+ func NewDirectSignal(source Node, _type string) BaseSignal

+ func NewDownSignal(source Node, _type string) BaseSignal

+ func NewSignal(source Node, _type string) BaseSignal

+ func (signal BaseSignal) Direction() SignalDirection

+ func (signal BaseSignal) Source() NodeID

+ func (signal BaseSignal) Type() string

+ func (state BaseSignal) String() string

+ type ConsoleLogger struct

+ func NewConsoleLogger(components []string) *ConsoleLogger

+ func (logger *ConsoleLogger) Logf(component string, format string, items ...interface{})

+ func (logger *ConsoleLogger) Logj(component string, s interface{}, format string, items ...interface{})

+ func (logger *ConsoleLogger) Logm(component string, fields map[string]interface{}, format string, ...)

+ func (logger *ConsoleLogger) SetComponents(components []string) error

+ type Context struct

+ DB *badger.DB

+ GQL GQLContext

+ Log Logger

+ Types map[uint64]NodeDef

+ func NewContext(db *badger.DB, log Logger) *Context

+ func (ctx *Context) AddGQLType(gql_type graphql.Type)

+ func (ctx *Context) RebuildSchema() error

+ func (ctx *Context) RegisterNodeType(def NodeDef) error

+ type DBHeader struct

+ Magic uint32

+ TypeHash uint64

+ func NewDBHeader(node_type NodeType) DBHeader

+ func (header DBHeader) Serialize() []byte

+ type GQLContext struct

+ LockableType reflect.Type

+ Mutation *graphql.Object

+ NodeType reflect.Type

+ Query *graphql.Object

+ Schema graphql.Schema

+ Subscription *graphql.Object

+ ThreadType reflect.Type

+ TypeList []graphql.Type

+ ValidLockables ObjTypeMap

+ ValidNodes ObjTypeMap

+ ValidThreads ObjTypeMap

+ func NewGQLContext() GQLContext

+ type GQLThread struct

+ Listen string

+ func NewGQLThread(id NodeID, name string, state_name string, listen string) GQLThread

+ func (thread *GQLThread) DeserializeInfo(ctx *Context, data []byte) (ThreadInfo, error)

+ func (thread *GQLThread) Serialize() ([]byte, error)

+ func (thread *GQLThread) Type() NodeType

+ type GQLThreadInfo struct

+ RestoreAction string

+ Start bool

+ StartAction string

+ func NewGQLThreadInfo(start bool, start_action string, restore_action string) GQLThreadInfo

+ type GQLThreadJSON struct

+ Listen string

+ func NewGQLThreadJSON(thread *GQLThread) GQLThreadJSON

+ type GQLWSMsg struct

+ ID string

+ Payload GQLWSPayload

+ Type string

+ type GQLWSPayload struct

+ Data string

+ Extensions map[string]interface{}

+ OperationName string

+ Query string

+ Variables map[string]interface{}

+ type GraphNode struct

+ func NewGraphNode(id NodeID) GraphNode

+ func (node *GraphNode) ID() NodeID

+ func (node *GraphNode) RegisterChannel(id NodeID, listener chan GraphSignal)

+ func (node *GraphNode) Serialize() ([]byte, error)

+ func (node *GraphNode) Signal(ctx *Context, signal GraphSignal, nodes NodeMap) error

+ func (node *GraphNode) Type() NodeType

+ func (node *GraphNode) UnregisterChannel(id NodeID)

+ type GraphSignal interface

+ Direction func() SignalDirection

+ Source func() NodeID

+ String func() string

+ Type func() string

+ type Lockable interface

+ AddDependency func(dependency Lockable)

+ AddRequirement func(requirement Lockable)

+ AllowedToTakeLock func(new_owner Lockable, lockable Lockable) bool

+ CanLock func(new_owner Lockable) error

+ CanUnlock func(old_owner Lockable) error

+ Dependencies func() []Lockable

+ Name func() string

+ Owner func() Lockable

+ RecordLock func(lockable Lockable, last_owner Lockable)

+ RecordUnlock func(lockable Lockable) Lockable

+ RemoveDependency func(dependency Lockable)

+ RemoveRequirement func(requirement Lockable)

+ Requirements func() []Lockable

+ SetOwner func(new_owner Lockable)

+ type Logger interface

+ Logf func(component string, format string, items ...interface{})

+ Logj func(component string, s interface{}, format string, items ...interface{})

+ Logm func(component string, fields map[string]interface{}, format string, ...)

+ SetComponents func(components []string) error

+ type Node interface

+ ID func() NodeID

+ RLock func()

+ RUnlock func()

+ RegisterChannel func(id NodeID, listener chan GraphSignal)

+ Serialize func() ([]byte, error)

+ Signal func(ctx *Context, signal GraphSignal, nodes NodeMap) error

+ Type func() NodeType

+ UnregisterChannel func(id NodeID)

+ func LoadGQLThread(ctx *Context, id NodeID, data []byte, nodes NodeMap) (Node, error)

+ func LoadGraphNode(ctx *Context, id NodeID, data []byte, nodes NodeMap) (Node, error)

+ func LoadNode(ctx *Context, id NodeID) (Node, error)

+ func LoadNodeRecurse(ctx *Context, id NodeID, nodes NodeMap) (Node, error)

+ func LoadSimpleLockable(ctx *Context, id NodeID, data []byte, nodes NodeMap) (Node, error)

+ func LoadSimpleThread(ctx *Context, id NodeID, data []byte, nodes NodeMap) (Node, error)

+ func NodeList(list []K) []Node

+ type NodeDef struct

+ GQLType *graphql.Object

+ Load NodeLoadFunc

+ Reflect reflect.Type

+ Type NodeType

+ func NewNodeDef(example Node, load_func NodeLoadFunc, gql_type *graphql.Object) NodeDef

+ type NodeID string

+ func RandID() NodeID

+ func (id NodeID) Serialize() []byte

+ type NodeLoadFunc func(*Context, NodeID, []byte, NodeMap) (Node, error)

+ type NodeMap map[NodeID]Node

+ type NodeType string

+ func (node_type NodeType) Hash() uint64

+ type NodesFn func(nodes NodeMap) error

+ type ObjTypeMap map[reflect.Type]*graphql.Object

+ type SignalDirection int

+ const Direct

+ const Down

+ const Up

+ type SimpleLockable struct

+ func NewSimpleLockable(id NodeID, name string) SimpleLockable

+ func (lockable *SimpleLockable) AddDependency(dependency Lockable)

+ func (lockable *SimpleLockable) AddRequirement(requirement Lockable)

+ func (lockable *SimpleLockable) AllowedToTakeLock(l Lockable, new_owner Lockable) bool

+ func (lockable *SimpleLockable) CanLock(new_owner Lockable) error

+ func (lockable *SimpleLockable) CanUnlock(new_owner Lockable) error

+ func (lockable *SimpleLockable) Dependencies() []Lockable

+ func (lockable *SimpleLockable) Name() string

+ func (lockable *SimpleLockable) Owner() Lockable

+ func (lockable *SimpleLockable) RecordLock(l Lockable, last_owner Lockable)

+ func (lockable *SimpleLockable) RecordUnlock(l Lockable) Lockable

+ func (lockable *SimpleLockable) RemoveDependency(dependency Lockable)

+ func (lockable *SimpleLockable) RemoveRequirement(requirement Lockable)

+ func (lockable *SimpleLockable) Requirements() []Lockable

+ func (lockable *SimpleLockable) Serialize() ([]byte, error)

+ func (lockable *SimpleLockable) SetOwner(owner Lockable)

+ func (lockable *SimpleLockable) Signal(ctx *Context, signal GraphSignal, nodes NodeMap) error

+ func (state *SimpleLockable) Type() NodeType

+ type SimpleLockableJSON struct

+ Dependencies []NodeID

+ LocksHeld map[NodeID]*NodeID

+ Name string

+ Owner *NodeID

+ Requirements []NodeID

+ func NewSimpleLockableJSON(lockable *SimpleLockable) SimpleLockableJSON

+ type SimpleThread struct

+ InfoType reflect.Type

+ func NewSimpleThread(id NodeID, name string, state_name string, info_type reflect.Type, ...) SimpleThread

+ func (thread *SimpleThread) Action(action string) (ThreadAction, bool)

+ func (thread *SimpleThread) AddChild(child Thread, info ThreadInfo) error

+ func (thread *SimpleThread) Child(id NodeID) Thread

+ func (thread *SimpleThread) ChildInfo(child NodeID) ThreadInfo

+ func (thread *SimpleThread) ChildWaits() *sync.WaitGroup

+ func (thread *SimpleThread) Children() []Thread

+ func (thread *SimpleThread) ClearTimeout()

+ func (thread *SimpleThread) DeserializeInfo(ctx *Context, data []byte) (ThreadInfo, error)

+ func (thread *SimpleThread) Handler(signal_type string) (ThreadHandler, bool)

+ func (thread *SimpleThread) Parent() Thread

+ func (thread *SimpleThread) RemoveChild(child Thread)

+ func (thread *SimpleThread) Serialize() ([]byte, error)

+ func (thread *SimpleThread) SetActive(active bool) error

+ func (thread *SimpleThread) SetParent(parent Thread)

+ func (thread *SimpleThread) SetState(new_state string) error

+ func (thread *SimpleThread) SetTimeout(timeout time.Time, action string)

+ func (thread *SimpleThread) Signal(ctx *Context, signal GraphSignal, nodes NodeMap) error

+ func (thread *SimpleThread) SignalChannel() <-chan GraphSignal

+ func (thread *SimpleThread) State() string

+ func (thread *SimpleThread) Timeout() <-chan time.Time

+ func (thread *SimpleThread) TimeoutAction() string

+ func (thread *SimpleThread) Type() NodeType

+ type SimpleThreadJSON struct

+ Children map[NodeID]interface{}

+ Parent *NodeID

+ StateName string

+ Timeout time.Time

+ TimeoutAction string

+ func NewSimpleThreadJSON(thread *SimpleThread) SimpleThreadJSON

+ type Thread interface

+ Action func(action string) (ThreadAction, bool)

+ AddChild func(child Thread, info ThreadInfo) error

+ Child func(id NodeID) Thread

+ ChildInfo func(child NodeID) ThreadInfo

+ ChildWaits func() *sync.WaitGroup

+ Children func() []Thread

+ ClearTimeout func()

+ DeserializeInfo func(ctx *Context, data []byte) (ThreadInfo, error)

+ Handler func(signal_type string) (ThreadHandler, bool)

+ Parent func() Thread

+ RemoveChild func(child Thread)

+ SetActive func(active bool) error

+ SetParent func(parent Thread)

+ SetState func(new_thread string) error

+ SetTimeout func(end_time time.Time, action string)

+ SignalChannel func() <-chan GraphSignal

+ State func() string

+ Timeout func() <-chan time.Time

+ TimeoutAction func() string

+ func FindChild(ctx *Context, thread Thread, id NodeID, nodes NodeMap) Thread

+ type ThreadAbortedError NodeID

+ func NewThreadAbortedError(aborter NodeID) ThreadAbortedError

+ func (e ThreadAbortedError) Error() string

+ func (e ThreadAbortedError) Is(target error) bool

+ type ThreadAction func(*Context, Thread) (string, error)

+ type ThreadActions map[string]ThreadAction

+ func NewThreadActions() ThreadActions

+ type ThreadHandler func(*Context, Thread, GraphSignal) (string, error)

+ type ThreadHandlers map[string]ThreadHandler

+ func NewThreadHandlers() ThreadHandlers

+ type ThreadInfo interface

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL