diff --git a/event.go b/event.go deleted file mode 100644 index 273ebb1..0000000 --- a/event.go +++ /dev/null @@ -1,156 +0,0 @@ -package graphvent - -import ( - "time" - "fmt" -) - -type EventCommand string -type EventState string - -type EventExt struct { - Name string `gv:"name"` - State EventState `gv:"state"` - StateStart time.Time `gv:"state_start"` - Parent NodeID `gv:"parent" node:"Base"` -} - -func (ext *EventExt) Load(ctx *Context, node *Node) error { - return nil -} - -func (ext *EventExt) Unload(ctx *Context, node *Node) { -} - -func NewEventExt(parent NodeID, name string) *EventExt { - return &EventExt{ - Name: name, - State: "init", - Parent: parent, - } -} - -type EventStateSignal struct { - SignalHeader - Source NodeID `gv:"source"` - State EventState `gv:"state"` - Time time.Time `gv:"time"` -} - -func (signal EventStateSignal) String() string { - return fmt.Sprintf("EventStateSignal(%s, %s, %s, %+v)", signal.SignalHeader, signal.Source, signal.State, signal.Time) -} - -func NewEventStateSignal(source NodeID, state EventState, t time.Time) *EventStateSignal { - return &EventStateSignal{ - SignalHeader: NewSignalHeader(), - Source: source, - State: state, - Time: t, - } -} - -type EventControlSignal struct { - SignalHeader - Command EventCommand `gv:"command"` -} - -func (signal EventControlSignal) String() string { - return fmt.Sprintf("EventControlSignal(%s, %s)", signal.SignalHeader, signal.Command) -} - -func NewEventControlSignal(command EventCommand) *EventControlSignal { - return &EventControlSignal{ - NewSignalHeader(), - command, - } -} - -func (ext *EventExt) UpdateState(node *Node, changes Changes, state EventState, state_start time.Time) { - if ext.State != state { - ext.StateStart = state_start - changes = append(changes, "state") - ext.State = state - node.QueueSignal(time.Now(), NewEventStateSignal(node.ID, ext.State, time.Now())) - } -} - -func (ext *EventExt) Process(ctx *Context, node *Node, source NodeID, signal Signal) ([]SendMsg, Changes) { - var messages []SendMsg = nil - var changes = Changes{} - - return messages, changes -} - -type TestEventExt struct { - Length time.Duration -} - -func (ext *TestEventExt) Load(ctx *Context, node *Node) error { - return nil -} - -func (ext *TestEventExt) Unload(ctx *Context, node *Node) { -} - -type EventCommandMap map[EventCommand]map[EventState]EventState -var test_event_commands = EventCommandMap{ - "ready?": { - "init": "ready", - }, - "start": { - "ready": "running", - }, - "abort": { - "ready": "init", - }, - "stop": { - "running": "stopped", - }, - "finish": { - "running": "done", - }, -} - - -func (ext *TestEventExt) Process(ctx *Context, node *Node, source NodeID, signal Signal) ([]SendMsg, Changes) { - var messages []SendMsg = nil - var changes = Changes{} - - switch sig := signal.(type) { - case *EventControlSignal: - event_ext, err := GetExt[EventExt](node) - if err != nil { - messages = append(messages, SendMsg{source, NewErrorSignal(sig.Id, "not_event")}) - } else { - ctx.Log.Logf("event", "%s got %s EventControlSignal while in %s", node.ID, sig.Command, event_ext.State) - new_state, error_signal := event_ext.ValidateEventCommand(sig, test_event_commands) - if error_signal != nil { - messages = append(messages, SendMsg{source, error_signal}) - } else { - switch sig.Command { - case "start": - node.QueueSignal(time.Now().Add(ext.Length), NewEventControlSignal("finish")) - } - event_ext.UpdateState(node, changes, new_state, time.Now()) - messages = append(messages, SendMsg{source, NewSuccessSignal(sig.Id)}) - } - } - } - - return messages, changes -} - -func(ext *EventExt) ValidateEventCommand(signal *EventControlSignal, commands EventCommandMap) (EventState, *ErrorSignal) { - transitions, command_mapped := commands[signal.Command] - if command_mapped == false { - return "", NewErrorSignal(signal.Id, "unknown command %s", signal.Command) - } else { - new_state, valid_transition := transitions[ext.State] - if valid_transition == false { - return "", NewErrorSignal(signal.Id, "invalid command state %s(%s)", signal.Command, ext.State) - } else { - return new_state, nil - } - } -} diff --git a/event_test.go b/event_test.go deleted file mode 100644 index b2008b6..0000000 --- a/event_test.go +++ /dev/null @@ -1,86 +0,0 @@ -package graphvent - -import ( - "crypto/ed25519" - "testing" - "time" - "crypto/rand" -) - -func TestEvent(t *testing.T) { - ctx := logTestContext(t, []string{"event", "listener", "listener_debug"}) - err := RegisterExtension[TestEventExt](ctx, nil) - fatalErr(t, err) - err = RegisterObject[TestEventExt](ctx) - fatalErr(t, err) - - - event_public, event_private, err := ed25519.GenerateKey(rand.Reader) - event_listener := NewListenerExt(100) - event, err := NewNode(ctx, event_private, "Base", 100, NewEventExt(KeyID(event_public), "Test Event"), &TestEventExt{time.Second}, event_listener) - fatalErr(t, err) - - response, signals := testSend(t, ctx, NewEventControlSignal("ready?"), event, event) - switch resp := response.(type) { - case *SuccessSignal: - case *ErrorSignal: - t.Fatalf("Error response %+v", resp.Error) - default: - t.Fatalf("Unexpected response %+v", resp) - } - - var state_signal *EventStateSignal = nil - for _, signal := range(signals) { - event_state, is_event_state := signal.(*EventStateSignal) - if is_event_state == true && event_state.Source == event.ID && event_state.State == "ready" { - state_signal = event_state - break - } - } - - if state_signal == nil { - state_signal, err = WaitForSignal(event_listener.Chan, 10*time.Millisecond, func(sig *EventStateSignal) bool { - return sig.Source == event.ID && sig.State == "ready" - }) - fatalErr(t, err) - } - - response, signals = testSend(t, ctx, NewEventControlSignal("start"), event, event) - switch resp := response.(type) { - case *SuccessSignal: - case *ErrorSignal: - t.Fatalf("Error response %+v", resp.Error) - default: - t.Fatalf("Unexpected response %+v", resp) - } - - state_signal = nil - for _, signal := range(signals) { - event_state, is_event_state := signal.(*EventStateSignal) - if is_event_state == true && event_state.Source == event.ID && event_state.State == "running" { - state_signal = event_state - break - } - } - - if state_signal == nil { - state_signal, err = WaitForSignal(event_listener.Chan, 10*time.Millisecond, func(sig *EventStateSignal) bool { - return sig.Source == event.ID && sig.State == "running" - }) - fatalErr(t, err) - } - - _, err = WaitForSignal(event_listener.Chan, time.Second * 2, func(sig *EventStateSignal) bool { - return sig.Source == event.ID && sig.State == "done" - }) - fatalErr(t, err) - - response, signals = testSend(t, ctx, NewEventControlSignal("start"), event, event) - switch resp := response.(type) { - case *SuccessSignal: - t.Fatalf("Success response starting finished TestEventExt") - case *ErrorSignal: - default: - t.Fatalf("Unexpected response %+v", resp) - } -}