Add domain and subdomain support for MinioAPI

This change brings in domain and subdomain support

   - ./minio --domain "yourminiodomain.com"

This change brings in a much needed feature by keeping
bucketnames as part of your 'DNS' name.

All your existing applications can be migrated off from s3 to
Minio without little to no modifications.

NOTE: Setting up DNS for your `buckets` is out of scope of this feature

pkg/api/minioapi/api_test.go

@@ -40,7 +40,7 @@ var _ = Suite(&MySuite{})
 
 func (s *MySuite) TestNonExistantObject(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -52,7 +52,7 @@ func (s *MySuite) TestNonExistantObject(c *C) {
 
 func (s *MySuite) TestEmptyObject(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -77,7 +77,7 @@ func (s *MySuite) TestEmptyObject(c *C) {
 
 func (s *MySuite) TestObject(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -100,7 +100,7 @@ func (s *MySuite) TestObject(c *C) {
 
 func (s *MySuite) TestMultipleObjects(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -180,7 +180,7 @@ func (s *MySuite) TestMultipleObjects(c *C) {
 
 func (s *MySuite) TestNotImplemented(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -191,7 +191,7 @@ func (s *MySuite) TestNotImplemented(c *C) {
 
 func (s *MySuite) TestHeader(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -214,7 +214,7 @@ func (s *MySuite) TestHeader(c *C) {
 
 func (s *MySuite) TestPutBucket(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -239,7 +239,7 @@ func (s *MySuite) TestPutBucket(c *C) {
 
 func (s *MySuite) TestPutObject(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -289,7 +289,7 @@ func (s *MySuite) TestPutObject(c *C) {
 
 func (s *MySuite) TestListBuckets(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -368,7 +368,7 @@ func verifyHeaders(c *C, header http.Header, date time.Time, size int, contentTy
 
 func (s *MySuite) TestXMLNameNotInBucketListJson(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -393,7 +393,7 @@ func (s *MySuite) TestXMLNameNotInBucketListJson(c *C) {
 
 func (s *MySuite) TestXMLNameNotInObjectListJson(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -418,7 +418,7 @@ func (s *MySuite) TestXMLNameNotInObjectListJson(c *C) {
 
 func (s *MySuite) TestContentTypePersists(c *C) {
 	_, _, storage := inmemory.Start()
-	httpHandler := HttpHandler(storage)
+	httpHandler := HttpHandler("", storage)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 

pkg/api/minioapi/bucket_handlers.go

@@ -1,116 +1,13 @@
 package minioapi
 
 import (
-	"encoding/json"
 	"log"
 	"net/http"
 
 	"github.com/gorilla/mux"
 	mstorage "github.com/minio-io/minio/pkg/storage"
-	"github.com/minio-io/minio/pkg/utils/policy"
 )
 
-func (server *minioApi) putBucketPolicyHandler(w http.ResponseWriter, req *http.Request) {
-	vars := mux.Vars(req)
-	bucket := vars["bucket"]
-	acceptsContentType := getContentType(req)
-
-	policy, ok := policy.Parsepolicy(req.Body)
-	if ok == false {
-		error := errorCodeError(InvalidPolicyDocument)
-		errorResponse := getErrorResponse(error, bucket)
-		w.WriteHeader(error.HttpStatusCode)
-		w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-		return
-	}
-
-	err := server.storage.StoreBucketPolicy(bucket, policy)
-	switch err := err.(type) {
-	case nil:
-		{
-			w.WriteHeader(http.StatusNoContent)
-			writeCommonHeaders(w, getContentString(acceptsContentType))
-			w.Header().Set("Connection", "keep-alive")
-		}
-	case mstorage.BucketNameInvalid:
-		{
-			error := errorCodeError(InvalidBucketName)
-			errorResponse := getErrorResponse(error, bucket)
-			w.WriteHeader(error.HttpStatusCode)
-			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-		}
-	case mstorage.BucketNotFound:
-		{
-			error := errorCodeError(NoSuchBucket)
-			errorResponse := getErrorResponse(error, bucket)
-			w.WriteHeader(error.HttpStatusCode)
-			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-		}
-	case mstorage.BackendCorrupted:
-	case mstorage.ImplementationError:
-		{
-			log.Println(err)
-			error := errorCodeError(InternalError)
-			errorResponse := getErrorResponse(error, bucket)
-			w.WriteHeader(error.HttpStatusCode)
-			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-		}
-	}
-}
-
-func (server *minioApi) getBucketPolicyHandler(w http.ResponseWriter, req *http.Request) {
-	vars := mux.Vars(req)
-	bucket := vars["bucket"]
-	acceptsContentType := getContentType(req)
-
-	p, err := server.storage.GetBucketPolicy(bucket)
-	switch err := err.(type) {
-	case nil:
-		{
-			responsePolicy, ret := json.Marshal(p)
-			if ret != nil {
-				error := errorCodeError(InternalError)
-				errorResponse := getErrorResponse(error, bucket)
-				w.WriteHeader(error.HttpStatusCode)
-				w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-			}
-			writeCommonHeaders(w, getContentString(acceptsContentType))
-			w.Header().Set("Connection", "keep-alive")
-			w.Write(responsePolicy)
-		}
-	case mstorage.BucketNameInvalid:
-		{
-			error := errorCodeError(InvalidBucketName)
-			errorResponse := getErrorResponse(error, bucket)
-			w.WriteHeader(error.HttpStatusCode)
-			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-		}
-	case mstorage.BucketNotFound:
-		{
-			error := errorCodeError(NoSuchBucket)
-			errorResponse := getErrorResponse(error, bucket)
-			w.WriteHeader(error.HttpStatusCode)
-			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-		}
-	case mstorage.BucketPolicyNotFound:
-		{
-			error := errorCodeError(NoSuchBucketPolicy)
-			errorResponse := getErrorResponse(error, bucket)
-			w.WriteHeader(error.HttpStatusCode)
-			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-		}
-	case mstorage.BackendCorrupted:
-	case mstorage.ImplementationError:
-		{
-			log.Println(err)
-			error := errorCodeError(InternalError)
-			errorResponse := getErrorResponse(error, bucket)
-			w.WriteHeader(error.HttpStatusCode)
-			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-		}
-	}
-}
-
 func (server *minioApi) listObjectsHandler(w http.ResponseWriter, req *http.Request) {
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
@@ -224,7 +121,7 @@ func (server *minioApi) putBucketHandler(w http.ResponseWriter, req *http.Reques
 		}
 	case mstorage.ImplementationError:
 		{
-			// Embed errors log on serve side
+			// Embed errors log on server side
 			log.Println(err)
 			error := errorCodeError(InternalError)
 			errorResponse := getErrorResponse(error, bucket)

pkg/api/minioapi/headers.go

@@ -27,6 +27,11 @@ import (
 	mstorage "github.com/minio-io/minio/pkg/storage"
 )
 
+// No encoder interface exists, so we create one.
+type encoder interface {
+	Encode(v interface{}) error
+}
+
 // Write Common Header helpers
 func writeCommonHeaders(w http.ResponseWriter, acceptsType string) {
 	w.Header().Set("Server", "Minio")

pkg/api/minioapi/muxer.go

@@ -20,7 +20,7 @@ import (
 	"log"
 	"net/http"
 
-	"github.com/gorilla/mux"
+	x "github.com/gorilla/mux"
 	mstorage "github.com/minio-io/minio/pkg/storage"
 	"github.com/minio-io/minio/pkg/utils/config"
 )
@@ -30,24 +30,11 @@ const (
 )
 
 type minioApi struct {
+	domain  string
 	storage mstorage.Storage
 }
 
-// No encoder interface exists, so we create one.
-type encoder interface {
-	Encode(v interface{}) error
-}
-
-func HttpHandler(storage mstorage.Storage) http.Handler {
-	mux := mux.NewRouter()
-	var api = minioApi{}
-	api.storage = storage
-
-	var conf = config.Config{}
-	if err := conf.SetupConfig(); err != nil {
-		log.Fatal(err)
-	}
-
+func pathMux(api minioApi, mux *x.Router) *x.Router {
 	mux.HandleFunc("/", api.listBucketsHandler).Methods("GET")
 	mux.HandleFunc("/{bucket}", api.listObjectsHandler).Methods("GET")
 	mux.HandleFunc("/{bucket}", api.putBucketHandler).Methods("PUT")
@@ -55,5 +42,48 @@ func HttpHandler(storage mstorage.Storage) http.Handler {
 	mux.HandleFunc("/{bucket}/{object:.*}", api.headObjectHandler).Methods("HEAD")
 	mux.HandleFunc("/{bucket}/{object:.*}", api.putObjectHandler).Methods("PUT")
 
+	return mux
+}
+
+func domainMux(api minioApi, mux *x.Router) *x.Router {
+	mux.HandleFunc("/",
+		api.listObjectsHandler).Host("{bucket}" + "." + api.domain).Methods("GET")
+	mux.HandleFunc("/{object:.*}",
+		api.getObjectHandler).Host("{bucket}" + "." + api.domain).Methods("GET")
+	mux.HandleFunc("/{object:.*}",
+		api.headObjectHandler).Host("{bucket}" + "." + api.domain).Methods("HEAD")
+	mux.HandleFunc("/{object:.*}",
+		api.putObjectHandler).Host("{bucket}" + "." + api.domain).Methods("PUT")
+	mux.HandleFunc("/", api.listBucketsHandler).Methods("GET")
+	mux.HandleFunc("/{bucket}", api.putBucketHandler).Methods("PUT")
+
+	return mux
+}
+
+func getMux(api minioApi, mux *x.Router) *x.Router {
+	switch true {
+	case api.domain == "":
+		return pathMux(api, mux)
+	case api.domain != "":
+		s := mux.Host(api.domain).Subrouter()
+		return domainMux(api, s)
+	}
+	return nil
+}
+
+func HttpHandler(domain string, storage mstorage.Storage) http.Handler {
+	var mux *x.Router
+	var api = minioApi{}
+	api.storage = storage
+	api.domain = domain
+
+	r := x.NewRouter()
+	mux = getMux(api, r)
+
+	var conf = config.Config{}
+	if err := conf.SetupConfig(); err != nil {
+		log.Fatal(err)
+	}
+
 	return validateHandler(conf, ignoreResourcesHandler(mux))
 }

pkg/api/minioapi/object_handlers.go

@@ -103,6 +103,12 @@ func (server *minioApi) putObjectHandler(w http.ResponseWriter, req *http.Reques
 	bucket = vars["bucket"]
 	object = vars["object"]
 
+	resources := getBucketResources(req.URL.Query())
+	if resources.policy == true && object == "" {
+		server.putBucketPolicyHandler(w, req)
+		return
+	}
+
 	err := server.storage.StoreObject(bucket, object, "", req.Body)
 	switch err := err.(type) {
 	case nil:

pkg/api/minioapi/policy_handlers.go

@@ -0,0 +1,112 @@
+package minioapi
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	mstorage "github.com/minio-io/minio/pkg/storage"
+	"github.com/minio-io/minio/pkg/utils/policy"
+)
+
+func (server *minioApi) putBucketPolicyHandler(w http.ResponseWriter, req *http.Request) {
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	acceptsContentType := getContentType(req)
+
+	policy, ok := policy.Parsepolicy(req.Body)
+	if ok == false {
+		error := errorCodeError(InvalidPolicyDocument)
+		errorResponse := getErrorResponse(error, bucket)
+		w.WriteHeader(error.HttpStatusCode)
+		w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
+		return
+	}
+
+	err := server.storage.StoreBucketPolicy(bucket, policy)
+	switch err := err.(type) {
+	case nil:
+		{
+			w.WriteHeader(http.StatusNoContent)
+			writeCommonHeaders(w, getContentString(acceptsContentType))
+			w.Header().Set("Connection", "keep-alive")
+		}
+	case mstorage.BucketNameInvalid:
+		{
+			error := errorCodeError(InvalidBucketName)
+			errorResponse := getErrorResponse(error, bucket)
+			w.WriteHeader(error.HttpStatusCode)
+			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
+		}
+	case mstorage.BucketNotFound:
+		{
+			error := errorCodeError(NoSuchBucket)
+			errorResponse := getErrorResponse(error, bucket)
+			w.WriteHeader(error.HttpStatusCode)
+			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
+		}
+	case mstorage.BackendCorrupted:
+	case mstorage.ImplementationError:
+		{
+			log.Println(err)
+			error := errorCodeError(InternalError)
+			errorResponse := getErrorResponse(error, bucket)
+			w.WriteHeader(error.HttpStatusCode)
+			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
+		}
+	}
+}
+
+func (server *minioApi) getBucketPolicyHandler(w http.ResponseWriter, req *http.Request) {
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	acceptsContentType := getContentType(req)
+
+	p, err := server.storage.GetBucketPolicy(bucket)
+	switch err := err.(type) {
+	case nil:
+		{
+			responsePolicy, ret := json.Marshal(p)
+			if ret != nil {
+				error := errorCodeError(InternalError)
+				errorResponse := getErrorResponse(error, bucket)
+				w.WriteHeader(error.HttpStatusCode)
+				w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
+			}
+			writeCommonHeaders(w, getContentString(acceptsContentType))
+			w.Header().Set("Connection", "keep-alive")
+			w.Write(responsePolicy)
+		}
+	case mstorage.BucketNameInvalid:
+		{
+			error := errorCodeError(InvalidBucketName)
+			errorResponse := getErrorResponse(error, bucket)
+			w.WriteHeader(error.HttpStatusCode)
+			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
+		}
+	case mstorage.BucketNotFound:
+		{
+			error := errorCodeError(NoSuchBucket)
+			errorResponse := getErrorResponse(error, bucket)
+			w.WriteHeader(error.HttpStatusCode)
+			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
+		}
+	case mstorage.BucketPolicyNotFound:
+		{
+			error := errorCodeError(NoSuchBucketPolicy)
+			errorResponse := getErrorResponse(error, bucket)
+			w.WriteHeader(error.HttpStatusCode)
+			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
+		}
+	case mstorage.BackendCorrupted:
+	case mstorage.ImplementationError:
+		{
+			log.Println(err)
+			error := errorCodeError(InternalError)
+			errorResponse := getErrorResponse(error, bucket)
+			w.WriteHeader(error.HttpStatusCode)
+			w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
+		}
+	}
+}