Path prefix support for running registry somewhere other than root of server

Signed-off-by: David Lawrence <david.lawrence@docker.com> (github: endophage)

docs/api/v2/descriptors.go

@@ -1410,13 +1410,18 @@ var errorDescriptors = []ErrorDescriptor{
 
 var errorCodeToDescriptors map[ErrorCode]ErrorDescriptor
 var idToDescriptors map[string]ErrorDescriptor
+var routeDescriptorsMap map[string]RouteDescriptor
 
 func init() {
 	errorCodeToDescriptors = make(map[ErrorCode]ErrorDescriptor, len(errorDescriptors))
 	idToDescriptors = make(map[string]ErrorDescriptor, len(errorDescriptors))
+	routeDescriptorsMap = make(map[string]RouteDescriptor, len(routeDescriptors))
 
 	for _, descriptor := range errorDescriptors {
 		errorCodeToDescriptors[descriptor.Code] = descriptor
 		idToDescriptors[descriptor.Value] = descriptor
 	}
+	for _, descriptor := range routeDescriptors {
+		routeDescriptorsMap[descriptor.Name] = descriptor
+	}
 }

docs/api/v2/routes.go

@@ -25,12 +25,23 @@ var allEndpoints = []string{
 // methods. This can be used directly by both server implementations and
 // clients.
 func Router() *mux.Router {
-	router := mux.NewRouter().
-		StrictSlash(true)
+	return RouterWithPrefix("")
+}
+
+// RouterWithPrefix builds a gorilla router with a configured prefix
+// on all routes.
+func RouterWithPrefix(prefix string) *mux.Router {
+	rootRouter := mux.NewRouter()
+	router := rootRouter
+	if prefix != "" {
+		router = router.PathPrefix(prefix).Subrouter()
+	}
+
+	router.StrictSlash(true)
 
 	for _, descriptor := range routeDescriptors {
 		router.Path(descriptor.Path).Name(descriptor.Name)
 	}
 
-	return router
+	return rootRouter
 }

docs/api/v2/routes_test.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"reflect"
+	"strings"
 	"testing"
 
 	"github.com/gorilla/mux"
@@ -24,8 +25,16 @@ type routeTestCase struct {
 //
 // This may go away as the application structure comes together.
 func TestRouter(t *testing.T) {
+	baseTestRouter(t, "")
+}
 
-	router := Router()
+func TestRouterWithPrefix(t *testing.T) {
+	baseTestRouter(t, "/prefix/")
+}
+
+func baseTestRouter(t *testing.T, prefix string) {
+
+	router := RouterWithPrefix(prefix)
 
 	testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		testCase := routeTestCase{
@@ -147,6 +156,8 @@ func TestRouter(t *testing.T) {
 			StatusCode: http.StatusNotFound,
 		},
 	} {
+		testcase.RequestURI = strings.TrimSuffix(prefix, "/") + testcase.RequestURI
+
 		// Register the endpoint
 		route := router.GetRoute(testcase.RouteName)
 		if route == nil {

docs/api/v2/urls.go

@@ -3,6 +3,7 @@ package v2
 import (
 	"net/http"
 	"net/url"
+	"strings"
 
 	"github.com/docker/distribution/digest"
 	"github.com/gorilla/mux"
@@ -64,11 +65,21 @@ func NewURLBuilderFromRequest(r *http.Request) *URLBuilder {
 		host = forwardedHost
 	}
 
+	basePath := routeDescriptorsMap[RouteNameBase].Path
+
+	requestPath := r.URL.Path
+	index := strings.Index(requestPath, basePath)
+
 	u := &url.URL{
 		Scheme: scheme,
 		Host:   host,
 	}
 
+	if index > 0 {
+		// N.B. index+1 is important because we want to include the trailing /
+		u.Path = requestPath[0 : index+1]
+	}
+
 	return NewURLBuilder(u)
 }
 
@@ -171,6 +182,10 @@ func (cr clonedRoute) URL(pairs ...string) (*url.URL, error) {
 		return nil, err
 	}
 
+	if routeURL.Scheme == "" && routeURL.User == nil && routeURL.Host == "" {
+		routeURL.Path = routeURL.Path[1:]
+	}
+
 	return cr.root.ResolveReference(routeURL), nil
 }
 

docs/api/v2/urls_test.go

@@ -108,6 +108,35 @@ func TestURLBuilder(t *testing.T) {
 	}
 }
 
+func TestURLBuilderWithPrefix(t *testing.T) {
+	roots := []string{
+		"http://example.com/prefix/",
+		"https://example.com/prefix/",
+		"http://localhost:5000/prefix/",
+		"https://localhost:5443/prefix/",
+	}
+
+	for _, root := range roots {
+		urlBuilder, err := NewURLBuilderFromString(root)
+		if err != nil {
+			t.Fatalf("unexpected error creating urlbuilder: %v", err)
+		}
+
+		for _, testCase := range makeURLBuilderTestCases(urlBuilder) {
+			url, err := testCase.build()
+			if err != nil {
+				t.Fatalf("%s: error building url: %v", testCase.description, err)
+			}
+
+			expectedURL := root[0:len(root)-1] + testCase.expectedPath
+
+			if url != expectedURL {
+				t.Fatalf("%s: %q != %q", testCase.description, url, expectedURL)
+			}
+		}
+	}
+}
+
 type builderFromRequestTestCase struct {
 	request *http.Request
 	base    string
@@ -153,3 +182,44 @@ func TestBuilderFromRequest(t *testing.T) {
 		}
 	}
 }
+
+func TestBuilderFromRequestWithPrefix(t *testing.T) {
+	u, err := url.Parse("http://example.com/prefix/v2/")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	forwardedProtoHeader := make(http.Header, 1)
+	forwardedProtoHeader.Set("X-Forwarded-Proto", "https")
+
+	testRequests := []struct {
+		request *http.Request
+		base    string
+	}{
+		{
+			request: &http.Request{URL: u, Host: u.Host},
+			base:    "http://example.com/prefix/",
+		},
+		{
+			request: &http.Request{URL: u, Host: u.Host, Header: forwardedProtoHeader},
+			base:    "https://example.com/prefix/",
+		},
+	}
+
+	for _, tr := range testRequests {
+		builder := NewURLBuilderFromRequest(tr.request)
+
+		for _, testCase := range makeURLBuilderTestCases(builder) {
+			url, err := testCase.build()
+			if err != nil {
+				t.Fatalf("%s: error building url: %v", testCase.description, err)
+			}
+
+			expectedURL := tr.base[0:len(tr.base)-1] + testCase.expectedPath
+
+			if url != expectedURL {
+				t.Fatalf("%s: %q != %q", testCase.description, url, expectedURL)
+			}
+		}
+	}
+}