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
|
// SPDX-License-Identifier: GPL-3.0-or-later
package lighttpd
import (
"bufio"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"github.com/netdata/netdata/go/go.d.plugin/pkg/web"
)
const (
busyWorkers = "BusyWorkers"
idleWorkers = "IdleWorkers"
busyServers = "BusyServers"
idleServers = "IdleServers"
totalAccesses = "Total Accesses"
totalkBytes = "Total kBytes"
uptime = "Uptime"
scoreBoard = "Scoreboard"
)
func newAPIClient(client *http.Client, request web.Request) *apiClient {
return &apiClient{httpClient: client, request: request}
}
type apiClient struct {
httpClient *http.Client
request web.Request
}
func (a apiClient) getServerStatus() (*serverStatus, error) {
req, err := web.NewHTTPRequest(a.request)
if err != nil {
return nil, fmt.Errorf("error on creating request : %v", err)
}
resp, err := a.doRequestOK(req)
defer closeBody(resp)
if err != nil {
return nil, err
}
status, err := parseResponse(resp.Body)
if err != nil {
return nil, fmt.Errorf("error on parsing response from %s : %v", req.URL, err)
}
return status, nil
}
func (a apiClient) doRequestOK(req *http.Request) (*http.Response, error) {
resp, err := a.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("error on request : %v", err)
}
if resp.StatusCode != http.StatusOK {
return resp, fmt.Errorf("%s returned HTTP status %d", req.URL, resp.StatusCode)
}
return resp, nil
}
func parseResponse(r io.Reader) (*serverStatus, error) {
s := bufio.NewScanner(r)
var status serverStatus
for s.Scan() {
parts := strings.Split(s.Text(), ":")
if len(parts) != 2 {
continue
}
key, value := strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1])
switch key {
default:
case busyWorkers, idleWorkers:
return nil, fmt.Errorf("found '%s', apache data", key)
case busyServers:
status.Servers.Busy = mustParseInt(value)
case idleServers:
status.Servers.Idle = mustParseInt(value)
case totalAccesses:
status.Total.Accesses = mustParseInt(value)
case totalkBytes:
status.Total.KBytes = mustParseInt(value)
case uptime:
status.Uptime = mustParseInt(value)
case scoreBoard:
status.Scoreboard = parseScoreboard(value)
}
}
return &status, nil
}
func parseScoreboard(value string) *scoreboard {
// Descriptions from https://blog.serverdensity.com/monitor-lighttpd/
//
// “.” = Opening the TCP connection (connect)
// “C” = Closing the TCP connection if no other HTTP request will use it (close)
// “E” = hard error
// “k” = Keeping the TCP connection open for more HTTP requests from the same client to avoid the TCP handling overhead (keep-alive)
// “r” = ReadAsMap the content of the HTTP request (read)
// “R” = ReadAsMap the content of the HTTP request (read-POST)
// “W” = Write the HTTP response to the socket (write)
// “h” = Decide action to take with the request (handle-request)
// “q” = Start of HTTP request (request-start)
// “Q” = End of HTTP request (request-end)
// “s” = Start of the HTTP request response (response-start)
// “S” = End of the HTTP request response (response-end)
// “_” Waiting for Connection (NOTE: not sure, copied the description from apache score board)
var sb scoreboard
for _, s := range strings.Split(value, "") {
switch s {
case "_":
sb.Waiting++
case ".":
sb.Open++
case "C":
sb.Close++
case "E":
sb.HardError++
case "k":
sb.KeepAlive++
case "r":
sb.Read++
case "R":
sb.ReadPost++
case "W":
sb.Write++
case "h":
sb.HandleRequest++
case "q":
sb.RequestStart++
case "Q":
sb.RequestEnd++
case "s":
sb.ResponseStart++
case "S":
sb.ResponseEnd++
}
}
return &sb
}
func mustParseInt(value string) *int64 {
v, err := strconv.ParseInt(value, 10, 64)
if err != nil {
panic(err)
}
return &v
}
func closeBody(resp *http.Response) {
if resp != nil && resp.Body != nil {
_, _ = io.Copy(io.Discard, resp.Body)
_ = resp.Body.Close()
}
}
|
