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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"sync"
"time"
)
// lockedWriter serializes Write calls to an underlying Writer.
type lockedWriter struct {
lock sync.Mutex
w io.Writer
}
func (w *lockedWriter) Write(b []byte) (int, error) {
w.lock.Lock()
defer w.lock.Unlock()
return w.w.Write(b)
}
// testJSONFilter is an io.Writer filter that replaces the Package field in
// test2json output.
type testJSONFilter struct {
w io.Writer // Underlying writer
variant string // Add ":variant" to Package field
lineBuf bytes.Buffer // Buffer for incomplete lines
}
func (f *testJSONFilter) Write(b []byte) (int, error) {
bn := len(b)
// Process complete lines, and buffer any incomplete lines.
for len(b) > 0 {
nl := bytes.IndexByte(b, '\n')
if nl < 0 {
f.lineBuf.Write(b)
break
}
var line []byte
if f.lineBuf.Len() > 0 {
// We have buffered data. Add the rest of the line from b and
// process the complete line.
f.lineBuf.Write(b[:nl+1])
line = f.lineBuf.Bytes()
} else {
// Process a complete line from b.
line = b[:nl+1]
}
b = b[nl+1:]
f.process(line)
f.lineBuf.Reset()
}
return bn, nil
}
func (f *testJSONFilter) Flush() {
// Write any remaining partial line to the underlying writer.
if f.lineBuf.Len() > 0 {
f.w.Write(f.lineBuf.Bytes())
f.lineBuf.Reset()
}
}
func (f *testJSONFilter) process(line []byte) {
if len(line) > 0 && line[0] == '{' {
// Plausible test2json output. Parse it generically.
//
// We go to some effort here to preserve key order while doing this
// generically. This will stay robust to changes in the test2json
// struct, or other additions outside of it. If humans are ever looking
// at the output, it's really nice to keep field order because it
// preserves a lot of regularity in the output.
dec := json.NewDecoder(bytes.NewBuffer(line))
dec.UseNumber()
val, err := decodeJSONValue(dec)
if err == nil && val.atom == json.Delim('{') {
// Rewrite the Package field.
found := false
for i := 0; i < len(val.seq); i += 2 {
if val.seq[i].atom == "Package" {
if pkg, ok := val.seq[i+1].atom.(string); ok {
val.seq[i+1].atom = pkg + ":" + f.variant
found = true
break
}
}
}
if found {
data, err := json.Marshal(val)
if err != nil {
// Should never happen.
panic(fmt.Sprintf("failed to round-trip JSON %q: %s", string(line), err))
}
f.w.Write(data)
// Copy any trailing text. We expect at most a "\n" here, but
// there could be other text and we want to feed that through.
io.Copy(f.w, dec.Buffered())
return
}
}
}
// Something went wrong. Just pass the line through.
f.w.Write(line)
}
type jsonValue struct {
atom json.Token // If json.Delim, then seq will be filled
seq []jsonValue // If atom == json.Delim('{'), alternating pairs
}
var jsonPop = errors.New("end of JSON sequence")
func decodeJSONValue(dec *json.Decoder) (jsonValue, error) {
t, err := dec.Token()
if err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
return jsonValue{}, err
}
switch t := t.(type) {
case json.Delim:
if t == '}' || t == ']' {
return jsonValue{}, jsonPop
}
var seq []jsonValue
for {
val, err := decodeJSONValue(dec)
if err == jsonPop {
break
} else if err != nil {
return jsonValue{}, err
}
seq = append(seq, val)
}
return jsonValue{t, seq}, nil
default:
return jsonValue{t, nil}, nil
}
}
func (v jsonValue) MarshalJSON() ([]byte, error) {
var buf bytes.Buffer
var marshal1 func(v jsonValue) error
marshal1 = func(v jsonValue) error {
if t, ok := v.atom.(json.Delim); ok {
buf.WriteRune(rune(t))
for i, v2 := range v.seq {
if t == '{' && i%2 == 1 {
buf.WriteByte(':')
} else if i > 0 {
buf.WriteByte(',')
}
if err := marshal1(v2); err != nil {
return err
}
}
if t == '{' {
buf.WriteByte('}')
} else {
buf.WriteByte(']')
}
return nil
}
bytes, err := json.Marshal(v.atom)
if err != nil {
return err
}
buf.Write(bytes)
return nil
}
err := marshal1(v)
return buf.Bytes(), err
}
func synthesizeSkipEvent(enc *json.Encoder, pkg, msg string) {
type event struct {
Time time.Time
Action string
Package string
Output string `json:",omitempty"`
}
ev := event{Time: time.Now(), Package: pkg, Action: "start"}
enc.Encode(ev)
ev.Action = "output"
ev.Output = msg
enc.Encode(ev)
ev.Action = "skip"
ev.Output = ""
enc.Encode(ev)
}
|
