16101: Handle logout without sso-provider.
[arvados.git] / lib / controller / handler.go
1 // Copyright (C) The Arvados Authors. All rights reserved.
2 //
3 // SPDX-License-Identifier: AGPL-3.0
4
5 package controller
6
7 import (
8         "context"
9         "database/sql"
10         "errors"
11         "fmt"
12         "net/http"
13         "net/url"
14         "strings"
15         "sync"
16         "time"
17
18         "git.arvados.org/arvados.git/lib/controller/federation"
19         "git.arvados.org/arvados.git/lib/controller/railsproxy"
20         "git.arvados.org/arvados.git/lib/controller/router"
21         "git.arvados.org/arvados.git/sdk/go/arvados"
22         "git.arvados.org/arvados.git/sdk/go/health"
23         "git.arvados.org/arvados.git/sdk/go/httpserver"
24         _ "github.com/lib/pq"
25 )
26
27 type Handler struct {
28         Cluster *arvados.Cluster
29
30         setupOnce      sync.Once
31         handlerStack   http.Handler
32         proxy          *proxy
33         secureClient   *http.Client
34         insecureClient *http.Client
35         pgdb           *sql.DB
36         pgdbMtx        sync.Mutex
37 }
38
39 func (h *Handler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
40         h.setupOnce.Do(h.setup)
41         if req.Method != "GET" && req.Method != "HEAD" {
42                 // http.ServeMux returns 301 with a cleaned path if
43                 // the incoming request has a double slash. Some
44                 // clients (including the Go standard library) change
45                 // the request method to GET when following a 301
46                 // redirect if the original method was not HEAD
47                 // (RFC7231 6.4.2 specifically allows this in the case
48                 // of POST). Thus "POST //foo" gets misdirected to
49                 // "GET /foo". To avoid this, eliminate double slashes
50                 // before passing the request to ServeMux.
51                 for strings.Contains(req.URL.Path, "//") {
52                         req.URL.Path = strings.Replace(req.URL.Path, "//", "/", -1)
53                 }
54         }
55         if h.Cluster.API.RequestTimeout > 0 {
56                 ctx, cancel := context.WithDeadline(req.Context(), time.Now().Add(time.Duration(h.Cluster.API.RequestTimeout)))
57                 req = req.WithContext(ctx)
58                 defer cancel()
59         }
60
61         h.handlerStack.ServeHTTP(w, req)
62 }
63
64 func (h *Handler) CheckHealth() error {
65         h.setupOnce.Do(h.setup)
66         _, _, err := railsproxy.FindRailsAPI(h.Cluster)
67         return err
68 }
69
70 func neverRedirect(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
71
72 func (h *Handler) setup() {
73         mux := http.NewServeMux()
74         mux.Handle("/_health/", &health.Handler{
75                 Token:  h.Cluster.ManagementToken,
76                 Prefix: "/_health/",
77                 Routes: health.Routes{"ping": func() error { _, err := h.db(&http.Request{}); return err }},
78         })
79
80         rtr := router.New(federation.New(h.Cluster))
81         mux.Handle("/arvados/v1/config", rtr)
82
83         if !h.Cluster.ForceLegacyAPI14 {
84                 mux.Handle("/arvados/v1/collections", rtr)
85                 mux.Handle("/arvados/v1/collections/", rtr)
86                 mux.Handle("/arvados/v1/users", rtr)
87                 mux.Handle("/arvados/v1/users/", rtr)
88                 mux.Handle("/login", rtr)
89                 mux.Handle("/logout", rtr)
90         }
91
92         hs := http.NotFoundHandler()
93         hs = prepend(hs, h.proxyRailsAPI)
94         hs = h.setupProxyRemoteCluster(hs)
95         mux.Handle("/", hs)
96         h.handlerStack = mux
97
98         sc := *arvados.DefaultSecureClient
99         sc.CheckRedirect = neverRedirect
100         h.secureClient = &sc
101
102         ic := *arvados.InsecureHTTPClient
103         ic.CheckRedirect = neverRedirect
104         h.insecureClient = &ic
105
106         h.proxy = &proxy{
107                 Name: "arvados-controller",
108         }
109 }
110
111 var errDBConnection = errors.New("database connection error")
112
113 func (h *Handler) db(req *http.Request) (*sql.DB, error) {
114         h.pgdbMtx.Lock()
115         defer h.pgdbMtx.Unlock()
116         if h.pgdb != nil {
117                 return h.pgdb, nil
118         }
119
120         db, err := sql.Open("postgres", h.Cluster.PostgreSQL.Connection.String())
121         if err != nil {
122                 httpserver.Logger(req).WithError(err).Error("postgresql connect failed")
123                 return nil, errDBConnection
124         }
125         if p := h.Cluster.PostgreSQL.ConnectionPool; p > 0 {
126                 db.SetMaxOpenConns(p)
127         }
128         if err := db.Ping(); err != nil {
129                 httpserver.Logger(req).WithError(err).Error("postgresql connect succeeded but ping failed")
130                 return nil, errDBConnection
131         }
132         h.pgdb = db
133         return db, nil
134 }
135
136 type middlewareFunc func(http.ResponseWriter, *http.Request, http.Handler)
137
138 func prepend(next http.Handler, middleware middlewareFunc) http.Handler {
139         return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
140                 middleware(w, req, next)
141         })
142 }
143
144 func (h *Handler) localClusterRequest(req *http.Request) (*http.Response, error) {
145         urlOut, insecure, err := railsproxy.FindRailsAPI(h.Cluster)
146         if err != nil {
147                 return nil, err
148         }
149         urlOut = &url.URL{
150                 Scheme:   urlOut.Scheme,
151                 Host:     urlOut.Host,
152                 Path:     req.URL.Path,
153                 RawPath:  req.URL.RawPath,
154                 RawQuery: req.URL.RawQuery,
155         }
156         client := h.secureClient
157         if insecure {
158                 client = h.insecureClient
159         }
160         return h.proxy.Do(req, urlOut, client)
161 }
162
163 func (h *Handler) proxyRailsAPI(w http.ResponseWriter, req *http.Request, next http.Handler) {
164         resp, err := h.localClusterRequest(req)
165         n, err := h.proxy.ForwardResponse(w, resp, err)
166         if err != nil {
167                 httpserver.Logger(req).WithError(err).WithField("bytesCopied", n).Error("error copying response body")
168         }
169 }
170
171 // Use a localhost entry from Services.RailsAPI.InternalURLs if one is
172 // present, otherwise choose an arbitrary entry.
173 func findRailsAPI(cluster *arvados.Cluster) (*url.URL, bool, error) {
174         var best *url.URL
175         for target := range cluster.Services.RailsAPI.InternalURLs {
176                 target := url.URL(target)
177                 best = &target
178                 if strings.HasPrefix(target.Host, "localhost:") || strings.HasPrefix(target.Host, "127.0.0.1:") || strings.HasPrefix(target.Host, "[::1]:") {
179                         break
180                 }
181         }
182         if best == nil {
183                 return nil, false, fmt.Errorf("Services.RailsAPI.InternalURLs is empty")
184         }
185         return best, cluster.TLS.Insecure, nil
186 }