forked from vmware-archive/atc
/
build_step_delegate.go
134 lines (111 loc) · 2.6 KB
/
build_step_delegate.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
package engine
import (
"io"
"sync"
"unicode/utf8"
"code.cloudfoundry.org/clock"
"code.cloudfoundry.org/lager"
"github.com/concourse/atc"
"github.com/concourse/atc/db"
"github.com/concourse/atc/event"
"github.com/concourse/atc/exec"
)
type BuildStepDelegate struct {
build db.Build
planID atc.PlanID
clock clock.Clock
}
func NewBuildStepDelegate(
build db.Build,
planID atc.PlanID,
clock clock.Clock,
) *BuildStepDelegate {
return &BuildStepDelegate{
build: build,
planID: planID,
clock: clock,
}
}
func (delegate *BuildStepDelegate) ImageVersionDetermined(resourceCache *db.UsedResourceCache) error {
return delegate.build.SaveImageResourceVersion(resourceCache)
}
func (delegate *BuildStepDelegate) Stdout() io.Writer {
return newDBEventWriter(
delegate.build,
event.Origin{
Source: event.OriginSourceStdout,
ID: event.OriginID(delegate.planID),
},
delegate.clock,
)
}
func (delegate *BuildStepDelegate) Stderr() io.Writer {
return newDBEventWriter(
delegate.build,
event.Origin{
Source: event.OriginSourceStderr,
ID: event.OriginID(delegate.planID),
},
delegate.clock,
)
}
func (delegate *BuildStepDelegate) Errored(logger lager.Logger, message string) {
err := delegate.build.SaveEvent(event.Error{
Message: message,
Origin: event.Origin{
ID: event.OriginID(delegate.planID),
},
})
if err != nil {
logger.Error("failed-to-save-error-event", err)
}
}
func newDBEventWriter(build db.Build, origin event.Origin, clock clock.Clock) io.Writer {
return &dbEventWriter{
build: build,
origin: origin,
clock: clock,
}
}
type dbEventWriter struct {
build db.Build
origin event.Origin
dangling []byte
clock clock.Clock
}
func (writer *dbEventWriter) Write(data []byte) (int, error) {
text := append(writer.dangling, data...)
checkEncoding, _ := utf8.DecodeLastRune(text)
if checkEncoding == utf8.RuneError {
writer.dangling = text
return len(data), nil
}
writer.dangling = nil
err := writer.build.SaveEvent(event.Log{
Time: writer.clock.Now().Unix(),
Payload: string(text),
Origin: writer.origin,
})
if err != nil {
return 0, err
}
return len(data), nil
}
type implicitOutput struct {
resourceType string
info exec.VersionInfo
}
type implicitOutputsRepo struct {
outputs map[string]implicitOutput
lock *sync.Mutex
}
func (repo *implicitOutputsRepo) Register(resource string, output implicitOutput) {
repo.lock.Lock()
repo.outputs[resource] = output
repo.lock.Unlock()
}
func (repo *implicitOutputsRepo) Unregister(resource string) {
repo.lock.Lock()
delete(repo.outputs, resource)
repo.lock.Unlock()
}