github.com/datachainlab/burrow@v0.25.0/execution/exec/event.go (about)

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