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
|
package integrationtests
import (
"context"
"fmt"
"os"
"strings"
"testing"
"time"
)
// testDGrepWithServer tests dgrep command with a running server
func testDGrepWithServer(t *testing.T, args []string, outFile, expectedFile string) error {
port := getUniquePortNumber()
bindAddress := "localhost"
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Start server
serverCh, _, _, err := startCommand(ctx, t,
"", "../dserver",
"--cfg", "none",
"--logger", "stdout",
"--logLevel", "error",
"--bindAddress", bindAddress,
"--port", fmt.Sprintf("%d", port),
)
if err != nil {
return fmt.Errorf("failed to start server: %v", err)
}
// Give server time to start
time.Sleep(1 * time.Second)
// Prepare dgrep args with server connection
dgrepArgs := append([]string{
"--servers", fmt.Sprintf("%s:%d", bindAddress, port),
"--trustAllHosts",
"--noColor",
}, args...)
// Start dgrep client
clientCh, _, _, err := startCommand(ctx, t,
"", "../dgrep", dgrepArgs...)
if err != nil {
cancel()
return fmt.Errorf("failed to start dgrep client: %v", err)
}
// Collect all output
var output []string
timeout := time.After(15 * time.Second)
linesReceived := 0
for {
select {
case line := <-serverCh:
// Only log important server errors, not routine messages
if strings.Contains(line, "ERROR|") &&
!strings.Contains(line, "use of closed network connection") {
t.Logf("server error: %s", line)
}
case line := <-clientCh:
// Only log client errors if needed
// Process empty lines too - they are valid content
// Don't skip empty lines as they may be meaningful
if strings.HasPrefix(line, "REMOTE|") {
// Extract the actual content from DTail protocol format
// Format: REMOTE|hostname|priority|lineno|sourceID|hostname|filename|linenum|content
parts := strings.Split(line, "|")
if len(parts) >= 8 {
content := strings.Join(parts[7:], "|")
// Remove line number prefix if present (from DTail format)
if strings.Contains(content, " ") {
contentParts := strings.SplitN(content, " ", 2)
if len(contentParts) == 2 {
output = append(output, contentParts[1])
} else {
output = append(output, content)
}
} else {
output = append(output, content)
}
linesReceived++
}
} else if strings.HasPrefix(line, "CLIENT|") {
// Client status messages - ignore
continue
} else {
// Direct content line from dgrep (not wrapped in protocol)
// Include empty lines as they are meaningful content
output = append(output, line)
linesReceived++
}
case <-timeout:
// Timeout reached, finish collecting
goto done
case <-ctx.Done():
goto done
}
// If we received some output and haven't seen new lines for a bit, we're probably done
if linesReceived > 0 {
select {
case <-time.After(500 * time.Millisecond):
goto done
default:
continue
}
}
}
done:
cancel()
// Write collected output to file
if len(output) > 0 {
fd, err := os.Create(outFile)
if err != nil {
return fmt.Errorf("failed to create output file: %v", err)
}
defer fd.Close()
// Check if the expected file ends with a newline to match format
expectedData, err := os.ReadFile(expectedFile)
if err != nil {
return fmt.Errorf("failed to read expected file: %v", err)
}
endsWithNewline := len(expectedData) > 0 && expectedData[len(expectedData)-1] == '\n'
for i, line := range output {
if i == len(output)-1 && !endsWithNewline {
// Last line and original doesn't end with newline
fd.WriteString(line)
} else {
fd.WriteString(line + "\n")
}
}
}
// Compare results
if err := compareFiles(t, outFile, expectedFile); err != nil {
return err
}
os.Remove(outFile)
return nil
}
|
