You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
124 lines
2.9 KiB
Go
124 lines
2.9 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"github.com/containrrr/watchtower/pkg/api/metrics"
|
|
"github.com/containrrr/watchtower/pkg/api/middleware"
|
|
"github.com/containrrr/watchtower/pkg/api/prelude"
|
|
"github.com/containrrr/watchtower/pkg/api/updates"
|
|
"net/http"
|
|
"sync"
|
|
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
const tokenMissingMsg = "api token is empty or has not been set. exiting"
|
|
|
|
// API is the http server responsible for serving the HTTP API endpoints
|
|
type API struct {
|
|
Token string
|
|
hasHandlers bool
|
|
mux *http.ServeMux
|
|
server *http.Server
|
|
running *sync.Mutex
|
|
router router
|
|
authMiddleware prelude.Middleware
|
|
registered bool
|
|
}
|
|
|
|
// New is a factory function creating a new API instance
|
|
func New(token string) *API {
|
|
return &API{
|
|
Token: token,
|
|
hasHandlers: false,
|
|
mux: http.NewServeMux(),
|
|
running: &sync.Mutex{},
|
|
router: router{},
|
|
authMiddleware: middleware.RequireToken(token),
|
|
registered: false,
|
|
}
|
|
}
|
|
|
|
func (api *API) route(route string) methodHandlers {
|
|
return api.router.route(route)
|
|
}
|
|
|
|
func (api *API) registerHandlers() {
|
|
if api.registered {
|
|
return
|
|
}
|
|
for path, route := range api.router {
|
|
if len(route) < 1 {
|
|
continue
|
|
}
|
|
api.hasHandlers = true
|
|
api.mux.Handle(path, api.authMiddleware(route.Handler))
|
|
}
|
|
api.registered = true
|
|
return
|
|
}
|
|
|
|
// Start the API and serve over HTTP. Requires an API Token to be set.
|
|
func (api *API) Start() error {
|
|
|
|
api.registerHandlers()
|
|
|
|
if !api.hasHandlers {
|
|
log.Debug("Watchtower HTTP API skipped.")
|
|
return nil
|
|
}
|
|
|
|
if api.Token == "" {
|
|
log.Fatal(tokenMissingMsg)
|
|
}
|
|
|
|
api.running.Lock()
|
|
go func() {
|
|
defer api.running.Unlock()
|
|
api.server = &http.Server{
|
|
Addr: ":8080",
|
|
Handler: api.mux,
|
|
}
|
|
|
|
if err := api.server.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
|
|
log.Errorf("HTTP Server error: %v", err)
|
|
}
|
|
}()
|
|
|
|
return nil
|
|
}
|
|
|
|
// Stop tells the api server to shut down (if its running) and returns a sync.Mutex that is locked
|
|
// until the server has handled all remaining requests and shut down
|
|
func (api *API) Stop() *sync.Mutex {
|
|
|
|
if api.server != nil {
|
|
go func() {
|
|
if err := api.server.Shutdown(context.Background()); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
log.Errorf("Error stopping HTTP Server: %v", err)
|
|
}
|
|
}()
|
|
}
|
|
|
|
return api.running
|
|
}
|
|
|
|
// Handler is used to get a http.Handler for testing
|
|
func (api *API) Handler() http.Handler {
|
|
api.registerHandlers()
|
|
return api.mux
|
|
}
|
|
|
|
// EnableUpdates registers the `updates` endpoints
|
|
func (api *API) EnableUpdates(f updates.InvokedFunc, updateLock *sync.Mutex) {
|
|
api.route("/v1/updates").post(updates.PostV1(f, updateLock))
|
|
api.route("/v2/updates/apply").post(updates.PostV2Apply(f, updateLock))
|
|
api.route("/v2/updates/check").post(updates.PostV2Check(f, updateLock))
|
|
}
|
|
|
|
// EnableMetrics registers the `metrics` endpoints
|
|
func (api *API) EnableMetrics() {
|
|
api.route("/v1/metrics").get(metrics.GetV1())
|
|
}
|