forked from cisco-app-networking/networkservicemesh
/
crossconnect_event.go
126 lines (102 loc) · 3.4 KB
/
crossconnect_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
package crossconnect
import (
context "context"
"github.com/pkg/errors"
"cisco-app-networking.github.io/networkservicemesh/controlplane/api/crossconnect"
"cisco-app-networking.github.io/networkservicemesh/sdk/monitor"
)
// Event is a monitor.Event for crossconnect GRPC API
type Event struct {
monitor.BaseEvent
Statistics map[string]*crossconnect.Metrics
ctx context.Context
}
// Message converts Event to CrossConnectEvent
func (e *Event) Message() (interface{}, error) {
eventType, err := eventTypeToXconEventType(e.EventType())
if err != nil {
return nil, err
}
xcons, err := xconsFromEntities(e.Entities())
if err != nil {
return nil, err
}
return &crossconnect.CrossConnectEvent{
Type: eventType,
CrossConnects: xcons,
Metrics: e.Statistics,
}, nil
}
// Context - return associated event caller context
func (e *Event) Context() context.Context {
return e.ctx
}
type eventFactory struct {
}
func (m *eventFactory) FactoryName() string {
return "CrossConnect"
}
func (m *eventFactory) NewEvent(ctx context.Context, eventType monitor.EventType, entities map[string]monitor.Entity) monitor.Event {
return &Event{
BaseEvent: monitor.NewBaseEvent(ctx, eventType, entities),
Statistics: map[string]*crossconnect.Metrics{},
ctx: ctx,
}
}
func (m *eventFactory) EventFromMessage(ctx context.Context, message interface{}) (monitor.Event, error) {
xconEvent, ok := message.(*crossconnect.CrossConnectEvent)
if !ok {
return nil, errors.Errorf("unable to cast %v to CrossConnectEvent", message)
}
eventType, err := xconEventTypeToEventType(xconEvent.GetType())
if err != nil {
return nil, err
}
entities := entitiesFromXcons(xconEvent.CrossConnects)
return &Event{
BaseEvent: monitor.NewBaseEvent(ctx, eventType, entities),
Statistics: xconEvent.Metrics,
}, nil
}
func eventTypeToXconEventType(eventType monitor.EventType) (crossconnect.CrossConnectEventType, error) {
switch eventType {
case monitor.EventTypeInitialStateTransfer:
return crossconnect.CrossConnectEventType_INITIAL_STATE_TRANSFER, nil
case monitor.EventTypeUpdate:
return crossconnect.CrossConnectEventType_UPDATE, nil
case monitor.EventTypeDelete:
return crossconnect.CrossConnectEventType_DELETE, nil
default:
return 0, errors.Errorf("unable to cast %v to CrossConnectEventType", eventType)
}
}
func xconEventTypeToEventType(connectionEventType crossconnect.CrossConnectEventType) (monitor.EventType, error) {
switch connectionEventType {
case crossconnect.CrossConnectEventType_INITIAL_STATE_TRANSFER:
return monitor.EventTypeInitialStateTransfer, nil
case crossconnect.CrossConnectEventType_UPDATE:
return monitor.EventTypeUpdate, nil
case crossconnect.CrossConnectEventType_DELETE:
return monitor.EventTypeDelete, nil
default:
return "", errors.Errorf("unable to cast %v to monitor.EventType", connectionEventType)
}
}
func xconsFromEntities(entities map[string]monitor.Entity) (map[string]*crossconnect.CrossConnect, error) {
xcons := map[string]*crossconnect.CrossConnect{}
for k, v := range entities {
if conn, ok := v.(*crossconnect.CrossConnect); ok {
xcons[k] = conn
} else {
return nil, errors.New("unable to cast Entity to CrossConnect")
}
}
return xcons, nil
}
func entitiesFromXcons(xcons map[string]*crossconnect.CrossConnect) map[string]monitor.Entity {
entities := map[string]monitor.Entity{}
for k, v := range xcons {
entities[k] = v
}
return entities
}