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
|
// Package serviceapi Provides a Container compatible interface.
//
// This documentation describes the HTTP LibPod interface
//
// Schemes: http, https
// Host: podman.io
// BasePath: /
// Version: 0.0.1
// License: Apache-2.0 https://opensource.org/licenses/Apache-2.0
// Contact: Podman <podman@lists.podman.io> https://podman.io/community/
//
// Consumes:
// - application/json
// - application/x-tar
//
// Produces:
// - application/json
// - text/plain
// - text/html
//
// tags:
// - name: "Containers"
// description: manage containers
// - name: "Images"
// description: manage images
// - name: "System"
// description: manage system resources
//
// swagger:meta
package server
import (
"context"
"net"
"net/http"
"os"
"os/signal"
"strings"
"time"
"github.com/containers/libpod/libpod"
"github.com/coreos/go-systemd/activation"
"github.com/gorilla/mux"
"github.com/gorilla/schema"
"github.com/pkg/errors"
log "github.com/sirupsen/logrus"
)
type APIServer struct {
http.Server // Where the HTTP work happens
*schema.Decoder // Decoder for Query parameters to structs
context.Context // Context for graceful server shutdown
*libpod.Runtime // Where the real work happens
net.Listener // mux for routing HTTP API calls to libpod routines
context.CancelFunc // Stop APIServer
*time.Timer // Hold timer for sliding window
time.Duration // Duration of client access sliding window
}
// NewServer will create and configure a new API HTTP server
func NewServer(runtime *libpod.Runtime) (*APIServer, error) {
listeners, err := activation.Listeners()
if err != nil {
return nil, errors.Wrap(err, "Cannot retrieve file descriptors from systemd")
}
if len(listeners) != 1 {
return nil, errors.Errorf("Wrong number of file descriptors from systemd for socket activation (%d != 1)", len(listeners))
}
quit := make(chan os.Signal, 1)
signal.Notify(quit)
router := mux.NewRouter()
server := APIServer{
Server: http.Server{
Handler: router,
ReadHeaderTimeout: 20 * time.Second,
ReadTimeout: 20 * time.Second,
WriteTimeout: 2 * time.Minute,
},
Decoder: schema.NewDecoder(),
Context: nil,
Runtime: runtime,
Listener: listeners[0],
CancelFunc: nil,
Duration: 300 * time.Second,
}
server.Timer = time.AfterFunc(server.Duration, func() {
if err := server.Shutdown(); err != nil {
log.Errorf("unable to shutdown server: %q", err)
}
})
ctx, cancelFn := context.WithCancel(context.Background())
// TODO: Use ConnContext when ported to go 1.13
ctx = context.WithValue(ctx, "decoder", server.Decoder)
ctx = context.WithValue(ctx, "runtime", runtime)
ctx = context.WithValue(ctx, "shutdownFunc", server.Shutdown)
server.Context = ctx
server.CancelFunc = cancelFn
server.Decoder.IgnoreUnknownKeys(true)
router.NotFoundHandler = http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
// We can track user errors...
log.Infof("Failed Request: (%d:%s) for %s:'%s'", http.StatusNotFound, http.StatusText(http.StatusNotFound), r.Method, r.URL.String())
http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
},
)
for _, fn := range []func(*mux.Router) error{
server.RegisterAuthHandlers,
server.RegisterContainersHandlers,
server.RegisterDistributionHandlers,
server.registerHealthCheckHandlers,
server.registerImagesHandlers,
server.registerInfoHandlers,
server.RegisterMonitorHandlers,
server.registerPingHandlers,
server.RegisterPluginsHandlers,
server.registerPodsHandlers,
server.RegisterSwarmHandlers,
server.registerSystemHandlers,
server.registerVersionHandlers,
server.registerVolumeHandlers,
} {
if err := fn(router); err != nil {
return nil, err
}
}
if log.IsLevelEnabled(log.DebugLevel) {
router.Walk(func(route *mux.Route, r *mux.Router, ancestors []*mux.Route) error { // nolint
path, err := route.GetPathTemplate()
if err != nil {
path = ""
}
methods, err := route.GetMethods()
if err != nil {
methods = []string{}
}
log.Debugf("Methods: %s Path: %s", strings.Join(methods, ", "), path)
return nil
})
}
return &server, nil
}
// Serve starts responding to HTTP requests
func (s *APIServer) Serve() error {
defer s.CancelFunc()
err := s.Server.Serve(s.Listener)
if err != nil && err != http.ErrServerClosed {
return errors.Wrap(err, "Failed to start APIServer")
}
return nil
}
// Shutdown is a clean shutdown waiting on existing clients
func (s *APIServer) Shutdown() error {
// We're still in the sliding service window
if s.Timer.Stop() {
s.Timer.Reset(s.Duration)
return nil
}
// We've been idle for the service window, really shutdown
go func() {
err := s.Server.Shutdown(s.Context)
if err != nil && err != context.Canceled {
log.Errorf("Failed to cleanly shutdown APIServer: %s", err.Error())
}
}()
// Wait for graceful shutdown vs. just killing connections and dropping data
<-s.Context.Done()
return nil
}
// Close immediately stops responding to clients and exits
func (s *APIServer) Close() error {
return s.Server.Close()
}
|
