http: Refactor automatic HTTPS (fixes #2972)

This splits automatic HTTPS into two phases. The first provisions the
route matchers and uses them to build the domain set and configure
auto HTTP->HTTPS redirects. This happens before the rest of the
provisioning does.

The second phase takes place at the beginning of the app start. It
attaches pointers to the tls app to each server, and begins certificate
management for the domains that were found in the first phase.

1 files changed, 24 insertions, 5 deletions

diff --git a/modules/caddyhttp/routes.go b/modules/caddyhttp/routes.go
index 431d1a5ee..d4ff02a2e 100644
--- a/modules/caddyhttp/routes.go
+++ b/modules/caddyhttp/routes.go
@@ -113,23 +113,43 @@ func (r Route) Empty() bool {
 // create a middleware chain.
 type RouteList []Route
 
-// Provision sets up all the routes by loading the modules.
+// Provision sets up both the matchers and handlers in the route.
 func (routes RouteList) Provision(ctx caddy.Context) error {
+	err := routes.ProvisionMatchers(ctx)
+	if err != nil {
+		return err
+	}
+	return routes.ProvisionHandlers(ctx)
+}
+
+// ProvisionMatchers sets up all the matchers by loading the
+// matcher modules. Only call this method directly if you need
+// to set up matchers and handlers separately without having
+// to provision a second time; otherwise use Provision instead.
+func (routes RouteList) ProvisionMatchers(ctx caddy.Context) error {
 	for i := range routes {
 		// matchers
 		matchersIface, err := ctx.LoadModule(&routes[i], "MatcherSetsRaw")
 		if err != nil {
-			return fmt.Errorf("loading matchers in route %d: %v", i, err)
+			return fmt.Errorf("route %d: loading matcher modules: %v", i, err)
 		}
 		err = routes[i].MatcherSets.FromInterface(matchersIface)
 		if err != nil {
 			return fmt.Errorf("route %d: %v", i, err)
 		}
+	}
+	return nil
+}
 
-		// handlers
+// ProvisionHandlers sets up all the handlers by loading the
+// handler modules. Only call this method directly if you need
+// to set up matchers and handlers separately without having
+// to provision a second time; otherwise use Provision instead.
+func (routes RouteList) ProvisionHandlers(ctx caddy.Context) error {
+	for i := range routes {
 		handlersIface, err := ctx.LoadModule(&routes[i], "HandlersRaw")
 		if err != nil {
-			return fmt.Errorf("loading handler modules in route %d: %v", i, err)
+			return fmt.Errorf("route %d: loading handler modules: %v", i, err)
 		}
 		for _, handler := range handlersIface.([]interface{}) {
 			routes[i].Handlers = append(routes[i].Handlers, handler.(MiddlewareHandler))
@@ -140,7 +160,6 @@ func (routes RouteList) Provision(ctx caddy.Context) error {
 			routes[i].middleware = append(routes[i].middleware, wrapMiddleware(midhandler))
 		}
 	}
-
 	return nil
 }