From 66e6c4263c42f672efcd97904ea123e27aeb5e39 Mon Sep 17 00:00:00 2001 From: Noah Metz Date: Sun, 18 Jun 2023 18:11:59 -0600 Subject: [PATCH] Refactored GraphSignal to remove pointers and updated update path --- event.go | 83 +++++++++++-------------------- gql.go | 27 +++++----- gql_vex.go | 8 --- graph.go | 83 +++++++++++++++---------------- main.go | 3 +- manager_test.go | 47 +++++++---------- resource.go | 78 +++++++++-------------------- test-site/src/routes/+page.svelte | 5 +- vex.go | 22 +++----- vex_test.go | 16 +++--- 10 files changed, 143 insertions(+), 229 deletions(-) diff --git a/event.go b/event.go index 394985b..79d14d4 100644 --- a/event.go +++ b/event.go @@ -11,20 +11,28 @@ import ( // Update the events listeners, and notify the parent to do the same func (event * BaseEvent) update(signal GraphSignal) { - event.signal <- signal - new_signal := signal.Trace(event.ID()) - - if event.parent != nil { - SendUpdate(event.parent, new_signal) - } - - source_id := signal.Last() + if signal.Downwards() == false { + // Child->Parent + event.parent_lock.Lock() + defer event.parent_lock.Unlock() + if event.parent != nil { + SendUpdate(event.parent, signal) + } - for _, resource := range(event.RequiredResources()) { - if source_id != resource.ID() { - SendUpdate(resource, new_signal) + event.rr_lock.Lock() + defer event.rr_lock.Unlock() + for _, resource := range(event.required_resources) { + SendUpdate(resource, signal) + } + } else { + // Parent->Child + event.child_lock.Lock() + defer event.child_lock.Unlock() + for _, child := range(event.children) { + SendUpdate(child, signal) } } + event.signal <- signal } type EventInfo interface { @@ -197,15 +205,13 @@ func AddChild(event Event, child Event, info EventInfo) error { child.UnlockParent() event.UnlockParent() - update := NewSignal(event, "child_added") - update.description = child.Name() SendUpdate(event, NewSignal(event, "child_added")) return nil } func RunEvent(event Event) error { log.Logf("event", "EVENT_RUN: %s", event.Name()) - go SendUpdate(event, NewSignal(event, "event_start")) + SendUpdate(event, NewSignal(event, "event_start")) next_action := "start" var err error = nil for next_action != "" { @@ -229,42 +235,14 @@ func RunEvent(event Event) error { func EventAbort(event Event) func(signal GraphSignal) (string, error) { return func(signal GraphSignal) (string, error) { - if signal.Description() == event.ID() { - AbortChildren(event) - return "", errors.New(fmt.Sprintf("%s aborted by signal", event.ID())) - } - return "wait", nil + return "", errors.New(fmt.Sprintf("%s aborted by signal", event.ID())) } } func EventCancel(event Event) func(signal GraphSignal) (string, error) { return func(signal GraphSignal) (string, error) { - if signal.Description() == event.ID() { - CancelChildren(event) - return "", nil - } - return "wait", nil - } -} - -func CancelChildren(event Event) { - event.LockChildren() - for _, child := range(event.Children()) { - signal := NewSignal(event, "cancel") - signal.description = child.ID() - SendUpdate(child, signal) - } - event.UnlockChildren() -} - -func AbortChildren(event Event) { - event.LockChildren() - for _, child := range(event.Children()) { - signal := NewSignal(event, "abort") - signal.description = child.ID() - SendUpdate(child, signal) + return "", nil } - event.UnlockChildren() } func LockResources(event Event) error { @@ -287,22 +265,19 @@ func LockResources(event Event) error { return lock_err } - for _, resource := range(locked_resources) { - NotifyResourceLocked(resource) - } + signal := NewDownSignal(event, "locked") + SendUpdate(event, signal) return nil } func FinishEvent(event Event) error { - // TODO make more 'safe' like LockResources, or make UnlockResource not return errors log.Logf("event", "EVENT_FINISH: %s", event.Name()) for _, resource := range(event.RequiredResources()) { err := UnlockResource(resource, event) if err != nil { panic(err) } - NotifyResourceUnlocked(resource) } err := UnlockResource(event.DoneResource(), event) @@ -310,7 +285,8 @@ func FinishEvent(event Event) error { return err } - NotifyResourceUnlocked(event.DoneResource()) + SendUpdate(event, NewDownSignal(event, "unlocked")) + SendUpdate(event.DoneResource(), NewDownSignal(event, "unlocked")) err = event.finish() if err != nil { @@ -330,6 +306,7 @@ func FinishEvent(event Event) error { type BaseEvent struct { BaseNode done_resource Resource + rr_lock sync.Mutex required_resources []Resource children []Event child_info map[string]EventInfo @@ -353,11 +330,7 @@ func EventWait(event Event) (func() (string, error)) { log.Logf("event", "EVENT_WAIT: %s TIMEOUT: %+v", event.Name(), event.Timeout()) select { case signal := <- event.Signal(): - if signal.Source() != nil { - log.Logf("event", "EVENT_SIGNAL: %s %s %s -> %+v", event.Name(), signal.Last(), signal.Source().Name(), signal) - } else { - log.Logf("event", "EVENT_SIGNAL: %s %s nil -> %+v", event.Name(), signal.Last(), signal) - } + log.Logf("event", "EVENT_SIGNAL: %s %+v", event.Name(), signal) signal_fn, exists := event.Handler(signal.Type()) if exists == true { log.Logf("event", "EVENT_HANDLER: %s - %s", event.Name(), signal.Type()) diff --git a/gql.go b/gql.go index aef74ca..a8b921d 100644 --- a/gql.go +++ b/gql.go @@ -715,15 +715,15 @@ func GQLSignalType(p graphql.ResolveParams) (interface{}, error) { }) } -func GQLSignalDesc(p graphql.ResolveParams) (interface{}, error) { +func GQLSignalSource(p graphql.ResolveParams) (interface{}, error) { return GQLSignalFn(p, func(signal GraphSignal, p graphql.ResolveParams)(interface{}, error){ - return signal.Description(), nil + return signal.Source(), nil }) } -func GQLSignalTime(p graphql.ResolveParams) (interface{}, error) { +func GQLSignalDownwards(p graphql.ResolveParams) (interface{}, error) { return GQLSignalFn(p, func(signal GraphSignal, p graphql.ResolveParams)(interface{}, error){ - return signal.Time(), nil + return signal.Downwards(), nil }) } @@ -750,13 +750,13 @@ func GQLTypeSignal() *graphql.Object { Type: graphql.String, Resolve: GQLSignalType, }) - gql_type_signal.AddFieldConfig("Description", &graphql.Field{ + gql_type_signal.AddFieldConfig("Source", &graphql.Field{ Type: graphql.String, - Resolve: GQLSignalDesc, + Resolve: GQLSignalSource, }) - gql_type_signal.AddFieldConfig("Time", &graphql.Field{ - Type: graphql.DateTime, - Resolve: GQLSignalTime, + gql_type_signal.AddFieldConfig("Downwards", &graphql.Field{ + Type: graphql.Boolean, + Resolve: GQLSignalDownwards, }) gql_type_signal.AddFieldConfig("String", &graphql.Field{ Type: graphql.String, @@ -811,9 +811,12 @@ func GQLMutationUpdateEvent() *graphql.Field { if ok == false { return nil, errors.New(fmt.Sprintf("Failed to cast arg signal to GraphSignal: %+v", p.Args["signal"])) } - signal := NewSignal(server, signal_map["Type"].(string)) - signal.description = signal_map["Description"].(string) - signal.time = signal_map["Time"].(time.Time) + var signal GraphSignal = nil + if signal_map["Downwards"] == false { + signal = NewSignal(server, signal_map["Type"].(string)) + } else { + signal = NewDownSignal(server, signal_map["Type"].(string)) + } id , ok := p.Args["id"].(string) if ok == false { diff --git a/gql_vex.go b/gql_vex.go index 6625a31..28c9f70 100644 --- a/gql_vex.go +++ b/gql_vex.go @@ -5,7 +5,6 @@ import ( "reflect" "fmt" "errors" - "time" ) func GQLVexTypes() map[reflect.Type]*graphql.Object { @@ -122,14 +121,7 @@ func GQLVexMutationSetMatchState() *graphql.Field { return nil, errors.New("Failed to cast arg state to string") } - start, ok := p.Args["time"].(time.Time) - if ok == false { - start = time.Now() - } - signal := NewSignal(server, state) - signal.description = id - signal.time = start owner := server.Owner() if owner == nil { diff --git a/graph.go b/graph.go index 50b32b3..a2633b3 100644 --- a/graph.go +++ b/graph.go @@ -59,7 +59,7 @@ func (logger * DefaultLogger) Init(components []string) error { } func (logger * DefaultLogger) Logm(component string, fields map[string]interface{}, format string, items ... interface{}) { - logger.Init([]string{"gqlws", "gqlws_new"}) + logger.Init([]string{"update"}) l, exists := logger.loggers[component] if exists == true { log := l.Log() @@ -71,7 +71,7 @@ func (logger * DefaultLogger) Logm(component string, fields map[string]interface } func (logger * DefaultLogger) Logf(component string, format string, items ... interface{}) { - logger.Init([]string{"gqlws", "gqlws_new"}) + logger.Init([]string{"update"}) l, exists := logger.loggers[component] if exists == true { l.Log().Msg(fmt.Sprintf(format, items...)) @@ -85,63 +85,66 @@ func randid() string{ } type GraphSignal interface { - Source() GraphNode + Downwards() bool + Source() string Type() string - Description() string - Time() time.Time - Last() string - Trace(id string) GraphSignal String() string } type BaseSignal struct { - source GraphNode - signal_type string - description string - time time.Time - last_id string -} - -func (signal BaseSignal) String() string { - source_name := "nil" - source := signal.source - if source != nil { - source_name = source.Name() - } - return fmt.Sprintf("{type: %s, description: %s, source: %s, last: %s}", signal.signal_type, signal.description, source_name, signal.last_id) + downwards bool + source string + _type string } -func (signal BaseSignal) Time() time.Time { - return signal.time +func (signal BaseSignal) Downwards() bool { + return signal.downwards } -func (signal BaseSignal) Source() GraphNode { +func (signal BaseSignal) Source() string { return signal.source } func (signal BaseSignal) Type() string { - return signal.signal_type + return signal._type } -func (signal BaseSignal) Description() string { - return signal.description +func (signal BaseSignal) String() string { + return fmt.Sprintf("{downwards: %t, source: %s, type: %s}", signal.downwards, signal.source, signal._type) } -func (signal BaseSignal) Trace(id string) GraphSignal { - new_signal := signal - new_signal.last_id = id - return new_signal +type TimeSignal struct { + BaseSignal + time time.Time } -func (signal BaseSignal) Last() string { - return signal.last_id +func NewDownSignal(source GraphNode, _type string) (BaseSignal) { + source_id := "" + if source != nil { + source_id = source.ID() + } + + signal := BaseSignal{ + downwards: true, + source: source_id, + _type: _type, + } + + return signal } -func NewSignal(source GraphNode, signal_type string) (BaseSignal) { +func NewSignal(source GraphNode, _type string) (BaseSignal) { + source_id := "" + if source != nil { + source_id = source.ID() + } + signal := BaseSignal{ - source: source, - signal_type: signal_type, + downwards: false, + source: source_id, + _type: _type, } + return signal } @@ -251,17 +254,11 @@ func (node * BaseNode) update(signal GraphSignal) { } func SendUpdate(node GraphNode, signal GraphSignal) { - source := signal.Source() - source_name := "nil" - if source != nil { - source_name = source.Name() - } - node_name := "nil" if node != nil { node_name = node.Name() } - log.Logf("update", "UPDATE %s -> %s: %+v", source_name, node_name, signal) + log.Logf("update", "UPDATE %s <- %s: %+v", node_name, signal.Source(), signal) node.UpdateListeners(signal) node.update(signal) } diff --git a/main.go b/main.go index bdcdc43..c22a1d2 100644 --- a/main.go +++ b/main.go @@ -201,8 +201,7 @@ func main() { select { case <-sigs: pprof.Lookup("goroutine").WriteTo(os.Stdout, 1) - signal := NewSignal(nil, "abort") - signal.description = event_manager.root_event.ID() + signal := NewDownSignal(nil, "abort") SendUpdate(event_manager.root_event, signal) break } diff --git a/manager_test.go b/manager_test.go index 3c2a6f3..b398b71 100644 --- a/manager_test.go +++ b/manager_test.go @@ -17,16 +17,9 @@ func (t * graph_tester) WaitForValue(listener chan GraphSignal, signal_type stri select { case signal := <- listener: if signal.Type() == signal_type { - if signal.Source() == nil || source == nil { - fmt.Printf("SIGNAL_TYPE_FOUND: %s - %s\n", signal.Type(), signal.Source()) - if source == nil && signal.Source() == nil{ - return signal - } - } else { - fmt.Printf("SIGNAL_TYPE_FOUND: %s - %s\n", signal.Type(), signal.Source().Name()) - if signal.Source().ID() == source.ID() { - return signal - } + fmt.Printf("SIGNAL_TYPE_FOUND: %s - %s %+v\n", signal.Type(), signal.Source(), listener) + if signal.Source() == source.ID() { + return signal } } case <-timeout_channel: @@ -211,10 +204,10 @@ func TestLockResource(t * testing.T) { if err != nil { t.Fatal("Failed to lock r3") } - NotifyResourceLocked(r3) + SendUpdate(r3, NewDownSignal(r3, "locked")) - (*graph_tester)(t).WaitForValue(r1_l, "lock_changed", r1, time.Second, "Wasn't notified of r1 lock on r1 after r3 lock") - (*graph_tester)(t).WaitForValue(rel, "lock_changed", r1, time.Second, "Wasn't notified of r1 lock on rel after r3 lock") + (*graph_tester)(t).WaitForValue(r1_l, "locked", r3, time.Second, "Wasn't notified of r1 lock on r1 after r3 lock") + (*graph_tester)(t).WaitForValue(rel, "locked", r3, time.Second, "Wasn't notified of r1 lock on rel after r3 lock") err = LockResource(r3, root_event) if err == nil { @@ -240,23 +233,23 @@ func TestLockResource(t * testing.T) { if err != nil { t.Fatal("Failed to unlock r3") } - NotifyResourceUnlocked(r3) - (*graph_tester)(t).WaitForValue(r1_l, "lock_changed", r1, time.Second * 2, "Wasn't notified of r1 unlock on r1 after r3 unlock") + SendUpdate(r3, NewDownSignal(r3, "unlocked")) + (*graph_tester)(t).WaitForValue(r1_l, "unlocked", r3, time.Second * 2, "Wasn't notified of r1 unlock on r1 after r3 unlock") err = LockResource(r4, root_event) if err != nil { t.Fatal("Failed to lock r4 after unlocking r3") } - NotifyResourceLocked(r4) - (*graph_tester)(t).WaitForValue(r1_l, "lock_changed", r1, time.Second * 2, "Wasn't notified of r1 lock on r1 after r4 lock") - (*graph_tester)(t).WaitForValue(rel, "lock_changed", r1, time.Second * 2, "Wasn't notified of r1 lock on r1 after r4 lock") + SendUpdate(r4, NewDownSignal(r4, "locked")) + (*graph_tester)(t).WaitForValue(r1_l, "locked", r4, time.Second * 2, "Wasn't notified of r1 lock on r1 after r4 lock") + (*graph_tester)(t).WaitForValue(rel, "locked", r4, time.Second * 2, "Wasn't notified of r1 lock on r1 after r4 lock") err = UnlockResource(r4, root_event) if err != nil { t.Fatal("Failed to unlock r4") } - NotifyResourceUnlocked(r4) - (*graph_tester)(t).WaitForValue(r1_l, "lock_changed", r1, time.Second * 2, "Wasn't notified of r1 unlock on r1 after r4 lock") + SendUpdate(r4, NewDownSignal(r4, "unlocked")) + (*graph_tester)(t).WaitForValue(r1_l, "unlocked", r4, time.Second * 2, "Wasn't notified of r1 unlock on r1 after r4 lock") } func TestAddToEventQueue(t * testing.T) { @@ -299,8 +292,9 @@ func TestStartBaseEvent(t * testing.T) { t.Fatal(err) } // Check that the update channels for the event and resource have updates - (*graph_tester)(t).CheckForValue(e_l, "No update on event_1 after starting") - (*graph_tester)(t).CheckForValue(r_l, "No update on r_l after starting") + (*graph_tester)(t).WaitForValue(e_l, "event_start", event_1, 1*time.Second, "No event_start on e_l") + (*graph_tester)(t).WaitForValue(e_l, "event_done", event_1, 1*time.Second, "No event_start on e_l") + (*graph_tester)(t).WaitForValue(r_l, "unlocked", event_1, 1*time.Second, "No unlocked on r_l") if r.Owner() != nil { t.Fatal("r still owned after event completed") @@ -330,8 +324,7 @@ func TestAbortEventQueue(t * testing.T) { // start the queue and check that all the events are executed go func() { time.Sleep(100 * time.Millisecond) - abort_signal := NewSignal(nil, "abort") - abort_signal.description = root_event.ID() + abort_signal := NewDownSignal(nil, "abort") SendUpdate(root_event, abort_signal) }() @@ -388,8 +381,7 @@ func TestStartEventQueue(t * testing.T) { go func() { time.Sleep(5 * time.Second) if r.Owner() != nil { - abort_signal := NewSignal(nil, "abort") - abort_signal.description = root_event.ID() + abort_signal := NewDownSignal(nil, "abort") SendUpdate(root_event, abort_signal) } }() @@ -400,8 +392,7 @@ func TestStartEventQueue(t * testing.T) { (*graph_tester)(t).WaitForValue(e1_l, "event_done", e1, time.Second, "No event_done for e3") (*graph_tester)(t).WaitForValue(e2_l, "event_done", e2, time.Second, "No event_done for e3") (*graph_tester)(t).WaitForValue(e3_l, "event_done", e3, time.Second, "No event_done for e3") - signal := NewSignal(nil, "cancel") - signal.description = root_event.ID() + signal := NewDownSignal(nil, "cancel") SendUpdate(root_event, signal) }() diff --git a/resource.go b/resource.go index cffc3b4..c976706 100644 --- a/resource.go +++ b/resource.go @@ -9,24 +9,28 @@ import ( // 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(signal GraphSignal) { - new_signal := signal.Trace(resource.ID()) - for _, parent := range resource.Parents() { - SendUpdate(parent, new_signal) - } - resource.lock_holder_lock.Lock() - if resource.lock_holder != nil { - if resource.lock_holder.ID() != signal.Last() { - lock_holder := resource.lock_holder - resource.lock_holder_lock.Unlock() - SendUpdate(lock_holder, new_signal) - } else { - resource.lock_holder_lock.Unlock() + if signal.Downwards() == false { + // Child->Parent, resource updates parent resources + resource.parents_lock.Lock() + defer resource.parents_lock.Unlock() + for _, parent := range resource.Parents() { + SendUpdate(parent, signal) } } else { - resource.lock_holder_lock.Unlock() - } + // Parent->Child, resource updates lock holder + resource.lock_holder_lock.Lock() + defer resource.lock_holder_lock.Unlock() + if resource.lock_holder != nil { + SendUpdate(resource.lock_holder, signal) + } + resource.children_lock.Lock() + defer resource.children_lock.Unlock() + for _, child := range(resource.children) { + SendUpdate(child, signal) + } + } } // Resource is the interface that DAG nodes are made from @@ -75,13 +79,12 @@ func AddParent(resource Resource, parent Resource) error { func UnlockResource(resource Resource, event Event) error { var err error = nil resource.LockState() + defer resource.UnlockState() if resource.Owner() == nil { - resource.UnlockState() return errors.New("Resource already unlocked") } if resource.Owner().ID() != event.ID() { - resource.UnlockState() return errors.New("Resource not locked by parent, unlock failed") } @@ -95,36 +98,29 @@ func UnlockResource(resource Resource, event Event) error { } if lock_err != nil { - resource.UnlockState() - err_str := fmt.Sprintf("Resource failed to unlock: %s", lock_err) - return errors.New(err_str) + return fmt.Errorf("Resource failed to unlock: %s", lock_err) } resource.SetOwner(nil) err = resource.unlock(event) if err != nil { - resource.UnlockState() return errors.New("Failed to unlock resource") } - resource.UnlockState() return nil } func LockResource(resource Resource, node GraphNode) error { resource.LockState() + defer resource.UnlockState() if resource.Owner() != nil { - resource.UnlockState() - err_str := fmt.Sprintf("Resource already locked: %s", resource.Name()) - return errors.New(err_str) + return fmt.Errorf("Resource already locked: %s", resource.Name()) } err := resource.lock(node) if err != nil { - resource.UnlockState() - err_str := fmt.Sprintf("Failed to lock resource: %s", err) - return errors.New(err_str) + return fmt.Errorf("Failed to lock resource: %s", err) } var lock_err error = nil @@ -139,41 +135,15 @@ func LockResource(resource Resource, node GraphNode) error { } if lock_err != nil { - resource.UnlockState() - err_str := fmt.Sprintf("Resource failed to lock: %s", lock_err) - return errors.New(err_str) + return fmt.Errorf("Resource failed to lock: %s", lock_err) } log.Logf("resource", "Locked %s", resource.Name()) resource.SetOwner(node) - - resource.UnlockState() return nil } -func NotifyResourceLocked(resource Resource) { - signal := NewSignal(resource, "lock_changed") - signal.description = "lock" - - for _, child := range resource.Children() { - NotifyResourceLocked(child) - } - - go SendUpdate(resource, signal) -} - -func NotifyResourceUnlocked(resource Resource) { - signal := NewSignal(resource, "lock_changed") - signal.description = "unlock" - - for _, child := range(resource.Children()) { - NotifyResourceUnlocked(child) - } - - go SendUpdate(resource, signal) -} - // 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 { diff --git a/test-site/src/routes/+page.svelte b/test-site/src/routes/+page.svelte index c219f40..464a176 100644 --- a/test-site/src/routes/+page.svelte +++ b/test-site/src/routes/+page.svelte @@ -35,8 +35,9 @@ client.subscribe({ next: (data) => { console.log("ARENA_SUB") let obj = JSON.parse(data.data) - console.log(obj.Arena) - game_id = obj.Arena.Owner.ID + if(obj.Arena.Owner != null) { + game_id = obj.Arena.Owner.ID + } }, error: (err) => { console.log("ARENA_SUB") diff --git a/vex.go b/vex.go index 1c77f76..494444d 100644 --- a/vex.go +++ b/vex.go @@ -100,11 +100,9 @@ func (arena * VirtualArena) update(signal GraphSignal) { func (arena * VirtualArena) Init(abort chan error) bool { log.Logf("vex", "Initializing %s", arena.Name()) go func(arena * VirtualArena, abort chan error) { - update_str := fmt.Sprintf("VIRTUAL_ARENA connected: %s", arena.Name()) signal := NewSignal(arena, "resource_connected") - signal.description = update_str arena.connected = true - go SendUpdate(arena, signal) + SendUpdate(arena, signal) log.Logf("vex", "VIRTUAL_ARENA goroutine starting: %s", arena.Name()) for true { select { @@ -148,15 +146,10 @@ type Match struct { state string control string control_start time.Time - control_duration int + control_duration time.Duration alliances []*Alliance } -func (match * Match) update(signal GraphSignal) { - new_signal := signal.Trace(match.ID()) - match.BaseEvent.update(new_signal) -} - func NewMatch(alliance0 * Alliance, alliance1 * Alliance, arena Arena) * Match { name := fmt.Sprintf("Match: %s vs. %s on %s", alliance0.Name(), alliance1.Name(), arena.Name()) description := "A vex match" @@ -192,7 +185,6 @@ func NewMatch(alliance0 * Alliance, alliance1 * Alliance, arena Arena) * Match { match.state = "autonomous_queued" match.control_start = time.Now().Add(start_slack) new_signal := NewSignal(match, "autonomous_queued") - new_signal.time = match.control_start go SendUpdate(match, new_signal) return "wait", nil } @@ -205,7 +197,9 @@ func NewMatch(alliance0 * Alliance, alliance1 * Alliance, arena Arena) * Match { log.Logf("vex", "AUTONOMOUS_RUNNING: %s", match.Name()) match.control = "program" match.state = "autonomous_running" - match.control_start = signal.Time() + match.control_start = time.Now() // TODO + match.control_duration = TEMP_AUTON_TIME + go SendUpdate(match, NewSignal(match, "autonomous_running")) end_time := match.control_start.Add(TEMP_AUTON_TIME) @@ -235,7 +229,6 @@ func NewMatch(alliance0 * Alliance, alliance1 * Alliance, arena Arena) * Match { match.state = "driver_queued" match.control_start = time.Now().Add(start_slack) new_signal := NewSignal(match, "driver_queued") - new_signal.time = match.control_start go SendUpdate(match, new_signal) return "wait", nil } @@ -247,7 +240,8 @@ func NewMatch(alliance0 * Alliance, alliance1 * Alliance, arena Arena) * Match { } match.control = "driver" match.state = "driver_running" - match.control_start = signal.Time() + match.control_start = time.Now() // TODO + match.control_duration = TEMP_DRIVE_TIME go SendUpdate(match, NewSignal(match, "driver_running")) @@ -269,8 +263,6 @@ func NewMatch(alliance0 * Alliance, alliance1 * Alliance, arena Arena) * Match { } match.actions["driver_done"] = func() (string, error) { - new_signal := NewSignal(match, "driver_done") - new_signal.time = time.Now() SendUpdate(match, NewSignal(match, "driver_done")) return "wait", nil } diff --git a/vex_test.go b/vex_test.go index 00e883c..1ea4e87 100644 --- a/vex_test.go +++ b/vex_test.go @@ -144,30 +144,26 @@ func TestNewMatch(t *testing.T) { time.Sleep(time.Second * 20) if r.Owner() != nil { pprof.Lookup("goroutine").WriteTo(os.Stdout, 1) - abort_signal := NewSignal(root_event, "abort") - abort_signal.description = root_event.ID() + abort_signal := NewDownSignal(root_event, "abort") SendUpdate(root_event, abort_signal) } }() go func(arena_c chan GraphSignal) { (*graph_tester)(t).WaitForValue(arena_c, "event_start", match, 1*time.Second, "no event_start") - SendUpdate(arena, NewSignal(nil, "queue_autonomous")) + SendUpdate(arena, NewDownSignal(nil, "queue_autonomous")) (*graph_tester)(t).WaitForValue(arena_c, "autonomous_queued", match, 1*time.Second, "no autonomous_queued") - auton_signal := NewSignal(nil, "start_autonomous") - auton_signal.time = time.Now() + auton_signal := NewDownSignal(nil, "start_autonomous") SendUpdate(arena, auton_signal) (*graph_tester)(t).WaitForValue(arena_c, "autonomous_running", match, 1*time.Second, "no autonomous_running") (*graph_tester)(t).WaitForValue(arena_c, "autonomous_done", match, 6*time.Second, "no autonomous_done") - SendUpdate(arena, NewSignal(nil, "queue_driver")) + SendUpdate(arena, NewDownSignal(nil, "queue_driver")) (*graph_tester)(t).WaitForValue(arena_c, "driver_queued", match, 1*time.Second, "no driver_queued") - driver_signal := NewSignal(nil, "start_driver") - driver_signal.time = time.Now() + driver_signal := NewDownSignal(nil, "start_driver") SendUpdate(arena, driver_signal) (*graph_tester)(t).WaitForValue(arena_c, "driver_running", match, 1*time.Second, "no driver_running") (*graph_tester)(t).WaitForValue(arena_c, "driver_done", match, 6*time.Second, "no driver_done") - cancel_signal := NewSignal(nil, "cancel") - cancel_signal.description = root_event.ID() + cancel_signal := NewDownSignal(nil, "cancel") SendUpdate(root_event, cancel_signal) }(arena_c)