-
Notifications
You must be signed in to change notification settings - Fork 0
/
logger-server.go
101 lines (85 loc) · 2.29 KB
/
logger-server.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
package commonlog
import (
"bufio"
"net"
"github.com/tliron/kutil/util"
)
//
// LoggerServer
//
// A TCP server file that forwards all lines written to it to a [Logger].
type LoggerServer struct {
IPStack util.IPStack
Address string
Port int
Log Logger
Level Level
ClientAddressPorts []string
listeners []net.Listener
}
func NewLoggerServer(ipStack util.IPStack, address string, port int, log Logger, level Level) *LoggerServer {
return &LoggerServer{
IPStack: ipStack,
Address: address,
Port: port,
Log: NewKeyValueLogger(log, "tcp", port),
Level: level,
}
}
func (self *LoggerServer) Start() error {
return self.IPStack.StartServers(self.Address, self.start)
}
func (self *LoggerServer) Stop() {
for index, listener := range self.listeners {
self.Log.Notice("stopping logger server",
"index", index)
if err := listener.Close(); err != nil {
self.Log.Error(err.Error())
}
self.Log.Notice("stopped logger server",
"index", index)
}
}
// ([util.IPStackStartServerFunc] signature)
func (self *LoggerServer) start(level2protocol string, address string) error {
if address, err := util.ToReachableIPAddress(address); err == nil {
addressPort := util.JoinIPAddressPort(address, self.Port)
if listener, err := net.Listen(level2protocol, addressPort); err == nil {
self.Log.Notice("starting logger server",
"index", len(self.listeners),
"level2protocol", level2protocol,
"addressPort", listener.Addr().String())
self.ClientAddressPorts = append(self.ClientAddressPorts, util.IPAddressPortWithoutZone(addressPort))
self.listeners = append(self.listeners, listener)
go func() {
for {
if conn, err := listener.Accept(); err == nil {
self.Log.Debug("accepted logger server connection")
go self.handle(conn)
} else {
self.Log.Critical(err.Error())
return
}
}
}()
return nil
} else {
return err
}
} else {
return err
}
}
func (self *LoggerServer) handle(conn net.Conn) {
defer CallAndLogError(func() error {
self.Log.Debug("closing logger server connection")
return conn.Close()
}, "Conn.Close", self.Log)
scanner := bufio.NewScanner(conn)
for scanner.Scan() {
self.Log.Log(self.Level, 0, scanner.Text())
}
if err := scanner.Err(); err != nil {
self.Log.Error(err.Error())
}
}