forked from codeamp/circuit
/
releaseextension_handler.go
124 lines (102 loc) · 3.41 KB
/
releaseextension_handler.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
package codeamp
import (
"encoding/json"
"fmt"
"time"
"github.com/codeamp/circuit/plugins"
"github.com/codeamp/circuit/plugins/codeamp/model"
log "github.com/codeamp/logger"
"github.com/codeamp/transistor"
"github.com/jinzhu/gorm/dialects/postgres"
)
func (x *CodeAmp) ReleaseExtensionEventHandler(e transistor.Event) error {
payload := e.Payload.(plugins.ReleaseExtension)
var releaseExtension model.ReleaseExtension
var release model.Release
if e.Matches("release:.*:status") {
if x.DB.Where("id = ?", payload.Release.ID).Find(&release).RecordNotFound() {
log.InfoWithFields("release", log.Fields{
"id": payload.Release.ID,
})
return fmt.Errorf("Release %s not found", payload.Release.ID)
}
if x.DB.Where("id = ?", payload.ID).Find(&releaseExtension).RecordNotFound() {
log.InfoWithFields("release extension not found", log.Fields{
"id": payload.ID,
})
return fmt.Errorf("Release extension %s not found", payload.ID)
}
releaseExtension.State = e.State
releaseExtension.StateMessage = e.StateMessage
marshalledReArtifacts, err := json.Marshal(e.Artifacts)
if err != nil {
log.Error(err.Error(), log.Fields{})
return err
}
releaseExtension.Artifacts = postgres.Jsonb{marshalledReArtifacts}
x.DB.Save(&releaseExtension)
if e.State == transistor.GetState("complete") {
releaseExtension.Finished = time.Now()
x.DB.Save(&releaseExtension)
x.ReleaseExtensionCompleted(&releaseExtension)
}
if e.State == transistor.GetState("failed") {
releaseExtension.Finished = time.Now()
x.DB.Save(&releaseExtension)
x.ReleaseFailed(&release, e.StateMessage)
}
}
return nil
}
func (x *CodeAmp) ReleaseExtensionCompleted(re *model.ReleaseExtension) {
project := model.Project{}
release := model.Release{}
environment := model.Environment{}
releaseExtensions := []model.ReleaseExtension{}
if x.DB.Where("id = ?", re.ReleaseID).First(&release).RecordNotFound() {
log.ErrorWithFields("release not found", log.Fields{
"releaseExtension": re,
})
return
}
if x.DB.Where("id = ?", release.ProjectID).First(&project).RecordNotFound() {
log.ErrorWithFields("project not found", log.Fields{
"release": release,
})
return
}
if x.DB.Where("release_id = ?", re.ReleaseID).Find(&releaseExtensions).RecordNotFound() {
log.ErrorWithFields("release extensions not found", log.Fields{
"releaseExtension": re,
})
return
}
if x.DB.Where("id = ?", release.EnvironmentID).First(&environment).RecordNotFound() {
log.ErrorWithFields("Environment not found", log.Fields{
"id": release.EnvironmentID,
})
return
}
payload := plugins.WebsocketMsg{
Event: fmt.Sprintf("projects/%s/%s/releases/reCompleted", project.Slug, environment.Key),
Payload: release,
}
event := transistor.NewEvent(plugins.GetEventName("websocket"), transistor.GetAction("status"), payload)
event.AddArtifact("event", fmt.Sprintf("projects/%s/%s/releases/reCompleted", project.Slug, environment.Key), false)
x.Events <- event
// loop through and check if all same-type release extensions are completed
done := true
for _, releaseExtension := range releaseExtensions {
if releaseExtension.Type == re.Type && releaseExtension.State != transistor.GetState("complete") {
done = false
}
}
if done {
switch re.Type {
case plugins.GetType("workflow"):
x.WorkflowReleaseExtensionsCompleted(&release)
case plugins.GetType("deployment"):
x.ReleaseCompleted(&release)
}
}
}