@@ -98,9 +98,8 @@ type HttpTransportOptions struct {
98
98
// defaults to http.DefaultClient
99
99
Client * http.Client
100
100
101
- // Scheme (Optional) is either `http` or `https`. Should always be 'http' as
102
- // 'https' is not currently supported. `Scheme` is reserved here for future use.
103
- // defaults to `http`
101
+ // Scheme (Optional) is either `http` or `https`. `Scheme` is reserved here for future use.
102
+ // defaults to `http` when TLSConfig is not set.
104
103
Scheme string
105
104
106
105
// BasePath (Optional) specifies the HTTP path that will serve groupcache requests.
@@ -110,15 +109,19 @@ type HttpTransportOptions struct {
110
109
// Logger
111
110
Logger Logger
112
111
113
- // TODO: Support for TLS
112
+ // TLS support.
113
+ TLSConfig * tls.Config
114
114
}
115
115
116
+ // HttpTransport defines the HTTP transport
116
117
type HttpTransport struct {
117
- opts HttpTransportOptions
118
- instance GroupCacheInstance
119
- wg sync.WaitGroup
120
- listener net.Listener
121
- server * http.Server
118
+ opts HttpTransportOptions
119
+ instance GroupCacheInstance
120
+ wg sync.WaitGroup
121
+ listener net.Listener
122
+ server * http.Server
123
+ tlsListener net.Listener
124
+ tlsServer * http.Server
122
125
}
123
126
124
127
// NewHttpTransport returns a new HttpTransport instance based on the provided HttpTransportOptions.
@@ -151,6 +154,11 @@ func NewHttpTransport(opts HttpTransportOptions) *HttpTransport {
151
154
opts .Logger = slog .Default ()
152
155
}
153
156
157
+ // override the Scheme that is set to ensure it is https
158
+ if opts .TLSConfig != nil {
159
+ opts .Scheme = "https"
160
+ }
161
+
154
162
return & HttpTransport {
155
163
opts : opts ,
156
164
}
@@ -177,36 +185,61 @@ func (t *HttpTransport) ListenAndServe(ctx context.Context, address string) erro
177
185
return fmt .Errorf ("while starting HTTP listener: %w" , err )
178
186
}
179
187
180
- t .server = & http.Server {
181
- Handler : mux ,
188
+ if t .opts .TLSConfig != nil {
189
+ t .tlsListener = tls .NewListener (t .listener , t .opts .TLSConfig )
190
+ t .tlsServer = & http.Server {
191
+ Handler : mux ,
192
+ }
193
+ } else {
194
+ t .server = & http.Server {
195
+ Handler : mux ,
196
+ }
182
197
}
183
198
184
199
t .wg .Add (1 )
185
200
go func () {
186
201
t .opts .Logger .Info (fmt .Sprintf ("Listening on %s ...." , address ))
187
- if err := t .server .Serve (t .listener ); err != nil {
188
- if ! errors .Is (err , http .ErrServerClosed ) {
189
- t .opts .Logger .Error ("while starting HTTP server" , "err" , err )
202
+ if t .tlsServer != nil {
203
+ if err := t .tlsServer .Serve (t .tlsListener ); err != nil {
204
+ if ! errors .Is (err , http .ErrServerClosed ) {
205
+ t .opts .Logger .Error ("while starting HTTPs server" , "err" , err )
206
+ }
207
+ }
208
+ } else {
209
+ if err := t .server .Serve (t .listener ); err != nil {
210
+ if ! errors .Is (err , http .ErrServerClosed ) {
211
+ t .opts .Logger .Error ("while starting HTTP server" , "err" , err )
212
+ }
190
213
}
191
214
}
192
215
t .wg .Done ()
193
216
}()
194
217
195
218
// Ensure server is accepting connections before returning
196
- return waitForConnect (ctx , t .listener .Addr ().String (), nil )
219
+ return waitForConnect (ctx , t .listener .Addr ().String (), t . opts . TLSConfig )
197
220
}
198
221
199
222
// Shutdown shuts down the server started when calling ListenAndServe()
200
223
func (t * HttpTransport ) Shutdown (ctx context.Context ) error {
201
- if err := t .server .Shutdown (ctx ); err != nil {
202
- return err
224
+ if t .tlsServer != nil {
225
+ if err := t .tlsServer .Shutdown (ctx ); err != nil {
226
+ return err
227
+ }
228
+ } else {
229
+ if err := t .server .Shutdown (ctx ); err != nil {
230
+ return err
231
+ }
203
232
}
233
+
204
234
t .wg .Wait ()
205
235
return nil
206
236
}
207
237
208
238
// ListenAddress returns the address the server is listening on after calling ListenAndServe().
209
239
func (t * HttpTransport ) ListenAddress () string {
240
+ if t .tlsListener != nil {
241
+ return t .tlsListener .Addr ().String ()
242
+ }
210
243
return t .listener .Addr ().String ()
211
244
}
212
245
@@ -469,7 +502,16 @@ func waitForConnect(ctx context.Context, address string, cfg *tls.Config) error
469
502
errs = append (errs , ctx .Err ().Error ())
470
503
return errors .New (strings .Join (errs , "\n " ))
471
504
}
472
- time . Sleep (time .Millisecond * 100 )
505
+ wait (time .Millisecond * 100 )
473
506
continue
474
507
}
475
508
}
509
+
510
+ func wait (duration time.Duration ) {
511
+ stopCh := make (chan struct {}, 1 )
512
+ timer := time .AfterFunc (duration , func () {
513
+ stopCh <- struct {}{}
514
+ })
515
+ <- stopCh
516
+ timer .Stop ()
517
+ }
0 commit comments