Split to seperate files and removed FSM libary to prepare for embedded callback mechanism
parent
c06ff16fc9
commit
11bf1e5344
@ -0,0 +1,217 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"errors"
|
||||||
|
graphql "github.com/graph-gophers/graphql-go"
|
||||||
|
"reflect"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Update the events listeners, and notify the parent to do the same
|
||||||
|
func (event * BaseEvent) Update() error {
|
||||||
|
err := event.UpdateListeners()
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
if event.parent != nil{
|
||||||
|
return event.parent.Update()
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type EventInfo interface {
|
||||||
|
}
|
||||||
|
|
||||||
|
type BaseEventInfo interface {
|
||||||
|
EventInfo
|
||||||
|
}
|
||||||
|
|
||||||
|
type EventQueueInfo struct {
|
||||||
|
EventInfo
|
||||||
|
priority int
|
||||||
|
state string
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewEventQueueInfo(priority int) * EventQueueInfo {
|
||||||
|
info := &EventQueueInfo{
|
||||||
|
priority: priority,
|
||||||
|
state: "queued",
|
||||||
|
}
|
||||||
|
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
|
||||||
|
// Event is the interface that event tree nodes must implement
|
||||||
|
type Event interface {
|
||||||
|
GraphNode
|
||||||
|
Children() []Event
|
||||||
|
ChildInfo(event Event) EventInfo
|
||||||
|
Parent() Event
|
||||||
|
RegisterParent(parent Event) error
|
||||||
|
RequiredResources() []Resource
|
||||||
|
CreatedResources() []Resource
|
||||||
|
AddChild(child Event, info EventInfo) error
|
||||||
|
FindChild(id graphql.ID) Event
|
||||||
|
}
|
||||||
|
|
||||||
|
// BaseEvent is the most basic event that can exist in the event tree.
|
||||||
|
// On start it automatically transitions to completion.
|
||||||
|
// It can optionally require events, which will all need to be locked to start it
|
||||||
|
// It can optionally create resources, which will be locked by default and unlocked on completion
|
||||||
|
// This node by itself doesn't implement any special behaviours for children, so they will be ignored.
|
||||||
|
// When starter, this event automatically transitions to completion and unlocks all it's resources(including created)
|
||||||
|
type BaseEvent struct {
|
||||||
|
BaseNode
|
||||||
|
created_resources []Resource
|
||||||
|
required_resources []Resource
|
||||||
|
children []Event
|
||||||
|
child_info map[Event]EventInfo
|
||||||
|
parent Event
|
||||||
|
}
|
||||||
|
|
||||||
|
// EventQueue is a basic event that can have children.
|
||||||
|
// On start, it attempts to start it's children from the highest 'priority'
|
||||||
|
type EventQueue struct {
|
||||||
|
BaseEvent
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewEvent(name string, description string, required_resources []Resource) (* BaseEvent, Resource) {
|
||||||
|
done_resource := NewResource("event_done", "signal that event is done", []Resource{})
|
||||||
|
event := &BaseEvent{
|
||||||
|
BaseNode: BaseNode{
|
||||||
|
name: name,
|
||||||
|
description: description,
|
||||||
|
id: gql_randid(),
|
||||||
|
listeners: []chan error{},
|
||||||
|
},
|
||||||
|
parent: nil,
|
||||||
|
children: []Event{},
|
||||||
|
child_info: map[Event]EventInfo{},
|
||||||
|
created_resources: []Resource{done_resource},
|
||||||
|
required_resources: required_resources,
|
||||||
|
}
|
||||||
|
|
||||||
|
// Lock the done_resource by default
|
||||||
|
done_resource.Lock(event)
|
||||||
|
|
||||||
|
return event, done_resource
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewEventQueue(name string, description string, required_resources []Resource) (* EventQueue, Resource) {
|
||||||
|
done_resource := NewResource("event_done", "signal that event is done", []Resource{})
|
||||||
|
queue := &EventQueue{
|
||||||
|
BaseEvent: BaseEvent{
|
||||||
|
BaseNode: BaseNode{
|
||||||
|
name: name,
|
||||||
|
description: description,
|
||||||
|
id: gql_randid(),
|
||||||
|
listeners: []chan error{},
|
||||||
|
},
|
||||||
|
parent: nil,
|
||||||
|
children: []Event{},
|
||||||
|
child_info: map[Event]EventInfo{},
|
||||||
|
created_resources: []Resource{done_resource},
|
||||||
|
required_resources: required_resources,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
done_resource.Lock(queue)
|
||||||
|
|
||||||
|
return queue, done_resource
|
||||||
|
}
|
||||||
|
|
||||||
|
// Store the nodes parent for upwards propagation of changes
|
||||||
|
func (event * BaseEvent) RegisterParent(parent Event) error{
|
||||||
|
if event.parent != nil {
|
||||||
|
return errors.New("Parent already registered")
|
||||||
|
}
|
||||||
|
|
||||||
|
event.parent = parent
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (event * BaseEvent) Parent() Event {
|
||||||
|
return event.parent
|
||||||
|
}
|
||||||
|
|
||||||
|
func (event * BaseEvent) RequiredResources() []Resource {
|
||||||
|
return event.required_resources
|
||||||
|
}
|
||||||
|
|
||||||
|
func (event * BaseEvent) CreatedResources() []Resource {
|
||||||
|
return event.created_resources
|
||||||
|
}
|
||||||
|
|
||||||
|
func (event * BaseEvent) Children() []Event {
|
||||||
|
return event.children
|
||||||
|
}
|
||||||
|
|
||||||
|
func (event * BaseEvent) ChildInfo(idx Event) EventInfo {
|
||||||
|
val, ok := event.child_info[idx]
|
||||||
|
if ok == false {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
return val
|
||||||
|
}
|
||||||
|
|
||||||
|
func (event * BaseEvent) FindChild(id graphql.ID) Event {
|
||||||
|
if id == event.ID() {
|
||||||
|
return event
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, child := range event.Children() {
|
||||||
|
result := child.FindChild(id)
|
||||||
|
if result != nil {
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Checks that the type of info is equal to EventQueueInfo
|
||||||
|
func (event * EventQueue) AddChild(child Event, info EventInfo) error {
|
||||||
|
if checkType(info, (*EventQueueInfo)(nil)) == false {
|
||||||
|
return errors.New("EventQueue.AddChild passed invalid type for info")
|
||||||
|
}
|
||||||
|
|
||||||
|
return event.addChild(child, info)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (event * BaseEvent) addChild(child Event, info EventInfo) error {
|
||||||
|
err := child.RegisterParent(event)
|
||||||
|
if err != nil {
|
||||||
|
error_str := fmt.Sprintf("Failed to register %s as a parent of %s, cancelling AddChild", event.ID(), child.ID())
|
||||||
|
return errors.New(error_str)
|
||||||
|
}
|
||||||
|
|
||||||
|
event.children = append(event.children, child)
|
||||||
|
event.child_info[child] = info
|
||||||
|
event.Update()
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Overloaded function AddChild checks the info passed and calls the BaseEvent.addChild
|
||||||
|
func (event * BaseEvent) AddChild(child Event, info EventInfo) error {
|
||||||
|
if info != nil {
|
||||||
|
return errors.New("info must be nil for BaseEvent children")
|
||||||
|
}
|
||||||
|
|
||||||
|
return event.addChild(child, info)
|
||||||
|
}
|
||||||
|
|
||||||
|
func checkType(first interface{}, second interface{}) bool {
|
||||||
|
if first == nil || second == nil {
|
||||||
|
if first == nil && second == nil {
|
||||||
|
return true
|
||||||
|
} else {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
first_type := reflect.TypeOf(first)
|
||||||
|
second_type := reflect.TypeOf(second)
|
||||||
|
|
||||||
|
return first_type == second_type
|
||||||
|
}
|
||||||
@ -0,0 +1,132 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"log"
|
||||||
|
"errors"
|
||||||
|
graphql "github.com/graph-gophers/graphql-go"
|
||||||
|
"context"
|
||||||
|
)
|
||||||
|
|
||||||
|
type EventManager struct {
|
||||||
|
dag_nodes map[graphql.ID]Resource
|
||||||
|
root_event Event
|
||||||
|
}
|
||||||
|
|
||||||
|
// root_event's requirements must be in dag_nodes, and dag_nodes must be ordered by dependency(no children first)
|
||||||
|
func NewEventManager(root_event Event, dag_nodes []Resource) * EventManager {
|
||||||
|
|
||||||
|
manager := &EventManager{
|
||||||
|
dag_nodes: map[graphql.ID]Resource{},
|
||||||
|
root_event: nil,
|
||||||
|
}
|
||||||
|
|
||||||
|
// Construct the DAG
|
||||||
|
for _, resource := range dag_nodes {
|
||||||
|
err := manager.AddResource(resource)
|
||||||
|
if err != nil {
|
||||||
|
log.Printf("Failed to add %s to EventManager: %s", resource.ID(), err)
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
manager.AddEvent(nil, root_event, nil)
|
||||||
|
|
||||||
|
return manager;
|
||||||
|
}
|
||||||
|
|
||||||
|
func (manager * EventManager) Run(ctx context.Context) error {
|
||||||
|
//return manager.root_event.Run(ctx)
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (manager * EventManager) FindResource(id graphql.ID) Resource {
|
||||||
|
resource, exists := manager.dag_nodes[id]
|
||||||
|
if exists == false {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
return resource
|
||||||
|
}
|
||||||
|
|
||||||
|
func (manager * EventManager) FindEvent(id graphql.ID) Event {
|
||||||
|
event := manager.root_event.FindChild(id)
|
||||||
|
|
||||||
|
return event
|
||||||
|
}
|
||||||
|
|
||||||
|
func (manager * EventManager) AddResource(resource Resource) error {
|
||||||
|
_, exists := manager.dag_nodes[resource.ID()]
|
||||||
|
if exists == true {
|
||||||
|
error_str := fmt.Sprintf("%s is already in the resource DAG, cannot add again", resource.ID())
|
||||||
|
return errors.New(error_str)
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, child := range resource.Children() {
|
||||||
|
_, exists := manager.dag_nodes[child.ID()]
|
||||||
|
if exists == false {
|
||||||
|
error_str := fmt.Sprintf("%s is not in the resource DAG, cannot add %s to DAG", child.ID(), resource.ID())
|
||||||
|
return errors.New(error_str)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
manager.dag_nodes[resource.ID()] = resource
|
||||||
|
for _, child := range resource.Children() {
|
||||||
|
child.AddParent(resource)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check that the node doesn't already exist in the tree
|
||||||
|
// Check the the selected parent exists in the tree
|
||||||
|
// Check that required resources exist in the DAG
|
||||||
|
// Check that created resources don't exist in the DAG
|
||||||
|
// Add resources created by the event to the DAG
|
||||||
|
// Add child to parent
|
||||||
|
func (manager * EventManager) AddEvent(parent Event, child Event, info EventInfo) error {
|
||||||
|
if child == nil {
|
||||||
|
return errors.New("Cannot add nil Event to EventManager")
|
||||||
|
} else if len(child.Children()) != 0 {
|
||||||
|
return errors.New("Adding events recursively not implemented")
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, resource := range child.RequiredResources() {
|
||||||
|
_, exists := manager.dag_nodes[resource.ID()]
|
||||||
|
if exists == false {
|
||||||
|
error_str := fmt.Sprintf("Required resource %s not in DAG, cannot add event %s", resource.ID(), child.ID())
|
||||||
|
return errors.New(error_str)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, resource := range child.CreatedResources() {
|
||||||
|
_, exists := manager.dag_nodes[resource.ID()]
|
||||||
|
if exists == true {
|
||||||
|
error_str := fmt.Sprintf("Created resource %s already exists in DAG, cannot add event %s", resource.ID(), child.ID())
|
||||||
|
return errors.New(error_str)
|
||||||
|
}
|
||||||
|
manager.AddResource(resource)
|
||||||
|
}
|
||||||
|
|
||||||
|
if manager.root_event == nil && parent != nil {
|
||||||
|
error_str := fmt.Sprintf("EventManager has no root, so can't add event to parent")
|
||||||
|
return errors.New(error_str)
|
||||||
|
} else if manager.root_event != nil && parent == nil {
|
||||||
|
// TODO
|
||||||
|
return errors.New("Replacing root event not implemented")
|
||||||
|
} else if manager.root_event == nil && parent == nil {
|
||||||
|
manager.root_event = child
|
||||||
|
return nil;
|
||||||
|
} else {
|
||||||
|
if manager.root_event.FindChild(parent.ID()) == nil {
|
||||||
|
error_str := fmt.Sprintf("Event %s is not present in the event tree, cannot add %s as child", parent.ID(), child.ID())
|
||||||
|
return errors.New(error_str)
|
||||||
|
}
|
||||||
|
|
||||||
|
if manager.root_event.FindChild(child.ID()) != nil {
|
||||||
|
error_str := fmt.Sprintf("Event %s already exists in the event tree, can not add again", child.ID())
|
||||||
|
return errors.New(error_str)
|
||||||
|
}
|
||||||
|
return parent.AddChild(child, info)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,164 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"errors"
|
||||||
|
"sync"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Resources propagate update up to multiple parents, and not downwards
|
||||||
|
// (subscriber to team won't get update to alliance, but subscriber to alliance will get update to team)
|
||||||
|
func (resource * BaseResource) Update() error {
|
||||||
|
err := resource.UpdateListeners()
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, parent := range resource.Parents() {
|
||||||
|
err := parent.Update()
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if resource.lock_holder != nil {
|
||||||
|
resource.lock_holder.Update()
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Resource is the interface that DAG nodes are made from
|
||||||
|
type Resource interface {
|
||||||
|
GraphNode
|
||||||
|
AddParent(parent Resource) error
|
||||||
|
Children() []Resource
|
||||||
|
Parents() []Resource
|
||||||
|
Lock(event Event) error
|
||||||
|
Unlock(event Event) error
|
||||||
|
Owner() Event
|
||||||
|
}
|
||||||
|
|
||||||
|
// BaseResource is the most basic resource that can exist in the DAG
|
||||||
|
// It holds a single state variable, which contains a pointer to the event that is locking it
|
||||||
|
type BaseResource struct {
|
||||||
|
BaseNode
|
||||||
|
parents []Resource
|
||||||
|
children []Resource
|
||||||
|
lock_holder Event
|
||||||
|
state_lock sync.Mutex
|
||||||
|
}
|
||||||
|
|
||||||
|
func (resource * BaseResource) Owner() Event {
|
||||||
|
return resource.lock_holder
|
||||||
|
}
|
||||||
|
|
||||||
|
// Grab the state mutex and check the state, if unlocked continue to hold the mutex while doing the same for children
|
||||||
|
// When the bottom of a tree is reached(no more children) go back up and set the lock state
|
||||||
|
func (resource * BaseResource) Lock(event Event) error {
|
||||||
|
var err error = nil
|
||||||
|
locked := false
|
||||||
|
|
||||||
|
resource.state_lock.Lock()
|
||||||
|
if resource.lock_holder != nil {
|
||||||
|
err = errors.New("Resource already locked")
|
||||||
|
} else {
|
||||||
|
all_children_locked := true
|
||||||
|
for _, child := range resource.Children() {
|
||||||
|
err = child.Lock(event)
|
||||||
|
if err != nil {
|
||||||
|
all_children_locked = false
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if all_children_locked == true {
|
||||||
|
resource.lock_holder = event
|
||||||
|
locked = true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
resource.state_lock.Unlock()
|
||||||
|
|
||||||
|
if locked == true {
|
||||||
|
resource.Update()
|
||||||
|
}
|
||||||
|
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
// Recurse through children, unlocking until no more children
|
||||||
|
// If the child isn't locked by the unlocker
|
||||||
|
func (resource * BaseResource) Unlock(event Event) error {
|
||||||
|
var err error = nil
|
||||||
|
unlocked := false
|
||||||
|
|
||||||
|
resource.state_lock.Lock()
|
||||||
|
if resource.lock_holder == nil {
|
||||||
|
err = errors.New("Resource already unlocked")
|
||||||
|
} else if resource.lock_holder != event {
|
||||||
|
err = errors.New("Resource not locked by parent, can't unlock")
|
||||||
|
} else {
|
||||||
|
all_children_unlocked := true
|
||||||
|
for _, child := range resource.Children() {
|
||||||
|
err = child.Unlock(event)
|
||||||
|
if err != nil {
|
||||||
|
all_children_unlocked = false
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if all_children_unlocked == true{
|
||||||
|
resource.lock_holder = nil
|
||||||
|
unlocked = true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
resource.state_lock.Unlock()
|
||||||
|
|
||||||
|
if unlocked == true {
|
||||||
|
resource.Update()
|
||||||
|
}
|
||||||
|
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
func (resource * BaseResource) Children() []Resource {
|
||||||
|
return resource.children
|
||||||
|
}
|
||||||
|
|
||||||
|
func (resource * BaseResource) Parents() []Resource {
|
||||||
|
return resource.parents
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add a parent to a DAG node
|
||||||
|
func (resource * BaseResource) AddParent(parent Resource) error {
|
||||||
|
// Don't add self as parent
|
||||||
|
if parent.ID() == resource.ID() {
|
||||||
|
error_str := fmt.Sprintf("Will not add %s as parent of itself", parent.ID())
|
||||||
|
return errors.New(error_str)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Don't add parent if it's already a parent
|
||||||
|
for _, p := range resource.parents {
|
||||||
|
if p.ID() == parent.ID() {
|
||||||
|
error_str := fmt.Sprintf("%s is already a parent of %s, will not double-bond", p.ID(), resource.ID())
|
||||||
|
return errors.New(error_str)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add the parent
|
||||||
|
resource.parents = append(resource.parents, parent)
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewResource(name string, description string, children []Resource) * BaseResource {
|
||||||
|
resource := &BaseResource{
|
||||||
|
BaseNode: BaseNode{
|
||||||
|
name: name,
|
||||||
|
description: description,
|
||||||
|
id: gql_randid(),
|
||||||
|
listeners: []chan error{},
|
||||||
|
},
|
||||||
|
parents: []Resource{},
|
||||||
|
children: children,
|
||||||
|
}
|
||||||
|
|
||||||
|
return resource
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue