X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/890195dc78d25d9a8f1e513197e4adc71be4f146..bef56b9a22efac9ce73006623080e84a0b57f243:/lib/controller/handler.go

diff --git a/lib/controller/handler.go b/lib/controller/handler.go
index feccbe6084..25799aae9e 100644
--- a/lib/controller/handler.go
+++ b/lib/controller/handler.go
@@ -5,37 +5,61 @@
 package controller
 
 import (
+	"database/sql"
+	"errors"
 	"net"
 	"net/http"
 	"net/url"
 	"strings"
 	"sync"
+	"time"
 
 	"git.curoverse.com/arvados.git/sdk/go/arvados"
 	"git.curoverse.com/arvados.git/sdk/go/health"
 	"git.curoverse.com/arvados.git/sdk/go/httpserver"
+	_ "github.com/lib/pq"
 )
 
 type Handler struct {
 	Cluster     *arvados.Cluster
 	NodeProfile *arvados.NodeProfile
 
-	setupOnce    sync.Once
-	handlerStack http.Handler
-	proxyClient  *arvados.Client
+	setupOnce      sync.Once
+	handlerStack   http.Handler
+	proxy          *proxy
+	secureClient   *http.Client
+	insecureClient *http.Client
+	pgdb           *sql.DB
+	pgdbMtx        sync.Mutex
 }
 
 func (h *Handler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	h.setupOnce.Do(h.setup)
+	if req.Method != "GET" && req.Method != "HEAD" {
+		// http.ServeMux returns 301 with a cleaned path if
+		// the incoming request has a double slash. Some
+		// clients (including the Go standard library) change
+		// the request method to GET when following a 301
+		// redirect if the original method was not HEAD
+		// (RFC7231 6.4.2 specifically allows this in the case
+		// of POST). Thus "POST //foo" gets misdirected to
+		// "GET /foo". To avoid this, eliminate double slashes
+		// before passing the request to ServeMux.
+		for strings.Contains(req.URL.Path, "//") {
+			req.URL.Path = strings.Replace(req.URL.Path, "//", "/", -1)
+		}
+	}
 	h.handlerStack.ServeHTTP(w, req)
 }
 
 func (h *Handler) CheckHealth() error {
 	h.setupOnce.Do(h.setup)
-	_, err := findRailsAPI(h.Cluster, h.NodeProfile)
+	_, _, err := findRailsAPI(h.Cluster, h.NodeProfile)
 	return err
 }
 
+func neverRedirect(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
+
 func (h *Handler) setup() {
 	mux := http.NewServeMux()
 	mux.Handle("/_health/", &health.Handler{
@@ -47,6 +71,46 @@ func (h *Handler) setup() {
 	hs = prepend(hs, h.proxyRemoteCluster)
 	mux.Handle("/", hs)
 	h.handlerStack = mux
+
+	sc := *arvados.DefaultSecureClient
+	sc.Timeout = time.Duration(h.Cluster.HTTPRequestTimeout)
+	sc.CheckRedirect = neverRedirect
+	h.secureClient = &sc
+
+	ic := *arvados.InsecureHTTPClient
+	ic.Timeout = time.Duration(h.Cluster.HTTPRequestTimeout)
+	ic.CheckRedirect = neverRedirect
+	h.insecureClient = &ic
+
+	h.proxy = &proxy{
+		Name:           "arvados-controller",
+		RequestTimeout: time.Duration(h.Cluster.HTTPRequestTimeout),
+	}
+}
+
+var errDBConnection = errors.New("database connection error")
+
+func (h *Handler) db(req *http.Request) (*sql.DB, error) {
+	h.pgdbMtx.Lock()
+	defer h.pgdbMtx.Unlock()
+	if h.pgdb != nil {
+		return h.pgdb, nil
+	}
+
+	db, err := sql.Open("postgres", h.Cluster.PostgreSQL.Connection.String())
+	if err != nil {
+		httpserver.Logger(req).WithError(err).Error("postgresql connect failed")
+		return nil, errDBConnection
+	}
+	if p := h.Cluster.PostgreSQL.ConnectionPool; p > 0 {
+		db.SetMaxOpenConns(p)
+	}
+	if err := db.Ping(); err != nil {
+		httpserver.Logger(req).WithError(err).Error("postgresql connect succeeded but ping failed")
+		return nil, errDBConnection
+	}
+	h.pgdb = db
+	return db, nil
 }
 
 type middlewareFunc func(http.ResponseWriter, *http.Request, http.Handler)
@@ -58,7 +122,7 @@ func prepend(next http.Handler, middleware middlewareFunc) http.Handler {
 }
 
 func (h *Handler) proxyRailsAPI(w http.ResponseWriter, req *http.Request, next http.Handler) {
-	urlOut, err := findRailsAPI(h.Cluster, h.NodeProfile)
+	urlOut, insecure, err := findRailsAPI(h.Cluster, h.NodeProfile)
 	if err != nil {
 		httpserver.Error(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -70,12 +134,16 @@ func (h *Handler) proxyRailsAPI(w http.ResponseWriter, req *http.Request, next h
 		RawPath:  req.URL.RawPath,
 		RawQuery: req.URL.RawQuery,
 	}
-	h.proxy(w, req, urlOut)
+	client := h.secureClient
+	if insecure {
+		client = h.insecureClient
+	}
+	h.proxy.Do(w, req, urlOut, client)
 }
 
 // For now, findRailsAPI always uses the rails API running on this
 // node.
-func findRailsAPI(cluster *arvados.Cluster, np *arvados.NodeProfile) (*url.URL, error) {
+func findRailsAPI(cluster *arvados.Cluster, np *arvados.NodeProfile) (*url.URL, bool, error) {
 	hostport := np.RailsAPI.Listen
 	if len(hostport) > 1 && hostport[0] == ':' && strings.TrimRight(hostport[1:], "0123456789") == "" {
 		// ":12345" => connect to indicated port on localhost
@@ -83,11 +151,12 @@ func findRailsAPI(cluster *arvados.Cluster, np *arvados.NodeProfile) (*url.URL,
 	} else if _, _, err := net.SplitHostPort(hostport); err == nil {
 		// "[::1]:12345" => connect to indicated address & port
 	} else {
-		return nil, err
+		return nil, false, err
 	}
 	proto := "http"
 	if np.RailsAPI.TLS {
 		proto = "https"
 	}
-	return url.Parse(proto + "://" + hostport)
+	url, err := url.Parse(proto + "://" + hostport)
+	return url, np.RailsAPI.Insecure, err
 }