Restructure API handlers, add JSON RPC simple HelloService right now.

pkg/server/api/acl.go

@@ -0,0 +1,79 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import "net/http"
+
+// Please read for more information - http://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
+//
+// Here We are only supporting 'acl's through request headers not through their request body
+// http://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#setting-acls
+
+// Minio only supports three types for now i.e 'private, public-read, public-read-write'
+
+// ACLType - different acl types
+type ACLType int
+
+const (
+	unsupportedACLType ACLType = iota
+	privateACLType
+	publicReadACLType
+	publicReadWriteACLType
+)
+
+// Get acl type requested from 'x-amz-acl' header
+func getACLType(req *http.Request) ACLType {
+	aclHeader := req.Header.Get("x-amz-acl")
+	if aclHeader != "" {
+		switch {
+		case aclHeader == "private":
+			return privateACLType
+		case aclHeader == "public-read":
+			return publicReadACLType
+		case aclHeader == "public-read-write":
+			return publicReadWriteACLType
+		default:
+			return unsupportedACLType
+		}
+	}
+	// make it default private
+	return privateACLType
+}
+
+// ACL type to human readable string
+func getACLTypeString(acl ACLType) string {
+	switch acl {
+	case privateACLType:
+		{
+			return "private"
+		}
+	case publicReadACLType:
+		{
+			return "public-read"
+		}
+	case publicReadWriteACLType:
+		{
+			return "public-read-write"
+		}
+	case unsupportedACLType:
+		{
+			return ""
+		}
+	default:
+		return "private"
+	}
+}

pkg/server/api/api-bucket-handlers.go

@@ -0,0 +1,158 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+// MinioAPI -
+type MinioAPI struct{}
+
+func (api MinioAPI) isValidOp(w http.ResponseWriter, req *http.Request, acceptsContentType contentType) bool {
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	log.Println(bucket)
+	return true
+}
+
+// ListMultipartUploadsHandler - GET Bucket (List Multipart uploads)
+// -------------------------
+// This operation lists in-progress multipart uploads. An in-progress
+// multipart upload is a multipart upload that has been initiated,
+// using the Initiate Multipart Upload request, but has not yet been completed or aborted.
+// This operation returns at most 1,000 multipart uploads in the response.
+//
+func (api MinioAPI) ListMultipartUploadsHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	log.Println(acceptsContentType)
+
+	resources := getBucketMultipartResources(req.URL.Query())
+	if resources.MaxUploads == 0 {
+		resources.MaxUploads = maxObjectList
+	}
+
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	log.Println(bucket)
+}
+
+// ListObjectsHandler - GET Bucket (List Objects)
+// -------------------------
+// This implementation of the GET operation returns some or all (up to 1000)
+// of the objects in a bucket. You can use the request parameters as selection
+// criteria to return a subset of the objects in a bucket.
+//
+func (api MinioAPI) ListObjectsHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// verify if bucket allows this operation
+	if !api.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
+	if isRequestUploads(req.URL.Query()) {
+		api.ListMultipartUploadsHandler(w, req)
+		return
+	}
+
+	resources := getBucketResources(req.URL.Query())
+	if resources.Maxkeys == 0 {
+		resources.Maxkeys = maxObjectList
+	}
+
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	log.Println(bucket)
+
+}
+
+// ListBucketsHandler - GET Service
+// -----------
+// This implementation of the GET operation returns a list of all buckets
+// owned by the authenticated sender of the request.
+func (api MinioAPI) ListBucketsHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// uncomment this when we have webcli
+	// without access key credentials one cannot list buckets
+	// if _, err := stripAuth(req); err != nil {
+	//	writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
+	//	return
+	// }
+	log.Println(acceptsContentType)
+}
+
+// PutBucketHandler - PUT Bucket
+// ----------
+// This implementation of the PUT operation creates a new bucket for authenticated request
+func (api MinioAPI) PutBucketHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// uncomment this when we have webcli
+	// without access key credentials one cannot create a bucket
+	// if _, err := stripAuth(req); err != nil {
+	// 	writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
+	//	return
+	// }
+	if isRequestBucketACL(req.URL.Query()) {
+		api.PutBucketACLHandler(w, req)
+		return
+	}
+	// read from 'x-amz-acl'
+	aclType := getACLType(req)
+	if aclType == unsupportedACLType {
+		writeErrorResponse(w, req, NotImplemented, acceptsContentType, req.URL.Path)
+		return
+	}
+
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	log.Println(bucket)
+}
+
+// PutBucketACLHandler - PUT Bucket ACL
+// ----------
+// This implementation of the PUT operation modifies the bucketACL for authenticated request
+func (api MinioAPI) PutBucketACLHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// read from 'x-amz-acl'
+	aclType := getACLType(req)
+	if aclType == unsupportedACLType {
+		writeErrorResponse(w, req, NotImplemented, acceptsContentType, req.URL.Path)
+		return
+	}
+
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	log.Println(bucket)
+}
+
+// HeadBucketHandler - HEAD Bucket
+// ----------
+// This operation is useful to determine if a bucket exists.
+// The operation returns a 200 OK if the bucket exists and you
+// have permission to access it. Otherwise, the operation might
+// return responses such as 404 Not Found and 403 Forbidden.
+func (api MinioAPI) HeadBucketHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	log.Println(acceptsContentType)
+
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	log.Println(bucket)
+}

pkg/server/api/api-definitions.go

