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
|
package connectors
import (
"context"
"io"
"github.com/mimecast/dtail/internal/clients/handlers"
"github.com/mimecast/dtail/internal/config"
"github.com/mimecast/dtail/internal/io/dlog"
serverHandlers "github.com/mimecast/dtail/internal/server/handlers"
sshserver "github.com/mimecast/dtail/internal/ssh/server"
user "github.com/mimecast/dtail/internal/user/server"
)
// Serverless creates a server object directly without TCP.
type Serverless struct {
handler handlers.Handler
commands []string
userName string
}
var _ Connector = (*Serverless)(nil)
// NewServerless starts a new serverless session.
func NewServerless(userName string, handler handlers.Handler,
commands []string) *Serverless {
dlog.Client.Debug("Creating new serverless connector", handler, commands)
return &Serverless{
userName: userName,
handler: handler,
commands: commands,
}
}
// Server returns serverless server indicator.
func (s *Serverless) Server() string {
return "local(serverless)"
}
// Handler returns the handler used for the serverless connection.
func (s *Serverless) Handler() handlers.Handler {
return s.handler
}
// Start the serverless connection.
func (s *Serverless) Start(ctx context.Context, cancel context.CancelFunc,
throttleCh, statsCh chan struct{}) {
dlog.Client.Debug("Starting serverless connector")
go func() {
defer cancel()
if err := s.handle(ctx, cancel); err != nil {
dlog.Client.Warn(err)
}
}()
<-ctx.Done()
}
func (s *Serverless) handle(ctx context.Context, cancel context.CancelFunc) error {
dlog.Client.Debug("Creating server handler for a serverless session")
user, err := user.New(s.userName, s.Server())
if err != nil {
return err
}
var serverHandler serverHandlers.Handler
switch s.userName {
case config.HealthUser:
dlog.Client.Debug("Creating serverless health handler")
serverHandler = serverHandlers.NewHealthHandler(user)
default:
dlog.Client.Debug("Creating serverless server handler")
serverHandler = serverHandlers.NewServerHandler(
user,
make(chan struct{}, config.Server.MaxConcurrentCats),
make(chan struct{}, config.Server.MaxConcurrentTails),
config.Server,
sshserver.AuthKeys(),
)
}
terminate := func() {
dlog.Client.Debug("Terminating serverless connection")
serverHandler.Shutdown()
cancel()
}
// Use buffered channels to prevent deadlock
// This approach avoids the circular dependency of direct io.Copy
// Channels for data flow
toServer := make(chan []byte, 100)
fromServer := make(chan []byte, 100)
// Error tracking
errChan := make(chan error, 4)
// Read from client handler
go func() {
defer close(toServer)
buf := make([]byte, 32*1024)
for {
n, err := s.handler.Read(buf)
if n > 0 {
data := make([]byte, n)
copy(data, buf[:n])
select {
case toServer <- data:
case <-ctx.Done():
return
}
}
if err != nil {
if err != io.EOF {
errChan <- err
}
return
}
}
}()
// Write to server handler
go func() {
for data := range toServer {
if _, err := serverHandler.Write(data); err != nil {
errChan <- err
return
}
}
}()
// Read from server handler
go func() {
defer close(fromServer)
buf := make([]byte, 64*1024) // Larger buffer for server responses
for {
n, err := serverHandler.Read(buf)
if n > 0 {
data := make([]byte, n)
copy(data, buf[:n])
select {
case fromServer <- data:
case <-ctx.Done():
return
}
}
if err != nil {
if err != io.EOF {
errChan <- err
}
return
}
}
}()
// Write to client handler
serverDone := make(chan struct{})
go func() {
defer close(serverDone)
for data := range fromServer {
if _, err := s.handler.Write(data); err != nil {
errChan <- err
return
}
}
}()
// Send commands after setting up the data flow
for _, command := range s.commands {
dlog.Client.Debug("Sending command to serverless server", command)
if err := s.handler.SendMessage(command); err != nil {
dlog.Client.Debug(err)
}
}
// Monitor for completion
go func() {
defer terminate()
select {
case <-s.handler.Done():
dlog.Client.Trace("<-s.handler.Done()")
case <-serverDone:
dlog.Client.Trace("Server transfer done")
case <-ctx.Done():
dlog.Client.Trace("<-ctx.Done()")
}
}()
// Wait for completion
<-ctx.Done()
// Check for errors
select {
case err := <-errChan:
return err
default:
}
s.handler.Shutdown()
return nil
}
|
