forked from hyperledger-archives/burrow
/
event.go
136 lines (115 loc) · 2.52 KB
/
event.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package exec
import (
"reflect"
"fmt"
"github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/event/query"
)
var eventMessageTag = query.TagMap{event.MessageTypeKey: reflect.TypeOf(&Event{}).String()}
type EventType uint32
// Execution event types
const (
TypeUnknown EventType = iota
TypeCall
TypeLog
TypeAccountInput
TypeAccountOutput
TypeTxExecution
TypeBlockExecution
TypeGovernAccount
TypeBeginBlock
TypeBeginTx
TypeEnvelope
TypeEndTx
TypeEndBlock
)
var nameFromType = map[EventType]string{
TypeUnknown: "UnknownEvent",
TypeCall: "CallEvent",
TypeLog: "LogEvent",
TypeAccountInput: "AccountInputEvent",
TypeAccountOutput: "AccountOutputEvent",
TypeTxExecution: "TxExecutionEvent",
TypeBlockExecution: "BlockExecutionEvent",
TypeGovernAccount: "GovernAccountEvent",
TypeBeginBlock: "BeginBlockEvent",
TypeEndBlock: "EndBlockEvent",
}
var typeFromName = make(map[string]EventType)
func init() {
for t, n := range nameFromType {
typeFromName[n] = t
}
}
func EventTypeFromString(name string) EventType {
return typeFromName[name]
}
func (ev *Event) EventType() EventType {
return ev.Header.EventType
}
func (typ EventType) String() string {
name, ok := nameFromType[typ]
if ok {
return name
}
return "UnknownEventType"
}
func (typ EventType) MarshalText() ([]byte, error) {
return []byte(typ.String()), nil
}
func (typ *EventType) UnmarshalText(data []byte) error {
*typ = EventTypeFromString(string(data))
return nil
}
// Event
func (ev *Event) String() string {
return fmt.Sprintf("ExecutionEvent{%v: %s}", ev.Header.String(), ev.Body())
}
func (ev *Event) Body() string {
if ev.Input != nil {
return ev.Input.String()
}
if ev.Output != nil {
return ev.Output.String()
}
if ev.Log != nil {
return ev.Log.String()
}
if ev.Call != nil {
return ev.Call.String()
}
return "<empty>"
}
// Tags
type TaggedEvent struct {
query.Tagged
*Event
}
type TaggedEvents []*TaggedEvent
func (ev *Event) Tagged() *TaggedEvent {
if ev == nil {
return &TaggedEvent{
Tagged: query.TagMap{},
}
}
return &TaggedEvent{
Tagged: query.MergeTags(
query.MustReflectTags(ev.Header),
eventMessageTag,
query.MustReflectTags(ev.Input),
query.MustReflectTags(ev.Output),
query.MustReflectTags(ev.Call),
ev.Log,
),
Event: ev,
}
}
func (tevs TaggedEvents) Filter(qry query.Query) TaggedEvents {
var filtered TaggedEvents
for _, tev := range tevs {
if qry.Matches(tev) {
filtered = append(filtered, tev)
}
}
return filtered
}