@@ -0,0 +1,216 @@
+/*
+ * Minimalist Object Storage, (C) 2014 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import "encoding/xml"
+
+// Config - http server config
+type Config struct {
+	Address   string
+	TLS       bool
+	CertFile  string
+	KeyFile   string
+	RateLimit int
+}
+
+// Limit number of objects in a given response
+const (
+	maxObjectList = 1000
+)
+
+// ListObjectsResponse - format for list objects response
+type ListObjectsResponse struct {
+	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListBucketResult" json:"-"`
+
+	CommonPrefixes []*CommonPrefix
+	Contents       []*Object
+
+	Delimiter string
+
+	// Encoding type used to encode object keys in the response.
+	EncodingType string
+
+	// A flag that indicates whether or not ListObjects returned all of the results
+	// that satisfied the search criteria.
+	IsTruncated bool
+	Marker      string
+	MaxKeys     int
+	Name        string
+
+	// When response is truncated (the IsTruncated element value in the response
+	// is true), you can use the key name in this field as marker in the subsequent
+	// request to get next set of objects. Object storage lists objects in alphabetical
+	// order Note: This element is returned only if you have delimiter request parameter
+	// specified. If response does not include the NextMaker and it is truncated,
+	// you can use the value of the last Key in the response as the marker in the
+	// subsequent request to get the next set of object keys.
+	NextMarker string
+	Prefix     string
+}
+
+// ListPartsResponse - format for list parts response
+type ListPartsResponse struct {
+	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListPartsResult" json:"-"`
+
+	Bucket   string
+	Key      string
+	UploadID string `xml:"UploadId"`
+
+	Initiator Initiator
+	Owner     Owner
+
+	// The class of storage used to store the object.
+	StorageClass string
+
+	PartNumberMarker     int
+	NextPartNumberMarker int
+	MaxParts             int
+	IsTruncated          bool
+
+	// List of parts
+	Part []*Part
+}
+
+// ListMultipartUploadsResponse - format for list multipart uploads response
+type ListMultipartUploadsResponse struct {
+	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListMultipartUploadsResult" json:"-"`
+
+	Bucket             string
+	KeyMarker          string
+	UploadIDMarker     string `xml:"UploadIdMarker"`
+	NextKeyMarker      string
+	NextUploadIDMarker string `xml:"NextUploadIdMarker"`
+	EncodingType       string
+	MaxUploads         int
+	IsTruncated        bool
+	Upload             []*Upload
+	Prefix             string
+	Delimiter          string
+	CommonPrefixes     []*CommonPrefix
+}
+
+// ListBucketsResponse - format for list buckets response
+type ListBucketsResponse struct {
+	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListAllMyBucketsResult" json:"-"`
+	// Container for one or more buckets.
+	Buckets struct {
+		Bucket []*Bucket
+	} // Buckets are nested
+	Owner Owner
+}
+
+// Upload container for in progress multipart upload
+type Upload struct {
+	Key          string
+	UploadID     string `xml:"UploadId"`
+	Initiator    Initiator
+	Owner        Owner
+	StorageClass string
+	Initiated    string
+}
+
+// CommonPrefix container for prefix response in ListObjectsResponse
+type CommonPrefix struct {
+	Prefix string
+}
+
+// Bucket container for bucket metadata
+type Bucket struct {
+	Name         string
+	CreationDate string
+}
+
+// Part container for part metadata
+type Part struct {
+	PartNumber   int
+	ETag         string
+	LastModified string
+	Size         int64
+}
+
+// Object container for object metadata
+type Object struct {
+	ETag         string
+	Key          string
+	LastModified string
+	Size         int64
+
+	Owner Owner
+
+	// The class of storage used to store the object.
+	StorageClass string
+}
+
+// Initiator inherit from Owner struct, fields are same
+type Initiator Owner
+
+// Owner - bucket owner/principal
+type Owner struct {
+	ID          string
+	DisplayName string
+}
+
+// InitiateMultipartUploadResult container for InitiateMultiPartUpload response, provides uploadID to start MultiPart upload
+type InitiateMultipartUploadResult struct {
+	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ InitiateMultipartUploadResult" json:"-"`
+
+	Bucket   string
+	Key      string
+	UploadID string `xml:"UploadId"`
+}
+
+// completedParts is a sortable interface for Part slice
+type completedParts []Part
+
+func (a completedParts) Len() int           { return len(a) }
+func (a completedParts) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a completedParts) Less(i, j int) bool { return a[i].PartNumber < a[j].PartNumber }
+
+// CompleteMultipartUpload container for completing multipart upload
+type CompleteMultipartUpload struct {
+	Part []Part
+}
+
+// CompleteMultipartUploadResult container for completed multipart upload response
+type CompleteMultipartUploadResult struct {
+	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CompleteMultipartUploadResult" json:"-"`
+
+	Location string
+	Bucket   string
+	Key      string
+	ETag     string
+}
+
+// List of not implemented bucket queries
+var notimplementedBucketResourceNames = map[string]bool{
+	"policy":         true,
+	"cors":           true,
+	"lifecycle":      true,
+	"location":       true,
+	"logging":        true,
+	"notification":   true,
+	"tagging":        true,
+	"versions":       true,
+	"requestPayment": true,
+	"versioning":     true,
+	"website":        true,
+}
+
+// List of not implemented object queries
+var notimplementedObjectResourceNames = map[string]bool{
+	"torrent": true,
+}

pkg/server/api/api-generic-handlers.go

@@ -0,0 +1,257 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/minio/minio/pkg/server/config"
+	"github.com/minio/minio/pkg/utils/crypto/keys"
+)
+
+type contentTypeHandler struct {
+	handler http.Handler
+}
+
+type timeHandler struct {
+	handler http.Handler
+}
+
+type validateAuthHandler struct {
+	handler http.Handler
+}
+
+type resourceHandler struct {
+	handler http.Handler
+}
+
+type auth struct {
+	prefix        string
+	credential    string
+	signedheaders string
+	signature     string
+	accessKey     string
+}
+
+const (
+	timeFormat = "20060102T150405Z"
+)
+
+const (
+	authHeaderPrefix = "AWS4-HMAC-SHA256"
+)
+
+// strip auth from authorization header
+func stripAuth(r *http.Request) (*auth, error) {
+	authHeader := r.Header.Get("Authorization")
+	if authHeader == "" {
+		return nil, errors.New("Missing auth header")
+	}
+	a := new(auth)
+	authFields := strings.Split(authHeader, ",")
+	if len(authFields) != 3 {
+		return nil, errors.New("Missing fields in Auth header")
+	}
+	authPrefixFields := strings.Fields(authFields[0])
+	if len(authPrefixFields) != 2 {
+		return nil, errors.New("Missing fields in Auth header")
+	}
+	if authPrefixFields[0] != authHeaderPrefix {
+		return nil, errors.New("Missing fields is Auth header")
+	}
+	credentials := strings.Split(authPrefixFields[1], "=")
+	if len(credentials) != 2 {
+		return nil, errors.New("Missing fields in Auth header")
+	}
+	signedheaders := strings.Split(authFields[1], "=")
+	if len(signedheaders) != 2 {
+		return nil, errors.New("Missing fields in Auth header")
+	}
+	signature := strings.Split(authFields[2], "=")
+	if len(signature) != 2 {
+		return nil, errors.New("Missing fields in Auth header")
+	}
+	a.credential = credentials[1]
+	a.signedheaders = signedheaders[1]
+	a.signature = signature[1]
+	a.accessKey = strings.Split(a.credential, "/")[0]
+	if !keys.IsValidAccessKey(a.accessKey) {
+		return nil, errors.New("Invalid access key")
+	}
+	return a, nil
+}
+
+func parseDate(req *http.Request) (time.Time, error) {
+	amzDate := req.Header.Get("X-Amz-Date")
+	switch {
+	case amzDate != "":
+		if _, err := time.Parse(time.RFC1123, amzDate); err == nil {
+			return time.Parse(time.RFC1123, amzDate)
+		}
+		if _, err := time.Parse(time.RFC1123Z, amzDate); err == nil {
+			return time.Parse(time.RFC1123Z, amzDate)
+		}
+		if _, err := time.Parse(timeFormat, amzDate); err == nil {
+			return time.Parse(timeFormat, amzDate)
+		}
+	}
+	date := req.Header.Get("Date")
+	switch {
+	case date != "":
+		if _, err := time.Parse(time.RFC1123, date); err == nil {
+			return time.Parse(time.RFC1123, date)
+		}
+		if _, err := time.Parse(time.RFC1123Z, date); err == nil {
+			return time.Parse(time.RFC1123Z, date)
+		}
+		if _, err := time.Parse(timeFormat, amzDate); err == nil {
+			return time.Parse(timeFormat, amzDate)
+		}
+	}
+	return time.Time{}, errors.New("invalid request")
+}
+
+// ValidContentTypeHandler -
+func ValidContentTypeHandler(h http.Handler) http.Handler {
+	return contentTypeHandler{h}
+}
+
+func (h contentTypeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	acceptsContentType := getContentType(r)
+	if acceptsContentType == unknownContentType {
+		writeErrorResponse(w, r, NotAcceptable, acceptsContentType, r.URL.Path)
+		return
+	}
+	h.handler.ServeHTTP(w, r)
+}
+
+// TimeValidityHandler -
+func TimeValidityHandler(h http.Handler) http.Handler {
+	return timeHandler{h}
+}
+
+func (h timeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	acceptsContentType := getContentType(r)
+	// Verify if date headers are set, if not reject the request
+	if r.Header.Get("Authorization") != "" {
+		if r.Header.Get("X-Amz-Date") == "" && r.Header.Get("Date") == "" {
+			// there is no way to knowing if this is a valid request, could be a attack reject such clients
+			writeErrorResponse(w, r, RequestTimeTooSkewed, acceptsContentType, r.URL.Path)
+			return
+		}
+		date, err := parseDate(r)
+		if err != nil {
+			// there is no way to knowing if this is a valid request, could be a attack reject such clients
+			writeErrorResponse(w, r, RequestTimeTooSkewed, acceptsContentType, r.URL.Path)
+			return
+		}
+		duration := time.Since(date)
+		minutes := time.Duration(5) * time.Minute
+		if duration.Minutes() > minutes.Minutes() {
+			writeErrorResponse(w, r, RequestTimeTooSkewed, acceptsContentType, r.URL.Path)
+			return
+		}
+	}
+	h.handler.ServeHTTP(w, r)
+}
+
+// ValidateAuthHeaderHandler -
+// validate auth header handler is wrapper handler used for API request validation with authorization header.
+// Current authorization layer supports S3's standard HMAC based signature request.
+func ValidateAuthHeaderHandler(h http.Handler) http.Handler {
+	return validateAuthHandler{h}
+}
+
+// validate auth header handler ServeHTTP() wrapper
+func (h validateAuthHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	acceptsContentType := getContentType(r)
+	_, err := stripAuth(r)
+	switch err.(type) {
+	case nil:
+		var conf = config.Config{}
+		if err := conf.SetupConfig(); err != nil {
+			writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path)
+			return
+		}
+		if err := conf.ReadConfig(); err != nil {
+			writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path)
+			return
+		}
+		// uncomment this when we have webcli
+		// _, ok := conf.Users[auth.accessKey]
+		//if !ok {
+		//	writeErrorResponse(w, r, AccessDenied, acceptsContentType, r.URL.Path)
+		//	return
+		//}
+		// Success
+		h.handler.ServeHTTP(w, r)
+	default:
+		// control reaches here, we should just send the request up the stack - internally
+		// individual calls will validate themselves against un-authenticated requests
+		h.handler.ServeHTTP(w, r)
+	}
+}
+
+// IgnoreResourcesHandler -
+// Ignore resources handler is wrapper handler used for API request resource validation
+// Since we do not support all the S3 queries, it is necessary for us to throw back a
+// valid error message indicating such a feature is not implemented.
+func IgnoreResourcesHandler(h http.Handler) http.Handler {
+	return resourceHandler{h}
+}
+
+// Resource handler ServeHTTP() wrapper
+func (h resourceHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	acceptsContentType := getContentType(r)
+	if ignoreNotImplementedObjectResources(r) || ignoreNotImplementedBucketResources(r) {
+		error := getErrorCode(NotImplemented)
+		errorResponse := getErrorResponse(error, "")
+		encodeErrorResponse := encodeErrorResponse(errorResponse, acceptsContentType)
+		setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodeErrorResponse))
+		w.WriteHeader(error.HTTPStatusCode)
+		w.Write(encodeErrorResponse)
+		return
+	}
+	h.handler.ServeHTTP(w, r)
+}
+
+//// helpers
+
+// Checks requests for not implemented Bucket resources
+func ignoreNotImplementedBucketResources(req *http.Request) bool {
+	q := req.URL.Query()
+	for name := range q {
+		if notimplementedBucketResourceNames[name] {
+			return true
+		}
+	}
+	return false
+}
+
+// Checks requests for not implemented Object resources
+func ignoreNotImplementedObjectResources(req *http.Request) bool {
+	q := req.URL.Query()
+	for name := range q {
+		if notimplementedObjectResourceNames[name] {
+			return true
+		}
+	}
+	return false
+}

pkg/server/api/api-logging-handlers.go

@@ -0,0 +1,118 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/dustin/go-humanize"
+	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/utils/log"
+)
+
+type logHandler struct {
+	handler http.Handler
+	logger  chan<- []byte
+}
+
+// logMessage is a serializable json log message
+type logMessage struct {
+	StartTime     time.Time
+	Duration      time.Duration
+	StatusMessage string // human readable http status message
+	ContentLength string // human readable content length
+
+	// HTTP detailed message
+	HTTP struct {
+		ResponseHeaders http.Header
+		Request         *http.Request
+	}
+}
+
+// logWriter is used to capture status for log messages
+type logWriter struct {
+	responseWriter http.ResponseWriter
+	logMessage     *logMessage
+}
+
+// WriteHeader writes headers and stores status in LogMessage
+func (w *logWriter) WriteHeader(status int) {
+	w.logMessage.StatusMessage = http.StatusText(status)
+	w.responseWriter.WriteHeader(status)
+}
+
+// Header Dummy wrapper for LogWriter
+func (w *logWriter) Header() http.Header {
+	return w.responseWriter.Header()
+}
+
+// Write Dummy wrapper for LogWriter
+func (w *logWriter) Write(data []byte) (int, error) {
+	return w.responseWriter.Write(data)
+}
+
+func (h *logHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	logMessage := &logMessage{
+		StartTime: time.Now().UTC(),
+	}
+	logWriter := &logWriter{responseWriter: w, logMessage: logMessage}
+	h.handler.ServeHTTP(logWriter, req)
+	h.logger <- getLogMessage(logMessage, w, req)
+}
+
+func getLogMessage(logMessage *logMessage, w http.ResponseWriter, req *http.Request) []byte {
+	// store lower level details
+	logMessage.HTTP.ResponseHeaders = w.Header()
+	logMessage.HTTP.Request = req
+
+	// humanize content-length to be printed in logs
+	contentLength, _ := strconv.Atoi(logMessage.HTTP.ResponseHeaders.Get("Content-Length"))
+	logMessage.ContentLength = humanize.IBytes(uint64(contentLength))
+	logMessage.Duration = time.Now().UTC().Sub(logMessage.StartTime)
+	js, _ := json.Marshal(logMessage)
+	js = append(js, byte('\n')) // append a new line
+	return js
+}
+
+// LoggingHandler logs requests
+func LoggingHandler(h http.Handler) http.Handler {
+	logger, _ := fileLogger("access.log")
+	return &logHandler{handler: h, logger: logger}
+}
+
+// fileLogger returns a channel that is used to write to the logger
+func fileLogger(filename string) (chan<- []byte, error) {
+	ch := make(chan []byte)
+	file, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
+	if err != nil {
+		return nil, iodine.New(err, map[string]string{"logfile": filename})
+	}
+	go func() {
+		for message := range ch {
+			if _, err := io.Copy(file, bytes.NewBuffer(message)); err != nil {
+				log.Println(iodine.New(err, nil))
+			}
+		}
+	}()
+	return ch, nil
+}

pkg/server/api/api-object-handlers.go

@@ -0,0 +1,274 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"net/http"
+	"sort"
+	"strconv"
+
+	"encoding/xml"
+
+	"github.com/gorilla/mux"
+	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/utils/log"
+)
+
+const (
+	maxPartsList = 1000
+)
+
+// GetObjectHandler - GET Object
+// ----------
+// This implementation of the GET operation retrieves object. To use GET,
+// you must have READ access to the object.
+func (api MinioAPI) GetObjectHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// verify if this operation is allowed
+	if !api.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
+	var object, bucket string
+	vars := mux.Vars(req)
+	bucket = vars["bucket"]
+	object = vars["object"]
+	log.Println(bucket, object)
+
+}
+
+// HeadObjectHandler - HEAD Object
+// -----------
+// The HEAD operation retrieves metadata from an object without returning the object itself.
+func (api MinioAPI) HeadObjectHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// verify if this operation is allowed
+	if !api.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
+	var object, bucket string
+	vars := mux.Vars(req)
+	bucket = vars["bucket"]
+	object = vars["object"]
+	log.Println(bucket, object)
+}
+
+// PutObjectHandler - PUT Object
+// ----------
+// This implementation of the PUT operation adds an object to a bucket.
+func (api MinioAPI) PutObjectHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// verify if this operation is allowed
+	if !api.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
+	var object, bucket string
+	vars := mux.Vars(req)
+	bucket = vars["bucket"]
+	object = vars["object"]
+
+	// get Content-MD5 sent by client and verify if valid
+	md5 := req.Header.Get("Content-MD5")
+	if !isValidMD5(md5) {
+		writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path)
+		return
+	}
+	/// if Content-Length missing, throw away
+	size := req.Header.Get("Content-Length")
+	if size == "" {
+		writeErrorResponse(w, req, MissingContentLength, acceptsContentType, req.URL.Path)
+		return
+	}
+	/// maximum Upload size for objects in a single operation
+	if isMaxObjectSize(size) {
+		writeErrorResponse(w, req, EntityTooLarge, acceptsContentType, req.URL.Path)
+		return
+	}
+	/// minimum Upload size for objects in a single operation
+	//
+	// Surprisingly while Amazon in their document states that S3 objects have 1byte
+	// as the minimum limit, they do not seem to enforce it one can successfully
+	// create a 0byte file using a regular putObject() operation
+	//
+	// if isMinObjectSize(size) {
+	//      writeErrorResponse(w, req, EntityTooSmall, acceptsContentType, req.URL.Path)
+	//	return
+	// }
+	sizeInt64, err := strconv.ParseInt(size, 10, 64)
+	if err != nil {
+		writeErrorResponse(w, req, InvalidRequest, acceptsContentType, req.URL.Path)
+		return
+	}
+	log.Println(bucket, object, sizeInt64)
+}
+
+/// Multipart API
+
+// NewMultipartUploadHandler - New multipart upload
+func (api MinioAPI) NewMultipartUploadHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// handle ACL's here at bucket level
+	if !api.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
+	if !isRequestUploads(req.URL.Query()) {
+		writeErrorResponse(w, req, MethodNotAllowed, acceptsContentType, req.URL.Path)
+		return
+	}
+
+	var object, bucket string
+	vars := mux.Vars(req)
+	bucket = vars["bucket"]
+	object = vars["object"]
+	log.Println(bucket, object)
+}
+
+// PutObjectPartHandler - Upload part
+func (api MinioAPI) PutObjectPartHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// handle ACL's here at bucket level
+	if !api.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
+	// get Content-MD5 sent by client and verify if valid
+	md5 := req.Header.Get("Content-MD5")
+	if !isValidMD5(md5) {
+		writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path)
+		return
+	}
+
+	/// if Content-Length missing, throw away
+	size := req.Header.Get("Content-Length")
+	if size == "" {
+		writeErrorResponse(w, req, MissingContentLength, acceptsContentType, req.URL.Path)
+		return
+	}
+
+	/// maximum Upload size for multipart objects in a single operation
+	if isMaxObjectSize(size) {
+		writeErrorResponse(w, req, EntityTooLarge, acceptsContentType, req.URL.Path)
+		return
+	}
+
+	sizeInt64, err := strconv.ParseInt(size, 10, 64)
+	if err != nil {
+		writeErrorResponse(w, req, InvalidRequest, acceptsContentType, req.URL.Path)
+		return
+	}
+
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	object := vars["object"]
+	log.Println(bucket, object, sizeInt64)
+
+	uploadID := req.URL.Query().Get("uploadId")
+	partIDString := req.URL.Query().Get("partNumber")
+
+	partID, err := strconv.Atoi(partIDString)
+	if err != nil {
+		writeErrorResponse(w, req, InvalidPart, acceptsContentType, req.URL.Path)
+	}
+	log.Println(uploadID, partID)
+}
+
+// AbortMultipartUploadHandler - Abort multipart upload
+func (api MinioAPI) AbortMultipartUploadHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// handle ACL's here at bucket level
+	if !api.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	object := vars["object"]
+
+	//objectResourcesMetadata := getObjectResources(req.URL.Query())
+	log.Println(bucket, object)
+}
+
+// ListObjectPartsHandler - List object parts
+func (api MinioAPI) ListObjectPartsHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// handle ACL's here at bucket level
+	if !api.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
+	objectResourcesMetadata := getObjectResources(req.URL.Query())
+	if objectResourcesMetadata.MaxParts == 0 {
+		objectResourcesMetadata.MaxParts = maxPartsList
+	}
+
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	object := vars["object"]
+	log.Println(bucket, object)
+}
+
+// CompleteMultipartUploadHandler - Complete multipart upload
+func (api MinioAPI) CompleteMultipartUploadHandler(w http.ResponseWriter, req *http.Request) {
+	acceptsContentType := getContentType(req)
+	// handle ACL's here at bucket level
+	if !api.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
+	decoder := xml.NewDecoder(req.Body)
+	parts := &CompleteMultipartUpload{}
+	err := decoder.Decode(parts)
+	if err != nil {
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+		return
+	}
+	if !sort.IsSorted(completedParts(parts.Part)) {
+		writeErrorResponse(w, req, InvalidPartOrder, acceptsContentType, req.URL.Path)
+		return
+	}
+
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+	object := vars["object"]
+	log.Println(bucket, object)
+
+	//objectResourcesMetadata := getObjectResources(req.URL.Query())
+
+	partMap := make(map[int]string)
+	for _, part := range parts.Part {
+		partMap[part.PartNumber] = part.ETag
+	}
+
+}
+
+/// Delete API
+
+// DeleteBucketHandler - Delete bucket
+func (api MinioAPI) DeleteBucketHandler(w http.ResponseWriter, req *http.Request) {
+	error := getErrorCode(NotImplemented)
+	w.WriteHeader(error.HTTPStatusCode)
+}
+
+// DeleteObjectHandler - Delete object
+func (api MinioAPI) DeleteObjectHandler(w http.ResponseWriter, req *http.Request) {
+	error := getErrorCode(NotImplemented)
+	w.WriteHeader(error.HTTPStatusCode)
+}

pkg/server/api/api-ratelimit-handlers.go

@@ -0,0 +1,50 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import "net/http"
+
+// rateLimit
+type rateLimit struct {
+	handler   http.Handler
+	rateQueue chan bool
+}
+
+func (c rateLimit) Add() {
+	c.rateQueue <- true // fill in the queue
+	return
+}
+
+func (c rateLimit) Remove() {
+	<-c.rateQueue // invalidate the queue, after the request is served
+	return
+}
+
+// ServeHTTP is an http.Handler ServeHTTP method
+func (c rateLimit) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	c.Add()                     // add
+	c.handler.ServeHTTP(w, req) // serve
+	c.Remove()                  // remove
+}
+
+// RateLimitHandler limits the number of concurrent http requests
+func RateLimitHandler(handle http.Handler, limit int) http.Handler {
+	return rateLimit{
+		handler:   handle,
+		rateQueue: make(chan bool, limit),
+	}
+}

pkg/server/api/api-response.go

@@ -0,0 +1,206 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"net/http"
+	"sort"
+
+	"github.com/minio/minio/pkg/storage/donut"
+)
+
+// Reply date format
+const (
+	iso8601Format = "2006-01-02T15:04:05.000Z"
+)
+
+// takes an array of Bucketmetadata information for serialization
+// input:
+// array of bucket metadata
+//
+// output:
+// populated struct that can be serialized to match xml and json api spec output
+func generateListBucketsResponse(buckets []donut.BucketMetadata) ListBucketsResponse {
+	var listbuckets []*Bucket
+	var data = ListBucketsResponse{}
+	var owner = Owner{}
+
+	owner.ID = "minio"
+	owner.DisplayName = "minio"
+
+	for _, bucket := range buckets {
+		var listbucket = &Bucket{}
+		listbucket.Name = bucket.Name
+		listbucket.CreationDate = bucket.Created.Format(iso8601Format)
+		listbuckets = append(listbuckets, listbucket)
+	}
+
+	data.Owner = owner
+	data.Buckets.Bucket = listbuckets
+
+	return data
+}
+
+// itemKey
+type itemKey []*Object
+
+func (b itemKey) Len() int           { return len(b) }
+func (b itemKey) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+func (b itemKey) Less(i, j int) bool { return b[i].Key < b[j].Key }
+
+// takes a set of objects and prepares the objects for serialization
+// input:
+// bucket name
+// array of object metadata
+// results truncated flag
+//
+// output:
+// populated struct that can be serialized to match xml and json api spec output
+func generateListObjectsResponse(bucket string, objects []donut.ObjectMetadata, bucketResources donut.BucketResourcesMetadata) ListObjectsResponse {
+	var contents []*Object
+	var prefixes []*CommonPrefix
+	var owner = Owner{}
+	var data = ListObjectsResponse{}
+
+	owner.ID = "minio"
+	owner.DisplayName = "minio"
+
+	for _, object := range objects {
+		var content = &Object{}
+		if object.Object == "" {
+			continue
+		}
+		content.Key = object.Object
+		content.LastModified = object.Created.Format(iso8601Format)
+		content.ETag = "\"" + object.MD5Sum + "\""
+		content.Size = object.Size
+		content.StorageClass = "STANDARD"
+		content.Owner = owner
+		contents = append(contents, content)
+	}
+	sort.Sort(itemKey(contents))
+	// TODO - support EncodingType in xml decoding
+	data.Name = bucket
+	data.Contents = contents
+	data.MaxKeys = bucketResources.Maxkeys
+	data.Prefix = bucketResources.Prefix
+	data.Delimiter = bucketResources.Delimiter
+	data.Marker = bucketResources.Marker
+	data.NextMarker = bucketResources.NextMarker
+	data.IsTruncated = bucketResources.IsTruncated
+	for _, prefix := range bucketResources.CommonPrefixes {
+		var prefixItem = &CommonPrefix{}
+		prefixItem.Prefix = prefix
+		prefixes = append(prefixes, prefixItem)
+	}
+	data.CommonPrefixes = prefixes
+	return data
+}
+
+// generateInitiateMultipartUploadResult
+func generateInitiateMultipartUploadResult(bucket, key, uploadID string) InitiateMultipartUploadResult {
+	return InitiateMultipartUploadResult{
+		Bucket:   bucket,
+		Key:      key,
+		UploadID: uploadID,
+	}
+}
+
+// generateCompleteMultipartUploadResult
+func generateCompleteMultpartUploadResult(bucket, key, location, etag string) CompleteMultipartUploadResult {
+	return CompleteMultipartUploadResult{
+		Location: location,
+		Bucket:   bucket,
+		Key:      key,
+		ETag:     etag,
+	}
+}
+
+// generateListPartsResult
+func generateListPartsResult(objectMetadata donut.ObjectResourcesMetadata) ListPartsResponse {
+	// TODO - support EncodingType in xml decoding
+	listPartsResponse := ListPartsResponse{}
+	listPartsResponse.Bucket = objectMetadata.Bucket
+	listPartsResponse.Key = objectMetadata.Key
+	listPartsResponse.UploadID = objectMetadata.UploadID
+	listPartsResponse.StorageClass = "STANDARD"
+	listPartsResponse.Initiator.ID = "minio"
+	listPartsResponse.Initiator.DisplayName = "minio"
+	listPartsResponse.Owner.ID = "minio"
+	listPartsResponse.Owner.DisplayName = "minio"
+
+	listPartsResponse.MaxParts = objectMetadata.MaxParts
+	listPartsResponse.PartNumberMarker = objectMetadata.PartNumberMarker
+	listPartsResponse.IsTruncated = objectMetadata.IsTruncated
+	listPartsResponse.NextPartNumberMarker = objectMetadata.NextPartNumberMarker
+
+	listPartsResponse.Part = make([]*Part, len(objectMetadata.Part))
+	for _, part := range objectMetadata.Part {
+		newPart := &Part{}
+		newPart.PartNumber = part.PartNumber
+		newPart.ETag = "\"" + part.ETag + "\""
+		newPart.Size = part.Size
+		newPart.LastModified = part.LastModified.Format(iso8601Format)
+		listPartsResponse.Part = append(listPartsResponse.Part, newPart)
+	}
+	return listPartsResponse
+}
+
+// generateListMultipartUploadsResult
+func generateListMultipartUploadsResult(bucket string, metadata donut.BucketMultipartResourcesMetadata) ListMultipartUploadsResponse {
+	listMultipartUploadsResponse := ListMultipartUploadsResponse{}
+	listMultipartUploadsResponse.Bucket = bucket
+	listMultipartUploadsResponse.Delimiter = metadata.Delimiter
+	listMultipartUploadsResponse.IsTruncated = metadata.IsTruncated
+	listMultipartUploadsResponse.EncodingType = metadata.EncodingType
+	listMultipartUploadsResponse.Prefix = metadata.Prefix
+	listMultipartUploadsResponse.KeyMarker = metadata.KeyMarker
+	listMultipartUploadsResponse.NextKeyMarker = metadata.NextKeyMarker
+	listMultipartUploadsResponse.MaxUploads = metadata.MaxUploads
+	listMultipartUploadsResponse.NextUploadIDMarker = metadata.NextUploadIDMarker
+	listMultipartUploadsResponse.UploadIDMarker = metadata.UploadIDMarker
+
+	listMultipartUploadsResponse.Upload = make([]*Upload, len(metadata.Upload))
+	for _, upload := range metadata.Upload {
+		newUpload := &Upload{}
+		newUpload.UploadID = upload.UploadID
+		newUpload.Key = upload.Key
+		newUpload.Initiated = upload.Initiated.Format(iso8601Format)
+		listMultipartUploadsResponse.Upload = append(listMultipartUploadsResponse.Upload, newUpload)
+	}
+	return listMultipartUploadsResponse
+}
+
+// writeSuccessResponse write success headers
+func writeSuccessResponse(w http.ResponseWriter, acceptsContentType contentType) {
+	setCommonHeaders(w, getContentTypeString(acceptsContentType), 0)
+	w.WriteHeader(http.StatusOK)
+}
+
+// writeErrorRespone write error headers
+func writeErrorResponse(w http.ResponseWriter, req *http.Request, errorType int, acceptsContentType contentType, resource string) {
+	error := getErrorCode(errorType)
+	// generate error response
+	errorResponse := getErrorResponse(error, resource)
+	encodedErrorResponse := encodeErrorResponse(errorResponse, acceptsContentType)
+	// set common headers
+	setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedErrorResponse))
+	// write Header
+	w.WriteHeader(error.HTTPStatusCode)
+	// write error body
+	w.Write(encodedErrorResponse)
+}

pkg/server/api/contenttype.go

@@ -0,0 +1,56 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import "net/http"
+
+type contentType int
+
+const (
+	unknownContentType contentType = iota
+	xmlContentType
+	jsonContentType
+)
+
+// Get content type requested from 'Accept' header
+func getContentType(req *http.Request) contentType {
+	acceptHeader := req.Header.Get("Accept")
+	switch {
+	case acceptHeader == "application/json":
+		return jsonContentType
+	default:
+		return xmlContentType
+	}
+}
+
+// Content type to human readable string
+func getContentTypeString(content contentType) string {
+	switch content {
+	case jsonContentType:
+		{
+			return "application/json"
+		}
+	case xmlContentType:
+		{
+			return "application/xml"
+		}
+	default:
+		{
+			return "application/xml"
+		}
+	}
+}

pkg/server/api/errors.go

@@ -0,0 +1,223 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"encoding/xml"
+	"net/http"
+)
+
+// Error structure
+type Error struct {
+	Code           string
+	Description    string
+	HTTPStatusCode int
+}
+
+// ErrorResponse - error response format
+type ErrorResponse struct {
+	XMLName   xml.Name `xml:"Error" json:"-"`
+	Code      string
+	Message   string
+	Resource  string
+	RequestID string `xml:"RequestId"`
+	HostID    string `xml:"HostId"`
+}
+
+// Error codes, non exhaustive list - http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html
+const (
+	AccessDenied = iota
+	BadDigest
+	BucketAlreadyExists
+	EntityTooSmall
+	EntityTooLarge
+	IncompleteBody
+	InternalError
+	InvalidAccessKeyID
+	InvalidBucketName
+	InvalidDigest
+	InvalidRange
+	InvalidRequest
+	MalformedXML
+	MissingContentLength
+	MissingRequestBodyError
+	NoSuchBucket
+	NoSuchKey
+	NoSuchUpload
+	NotImplemented
+	RequestTimeTooSkewed
+	SignatureDoesNotMatch
+	TooManyBuckets
+	MethodNotAllowed
+	InvalidPart
+	InvalidPartOrder
+)
+
+// Error codes, non exhaustive list - standard HTTP errors
+const (
+	NotAcceptable = iota + 25
+)
+
+// Error code to Error structure map
+var errorCodeResponse = map[int]Error{
+	AccessDenied: {
+		Code:           "AccessDenied",
+		Description:    "Access Denied",
+		HTTPStatusCode: http.StatusForbidden,
+	},
+	BadDigest: {
+		Code:           "BadDigest",
+		Description:    "The Content-MD5 you specified did not match what we received.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	BucketAlreadyExists: {
+		Code:           "BucketAlreadyExists",
+		Description:    "The requested bucket name is not available.",
+		HTTPStatusCode: http.StatusConflict,
+	},
+	EntityTooSmall: {
+		Code:           "EntityTooSmall",
+		Description:    "Your proposed upload is smaller than the minimum allowed object size.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	EntityTooLarge: {
+		Code:           "EntityTooLarge",
+		Description:    "Your proposed upload exceeds the maximum allowed object size.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	IncompleteBody: {
+		Code:           "IncompleteBody",
+		Description:    "You did not provide the number of bytes specified by the Content-Length HTTP header",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	InternalError: {
+		Code:           "InternalError",
+		Description:    "We encountered an internal error, please try again.",
+		HTTPStatusCode: http.StatusInternalServerError,
+	},
+	InvalidAccessKeyID: {
+		Code:           "InvalidAccessKeyID",
+		Description:    "The access key ID you provided does not exist in our records.",
+		HTTPStatusCode: http.StatusForbidden,
+	},
+	InvalidBucketName: {
+		Code:           "InvalidBucketName",
+		Description:    "The specified bucket is not valid.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	InvalidDigest: {
+		Code:           "InvalidDigest",
+		Description:    "The Content-MD5 you specified is not valid.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	InvalidRange: {
+		Code:           "InvalidRange",
+		Description:    "The requested range cannot be satisfied.",
+		HTTPStatusCode: http.StatusRequestedRangeNotSatisfiable,
+	},
+	MalformedXML: {
+		Code:           "MalformedXML",
+		Description:    "The XML you provided was not well-formed or did not validate against our published schema.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	MissingContentLength: {
+		Code:           "MissingContentLength",
+		Description:    "You must provide the Content-Length HTTP header.",
+		HTTPStatusCode: http.StatusLengthRequired,
+	},
+	MissingRequestBodyError: {
+		Code:           "MissingRequestBodyError",
+		Description:    "Request body is empty.",
+		HTTPStatusCode: http.StatusLengthRequired,
+	},
+	NoSuchBucket: {
+		Code:           "NoSuchBucket",
+		Description:    "The specified bucket does not exist.",
+		HTTPStatusCode: http.StatusNotFound,
+	},
+	NoSuchKey: {
+		Code:           "NoSuchKey",
+		Description:    "The specified key does not exist.",
+		HTTPStatusCode: http.StatusNotFound,
+	},
+	NoSuchUpload: {
+		Code:           "NoSuchUpload",
+		Description:    "The specified multipart upload does not exist.",
+		HTTPStatusCode: http.StatusNotFound,
+	},
+	NotImplemented: {
+		Code:           "NotImplemented",
+		Description:    "A header you provided implies functionality that is not implemented.",
+		HTTPStatusCode: http.StatusNotImplemented,
+	},
+	RequestTimeTooSkewed: {
+		Code:           "RequestTimeTooSkewed",
+		Description:    "The difference between the request time and the server's time is too large.",
+		HTTPStatusCode: http.StatusForbidden,
+	},
+	SignatureDoesNotMatch: {
+		Code:           "SignatureDoesNotMatch",
+		Description:    "The request signature we calculated does not match the signature you provided.",
+		HTTPStatusCode: http.StatusForbidden,
+	},
+	TooManyBuckets: {
+		Code:           "TooManyBuckets",
+		Description:    "You have attempted to create more buckets than allowed.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	MethodNotAllowed: {
+		Code:           "MethodNotAllowed",
+		Description:    "The specified method is not allowed against this resource.",
+		HTTPStatusCode: http.StatusMethodNotAllowed,
+	},
+	NotAcceptable: {
+		Code:           "NotAcceptable",
+		Description:    "The requested resource is only capable of generating content not acceptable according to the Accept headers sent in the request.",
+		HTTPStatusCode: http.StatusNotAcceptable,
+	},
+	InvalidPart: {
+		Code:           "InvalidPart",
+		Description:    "One or more of the specified parts could not be found",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	InvalidPartOrder: {
+		Code:           "InvalidPartOrder",
+		Description:    "The list of parts was not in ascending order. The parts list must be specified in order by part number.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+}
+
+// errorCodeError provides errorCode to Error. It returns empty if the code provided is unknown
+func getErrorCode(code int) Error {
+	return errorCodeResponse[code]
+}
+
+// getErrorResponse gets in standard error and resource value and
+// provides a encodable populated response values
+func getErrorResponse(err Error, resource string) ErrorResponse {
+	var data = ErrorResponse{}
+	data.Code = err.Code
+	data.Message = err.Description
+	if resource != "" {
+		data.Resource = resource
+	}
+	// TODO implement this in future
+	data.RequestID = "3L137"
+	data.HostID = "3L137"
+
+	return data
+}

pkg/server/api/headers.go

@@ -0,0 +1,95 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"net/http"
+	"strconv"
+
+	"github.com/minio/minio/pkg/storage/donut"
+)
+
+// No encoder interface exists, so we create one.
+type encoder interface {
+	Encode(v interface{}) error
+}
+
+//// helpers
+
+// Write http common headers
+func setCommonHeaders(w http.ResponseWriter, acceptsType string, contentLength int) {
+	w.Header().Set("Server", "Minio")
+	w.Header().Set("Accept-Ranges", "bytes")
+	w.Header().Set("Content-Type", acceptsType)
+	w.Header().Set("Connection", "close")
+	// should be set to '0' by default
+	w.Header().Set("Content-Length", strconv.Itoa(contentLength))
+}
+
+// Write error response headers
+func encodeErrorResponse(response interface{}, acceptsType contentType) []byte {
+	var bytesBuffer bytes.Buffer
+	var encoder encoder
+	// write common headers
+	switch acceptsType {
+	case xmlContentType:
+		encoder = xml.NewEncoder(&bytesBuffer)
+	case jsonContentType:
+		encoder = json.NewEncoder(&bytesBuffer)
+	// by default even if unknown Accept header received handle it by sending XML contenttype response
+	default:
+		encoder = xml.NewEncoder(&bytesBuffer)
+	}
+	encoder.Encode(response)
+	return bytesBuffer.Bytes()
+}
+
+// Write object header
+func setObjectHeaders(w http.ResponseWriter, metadata donut.ObjectMetadata) {
+	lastModified := metadata.Created.Format(http.TimeFormat)
+	// common headers
+	setCommonHeaders(w, metadata.Metadata["contentType"], int(metadata.Size))
+	// object related headers
+	w.Header().Set("ETag", "\""+metadata.MD5Sum+"\"")
+	w.Header().Set("Last-Modified", lastModified)
+}
+
+// Write range object header
+func setRangeObjectHeaders(w http.ResponseWriter, metadata donut.ObjectMetadata, contentRange *httpRange) {
+	// set common headers
+	setCommonHeaders(w, metadata.Metadata["contentType"], int(metadata.Size))
+	// set object headers
+	setObjectHeaders(w, metadata)
+	// set content range
+	w.Header().Set("Content-Range", contentRange.getContentRange())
+}
+
+func encodeSuccessResponse(response interface{}, acceptsType contentType) []byte {
+	var encoder encoder
+	var bytesBuffer bytes.Buffer
+	switch acceptsType {
+	case xmlContentType:
+		encoder = xml.NewEncoder(&bytesBuffer)
+	case jsonContentType:
+		encoder = json.NewEncoder(&bytesBuffer)
+	}
+	encoder.Encode(response)
+	return bytesBuffer.Bytes()
+}

pkg/server/api/range.go

@@ -0,0 +1,122 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+const (
+	b = "bytes="
+)
+
+// HttpRange specifies the byte range to be sent to the client.
+type httpRange struct {
+	start, length, size int64
+}
+
+// GetContentRange populate range header
+func (r *httpRange) getContentRange() string {
+	return fmt.Sprintf("bytes %d-%d/%d", r.start, r.start+r.length-1, r.size)
+}
+
+// Grab new range from request header
+func getRequestedRange(req *http.Request, size int64) (*httpRange, error) {
+	r := &httpRange{
+		start:  0,
+		length: 0,
+		size:   0,
+	}
+	r.size = size
+	if s := req.Header.Get("Range"); s != "" {
+		err := r.parseRange(s)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return r, nil
+}
+
+func (r *httpRange) parse(ra string) error {
+	i := strings.Index(ra, "-")
+	if i < 0 {
+		return errors.New("invalid range")
+	}
+	start, end := strings.TrimSpace(ra[:i]), strings.TrimSpace(ra[i+1:])
+	if start == "" {
+		// If no start is specified, end specifies the
+		// range start relative to the end of the file.
+		i, err := strconv.ParseInt(end, 10, 64)
+		if err != nil {
+			return errors.New("invalid range")
+		}
+		if i > r.size {
+			i = r.size
+		}
+		r.start = r.size - i
+		r.length = r.size - r.start
+	} else {
+		i, err := strconv.ParseInt(start, 10, 64)
+		if err != nil || i > r.size || i < 0 {
+			return errors.New("invalid range")
+		}
+		r.start = i
+		if end == "" {
+			// If no end is specified, range extends to end of the file.
+			r.length = r.size - r.start
+		} else {
+			i, err := strconv.ParseInt(end, 10, 64)
+			if err != nil || r.start > i {
+				return errors.New("invalid range")
+			}
+			if i >= r.size {
+				i = r.size - 1
+			}
+			r.length = i - r.start + 1
+		}
+	}
+	return nil
+}
+
+// parseRange parses a Range header string as per RFC 2616.
+func (r *httpRange) parseRange(s string) error {
+	if s == "" {
+		return errors.New("header not present")
+	}
+	if !strings.HasPrefix(s, b) {
+		return errors.New("invalid range")
+	}
+
+	ras := strings.Split(s[len(b):], ",")
+	if len(ras) == 0 {
+		return errors.New("invalid request")
+	}
+	// Just pick the first one and ignore the rest, we only support one range per object
+	if len(ras) > 1 {
+		return errors.New("multiple ranges specified")
+	}
+
+	ra := strings.TrimSpace(ras[0])
+	if ra == "" {
+		return errors.New("invalid range")
+	}
+	return r.parse(ra)
+}

pkg/server/api/resources.go

@@ -0,0 +1,66 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"net/url"
+	"strconv"
+
+	"github.com/minio/minio/pkg/storage/donut"
+)
+
+// parse bucket url queries
+func getBucketResources(values url.Values) (v donut.BucketResourcesMetadata) {
+	v.Prefix = values.Get("prefix")
+	v.Marker = values.Get("marker")
+	v.Maxkeys, _ = strconv.Atoi(values.Get("max-keys"))
+	v.Delimiter = values.Get("delimiter")
+	v.EncodingType = values.Get("encoding-type")
+	return
+}
+
+// part bucket url queries for ?uploads
+func getBucketMultipartResources(values url.Values) (v donut.BucketMultipartResourcesMetadata) {
+	v.Prefix = values.Get("prefix")
+	v.KeyMarker = values.Get("key-marker")
+	v.MaxUploads, _ = strconv.Atoi(values.Get("max-uploads"))
+	v.Delimiter = values.Get("delimiter")
+	v.EncodingType = values.Get("encoding-type")
+	v.UploadIDMarker = values.Get("upload-id-marker")
+	return
+}
+
+// parse object url queries
+func getObjectResources(values url.Values) (v donut.ObjectResourcesMetadata) {
+	v.UploadID = values.Get("uploadId")
+	v.PartNumberMarker, _ = strconv.Atoi(values.Get("part-number-marker"))
+	v.MaxParts, _ = strconv.Atoi(values.Get("max-parts"))
+	v.EncodingType = values.Get("encoding-type")
+	return
+}
+
+// check if req quere values carry uploads resource
+func isRequestUploads(values url.Values) bool {
+	_, ok := values["uploads"]
+	return ok
+}
+
+// check if req query values carry acl resource
+func isRequestBucketACL(values url.Values) bool {
+	_, ok := values["acl"]
+	return ok
+}

pkg/server/api/utils.go

@@ -0,0 +1,81 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package api
+
+import (
+	"encoding/base64"
+	"strconv"
+	"strings"
+)
+
+// isValidMD5 - verify if valid md5
+func isValidMD5(md5 string) bool {
+	if md5 == "" {
+		return true
+	}
+	_, err := base64.StdEncoding.DecodeString(strings.TrimSpace(md5))
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+/// http://docs.aws.amazon.com/AmazonS3/latest/dev/UploadingObjects.html
+const (
+	// maximum object size per PUT request is 5GB
+	maxObjectSize = 1024 * 1024 * 1024 * 5
+	// mimimum object size per Multipart PUT request is 5MB
+	minMultiPartObjectSize = 1024 * 1024 * 5
+	// minimum object size per PUT request is 1B
+	minObjectSize = 1
+)
+
+// isMaxObjectSize - verify if max object size
+func isMaxObjectSize(size string) bool {
+	i, err := strconv.ParseInt(size, 10, 64)
+	if err != nil {
+		return true
+	}
+	if i > maxObjectSize {
+		return true
+	}
+	return false
+}
+
+// isMinObjectSize - verify if min object size
+func isMinObjectSize(size string) bool {
+	i, err := strconv.ParseInt(size, 10, 64)
+	if err != nil {
+		return true
+	}
+	if i < minObjectSize {
+		return true
+	}
+	return false
+}
+
+// isMinMultipartObjectSize - verify if the uploaded multipart is of minimum size
+func isMinMultipartObjectSize(size string) bool {
+	i, err := strconv.ParseInt(size, 10, 64)
+	if err != nil {
+		return true
+	}
+	if i < minMultiPartObjectSize {
+		return true
+	}
+	return false
+}