/
events.go
167 lines (140 loc) · 5.54 KB
/
events.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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
package events
import (
"fmt"
"errors"
"time"
"encoding/json"
"github.com/google/uuid"
"github.com/go-playground/validator"
log "github.com/sirupsen/logrus"
)
var (
InvalidEventError = errors.New("invalid go-get-git event payload")
validate = validator.New()
parser EventParser
)
func ParseEvent(payload []byte) (*Event, error) {
log.Info(fmt.Sprintf("received event payload %s", payload))
parser := DefaultParser{}
return parser.ParseEvent(payload)
}
type Event struct {
ApplicationId string `json:"application_id" validate:"required"`
ParentId uuid.UUID `json:"parent_id" validate:"required"`
EventId uuid.UUID `json:"event_id" validate:"required"`
EventTimestamp time.Time `json:"event_timestamp" validate:"required"`
EventType string `json:"event_type" validate:"required"`
EventPayload interface{} `json:"event_payload" validate:"required"`
}
type GitPushEvent struct {
RepoUrl string `json:"repo_url" validate:"required"`
ApplicationDirectory string `json:"application_directory" validate:"required"`
}
type NewGitRepoEvent struct {
RepoUrl string `json:"repo_url" validate:"required"`
ApplicationDirectory string `json:"application_directory" validate:"required"`
}
type BuildTriggeredEvent struct {
EntryId uuid.UUID `json:"entry_id" validate:"required"`
RepoUrl string `json:"repo_url" validate:"required"`
}
type BuildFailedEvent struct {
EntryId uuid.UUID `json:"entry_id" validate:"required"`
RepoUrl string `json:"repo_url" validate:"required"`
}
type BuildCompletedEvent struct {
EntryId uuid.UUID `json:"entry_id" validate:"required"`
RepoUrl string `json:"repo_url" validate:"required"`
ContainerId string `json:"container_id" validate:"required"`
}
type ContainerCrashedEvent struct {
ContainerId string `json:"container_id" validate:"required"`
}
type ContainerRestartEvent struct {
ContainerId string `json:"container_id" validate:"required"`
}
// #######################################
// # Define interface used to parse events
// #######################################
type EventParser interface {
ParseEvent(payload []byte) interface{}
}
type DefaultParser struct {}
// basic function used to parse an event into Event structs. Note that
// Event objects contaim a specific EventPayload struct, which must
// first be parsed. All Event JSON messages must contain an event_type
// which is parsed and returned
func(parser DefaultParser) ParseEvent(payload []byte) (*Event, error) {
var e Event
// parse generic JSON into Event struct and return error if event cannot be parsed
err := json.Unmarshal(payload, &e)
if err != nil || e.EventPayload == nil {
log.Error("unable to parse event from JSON format")
return &Event{}, InvalidEventError
}
log.Info(fmt.Sprintf("parsing event type '%s' with payload '%s'", e.EventType, e.EventPayload))
var event interface{}
// parse original payload back to JSON format to parse manually
eventPayload, _ := json.Marshal(e.EventPayload)
switch e.EventType {
case "NewGitRepoEvent":
event, err= parser.ParseNewGitRepoEvent(eventPayload)
case "GitPushEvent":
event, err = parser.ParseGitPushEvent(eventPayload)
case "BuildTriggeredEvent":
event, err = parser.ParseBuildTriggeredEvent(eventPayload)
case "BuildFailedEvent":
event, err = parser.ParseBuildFailedEvent(eventPayload)
case "BuildCompletedEvent":
event, err = parser.ParseBuildCompletedEvent(eventPayload)
case "ContainerCrashedEvent":
event, err = parser.ParseContainerCrashedEvent(eventPayload)
case "ContainerRestartEvent":
event, err = parser.ParseContainerRestartEvent(eventPayload)
default:
event, err = nil, InvalidEventError
}
if err != nil {
log.Error(fmt.Errorf("unable to parse event: %+v", err))
return nil, err
}
// assign parsed event payload as attribute of event
log.Info(fmt.Sprintf("successfully parsed event %+v", event))
e.EventPayload = event
return &e, validate.Struct(event)
}
func(parser DefaultParser) ParseGitPushEvent(eventPayload []byte) (GitPushEvent, error) {
var event GitPushEvent
err := json.Unmarshal(eventPayload, &event)
return event, err
}
func(parser DefaultParser) ParseBuildTriggeredEvent(eventPayload []byte) (BuildTriggeredEvent, error) {
var event BuildTriggeredEvent
err := json.Unmarshal(eventPayload, &event)
return event, err
}
func(parser DefaultParser) ParseBuildFailedEvent(eventPayload []byte) (BuildFailedEvent, error) {
var event BuildFailedEvent
err := json.Unmarshal(eventPayload, &event)
return event, err
}
func(parser DefaultParser) ParseBuildCompletedEvent(eventPayload []byte) (BuildCompletedEvent, error) {
var event BuildCompletedEvent
err := json.Unmarshal(eventPayload, &event)
return event, err
}
func(parser DefaultParser) ParseContainerCrashedEvent(eventPayload []byte) (ContainerCrashedEvent, error) {
var event ContainerCrashedEvent
err := json.Unmarshal(eventPayload, &event)
return event, err
}
func(parser DefaultParser) ParseContainerRestartEvent(eventPayload []byte) (ContainerRestartEvent, error) {
var event ContainerRestartEvent
err := json.Unmarshal(eventPayload, &event)
return event, err
}
func(parser DefaultParser) ParseNewGitRepoEvent(eventPayload []byte) (NewGitRepoEvent, error) {
var event NewGitRepoEvent
err := json.Unmarshal(eventPayload, &event)
return event, err
}