vendor: sha256 32bit updated. (#2459 )

build: Add platform specific fixes.
fs/delete-object: fs.json filepath was incorrect. (#2448 )
2026-11-01 05:12:07 +03:00 · 2016-08-16 16:19:29 -07:00 · 2016-08-16 14:40:41 -07:00 · 2016-08-16 10:05:08 -07:00 · 2016-08-16 10:04:40 -07:00 · 2016-08-15 21:01:24 -07:00
487 changed files with 63932 additions and 8320 deletions
@@ -14,4 +14,5 @@ vendor/**/*.js
 vendor/**/*.json
 release
 .DS_Store
-*.syso
+*.syso
+coverage.txt
@@ -4,22 +4,20 @@ language: go

 os:
 - linux
-# Enable OSX builds when travis service is back.
-#- osx
+- osx

-#osx_image: xcode7.2
+osx_image: xcode7.2

 env:
 - ARCH=x86_64
 - ARCH=i686

 script:
- make test
 - make test GOFLAGS="-race"
+- make coverage
+
+after_success:
+- bash <(curl -s https://codecov.io/bash)

 go:
- 1.6
-
-notifications:
-  slack:
-    secure: K9tsn5MvrCAxuEZTxn+m3Kq1K2NG2xMEJFSv/sTp+RQBW7TslPHzv859GsIvrm8mU1y1btOU9RlOzqrRUczI5cJpE8IL1oljPZbXrIXgetE0kbsw0Wpy99g27UQ2VGp933WDu8tfj7zU4cZv+BI0RltNLwqYO6GWXmcWP0IueCU=
+- 1.6.2
@@ -1,76 +0,0 @@
-## Using aws-sdk-go with Minio
-
-aws-sdk-go is the official AWS SDK for the Go programming language. This document covers
-how to use aws-sdk-go with Minio server.
-
-### Install AWS SDK S3 service
-
-```sh
-$ go get github.com/aws/aws-sdk-go/service/s3
-```
-
-### List all buckets on Minio
-
-```go
-package main
-
-import (
-	"fmt"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/s3"
-)
-
-func main() {
-	newSession := session.New()
-	s3Config := &aws.Config{
-		Credentials: credentials.NewStaticCredentials("<YOUR-ACCESS-KEY-ID>", "<YOUR-SECRET-ACCESS-KEY", ""),
-		Endpoint:         aws.String("http://localhost:9000"),
-		Region:           aws.String("us-east-1"),
-		DisableSSL:       aws.Bool(true),
-		S3ForcePathStyle: aws.Bool(true),
-	}
-	// Create an S3 service object in the default region.
-	s3Client := s3.New(newSession, s3Config)
-
-	cparams := &s3.CreateBucketInput{
-		Bucket: aws.String("newbucket"), // Required
-	}
-	_, err := s3Client.CreateBucket(cparams)
-	if err != nil {
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	var lparams *s3.ListBucketsInput
-	// Call the ListBuckets() Operation
-	resp, err := s3Client.ListBuckets(lparams)
-	if err != nil {
-		// Message from an error.
-		fmt.Println(err.Error())
-		return
-	}
-
-	// Pretty-print the response data.
-	fmt.Println(resp)
-}
-```
-
-Populate your AccessKeyId and SecretAccessKey credentials and run the program as shown below.
-
-```sh
-$ go run aws-sdk-minio.go
-{
-  Buckets: [{
-      CreationDate: 2015-10-22 01:46:04 +0000 UTC,
-      Name: "newbucket"
-    }],
-  Owner: {
-    DisplayName: "minio",
-    ID: "minio"
-  }
-}
-```
@@ -51,7 +51,7 @@ Building Libraries
    - Push to the branch (git push origin my-new-feature)
    - Create new Pull Request

-* If you have additional dependencies for ``Minio``, ``Minio`` manages its depedencies using [govendor](https://github.com/kardianos/govendor)
+* If you have additional dependencies for ``Minio``, ``Minio`` manages its dependencies using [govendor](https://github.com/kardianos/govendor)
    - Run `go get foo/bar`
    - Edit your code to import foo/bar
    - Run `make pkg-add PKG=foo/bar` from top-level directory
@@ -1,27 +0,0 @@
-## Setting up Proxy using Caddy.
-
-Please download [Caddy Server](https://caddyserver.com/download)
-
-Create a caddy configuration file as below, change the ip addresses according to your local
-minio and DNS configuration.
-
-```bash
-$ ./minio --address localhost:9000 server <your_export_dir>
-```
-
-```bash
-your.public.com {
-    proxy / localhost:9000 {
-        proxy_header Host {host}
-        proxy_header X-Real-IP {remote}
-        proxy_header X-Forwarded-Proto {scheme}
-    }
-}
-```
-
-```bash
-$ ./caddy
-Activating privacy features... done.
-your.public.com:443
-your.public.com:80
-```
@@ -8,7 +8,7 @@ RUN go-wrapper download
 RUN go-wrapper install

 ENV ALLOW_CONTAINER_ROOT=1
-RUN mkdir -p /export/docker && cp /go/src/app/Docker.md /export/docker/
+RUN mkdir -p /export/docker && cp /go/src/app/docs/Docker.md /export/docker/

 EXPOSE 9000
 ENTRYPOINT ["go-wrapper", "run", "server"]
@@ -1,84 +0,0 @@
-## Ubuntu (Kylin) 14.04
-### Build Dependencies
-This installation document assumes Ubuntu 14.04+ on x86-64 platform.
-
-##### Install Git, GCC
-```sh
-$ sudo apt-get install git build-essential
-```
-
-##### Install Go 1.6+
-
-Download Go 1.6+ from [https://golang.org/dl/](https://golang.org/dl/).
-
-```sh
-$ wget https://storage.googleapis.com/golang/go1.6.linux-amd64.tar.gz
-$ mkdir -p ${HOME}/bin/
-$ mkdir -p ${HOME}/go/
-$ tar -C ${HOME}/bin/ -xzf go1.6.linux-amd64.tar.gz
-```
-##### Setup GOROOT and GOPATH
-
-Add the following exports to your ``~/.bashrc``. Environment variable GOROOT specifies the location of your golang binaries
-and GOPATH specifies the location of your project workspace.
-
-```sh
-export GOROOT=${HOME}/bin/go
-export GOPATH=${HOME}/go
-export PATH=${HOME}/bin/go/bin:${GOPATH}/bin:$PATH
-```
-##### Source the new enviornment
-
-```sh
-$ source ~/.bashrc
-```
-
-##### Testing it all
-
-```sh
-$ go env
-```
-
-## OS X (Yosemite) 10.10
-### Build Dependencies
-This installation document assumes OS X Yosemite 10.10+ on x86-64 platform.
-
-##### Install brew
-```sh
-$ ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
-```
-
-##### Install Git, Python
-```sh
-$ brew install git python
-```
-
-##### Install Go 1.6+
-
-Install golang binaries using `brew`
-
-```sh
-$ brew install go
-$ mkdir -p $HOME/go
-```
-
-##### Setup GOROOT and GOPATH
-
-Add the following exports to your ``~/.bash_profile``. Environment variable GOROOT specifies the location of your golang binaries
-and GOPATH specifies the location of your project workspace.
-
-```sh
-export GOPATH=${HOME}/go
-export GOVERSION=$(brew list go | head -n 1 | cut -d '/' -f 6)
-export GOROOT=$(brew --prefix)/Cellar/go/${GOVERSION}/libexec
-export PATH=${GOPATH}/bin:$PATH
-```
-##### Source the new enviornment
-```sh
-$ source ~/.bash_profile
-```
-##### Testing it all
-
-```sh
-$ go env
-```
@@ -101,14 +101,18 @@ deadcode:
 	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/deadcode

 spelling:
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/misspell *.go
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/misspell pkg/**/*
+	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/misspell -error *.go
+	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/misspell -error pkg/**/*

 test: build
 	@echo "Running all minio testing:"
 	@GO15VENDOREXPERIMENT=1 go test $(GOFLAGS) .
 	@GO15VENDOREXPERIMENT=1 go test $(GOFLAGS) github.com/minio/minio/pkg...

+coverage: build
+	@echo "Running all coverage for minio:"
+	@GO15VENDOREXPERIMENT=1 ./buildscripts/go-coverage.sh
+
 gomake-all: build
 	@echo "Installing minio:"
 	@GO15VENDOREXPERIMENT=1 go build --ldflags $(BUILD_LDFLAGS) -o $(GOPATH)/bin/minio
@@ -1,102 +1,44 @@
-## Minio [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/minio/minio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Minio Quickstart Guide [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/minio/minio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)

-Minio is an object storage server compatible with Amazon S3 and licensed under [Apache license 2.0](./LICENSE).
+Minio is an object storage server released under Apache License v2.0. It is compatible with Amazon S3 cloud storage service. It is best suited for storing unstructured data such as photos, videos, log files, backups and container / VM images. Size of an object can range from a few KBs to a maximum of 5TB.

-## Description
+##  1. Download

-Minio is an open source object storage server released under Apache License V2. It is compatible with Amazon S3 cloud storage service. Minio follows a minimalist design philosophy.
-Minio is light enough to be bundled with the application stack. It sits on the side of NodeJS, Redis, MySQL and the likes. Unlike databases, Minio stores objects such as photos, videos, log files, backups, container / VM images and so on. Minio is best suited for storing blobs of information ranging from KBs to 5 TBs each. In a simplistic sense, it is like a FTP server with a simple get / put API over HTTP.
+Minio server is light enough to be bundled with the application stack, similar to NodeJS, Redis and MySQL.

-Minio currently implements two backends
+| Platform| Architecture | URL|
+| ----------| -------- | ------|
+|GNU/Linux|64-bit Intel|https://dl.minio.io/server/minio/release/linux-amd64/minio|
+||32-bit Intel|https://dl.minio.io/server/minio/release/linux-386/minio|
+||32-bit ARM|https://dl.minio.io/server/minio/release/linux-arm/minio|
+|Apple OS X|64-bit Intel|https://dl.minio.io/server/minio/release/darwin-amd64/minio|
+|Microsoft Windows|64-bit|https://dl.minio.io/server/minio/release/windows-amd64/minio.exe|
+||32-bit|https://dl.minio.io/server/minio/release/windows-386/minio.exe|
+|FreeBSD|64-bit|https://dl.minio.io/server/minio/release/freebsd-amd64/minio|

-  - Filesystem (FS) - is available and ready for general purpose use.
-  - ErasureCoded (XL) - is available, but it is not ready for general purpose use.
+### Install from Source

-## Minio Client
+Source installation is only intended for developers and advanced users. If you do not have a working Golang environment, please follow [How to install Golang](https://docs.minio.io/docs/how-to-install-golang).

-[Minio Client (mc)](https://github.com/minio/mc#minio-client-mc-) provides a modern alternative to Unix commands like ``ls``, ``cat``, ``cp``, ``sync``, and ``diff``. It supports POSIX compatible filesystems and Amazon S3 compatible cloud storage systems. It is entirely written in Golang.

-## Amazon S3 Compatible Client Libraries
- [Golang Library](https://github.com/minio/minio-go)
- [Java Library](https://github.com/minio/minio-java)
- [Nodejs Library](https://github.com/minio/minio-js)
- [Python Library](https://github.com/minio/minio-py)
- [.Net Library](https://github.com/minio/minio-dotnet)
+```sh

-### Install [![Build Status](https://travis-ci.org/minio/minio.svg?branch=master)](https://travis-ci.org/minio/minio)[![Build status](https://ci.appveyor.com/api/projects/status/royh137dni8yevep/branch/master?svg=true)](https://ci.appveyor.com/project/harshavardhana/minio-qxbjq/branch/master)
-
-#### GNU/Linux
-
-Download ``minio`` for:
-
- ``64-bit Intel`` from https://dl.minio.io/server/minio/release/linux-amd64/minio
- ``32-bit Intel`` from https://dl.minio.io/server/minio/release/linux-386/minio
- ``32-bit ARM`` from https://dl.minio.io/server/minio/release/linux-arm/minio
-
-~~~
-$ chmod +x minio
-$ ./minio --help
-~~~
-
-#### OS X
-
-Download ``minio`` from https://dl.minio.io/server/minio/release/darwin-amd64/minio
-
-~~~
-$ chmod 755 minio
-$ ./minio --help
-~~~
-
-#### Microsoft Windows
-
-Download ``minio`` for:
-
- ``64-bit`` from https://dl.minio.io/server/minio/release/windows-amd64/minio.exe
- ``32-bit`` from https://dl.minio.io/server/minio/release/windows-386/minio.exe
-
-~~~
-C:\Users\Username\Downloads> minio.exe --help
-~~~
-
-#### FreeBSD
-
-Download ``minio`` from https://dl.minio.io/server/minio/release/freebsd-amd64/minio
-
-~~~
-$ chmod 755 minio
-$ ./minio --help
-~~~
-Read more here on [How to configure Minio on FreeBSD with ZFS backend.](./FreeBSD.md)
-
-#### Docker container
-
-Download ``minio`` for docker.
-
-~~~
-$ docker pull minio/minio
-~~~
-
-Read more here on [How to configure data volume containers for Minio?](./Docker.md)
-
-#### Source
-<blockquote>
-NOTE: Source installation is intended for only developers and advanced users.  For general use, please download official releases from https://minio.io/downloads.
-</blockquote>
-
-If you do not have a working Golang environment, please follow [Install Golang](./INSTALLGO.md).
-
-~~~
 $ go get -d github.com/minio/minio
 $ cd $GOPATH/src/github.com/minio/minio
 $ make
-~~~

-### How to use Minio?
+```

-Start minio server.
+## 2. Run Minio Server

-~~~
-$ minio server ~/Photos
+
+### GNU/Linux
+
+ ```sh
+
+$ chmod +x minio
+$ ./minio --help
+$ ./minio server ~/Photos

 Endpoint:  http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000
 AccessKey: USWUXHGYZQYFYFFIT3RE
@@ -106,156 +48,144 @@ Region:    us-east-1
 Browser Access:
   http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000

-Command-line Access: https://docs.minio.io/docs/minio-client-quick-start-guide
-   $ ./mc config host add myminio http://10.0.0.10:9000 USWUXHGYZQYFYFFIT3RE MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
+Command-line Access: https://docs.minio.io/docs/minio-client-quickstart-guide
+   $ mc config host add myminio http://10.0.0.10:9000 USWUXHGYZQYFYFFIT3RE MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03

 Object API (Amazon S3 compatible):
   Go:         https://docs.minio.io/docs/golang-client-quickstart-guide
   Java:       https://docs.minio.io/docs/java-client-quickstart-guide
   Python:     https://docs.minio.io/docs/python-client-quickstart-guide
   JavaScript: https://docs.minio.io/docs/javascript-client-quickstart-guide
-~~~
-
-#### How to use AWS CLI with Minio?
-
-<blockquote>
-This section assumes that you have already installed aws-cli, if not please visit https://aws.amazon.com/cli/
-</blockquote>
-
-To configure `aws-cli`, type `aws configure` and follow below steps.

-```
-$ aws configure
-AWS Access Key ID [None]: YOUR_ACCESS_KEY_HERE
-AWS Secret Access Key [None]: YOUR_SECRET_KEY_HERE
-Default region name [None]: us-east-1
-Default output format [None]: ENTER
 ```

-Additionally enable `aws-cli` to use AWS Signature Version '4' for Minio server.
+### OS X
+
+
+ ```sh
+
+$ chmod 755 minio
+$ ./minio --help
+$ ./minio server ~/Photos
+
+Endpoint:  http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000
+AccessKey: USWUXHGYZQYFYFFIT3RE
+SecretKey: MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
+Region:    us-east-1
+
+Browser Access:
+   http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000
+
+Command-line Access: https://docs.minio.io/docs/minio-client-quickstart-guide
+   $ mc config host add myminio http://10.0.0.10:9000 USWUXHGYZQYFYFFIT3RE MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
+
+Object API (Amazon S3 compatible):
+   Go:         https://docs.minio.io/docs/golang-client-quickstart-guide
+   Java:       https://docs.minio.io/docs/java-client-quickstart-guide
+   Python:     https://docs.minio.io/docs/python-client-quickstart-guide
+   JavaScript: https://docs.minio.io/docs/javascript-client-quickstart-guide

-```
-$ aws configure set default.s3.signature_version s3v4
 ```

-To list your buckets.
-```
-$ aws --endpoint-url http://localhost:9000 s3 ls
-2016-03-27 02:06:30 deebucket
-2016-03-28 21:53:49 guestbucket
-2016-03-29 13:34:34 mbtest
-2016-03-26 22:01:36 mybucket
-2016-03-26 15:37:02 testbucket
-```
+### Microsoft Windows

-To list contents inside bucket.
-```
-$ aws --endpoint-url http://localhost:9000 s3 ls s3://mybucket
-2016-03-30 00:26:53      69297 argparse-1.2.1.tar.gz
-2016-03-30 00:35:37      67250 simplejson-3.3.0.tar.gz
-```
+```sh

-To make a bucket.
-```
-$ aws --endpoint-url http://localhost:9000 s3 mb s3://mybucket
-make_bucket: s3://mybucket/
-```
+C:\Users\Username\Downloads> minio.exe --help
+C:\Users\Username\Downloads> minio.exe server D:\Photos

-To add an object to a bucket.
-```
-$ aws --endpoint-url http://localhost:9000 s3 cp simplejson-3.3.0.tar.gz s3://mybucket
-upload: ./simplejson-3.3.0.tar.gz to s3://mybucket/simplejson-3.3.0.tar.gz
-```
+Endpoint:  http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000
+AccessKey: USWUXHGYZQYFYFFIT3RE
+SecretKey: MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
+Region:    us-east-1

-Delete an object from a bucket.
-```
-$ aws --endpoint-url http://localhost:9000 s3 rm s3://mybucket/argparse-1.2.1.tar.gzdelete: s3://mybucket/argparse-1.2.1.tar.gz
-```
+Browser Access:
+   http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000

-Remove a bucket.
-```
-$ aws --endpoint-url http://localhost:9000 s3 rb s3://mybucket
-remove_bucket: s3://mybucket/
-```
+Command-line Access: https://docs.minio.io/docs/minio-client-quickstart-guide
+   $ mc.exe config host add myminio http://10.0.0.10:9000 USWUXHGYZQYFYFFIT3RE MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03

-#### How to use AWS SDK with Minio?
+Object API (Amazon S3 compatible):
+   Go:         https://docs.minio.io/docs/golang-client-quickstart-guide
+   Java:       https://docs.minio.io/docs/java-client-quickstart-guide
+   Python:     https://docs.minio.io/docs/python-client-quickstart-guide
+   JavaScript: https://docs.minio.io/docs/javascript-client-quickstart-guide

-Please follow the documentation here - [Using aws-sdk-go with Minio server](./AWS-SDK-GO.md)
-
-#### How to use s3cmd with Minio?
-
-<blockquote>
-This section assumes that you have already installed s3cmd, if not please visit http://s3tools.org/s3cmd
-</blockquote>
-
-Edit the following fields in your s3cmd configuration file `~/.s3cfg` .

 ```
-host_base = localhost:9000
-host_bucket = localhost:9000
-access_key = YOUR_ACCESS_KEY_HERE
-secret_key = YOUR_SECRET_KEY_HERE
-signature_v2 = False
-bucket_location = us-east-1
+
+### Docker Container
+
+```sh
+
+$ docker pull minio/minio
+$ docker run -p 9000:9000 minio/minio
+
 ```

-To make a bucket.
-```
-$ s3cmd mb s3://mybucket
-Bucket 's3://mybucket/' created
+### FreeBSD
+
+```sh
+
+$ chmod 755 minio
+$ ./minio --help
+$ ./minio server ~/Photos
+
+Endpoint:  http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000
+AccessKey: USWUXHGYZQYFYFFIT3RE
+SecretKey: MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
+Region:    us-east-1
+
+Browser Access:
+   http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000
+
+Command-line Access: https://docs.minio.io/docs/minio-client-quickstart-guide
+   $ mc config host add myminio http://10.0.0.10:9000 USWUXHGYZQYFYFFIT3RE MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
+
+Object API (Amazon S3 compatible):
+   Go:         https://docs.minio.io/docs/golang-client-quickstart-guide
+   Java:       https://docs.minio.io/docs/java-client-quickstart-guide
+   Python:     https://docs.minio.io/docs/python-client-quickstart-guide
+   JavaScript: https://docs.minio.io/docs/javascript-client-quickstart-guide
+
+
 ```

-To copy an object to bucket.
-```
-$ s3cmd put newfile s3://testbucket
-upload: 'newfile' -> 's3://testbucket/newfile'
+## 3. Test Minio Server using Minio Browser
+
+Open a web browser and navigate to http://127.0.0.1:9000 to view your buckets on minio server.
+
+![Screenshot](https://github.com/minio/minio/blob/master/docs/screenshots/minio-browser.jpg?raw=true)
+
+
+## 4. Test Minio Server using `mc`
+
+
+Install mc from [here](https://docs.minio.io/docs/minio-client-quickstart-guide). Use `mc ls` command to list all the buckets on your minio server.
+
+```sh
+
+$ mc ls myminio/
+[2015-08-05 08:13:22 IST]     0B andoria/
+[2015-08-05 06:14:26 IST]     0B deflector/
+[2015-08-05 08:13:11 IST]     0B ferenginar/
+[2016-03-08 14:56:35 IST]     0B jarjarbing/
+[2016-01-20 16:07:41 IST]     0B my.minio.io/
+
 ```

-To copy an object to local system.
-```
-$ s3cmd get s3://testbucket/newfile
-download: 's3://testbucket/newfile' -> './newfile'
-```
+For more examples please navigate to [Minio Client Complete Guide](https://docs.minio.io/docs/minio-client-complete-guide).

-To sync local file/directory to a bucket.
-```
-$ s3cmd sync newdemo s3://testbucket
-upload: 'newdemo/newdemofile.txt' -> 's3://testbucket/newdemo/newdemofile.txt'
-```

-To sync bucket or object with local filesystem.
-```
-$ s3cmd sync  s3://otherbucket otherlocalbucket
-download: 's3://otherbucket/cat.jpg' -> 'otherlocalbucket/cat.jpg'
-```
+## 5. Explore Further

-To list buckets.
-```
-$ s3cmd ls s3://
-2015-12-09 16:12  s3://testbbucket
-```
+- [Minio Erasure Code QuickStart Guide](https://docs.minio.io/docs/minio-erasure-code-quickstart-guide)
+- [Minio Docker Quickstart Guide](https://docs.minio.io/docs/minio-docker-quickstart-guide)
+- [Use `mc` with Minio Server](https://docs.minio.io/docs/minio-client-quickstart-guide)
+- [Use `aws-cli` with Minio Server](https://docs.minio.io/docs/aws-cli-with-minio)
+- [Use `s3cmd` with Minio Server](https://docs.minio.io/docs/s3cmd-with-minio)
+- [Use `minio-go` SDK with Minio Server](https://docs.minio.io/docs/golang-client-quickstart-guide)

-To list contents inside bucket.
-```
-$ s3cmd ls s3://testbucket/
-                       DIR   s3://testbucket/test/
-2015-12-09 16:05    138504   s3://testbucket/newfile
-```

-Delete an object from bucket.
-```
-$ s3cmd del s3://testbucket/newfile
-delete: 's3://testbucket/newfile'
-```
-
-Delete a bucket.
-```
-$ s3cmd rb s3://testbucket
-Bucket 's3://testbucket/' removed
-```
-
-## Contribute to Minio Project
-Please follow Minio [Contributor's Guide](./CONTRIBUTING.md)
-
-### Jobs
-If you think in Lisp or Haskell and hack in go, you would blend right in. Send your github link to callhome@minio.io.
+## 6. Contribute to Minio Project
+Please follow Minio [Contributor's Guide](https://github.com/minio/minio/blob/master/CONTRIBUTING.md)
@@ -1,118 +0,0 @@
-/*
- * 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 main
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/url"
-	"os"
-	"time"
-)
-
-type accessLogHandler struct {
-	http.Handler
-	accessLogFile *os.File
-}
-
-// 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         struct {
-			Method     string
-			URL        *url.URL
-			Proto      string // "HTTP/1.0"
-			ProtoMajor int    // 1
-			ProtoMinor int    // 0
-			Header     http.Header
-			Host       string
-			Form       url.Values
-			PostForm   url.Values
-			Trailer    http.Header
-			RemoteAddr string
-			RequestURI string
-		}
-	}
-}
-
-func (h *accessLogHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	message, err := getLogMessage(w, req)
-	fatalIf(err, "Unable to parse HTTP request and response fields.")
-	_, err = h.accessLogFile.Write(message)
-	fatalIf(err, "Unable to log HTTP access.")
-
-	h.Handler.ServeHTTP(w, req)
-}
-
-func getLogMessage(w http.ResponseWriter, req *http.Request) ([]byte, error) {
-	logMessage := &LogMessage{
-		StartTime: time.Now().UTC(),
-	}
-	// store lower level details
-	logMessage.HTTP.ResponseHeaders = w.Header()
-	logMessage.HTTP.Request = struct {
-		Method     string
-		URL        *url.URL
-		Proto      string // "HTTP/1.0"
-		ProtoMajor int    // 1
-		ProtoMinor int    // 0
-		Header     http.Header
-		Host       string
-		Form       url.Values
-		PostForm   url.Values
-		Trailer    http.Header
-		RemoteAddr string
-		RequestURI string
-	}{
-		Method:     req.Method,
-		URL:        req.URL,
-		Proto:      req.Proto,
-		ProtoMajor: req.ProtoMajor,
-		ProtoMinor: req.ProtoMinor,
-		Header:     req.Header,
-		Host:       req.Host,
-		Form:       req.Form,
-		PostForm:   req.PostForm,
-		Trailer:    req.Header,
-		RemoteAddr: req.RemoteAddr,
-		RequestURI: req.RequestURI,
-	}
-
-	// logMessage.HTTP.Request = req
-	logMessage.Duration = time.Now().UTC().Sub(logMessage.StartTime)
-	js, err := json.Marshal(logMessage)
-	if err != nil {
-		return nil, err
-	}
-	js = append(js, byte('\n')) // append a new line
-	return js, nil
-}
-
-// setAccessLogHandler logs requests
-func setAccessLogHandler(h http.Handler) http.Handler {
-	file, err := os.OpenFile("access.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
-	fatalIf(err, "Failed top open access log.")
-
-	return &accessLogHandler{Handler: h, accessLogFile: file}
-}
@@ -96,17 +96,33 @@ const (
 	ErrMissingSignHeadersTag
 	ErrPolicyAlreadyExpired
 	ErrMalformedDate
+	ErrMalformedPresignedDate
+	ErrMalformedCredentialDate
+	ErrMalformedCredentialRegion
 	ErrMalformedExpires
+	ErrNegativeExpires
 	ErrAuthHeaderEmpty
 	ErrExpiredPresignRequest
+	ErrUnsignedHeaders
 	ErrMissingDateHeader
 	ErrInvalidQuerySignatureAlgo
 	ErrInvalidQueryParams
 	ErrBucketAlreadyOwnedByYou
 	// Add new error codes here.

+	// Bucket notification related errors.
+	ErrEventNotification
+	ErrARNNotification
+	ErrRegionNotification
+	ErrOverlappingFilterNotification
+	ErrFilterNameInvalid
+	ErrFilterNamePrefix
+	ErrFilterNameSuffix
+	ErrFilterPrefixValueInvalid
+
 	// S3 extended errors.
 	ErrContentSHA256Mismatch
+
 	// Add new extended error codes here.

 	// Minio extended errors.
@@ -256,7 +272,7 @@ var errorCodeResponse = map[APIErrorCode]APIError{
 	},
 	ErrNoSuchUpload: {
 		Code:           "NoSuchUpload",
-		Description:    "The specified multipart upload does not exist.",
+		Description:    "The specified multipart upload does not exist. The upload ID may be invalid, or the upload may have been aborted or completed.",
 		HTTPStatusCode: http.StatusNotFound,
 	},
 	ErrNotImplemented: {
@@ -335,8 +351,8 @@ var errorCodeResponse = map[APIErrorCode]APIError{
 		HTTPStatusCode: http.StatusBadRequest,
 	},
 	ErrCredMalformed: {
-		Code:           "CredentialMalformed",
-		Description:    "Credential field malformed does not follow accessKeyID/credScope.",
+		Code:           "AuthorizationQueryParametersError",
+		Description:    "Error parsing the X-Amz-Credential parameter; the Credential is mal-formed; expecting \"<YOUR-AKID>/YYYYMMDD/REGION/SERVICE/aws4_request\".",
 		HTTPStatusCode: http.StatusBadRequest,
 	},
 	ErrMalformedDate: {
@@ -344,19 +360,46 @@ var errorCodeResponse = map[APIErrorCode]APIError{
 		Description:    "Invalid date format header, expected to be in ISO8601, RFC1123 or RFC1123Z time format.",
 		HTTPStatusCode: http.StatusBadRequest,
 	},
+	ErrMalformedPresignedDate: {
+		Code:           "AuthorizationQueryParametersError",
+		Description:    "X-Amz-Date must be in the ISO8601 Long Format \"yyyyMMdd'T'HHmmss'Z'\"",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	// FIXME: Should contain the invalid param set as seen in https://github.com/minio/minio/issues/2385.
+	// right Description:    "Error parsing the X-Amz-Credential parameter; incorrect date format \"%s\". This date in the credential must be in the format \"yyyyMMdd\".",
+	// Need changes to make sure variable messages can be constructed.
+	ErrMalformedCredentialDate: {
+		Code:           "AuthorizationQueryParametersError",
+		Description:    "Error parsing the X-Amz-Credential parameter; incorrect date format \"%s\". This date in the credential must be in the format \"yyyyMMdd\".",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	// FIXME: Should contain the invalid param set as seen in https://github.com/minio/minio/issues/2385.
+	// right Description:    "Error parsing the X-Amz-Credential parameter; the region 'us-east-' is wrong; expecting 'us-east-1'".
+	// Need changes to make sure variable messages can be constructed.
+	ErrMalformedCredentialRegion: {
+		Code:           "AuthorizationQueryParametersError",
+		Description:    "Error parsing the X-Amz-Credential parameter; the region is wrong;",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
 	ErrInvalidRegion: {
 		Code:           "InvalidRegion",
 		Description:    "Region does not match.",
 		HTTPStatusCode: http.StatusBadRequest,
 	},
+	// FIXME: Should contain the invalid param set as seen in https://github.com/minio/minio/issues/2385.
+	// right Description:   "Error parsing the X-Amz-Credential parameter; incorrect service \"s4\". This endpoint belongs to \"s3\".".
+	// Need changes to make sure variable messages can be constructed.
 	ErrInvalidService: {
-		Code:           "AccessDenied",
-		Description:    "Service scope should be of value 's3'.",
+		Code:           "AuthorizationQueryParametersError",
+		Description:    "Error parsing the X-Amz-Credential parameter; incorrect service. This endpoint belongs to \"s3\".",
 		HTTPStatusCode: http.StatusBadRequest,
 	},
+	// FIXME: Should contain the invalid param set as seen in https://github.com/minio/minio/issues/2385.
+	// Description:   "Error parsing the X-Amz-Credential parameter; incorrect terminal "aws4_reque". This endpoint uses "aws4_request".
+	// Need changes to make sure variable messages can be constructed.
 	ErrInvalidRequestVersion: {
-		Code:           "AccessDenied",
-		Description:    "Request scope should be of value 'aws4_request'.",
+		Code:           "AuthorizationQueryParametersError",
+		Description:    "Error parsing the X-Amz-Credential parameter; incorrect terminal. This endpoint uses \"aws4_request\".",
 		HTTPStatusCode: http.StatusBadRequest,
 	},
 	ErrMissingSignTag: {
@@ -375,8 +418,13 @@ var errorCodeResponse = map[APIErrorCode]APIError{
 		HTTPStatusCode: http.StatusBadRequest,
 	},
 	ErrMalformedExpires: {
-		Code:           "MalformedExpires",
-		Description:    "Malformed expires header, expected non-zero number.",
+		Code:           "AuthorizationQueryParametersError",
+		Description:    "X-Amz-Expires should be a number",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	ErrNegativeExpires: {
+		Code:           "AuthorizationQueryParametersError",
+		Description:    "X-Amz-Expires must be non-negative",
 		HTTPStatusCode: http.StatusBadRequest,
 	},
 	ErrAuthHeaderEmpty: {
@@ -396,7 +444,13 @@ var errorCodeResponse = map[APIErrorCode]APIError{
 	},
 	ErrExpiredPresignRequest: {
 		Code:           "AccessDenied",
-		Description:    "Request has expired.",
+		Description:    "Request has expired",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	// FIXME: Actual XML error response also contains the header which missed in lsit of signed header parameters.
+	ErrUnsignedHeaders: {
+		Code:           "AccessDenied",
+		Description:    "There were headers present in the request which were not signed",
 		HTTPStatusCode: http.StatusBadRequest,
 	},
 	ErrInvalidQueryParams: {
@@ -410,6 +464,48 @@ var errorCodeResponse = map[APIErrorCode]APIError{
 		HTTPStatusCode: http.StatusConflict,
 	},

+	/// Bucket notification related errors.
+	ErrEventNotification: {
+		Code:           "InvalidArgument",
+		Description:    "A specified event is not supported for notifications.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	ErrARNNotification: {
+		Code:           "InvalidArgument",
+		Description:    "A specified destination ARN does not exist or is not well-formed. Verify the destination ARN.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	ErrRegionNotification: {
+		Code:           "InvalidArgument",
+		Description:    "A specified destination is in a different region than the bucket. You must use a destination that resides in the same region as the bucket.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	ErrOverlappingFilterNotification: {
+		Code:           "InvalidArgument",
+		Description:    "An object key name filtering rule defined with overlapping prefixes, overlapping suffixes, or overlapping combinations of prefixes and suffixes for the same event types.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	ErrFilterNameInvalid: {
+		Code:           "InvalidArgument",
+		Description:    "filter rule name must be either prefix or suffix",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	ErrFilterNamePrefix: {
+		Code:           "InvalidArgument",
+		Description:    "Cannot specify more than one prefix rule in a filter.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	ErrFilterNameSuffix: {
+		Code:           "InvalidArgument",
+		Description:    "Cannot specify more than one suffix rule in a filter.",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+	ErrFilterPrefixValueInvalid: {
+		Code:           "InvalidArgument",
+		Description:    "prefix rule value cannot exceed 1024 characters",
+		HTTPStatusCode: http.StatusBadRequest,
+	},
+
 	/// S3 extensions.
 	ErrContentSHA256Mismatch: {
 		Code:           "XAmzContentSHA256Mismatch",
@@ -526,3 +622,7 @@ func getAPIErrorResponse(err APIError, resource string) APIErrorResponse {

 	return data
 }
+
+func getErrMalformedCredentialDate(malformedDateStr string) {
+
+}
@@ -23,7 +23,6 @@ import (
 	"net/http"
 	"runtime"
 	"strconv"
-	"strings"
 )

 //// helpers
@@ -63,20 +62,21 @@ func setObjectHeaders(w http.ResponseWriter, objInfo ObjectInfo, contentRange *h
 	// set common headers
 	setCommonHeaders(w)

-	// set object-related metadata headers
+	// Set content length.
+	w.Header().Set("Content-Length", strconv.FormatInt(objInfo.Size, 10))
+
+	// Set last modified time.
 	lastModified := objInfo.ModTime.UTC().Format(http.TimeFormat)
 	w.Header().Set("Last-Modified", lastModified)

-	w.Header().Set("Content-Type", objInfo.ContentType)
+	// Set Etag if available.
 	if objInfo.MD5Sum != "" {
 		w.Header().Set("ETag", "\""+objInfo.MD5Sum+"\"")
 	}

-	w.Header().Set("Content-Length", strconv.FormatInt(objInfo.Size, 10))
+	// Set all other user defined metadata.
 	for k, v := range objInfo.UserDefined {
-		if strings.HasPrefix(k, "X-Amz-Meta-") {
-			w.Header().Set(k, v)
-		}
+		w.Header().Set(k, v)
 	}

 	// for providing ranged content
@@ -291,8 +291,8 @@ func generateListBucketsResponse(buckets []BucketInfo) ListBucketsResponse {
 	return data
 }

-// generates an ListObjects response for the said bucket with other enumerated options.
-func generateListObjectsResponse(bucket, prefix, marker, delimiter string, maxKeys int, resp ListObjectsInfo) ListObjectsResponse {
+// generates an ListObjectsV1 response for the said bucket with other enumerated options.
+func generateListObjectsV1Response(bucket, prefix, marker, delimiter string, maxKeys int, resp ListObjectsInfo) ListObjectsResponse {
 	var contents []Object
 	var prefixes []CommonPrefix
 	var owner = Owner{}
@@ -336,7 +336,7 @@ func generateListObjectsResponse(bucket, prefix, marker, delimiter string, maxKe
 	return data
 }

-// generates an ListObjects response for the said bucket with other enumerated options.
+// generates an ListObjectsV2 response for the said bucket with other enumerated options.
 func generateListObjectsV2Response(bucket, prefix, token, startAfter, delimiter string, maxKeys int, resp ListObjectsInfo) ListObjectsV2Response {
 	var contents []Object
 	var prefixes []CommonPrefix
@@ -60,12 +60,20 @@ func registerAPIRouter(mux *router.Router, api objectAPIHandlers) {
 	bucket.Methods("GET").HandlerFunc(api.GetBucketLocationHandler).Queries("location", "")
 	// GetBucketPolicy
 	bucket.Methods("GET").HandlerFunc(api.GetBucketPolicyHandler).Queries("policy", "")
+	// GetBucketNotification
+	bucket.Methods("GET").HandlerFunc(api.GetBucketNotificationHandler).Queries("notification", "")
+	// ListenBucketNotification
+	bucket.Methods("GET").HandlerFunc(api.ListenBucketNotificationHandler).Queries("notificationARN", "{notificationARN:.*}")
 	// ListMultipartUploads
 	bucket.Methods("GET").HandlerFunc(api.ListMultipartUploadsHandler).Queries("uploads", "")
-	// ListObjects
-	bucket.Methods("GET").HandlerFunc(api.ListObjectsHandler)
+	// ListObjectsV2
+	bucket.Methods("GET").HandlerFunc(api.ListObjectsV2Handler).Queries("list-type", "2")
+	// ListObjectsV1 (Legacy)
+	bucket.Methods("GET").HandlerFunc(api.ListObjectsV1Handler)
 	// PutBucketPolicy
 	bucket.Methods("PUT").HandlerFunc(api.PutBucketPolicyHandler).Queries("policy", "")
+	// PutBucketNotification
+	bucket.Methods("PUT").HandlerFunc(api.PutBucketNotificationHandler).Queries("notification", "")
 	// PutBucket
 	bucket.Methods("PUT").HandlerFunc(api.PutBucketHandler)
 	// HeadBucket
@@ -22,14 +22,16 @@ install:

 # to run your custom scripts instead of automatic MSBuild
 build_script:
-  - go test .
  - go test -race .
-  - go test github.com/minio/minio/pkg...
  - go test -race github.com/minio/minio/pkg...
+  - go test -coverprofile=coverage.txt -covermode=atomic
  - go run buildscripts/gen-ldflags.go > temp.txt
  - set /p BUILD_LDFLAGS=<temp.txt
  - go build -ldflags="%BUILD_LDFLAGS%" -o %GOPATH%\bin\minio.exe

+after_test:
+  - bash <(curl -s https://codecov.io/bash)
+
 # to disable automatic tests
 test: off

@@ -1,5 +1,5 @@
 /*
- * Minio Cloud Storage, (C) 2015 Minio, Inc.
+ * Minio Cloud Storage, (C) 2015, 2016 Minio, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -34,40 +34,28 @@ func isRequestUnsignedPayload(r *http.Request) bool {

 // Verify if request has JWT.
 func isRequestJWT(r *http.Request) bool {
-	if _, ok := r.Header["Authorization"]; ok {
-		if strings.HasPrefix(r.Header.Get("Authorization"), jwtAlgorithm) {
-			return true
-		}
-	}
-	return false
+	return strings.HasPrefix(r.Header.Get("Authorization"), jwtAlgorithm)
 }

 // Verify if request has AWS Signature Version '4'.
 func isRequestSignatureV4(r *http.Request) bool {
-	if _, ok := r.Header["Authorization"]; ok {
-		if strings.HasPrefix(r.Header.Get("Authorization"), signV4Algorithm) {
-			return true
-		}
-	}
-	return false
+	return strings.HasPrefix(r.Header.Get("Authorization"), signV4Algorithm)
 }

-// Verify if request has AWS Presignature Version '4'.
+// Verify if request has AWS PreSign Version '4'.
 func isRequestPresignedSignatureV4(r *http.Request) bool {
-	if _, ok := r.URL.Query()["X-Amz-Credential"]; ok {
-		return true
-	}
-	return false
+	_, ok := r.URL.Query()["X-Amz-Credential"]
+	return ok
 }

 // Verify if request has AWS Post policy Signature Version '4'.
 func isRequestPostPolicySignatureV4(r *http.Request) bool {
-	if _, ok := r.Header["Content-Type"]; ok {
-		if strings.Contains(r.Header.Get("Content-Type"), "multipart/form-data") && r.Method == "POST" {
-			return true
-		}
-	}
-	return false
+	return strings.Contains(r.Header.Get("Content-Type"), "multipart/form-data") && r.Method == "POST"
+}
+
+// Verify if the request has AWS Streaming Signature Version '4'. This is only valid for 'PUT' operation.
+func isRequestSignStreamingV4(r *http.Request) bool {
+	return r.Header.Get("x-amz-content-sha256") == streamingContentSHA256 && r.Method == "PUT"
 }

 // Authorization type.
@@ -79,13 +67,16 @@ const (
 	authTypeAnonymous
 	authTypePresigned
 	authTypePostPolicy
+	authTypeStreamingSigned
 	authTypeSigned
 	authTypeJWT
 )

 // Get request authentication type.
 func getRequestAuthType(r *http.Request) authType {
-	if isRequestSignatureV4(r) {
+	if isRequestSignStreamingV4(r) {
+		return authTypeStreamingSigned
+	} else if isRequestSignatureV4(r) {
 		return authTypeSigned
 	} else if isRequestPresignedSignatureV4(r) {
 		return authTypePresigned
@@ -147,8 +138,23 @@ func isReqAuthenticated(r *http.Request) (s3Error APIErrorCode) {
 	return ErrAccessDenied
 }

-// authHandler - handles all the incoming authorization headers and
-// validates them if possible.
+// checkAuth - checks for conditions satisfying the authorization of
+// the incoming request. Request should be either Presigned or Signed
+// in accordance with AWS S3 Signature V4 requirements. ErrAccessDenied
+// is returned for unhandled auth type. Once the auth type is indentified
+// request headers and body are used to calculate the signature validating
+// the client signature present in request.
+func checkAuth(r *http.Request) APIErrorCode {
+	aType := getRequestAuthType(r)
+	if aType != authTypePresigned && aType != authTypeSigned {
+		// For all unhandled auth types return error AccessDenied.
+		return ErrAccessDenied
+	}
+	// Validates the request for both Presigned and Signed.
+	return isReqAuthenticated(r)
+}
+
+// authHandler - handles all the incoming authorization headers and validates them if possible.
 type authHandler struct {
 	handler http.Handler
 }
@@ -158,23 +164,40 @@ func setAuthHandler(h http.Handler) http.Handler {
 	return authHandler{h}
 }

+// List of all support S3 auth types.
+var supportedS3AuthTypes = []authType{
+	authTypeAnonymous,
+	authTypePresigned,
+	authTypeSigned,
+	authTypePostPolicy,
+	authTypeStreamingSigned,
+}
+
+// Validate if the authType is valid and supported.
+func isSupportedS3AuthType(aType authType) bool {
+	for _, a := range supportedS3AuthTypes {
+		if a == aType {
+			return true
+		}
+	}
+	return false
+}
+
 // handler for validating incoming authorization headers.
 func (a authHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	switch getRequestAuthType(r) {
-	case authTypeAnonymous, authTypePresigned, authTypeSigned, authTypePostPolicy:
-		// Let top level caller validate for anonymous and known
-		// signed requests.
+	aType := getRequestAuthType(r)
+	if isSupportedS3AuthType(aType) {
+		// Let top level caller validate for anonymous and known signed requests.
 		a.handler.ServeHTTP(w, r)
 		return
-	case authTypeJWT:
+	} else if aType == authTypeJWT {
 		// Validate Authorization header if its valid for JWT request.
 		if !isJWTReqAuthenticated(r) {
 			w.WriteHeader(http.StatusUnauthorized)
 			return
 		}
 		a.handler.ServeHTTP(w, r)
-	default:
-		writeErrorResponse(w, r, ErrSignatureVersionNotSupported, r.URL.Path)
 		return
 	}
+	writeErrorResponse(w, r, ErrSignatureVersionNotSupported, r.URL.Path)
 }
@@ -0,0 +1,206 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"testing"
+)
+
+// Test all s3 supported auth types.
+func TestS3SupportedAuthType(t *testing.T) {
+	type testCase struct {
+		authT authType
+		pass  bool
+	}
+	// List of all valid and invalid test cases.
+	testCases := []testCase{
+		// Test 1 - supported s3 type anonymous.
+		{
+			authT: authTypeAnonymous,
+			pass:  true,
+		},
+		// Test 2 - supported s3 type presigned.
+		{
+			authT: authTypePresigned,
+			pass:  true,
+		},
+		// Test 3 - supported s3 type signed.
+		{
+			authT: authTypeSigned,
+			pass:  true,
+		},
+		// Test 4 - supported s3 type with post policy.
+		{
+			authT: authTypePostPolicy,
+			pass:  true,
+		},
+		// Test 5 - supported s3 type with streaming signed.
+		{
+			authT: authTypeStreamingSigned,
+			pass:  true,
+		},
+		// Test 6 - JWT is not supported s3 type.
+		{
+			authT: authTypeJWT,
+			pass:  false,
+		},
+		// Test 7 - unknown auth header is not supported s3 type.
+		{
+			authT: authTypeUnknown,
+			pass:  false,
+		},
+		// Test 8 - some new auth type is not supported s3 type.
+		{
+			authT: authType(7),
+			pass:  false,
+		},
+	}
+	// Validate all the test cases.
+	for i, tt := range testCases {
+		ok := isSupportedS3AuthType(tt.authT)
+		if ok != tt.pass {
+			t.Errorf("Test %d:, Expected %t, got %t", i+1, tt.pass, ok)
+		}
+	}
+}
+
+// TestIsRequestUnsignedPayload - Test validates the Unsigned payload detection logic.
+func TestIsRequestUnsignedPayload(t *testing.T) {
+	testCases := []struct {
+		inputAmzContentHeader string
+		expectedResult        bool
+	}{
+		// Test case - 1.
+		// Test case with "X-Amz-Content-Sha256" header set to empty value.
+		{"", false},
+		// Test case - 2.
+		// Test case with "X-Amz-Content-Sha256" header set to  "UNSIGNED-PAYLOAD"
+		// The payload is flagged as unsigned When "X-Amz-Content-Sha256" header is set to  "UNSIGNED-PAYLOAD".
+		{"UNSIGNED-PAYLOAD", true},
+		// Test case - 3.
+		// set to a random value.
+		{"abcd", false},
+	}
+
+	// creating an input HTTP request.
+	// Only the headers are relevant for this particular test.
+	inputReq, err := http.NewRequest("GET", "http://example.com", nil)
+	if err != nil {
+		t.Fatalf("Error initializing input HTTP request: %v", err)
+	}
+
+	for i, testCase := range testCases {
+		inputReq.Header.Set("X-Amz-Content-Sha256", testCase.inputAmzContentHeader)
+		actualResult := isRequestUnsignedPayload(inputReq)
+		if testCase.expectedResult != actualResult {
+			t.Errorf("Test %d: Expected the result to `%v`, but instead got `%v`", i+1, testCase.expectedResult, actualResult)
+		}
+	}
+}
+
+// TestIsRequestPresignedSignatureV4 - Test validates the logic for presign signature verision v4 detection.
+func TestIsRequestPresignedSignatureV4(t *testing.T) {
+	testCases := []struct {
+		inputQueryKey   string
+		inputQueryValue string
+		expectedResult  bool
+	}{
+		// Test case - 1.
+		// Test case with query key ""X-Amz-Credential" set.
+		{"", "", false},
+		// Test case - 2.
+		{"X-Amz-Credential", "", true},
+		// Test case - 3.
+		{"X-Amz-Content-Sha256", "", false},
+	}
+
+	for i, testCase := range testCases {
+		// creating an input HTTP request.
+		// Only the query parameters are relevant for this particular test.
+		inputReq, err := http.NewRequest("GET", "http://example.com", nil)
+		if err != nil {
+			t.Fatalf("Error initializing input HTTP request: %v", err)
+		}
+		q := inputReq.URL.Query()
+		q.Add(testCase.inputQueryKey, testCase.inputQueryValue)
+		inputReq.URL.RawQuery = q.Encode()
+
+		actualResult := isRequestPresignedSignatureV4(inputReq)
+		if testCase.expectedResult != actualResult {
+			t.Errorf("Test %d: Expected the result to `%v`, but instead got `%v`", i+1, testCase.expectedResult, actualResult)
+		}
+	}
+}
+
+// Provides a fully populated http request instance, fails otherwise.
+func mustNewRequest(method string, urlStr string, contentLength int64, body io.ReadSeeker, t *testing.T) *http.Request {
+	req, err := newTestRequest(method, urlStr, contentLength, body)
+	if err != nil {
+		t.Fatalf("Unable to initialize new http request %s", err)
+	}
+	return req
+}
+
+// This is similar to mustNewRequest but additionally the request
+// is signed with AWS Signature V4, fails if not able to do so.
+func mustNewSignedRequest(method string, urlStr string, contentLength int64, body io.ReadSeeker, t *testing.T) *http.Request {
+	req := mustNewRequest(method, urlStr, contentLength, body, t)
+	cred := serverConfig.GetCredential()
+	if err := signRequest(req, cred.AccessKeyID, cred.SecretAccessKey); err != nil {
+		t.Fatalf("Unable to inititalized new signed http request %s", err)
+	}
+	return req
+}
+
+// Tests is requested authenticated function, tests replies for s3 errors.
+func TestIsReqAuthenticated(t *testing.T) {
+	path, err := newTestConfig("us-east-1")
+	if err != nil {
+		t.Fatalf("unable initialize config file, %s", err)
+	}
+	defer removeAll(path)
+
+	serverConfig.SetCredential(credential{"myuser", "mypassword"})
+
+	// List of test cases for validating http request authentication.
+	testCases := []struct {
+		req     *http.Request
+		s3Error APIErrorCode
+	}{
+		// When request is nil, internal error is returned.
+		{nil, ErrInternalError},
+		// When request is unsigned, access denied is returned.
+		{mustNewRequest("GET", "http://localhost:9000", 0, nil, t), ErrAccessDenied},
+		// When request is properly signed, but has bad Content-MD5 header.
+		{mustNewSignedRequest("PUT", "http://localhost:9000", 5, bytes.NewReader([]byte("hello")), t), ErrBadDigest},
+		// When request is properly signed, error is none.
+		{mustNewSignedRequest("GET", "http://localhost:9000", 0, nil, t), ErrNone},
+	}
+
+	// Validates all testcases.
+	for _, testCase := range testCases {
+		if testCase.s3Error == ErrBadDigest {
+			testCase.req.Header.Set("Content-Md5", "garbage")
+		}
+		if s3Error := isReqAuthenticated(testCase.req); s3Error != testCase.s3Error {
+			t.Fatalf("Unexpected s3error returned wanted %d, got %d", testCase.s3Error, s3Error)
+		}
+	}
+}
@@ -133,7 +133,7 @@ func runPutObjectPartBenchmark(b *testing.B, obj ObjectLayer, partSize int) {
 }

 // creates XL/FS backend setup, obtains the object layer and calls the runPutObjectPartBenchmark function.
-func benchmarkPutObjectPart(b *testing.B, instanceType string, runBenchMark func(b *testing.B, obj ObjectLayer)) {
+func benchmarkPutObjectPart(b *testing.B, instanceType string, objSize int) {
 	// create a temp XL/FS backend.
 	objLayer, disks, err := makeTestBackend(instanceType)
 	if err != nil {
@@ -141,20 +141,12 @@ func benchmarkPutObjectPart(b *testing.B, instanceType string, runBenchMark func
 	}
 	// cleaning up the backend by removing all the directories and files created on function return.
 	defer removeRoots(disks)
-	// calling runPutObjectBenchmark which uses *testing.B and the object Layer to run the benchmark.
-	runBenchMark(b, objLayer)
-}
-
-// closure for returning the put object benchmark executor for given object size in bytes.
-func returnPutObjectPartBenchmark(objSize int) func(*testing.B, ObjectLayer) {
-	// FIXME: Avoid closure.
-	return func(b *testing.B, obj ObjectLayer) {
-		runPutObjectPartBenchmark(b, obj, objSize)
-	}
+	// uses *testing.B and the object Layer to run the benchmark.
+	runPutObjectPartBenchmark(b, objLayer, objSize)
 }

 // creates XL/FS backend setup, obtains the object layer and calls the runPutObjectBenchmark function.
-func benchmarkPutObject(b *testing.B, instanceType string, runBenchMark func(b *testing.B, obj ObjectLayer)) {
+func benchmarkPutObject(b *testing.B, instanceType string, objSize int) {
 	// create a temp XL/FS backend.
 	objLayer, disks, err := makeTestBackend(instanceType)
 	if err != nil {
@@ -162,16 +154,21 @@ func benchmarkPutObject(b *testing.B, instanceType string, runBenchMark func(b *
 	}
 	// cleaning up the backend by removing all the directories and files created on function return.
 	defer removeRoots(disks)
-	// calling runPutObjectBenchmark which uses *testing.B and the object Layer to run the benchmark.
-	runBenchMark(b, objLayer)
+	// uses *testing.B and the object Layer to run the benchmark.
+	runPutObjectBenchmark(b, objLayer, objSize)
 }

-// closure for returning the put object benchmark executor for given object size in bytes.
-func returnPutObjectBenchmark(objSize int) func(*testing.B, ObjectLayer) {
-	// FIXME: Avoid closure.
-	return func(b *testing.B, obj ObjectLayer) {
-		runPutObjectBenchmark(b, obj, objSize)
+// creates XL/FS backend setup, obtains the object layer and runs parallel benchmark for put object.
+func benchmarkPutObjectParallel(b *testing.B, instanceType string, objSize int) {
+	// create a temp XL/FS backend.
+	objLayer, disks, err := makeTestBackend(instanceType)
+	if err != nil {
+		b.Fatalf("Failed obtaining Temp Backend: <ERROR> %s", err)
 	}
+	// cleaning up the backend by removing all the directories and files created on function return.
+	defer removeRoots(disks)
+	// uses *testing.B and the object Layer to run the benchmark.
+	runPutObjectBenchmarkParallel(b, objLayer, objSize)
 }

 // Benchmark utility functions for ObjectLayer.GetObject().
@@ -243,7 +240,7 @@ func generateBytesData(size int) []byte {
 }

 // creates XL/FS backend setup, obtains the object layer and calls the runGetObjectBenchmark function.
-func benchmarkGetObject(b *testing.B, instanceType string, runBenchMark func(b *testing.B, obj ObjectLayer)) {
+func benchmarkGetObject(b *testing.B, instanceType string, objSize int) {
 	// create a temp XL/FS backend.
 	objLayer, disks, err := makeTestBackend(instanceType)
 	if err != nil {
@@ -251,16 +248,21 @@ func benchmarkGetObject(b *testing.B, instanceType string, runBenchMark func(b *
 	}
 	// cleaning up the backend by removing all the directories and files created.
 	defer removeRoots(disks)
-	// calling runGetObjectBenchmark which uses *testing.B and the object Layer to run the benchmark.
-	runBenchMark(b, objLayer)
+	//  uses *testing.B and the object Layer to run the benchmark.
+	runGetObjectBenchmark(b, objLayer, objSize)
 }

-// closure for returning the get object benchmark executor for given object size in bytes.
-// FIXME: Avoid closure.
-func returnGetObjectBenchmark(objSize int) func(*testing.B, ObjectLayer) {
-	return func(b *testing.B, obj ObjectLayer) {
-		runGetObjectBenchmark(b, obj, objSize)
+// creates XL/FS backend setup, obtains the object layer and runs parallel benchmark for ObjectLayer.GetObject() .
+func benchmarkGetObjectParallel(b *testing.B, instanceType string, objSize int) {
+	// create a temp XL/FS backend.
+	objLayer, disks, err := makeTestBackend(instanceType)
+	if err != nil {
+		b.Fatalf("Failed obtaining Temp Backend: <ERROR> %s", err)
 	}
+	// cleaning up the backend by removing all the directories and files created.
+	defer removeRoots(disks)
+	//  uses *testing.B and the object Layer to run the benchmark.
+	runGetObjectBenchmarkParallel(b, objLayer, objSize)
 }

 // Parallel benchmark utility functions for ObjectLayer.PutObject().
@@ -310,14 +312,6 @@ func runPutObjectBenchmarkParallel(b *testing.B, obj ObjectLayer, objSize int) {
 	b.StopTimer()
 }

-// closure for returning the put object benchmark executor for given object size in bytes.
-func returnPutObjectBenchmarkParallel(objSize int) func(*testing.B, ObjectLayer) {
-	// FIXME: Avoid closure.
-	return func(b *testing.B, obj ObjectLayer) {
-		runPutObjectBenchmarkParallel(b, obj, objSize)
-	}
-}
-
 // Parallel benchmark utility functions for ObjectLayer.GetObject().
 // Creates Object layer setup ( MakeBucket, PutObject) and then runs the benchmark.
 func runGetObjectBenchmarkParallel(b *testing.B, obj ObjectLayer, objSize int) {
@@ -374,11 +368,3 @@ func runGetObjectBenchmarkParallel(b *testing.B, obj ObjectLayer, objSize int) {
 	b.StopTimer()

 }
-
-// closure for returning the get object benchmark executor for given object size in bytes.
-// FIXME: Avoid closure.
-func returnGetObjectBenchmarkParallel(objSize int) func(*testing.B, ObjectLayer) {
-	return func(b *testing.B, obj ObjectLayer) {
-		runGetObjectBenchmarkParallel(b, obj, objSize)
-	}
-}
@@ -0,0 +1,167 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
+)
+
+// Validate all the ListObjects query arguments, returns an APIErrorCode
+// if one of the args do not meet the required conditions.
+// Special conditions required by Minio server are as below
+// - delimiter if set should be equal to '/', otherwise the request is rejected.
+// - marker if set should have a common prefix with 'prefix' param, otherwise
+//   the request is rejected.
+func listObjectsValidateArgs(prefix, marker, delimiter string, maxKeys int) APIErrorCode {
+	// Max keys cannot be negative.
+	if maxKeys < 0 {
+		return ErrInvalidMaxKeys
+	}
+
+	/// Minio special conditions for ListObjects.
+
+	// Verify if delimiter is anything other than '/', which we do not support.
+	if delimiter != "" && delimiter != "/" {
+		return ErrNotImplemented
+	}
+	// Marker is set validate pre-condition.
+	if marker != "" {
+		// Marker not common with prefix is not implemented.
+		if !strings.HasPrefix(marker, prefix) {
+			return ErrNotImplemented
+		}
+	}
+	// Success.
+	return ErrNone
+}
+
+// ListObjectsV2Handler - GET Bucket (List Objects) Version 2.
+// --------------------------
+// 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.
+//
+// NOTE: It is recommended that this API to be used for application development.
+// Minio continues to support ListObjectsV1 for supporting legacy tools.
+func (api objectAPIHandlers) ListObjectsV2Handler(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	bucket := vars["bucket"]
+
+	switch getRequestAuthType(r) {
+	default:
+		// For all unknown auth types return error.
+		writeErrorResponse(w, r, ErrAccessDenied, r.URL.Path)
+		return
+	case authTypeAnonymous:
+		// http://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html
+		if s3Error := enforceBucketPolicy(bucket, "s3:ListBucket", r.URL); s3Error != ErrNone {
+			writeErrorResponse(w, r, s3Error, r.URL.Path)
+			return
+		}
+	case authTypeSigned, authTypePresigned:
+		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
+			writeErrorResponse(w, r, s3Error, r.URL.Path)
+			return
+		}
+	}
+	// Extract all the listObjectsV2 query params to their native values.
+	prefix, token, startAfter, delimiter, maxKeys, _ := getListObjectsV2Args(r.URL.Query())
+
+	// In ListObjectsV2 'continuation-token' is the marker.
+	marker := token
+	// Check if 'continuation-token' is empty.
+	if token == "" {
+		// Then we need to use 'start-after' as marker instead.
+		marker = startAfter
+	}
+	// Validate all the query params before beginning to serve the request.
+	if s3Error := listObjectsValidateArgs(prefix, marker, delimiter, maxKeys); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
+		return
+	}
+	// Inititate a list objects operation based on the input params.
+	// On success would return back ListObjectsInfo object to be
+	// marshalled into S3 compatible XML header.
+	listObjectsInfo, err := api.ObjectAPI.ListObjects(bucket, prefix, marker, delimiter, maxKeys)
+	if err != nil {
+		errorIf(err, "Unable to list objects.")
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
+		return
+	}
+
+	response := generateListObjectsV2Response(bucket, prefix, token, startAfter, delimiter, maxKeys, listObjectsInfo)
+	// Write headers
+	setCommonHeaders(w)
+	// Write success response.
+	writeSuccessResponse(w, encodeResponse(response))
+}
+
+// ListObjectsV1Handler - GET Bucket (List Objects) Version 1.
+// --------------------------
+// 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 objectAPIHandlers) ListObjectsV1Handler(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	bucket := vars["bucket"]
+
+	switch getRequestAuthType(r) {
+	default:
+		// For all unknown auth types return error.
+		writeErrorResponse(w, r, ErrAccessDenied, r.URL.Path)
+		return
+	case authTypeAnonymous:
+		// http://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html
+		if s3Error := enforceBucketPolicy(bucket, "s3:ListBucket", r.URL); s3Error != ErrNone {
+			writeErrorResponse(w, r, s3Error, r.URL.Path)
+			return
+		}
+	case authTypeSigned, authTypePresigned:
+		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
+			writeErrorResponse(w, r, s3Error, r.URL.Path)
+			return
+		}
+	}
+
+	// Extract all the litsObjectsV1 query params to their native values.
+	prefix, marker, delimiter, maxKeys, _ := getListObjectsV1Args(r.URL.Query())
+
+	// Validate all the query params before beginning to serve the request.
+	if s3Error := listObjectsValidateArgs(prefix, marker, delimiter, maxKeys); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
+		return
+	}
+
+	// Inititate a list objects operation based on the input params.
+	// On success would return back ListObjectsInfo object to be
+	// marshalled into S3 compatible XML header.
+	listObjectsInfo, err := api.ObjectAPI.ListObjects(bucket, prefix, marker, delimiter, maxKeys)
+	if err != nil {
+		errorIf(err, "Unable to list objects.")
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
+		return
+	}
+	response := generateListObjectsV1Response(bucket, prefix, marker, delimiter, maxKeys, listObjectsInfo)
+	// Write headers
+	setCommonHeaders(w)
+	// Write success response.
+	writeSuccessResponse(w, encodeResponse(response))
+}
@@ -17,40 +17,25 @@
 package main

 import (
-	"bytes"
-	"encoding/base64"
-	"encoding/hex"
 	"encoding/xml"
 	"io"
-	"io/ioutil"
-	"mime/multipart"
 	"net/http"
 	"net/url"
+	"path"
 	"strings"

 	mux "github.com/gorilla/mux"
 )

 // http://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html
-func enforceBucketPolicy(action string, bucket string, reqURL *url.URL) (s3Error APIErrorCode) {
-	// Read saved bucket policy.
-	policy, err := readBucketPolicy(bucket)
-	if err != nil {
-		errorIf(err, "Unable read bucket policy.")
-		switch err.(type) {
-		case BucketNotFound:
-			return ErrNoSuchBucket
-		case BucketNameInvalid:
-			return ErrInvalidBucketName
-		default:
-			// For any other error just return AccessDenied.
-			return ErrAccessDenied
-		}
+// Enforces bucket policies for a bucket for a given tatusaction.
+func enforceBucketPolicy(bucket string, action string, reqURL *url.URL) (s3Error APIErrorCode) {
+	if !IsValidBucketName(bucket) {
+		return ErrInvalidBucketName
 	}
-	// Parse the saved policy.
-	bucketPolicy, err := parseBucketPolicy(policy)
-	if err != nil {
-		errorIf(err, "Unable to parse bucket policy.")
+	// Fetch bucket policy, if policy is not set return access denied.
+	policy := globalBucketPolicies.GetBucketPolicy(bucket)
+	if policy == nil {
 		return ErrAccessDenied
 	}

@@ -64,7 +49,7 @@ func enforceBucketPolicy(action string, bucket string, reqURL *url.URL) (s3Error
 	}

 	// Validate action, resource and conditions with current policy statements.
-	if !bucketPolicyEvalStatements(action, resource, conditions, bucketPolicy.Statements) {
+	if !bucketPolicyEvalStatements(action, resource, conditions, policy.Statements) {
 		return ErrAccessDenied
 	}
 	return ErrNone
@@ -84,33 +69,12 @@ func (api objectAPIHandlers) GetBucketLocationHandler(w http.ResponseWriter, r *
 		return
 	case authTypeAnonymous:
 		// http://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html
-		if s3Error := enforceBucketPolicy("s3:GetBucketLocation", bucket, r.URL); s3Error != ErrNone {
+		if s3Error := enforceBucketPolicy(bucket, "s3:GetBucketLocation", r.URL); s3Error != ErrNone {
 			writeErrorResponse(w, r, s3Error, r.URL.Path)
 			return
 		}
 	case authTypeSigned, authTypePresigned:
-		payload, err := ioutil.ReadAll(r.Body)
-		if err != nil {
-			writeErrorResponse(w, r, ErrInternalError, r.URL.Path)
-			return
-		}
-		// Verify Content-Md5, if payload is set.
-		if r.Header.Get("Content-Md5") != "" {
-			if r.Header.Get("Content-Md5") != base64.StdEncoding.EncodeToString(sumMD5(payload)) {
-				writeErrorResponse(w, r, ErrBadDigest, r.URL.Path)
-				return
-			}
-		}
-		// Populate back the payload.
-		r.Body = ioutil.NopCloser(bytes.NewReader(payload))
-		var s3Error APIErrorCode // API error code.
-		validateRegion := false  // Validate region.
-		if isRequestSignatureV4(r) {
-			s3Error = doesSignatureMatch(hex.EncodeToString(sum256(payload)), r, validateRegion)
-		} else if isRequestPresignedSignatureV4(r) {
-			s3Error = doesPresignedSignatureMatch(hex.EncodeToString(sum256(payload)), r, validateRegion)
-		}
-		if s3Error != ErrNone {
+		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
 			writeErrorResponse(w, r, s3Error, r.URL.Path)
 			return
 		}
@@ -154,7 +118,7 @@ func (api objectAPIHandlers) ListMultipartUploadsHandler(w http.ResponseWriter,
 		return
 	case authTypeAnonymous:
 		// http://docs.aws.amazon.com/AmazonS3/latest/dev/mpuAndPermissions.html
-		if s3Error := enforceBucketPolicy("s3:ListBucketMultipartUploads", bucket, r.URL); s3Error != ErrNone {
+		if s3Error := enforceBucketPolicy(bucket, "s3:ListBucketMultipartUploads", r.URL); s3Error != ErrNone {
 			writeErrorResponse(w, r, s3Error, r.URL.Path)
 			return
 		}
@@ -193,141 +157,31 @@ func (api objectAPIHandlers) ListMultipartUploadsHandler(w http.ResponseWriter,
 	writeSuccessResponse(w, encodedSuccessResponse)
 }

-// 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 objectAPIHandlers) ListObjectsHandler(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	bucket := vars["bucket"]
-
-	switch getRequestAuthType(r) {
-	default:
-		// For all unknown auth types return error.
-		writeErrorResponse(w, r, ErrAccessDenied, r.URL.Path)
-		return
-	case authTypeAnonymous:
-		// http://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html
-		if s3Error := enforceBucketPolicy("s3:ListBucket", bucket, r.URL); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	case authTypeSigned, authTypePresigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-	var prefix, marker, token, delimiter, startAfter string
-	var maxkeys int
-	var listV2 bool
-	// TODO handle encoding type.
-	if r.URL.Query().Get("list-type") == "2" {
-		listV2 = true
-		prefix, token, startAfter, delimiter, maxkeys, _ = getListObjectsV2Args(r.URL.Query())
-		// For ListV2 "start-after" is considered only if "continuation-token" is empty.
-		if token == "" {
-			marker = startAfter
-		} else {
-			marker = token
-		}
-	} else {
-		prefix, marker, delimiter, maxkeys, _ = getListObjectsV1Args(r.URL.Query())
-	}
-	if maxkeys < 0 {
-		writeErrorResponse(w, r, ErrInvalidMaxKeys, r.URL.Path)
-		return
-	}
-	// Verify if delimiter is anything other than '/', which we do not support.
-	if delimiter != "" && delimiter != "/" {
-		writeErrorResponse(w, r, ErrNotImplemented, r.URL.Path)
-		return
-	}
-	// If marker is set unescape.
-	if marker != "" {
-		// Marker not common with prefix is not implemented.
-		if !strings.HasPrefix(marker, prefix) {
-			writeErrorResponse(w, r, ErrNotImplemented, r.URL.Path)
-			return
-		}
-	}
-
-	listObjectsInfo, err := api.ObjectAPI.ListObjects(bucket, prefix, marker, delimiter, maxkeys)
-
-	if err == nil {
-		var encodedSuccessResponse []byte
-		// generate response
-		if listV2 {
-			response := generateListObjectsV2Response(bucket, prefix, token, startAfter, delimiter, maxkeys, listObjectsInfo)
-			encodedSuccessResponse = encodeResponse(response)
-		} else {
-			response := generateListObjectsResponse(bucket, prefix, marker, delimiter, maxkeys, listObjectsInfo)
-			encodedSuccessResponse = encodeResponse(response)
-		}
-		// Write headers
-		setCommonHeaders(w)
-		// Write success response.
-		writeSuccessResponse(w, encodedSuccessResponse)
-		return
-	}
-	errorIf(err, "Unable to list objects.")
-	writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
-}
-
 // 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 objectAPIHandlers) ListBucketsHandler(w http.ResponseWriter, r *http.Request) {
-	// List buckets does not support bucket policies.
-	switch getRequestAuthType(r) {
-	default:
-		// For all unknown auth types return error.
-		writeErrorResponse(w, r, ErrAccessDenied, r.URL.Path)
+	// List buckets does not support bucket policies, no need to enforce it.
+	if s3Error := checkAuth(r); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
 		return
-	case authTypeSigned, authTypePresigned:
-		payload, e := ioutil.ReadAll(r.Body)
-		if e != nil {
-			writeErrorResponse(w, r, ErrInternalError, r.URL.Path)
-			return
-		}
-		// Verify Content-Md5, if payload is set.
-		if r.Header.Get("Content-Md5") != "" {
-			if r.Header.Get("Content-Md5") != base64.StdEncoding.EncodeToString(sumMD5(payload)) {
-				writeErrorResponse(w, r, ErrBadDigest, r.URL.Path)
-				return
-			}
-		}
-		// Populate back the payload.
-		r.Body = ioutil.NopCloser(bytes.NewReader(payload))
-		var s3Error APIErrorCode // API error code.
-		validateRegion := false  // Validate region.
-		if isRequestSignatureV4(r) {
-			s3Error = doesSignatureMatch(hex.EncodeToString(sum256(payload)), r, validateRegion)
-		} else if isRequestPresignedSignatureV4(r) {
-			s3Error = doesPresignedSignatureMatch(hex.EncodeToString(sum256(payload)), r, validateRegion)
-		}
-		if s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
 	}

 	bucketsInfo, err := api.ObjectAPI.ListBuckets()
-	if err == nil {
-		// generate response
-		response := generateListBucketsResponse(bucketsInfo)
-		encodedSuccessResponse := encodeResponse(response)
-		// write headers
-		setCommonHeaders(w)
-		// write response
-		writeSuccessResponse(w, encodedSuccessResponse)
+	if err != nil {
+		errorIf(err, "Unable to list buckets.")
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
 		return
 	}
-	errorIf(err, "Unable to list buckets.")
-	writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
+
+	// Generate response.
+	response := generateListBucketsResponse(bucketsInfo)
+	encodedSuccessResponse := encodeResponse(response)
+	// Write headers.
+	setCommonHeaders(w)
+	// Write response.
+	writeSuccessResponse(w, encodedSuccessResponse)
 }

 // DeleteMultipleObjectsHandler - deletes multiple objects.
@@ -342,7 +196,7 @@ func (api objectAPIHandlers) DeleteMultipleObjectsHandler(w http.ResponseWriter,
 		return
 	case authTypeAnonymous:
 		// http://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html
-		if s3Error := enforceBucketPolicy("s3:DeleteObject", bucket, r.URL); s3Error != ErrNone {
+		if s3Error := enforceBucketPolicy(bucket, "s3:DeleteObject", r.URL); s3Error != ErrNone {
 			writeErrorResponse(w, r, s3Error, r.URL.Path)
 			return
 		}
@@ -416,31 +270,22 @@ func (api objectAPIHandlers) DeleteMultipleObjectsHandler(w http.ResponseWriter,
 // ----------
 // This implementation of the PUT operation creates a new bucket for authenticated request
 func (api objectAPIHandlers) PutBucketHandler(w http.ResponseWriter, r *http.Request) {
+	// PutBucket does not support policies, use checkAuth to validate signature.
+	if s3Error := checkAuth(r); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
+		return
+	}
+
 	vars := mux.Vars(r)
 	bucket := vars["bucket"]

-	// Set http request for signature.
-	switch getRequestAuthType(r) {
-	default:
-		// For all unknown auth types return error.
-		writeErrorResponse(w, r, ErrAccessDenied, r.URL.Path)
-		return
-	case authTypePresigned, authTypeSigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
+	// Validate if incoming location constraint is valid, reject
+	// requests which do not follow valid region requirements.
+	if s3Error := isValidLocationConstraint(r); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
 	}

-	// the location value in the request body should match the Region in serverConfig.
-	// other values of location are not accepted.
-	// make bucket fails in such cases.
-	errCode := isValidLocationContraint(r.Body, serverConfig.GetRegion())
-	if errCode != ErrNone {
-		writeErrorResponse(w, r, errCode, r.URL.Path)
-		return
-	}
-	// Make bucket.
+	// Proceed to creating a bucket.
 	err := api.ObjectAPI.MakeBucket(bucket)
 	if err != nil {
 		errorIf(err, "Unable to create a bucket.")
@@ -452,32 +297,6 @@ func (api objectAPIHandlers) PutBucketHandler(w http.ResponseWriter, r *http.Req
 	writeSuccessResponse(w, nil)
 }

-func extractHTTPFormValues(reader *multipart.Reader) (io.Reader, map[string]string, error) {
-	/// HTML Form values
-	formValues := make(map[string]string)
-	filePart := new(bytes.Buffer)
-	var err error
-	for err == nil {
-		var part *multipart.Part
-		part, err = reader.NextPart()
-		if part != nil {
-			if part.FileName() == "" {
-				var buffer []byte
-				buffer, err = ioutil.ReadAll(part)
-				if err != nil {
-					return nil, nil, err
-				}
-				formValues[http.CanonicalHeaderKey(part.FormName())] = string(buffer)
-			} else {
-				if _, err = io.Copy(filePart, part); err != nil {
-					return nil, nil, err
-				}
-			}
-		}
-	}
-	return filePart, formValues, nil
-}
-
 // PostPolicyBucketHandler - POST policy
 // ----------
 // This implementation of the POST operation handles object creation with a specified
@@ -492,7 +311,7 @@ func (api objectAPIHandlers) PostPolicyBucketHandler(w http.ResponseWriter, r *h
 		return
 	}

-	fileBody, formValues, err := extractHTTPFormValues(reader)
+	fileBody, fileName, formValues, err := extractPostPolicyFormValues(reader)
 	if err != nil {
 		errorIf(err, "Unable to parse form values.")
 		writeErrorResponse(w, r, ErrMalformedPOSTRequest, r.URL.Path)
@@ -502,6 +321,12 @@ func (api objectAPIHandlers) PostPolicyBucketHandler(w http.ResponseWriter, r *h
 	formValues["Bucket"] = bucket
 	object := formValues["Key"]

+	if fileName != "" && strings.Contains(object, "${filename}") {
+		// S3 feature to replace ${filename} found in Key form field
+		// by the filename attribute passed in multipart
+		object = strings.Replace(object, "${filename}", fileName, -1)
+	}
+
 	// Verify policy signature.
 	apiErr := doesPolicySignatureMatch(formValues)
 	if apiErr != ErrNone {
@@ -532,8 +357,29 @@ func (api objectAPIHandlers) PostPolicyBucketHandler(w http.ResponseWriter, r *h
 		Key:      object,
 		ETag:     md5Sum,
 	})
+
 	setCommonHeaders(w)
+
 	writeSuccessResponse(w, encodedSuccessResponse)
+
+	// Fetch object info for notifications.
+	objInfo, err := api.ObjectAPI.GetObjectInfo(bucket, object)
+	if err != nil {
+		errorIf(err, "Unable to fetch object info for \"%s\"", path.Join(bucket, object))
+		return
+	}
+
+	if eventN.IsBucketNotificationSet(bucket) {
+		// Notify object created event.
+		eventNotify(eventData{
+			Type:    ObjectCreatedPost,
+			Bucket:  bucket,
+			ObjInfo: objInfo,
+			ReqParams: map[string]string{
+				"sourceIPAddress": r.RemoteAddr,
+			},
+		})
+	}
 }

 // HeadBucketHandler - HEAD Bucket
@@ -553,7 +399,7 @@ func (api objectAPIHandlers) HeadBucketHandler(w http.ResponseWriter, r *http.Re
 		return
 	case authTypeAnonymous:
 		// http://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html
-		if s3Error := enforceBucketPolicy("s3:ListBucket", bucket, r.URL); s3Error != ErrNone {
+		if s3Error := enforceBucketPolicy(bucket, "s3:ListBucket", r.URL); s3Error != ErrNone {
 			writeErrorResponse(w, r, s3Error, r.URL.Path)
 			return
 		}
@@ -574,21 +420,16 @@ func (api objectAPIHandlers) HeadBucketHandler(w http.ResponseWriter, r *http.Re

 // DeleteBucketHandler - Delete bucket
 func (api objectAPIHandlers) DeleteBucketHandler(w http.ResponseWriter, r *http.Request) {
+	// DeleteBucket does not support bucket policies, use checkAuth to validate signature.
+	if s3Error := checkAuth(r); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
+		return
+	}
+
 	vars := mux.Vars(r)
 	bucket := vars["bucket"]

-	switch getRequestAuthType(r) {
-	default:
-		// For all unknown auth types return error.
-		writeErrorResponse(w, r, ErrAccessDenied, r.URL.Path)
-		return
-	case authTypePresigned, authTypeSigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-
+	// Attempt to delete bucket.
 	if err := api.ObjectAPI.DeleteBucket(bucket); err != nil {
 		errorIf(err, "Unable to delete a bucket.")
 		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
@@ -596,7 +437,10 @@ func (api objectAPIHandlers) DeleteBucketHandler(w http.ResponseWriter, r *http.
 	}

 	// Delete bucket access policy, if present - ignore any errors.
-	removeBucketPolicy(bucket)
+	removeBucketPolicy(bucket, api.ObjectAPI)
+
+	// Delete notification config, if present - ignore any errors.
+	removeNotificationConfig(bucket, api.ObjectAPI)

 	// Write success response.
 	writeSuccessNoContent(w)
@@ -0,0 +1,178 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"encoding/xml"
+	"errors"
+)
+
+// Represents the criteria for the filter rule.
+type filterRule struct {
+	Name  string `xml:"Name"`
+	Value string `xml:"Value"`
+}
+
+// Collection of filter rules per service config.
+type keyFilter struct {
+	FilterRules []filterRule `xml:"FilterRule,omitempty"`
+}
+
+// Queue SQS configuration.
+type queueConfig struct {
+	Events []string `xml:"Event"`
+	Filter struct {
+		Key keyFilter `xml:"S3Key,omitempty"`
+	}
+	ID       string `xml:"Id"`
+	QueueARN string `xml:"Queue"`
+}
+
+// Topic SNS configuration, this is a compliance field not used by minio yet.
+type topicConfig struct {
+	Events []string `xml:"Event"`
+	Filter struct {
+		Key keyFilter `xml:"S3Key"`
+	}
+	ID       string `xml:"Id"`
+	TopicARN string `xml:"Topic"`
+}
+
+// Lambda function configuration, this is a compliance field not used by minio yet.
+type lambdaConfig struct {
+	Events []string `xml:"Event"`
+	Filter struct {
+		Key keyFilter `xml:"S3Key,omitempty"`
+	}
+	ID        string `xml:"Id"`
+	LambdaARN string `xml:"CloudFunction"`
+}
+
+// Notification configuration structure represents the XML format of
+// notification configuration of buckets.
+type notificationConfig struct {
+	XMLName       xml.Name       `xml:"NotificationConfiguration"`
+	QueueConfigs  []queueConfig  `xml:"QueueConfiguration"`
+	TopicConfigs  []topicConfig  `xml:"TopicConfiguration"`
+	LambdaConfigs []lambdaConfig `xml:"CloudFunctionConfiguration"`
+}
+
+// Internal error used to signal notifications not set.
+var errNoSuchNotifications = errors.New("The specified bucket does not have bucket notifications")
+
+// EventName is AWS S3 event type:
+// http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html
+type EventName int
+
+const (
+	// ObjectCreatedPut is s3:ObjectCreated:Put
+	ObjectCreatedPut EventName = iota
+	// ObjectCreatedPost is s3:ObjectCreated:Post
+	ObjectCreatedPost
+	// ObjectCreatedCopy is s3:ObjectCreated:Copy
+	ObjectCreatedCopy
+	// ObjectCreatedCompleteMultipartUpload is s3:ObjectCreated:CompleteMultipartUpload
+	ObjectCreatedCompleteMultipartUpload
+	// ObjectRemovedDelete is s3:ObjectRemoved:Delete
+	ObjectRemovedDelete
+)
+
+// Stringer interface for event name.
+func (eventName EventName) String() string {
+	switch eventName {
+	case ObjectCreatedPut:
+		return "s3:ObjectCreated:Put"
+	case ObjectCreatedPost:
+		return "s3:ObjectCreated:Post"
+	case ObjectCreatedCopy:
+		return "s3:ObjectCreated:Copy"
+	case ObjectCreatedCompleteMultipartUpload:
+		return "s3:ObjectCreated:CompleteMultipartUpload"
+	case ObjectRemovedDelete:
+		return "s3:ObjectRemoved:Delete"
+	default:
+		return "s3:Unknown"
+	}
+}
+
+// Indentity represents the user id, this is a compliance field.
+type identity struct {
+	PrincipalID string `json:"principalId"`
+}
+
+func defaultIdentity() identity {
+	return identity{"minio"}
+}
+
+// Notification event bucket metadata.
+type bucketMeta struct {
+	Name          string   `json:"name"`
+	OwnerIdentity identity `json:"ownerIdentity"`
+	ARN           string   `json:"arn"`
+}
+
+// Notification event object metadata.
+type objectMeta struct {
+	Key       string `json:"key"`
+	Size      int64  `json:"size,omitempty"`
+	ETag      string `json:"eTag,omitempty"`
+	VersionID string `json:"versionId,omitempty"`
+	Sequencer string `json:"sequencer"`
+}
+
+// Notification event server specific metadata.
+type eventMeta struct {
+	SchemaVersion   string     `json:"s3SchemaVersion"`
+	ConfigurationID string     `json:"configurationId"`
+	Bucket          bucketMeta `json:"bucket"`
+	Object          objectMeta `json:"object"`
+}
+
+// NotificationEvent represents an Amazon an S3 bucket notification event.
+type NotificationEvent struct {
+	EventVersion      string            `json:"eventVersion"`
+	EventSource       string            `json:"eventSource"`
+	AwsRegion         string            `json:"awsRegion"`
+	EventTime         string            `json:"eventTime"`
+	EventName         string            `json:"eventName"`
+	UserIdentity      identity          `json:"userIdentity"`
+	RequestParameters map[string]string `json:"requestParameters"`
+	ResponseElements  map[string]string `json:"responseElements"`
+	S3                eventMeta         `json:"s3"`
+}
+
+// Represents the minio topic type and account id's.
+type arnTopic struct {
+	Type      string
+	AccountID string
+}
+
+// Stringer for constructing AWS ARN compatible string.
+func (m arnTopic) String() string {
+	return minioTopic + serverConfig.GetRegion() + ":" + m.AccountID + ":" + m.Type
+}
+
+// Represents the minio sqs type and account id's.
+type arnSQS struct {
+	Type      string
+	AccountID string
+}
+
+// Stringer for constructing AWS ARN compatible string.
+func (m arnSQS) String() string {
+	return minioSqs + serverConfig.GetRegion() + ":" + m.AccountID + ":" + m.Type
+}
@@ -0,0 +1,269 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"io"
+	"net/http"
+	"path"
+	"time"
+
+	"github.com/gorilla/mux"
+)
+
+const (
+	bucketConfigPrefix       = "buckets"
+	bucketNotificationConfig = "notification.xml"
+)
+
+// GetBucketNotificationHandler - This implementation of the GET
+// operation uses the notification subresource to return the
+// notification configuration of a bucket. If notifications are
+// not enabled on the bucket, the operation returns an empty
+// NotificationConfiguration element.
+func (api objectAPIHandlers) GetBucketNotificationHandler(w http.ResponseWriter, r *http.Request) {
+	// Validate request authorization.
+	if s3Error := checkAuth(r); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
+		return
+	}
+	vars := mux.Vars(r)
+	bucket := vars["bucket"]
+	// Attempt to successfully load notification config.
+	nConfig, err := loadNotificationConfig(bucket, api.ObjectAPI)
+	if err != nil && err != errNoSuchNotifications {
+		errorIf(err, "Unable to read notification configuration.")
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
+		return
+	}
+	// For no notifications we write a dummy XML.
+	if err == errNoSuchNotifications {
+		// Complies with the s3 behavior in this regard.
+		nConfig = &notificationConfig{}
+	}
+	notificationBytes, err := xml.Marshal(nConfig)
+	if err != nil {
+		// For any marshalling failure.
+		errorIf(err, "Unable to marshal notification configuration into XML.", err)
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
+		return
+	}
+	// Success.
+	writeSuccessResponse(w, notificationBytes)
+}
+
+// PutBucketNotificationHandler - Minio notification feature enables
+// you to receive notifications when certain events happen in your bucket.
+// Using this API, you can replace an existing notification configuration.
+// The configuration is an XML file that defines the event types that you
+// want Minio to publish and the destination where you want Minio to publish
+// an event notification when it detects an event of the specified type.
+// By default, your bucket has no event notifications configured. That is,
+// the notification configuration will be an empty NotificationConfiguration.
+func (api objectAPIHandlers) PutBucketNotificationHandler(w http.ResponseWriter, r *http.Request) {
+	// Validate request authorization.
+	if s3Error := checkAuth(r); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
+		return
+	}
+	vars := mux.Vars(r)
+	bucket := vars["bucket"]
+
+	_, err := api.ObjectAPI.GetBucketInfo(bucket)
+	if err != nil {
+		errorIf(err, "Unable to bucket info.")
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
+		return
+	}
+
+	// If Content-Length is unknown or zero, deny the request. PutBucketNotification
+	// always needs a Content-Length if incoming request is not chunked.
+	if !contains(r.TransferEncoding, "chunked") {
+		if r.ContentLength == -1 {
+			writeErrorResponse(w, r, ErrMissingContentLength, r.URL.Path)
+			return
+		}
+	}
+
+	// Reads the incoming notification configuration.
+	var buffer bytes.Buffer
+	var bufferSize int64
+	if r.ContentLength >= 0 {
+		bufferSize, err = io.CopyN(&buffer, r.Body, r.ContentLength)
+	} else {
+		bufferSize, err = io.Copy(&buffer, r.Body)
+	}
+	if err != nil {
+		errorIf(err, "Unable to read incoming body.")
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
+		return
+	}
+
+	var notificationCfg notificationConfig
+	// Unmarshal notification bytes.
+	notificationConfigBytes := buffer.Bytes()
+	if err = xml.Unmarshal(notificationConfigBytes, &notificationCfg); err != nil {
+		errorIf(err, "Unable to parse notification configuration XML.")
+		writeErrorResponse(w, r, ErrMalformedXML, r.URL.Path)
+		return
+	} // Successfully marshalled notification configuration.
+
+	// Validate unmarshalled bucket notification configuration.
+	if s3Error := validateNotificationConfig(notificationCfg); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
+		return
+	}
+
+	// Proceed to save notification configuration.
+	notificationConfigPath := path.Join(bucketConfigPrefix, bucket, bucketNotificationConfig)
+	_, err = api.ObjectAPI.PutObject(minioMetaBucket, notificationConfigPath, bufferSize, bytes.NewReader(buffer.Bytes()), nil)
+	if err != nil {
+		errorIf(err, "Unable to write bucket notification configuration.")
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
+		return
+	}
+
+	// Set bucket notification config.
+	eventN.SetBucketNotificationConfig(bucket, &notificationCfg)
+
+	// Success.
+	writeSuccessResponse(w, nil)
+}
+
+// writeNotification marshals notification message before writing to client.
+func writeNotification(w http.ResponseWriter, notification map[string][]NotificationEvent) error {
+	// Invalid response writer.
+	if w == nil {
+		return errInvalidArgument
+	}
+	// Invalid notification input.
+	if notification == nil {
+		return errInvalidArgument
+	}
+	// Marshal notification data into XML and write to client.
+	notificationBytes, err := json.Marshal(&notification)
+	if err != nil {
+		return err
+	}
+	// Add additional CRLF characters for client to
+	// differentiate the individual events properly.
+	_, err = w.Write(append(notificationBytes, crlf...))
+	// Make sure we have flushed, this would set Transfer-Encoding: chunked.
+	w.(http.Flusher).Flush()
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// CRLF character used for chunked transfer in accordance with HTTP standards.
+var crlf = []byte("\r\n")
+
+// sendBucketNotification - writes notification back to client on the response writer
+// for each notification input, otherwise writes whitespace characters periodically
+// to keep the connection active. Each notification messages are terminated by CRLF
+// character. Upon any error received on response writer the for loop exits.
+//
+// TODO - do not log for all errors.
+func sendBucketNotification(w http.ResponseWriter, arnListenerCh <-chan []NotificationEvent) {
+	var dummyEvents = map[string][]NotificationEvent{"Records": nil}
+	// Continuously write to client either timely empty structures
+	// every 5 seconds, or return back the notifications.
+	for {
+		select {
+		case events := <-arnListenerCh:
+			if err := writeNotification(w, map[string][]NotificationEvent{"Records": events}); err != nil {
+				errorIf(err, "Unable to write notification to client.")
+				return
+			}
+		case <-time.After(5 * time.Second):
+			if err := writeNotification(w, dummyEvents); err != nil {
+				errorIf(err, "Unable to write notification to client.")
+				return
+			}
+		}
+	}
+}
+
+// ListenBucketNotificationHandler - list bucket notifications.
+func (api objectAPIHandlers) ListenBucketNotificationHandler(w http.ResponseWriter, r *http.Request) {
+	// Validate request authorization.
+	if s3Error := checkAuth(r); s3Error != ErrNone {
+		writeErrorResponse(w, r, s3Error, r.URL.Path)
+		return
+	}
+	vars := mux.Vars(r)
+	bucket := vars["bucket"]
+
+	// Get notification ARN.
+	topicARN := r.URL.Query().Get("notificationARN")
+	if topicARN == "" {
+		writeErrorResponse(w, r, ErrARNNotification, r.URL.Path)
+		return
+	}
+
+	// Validate if bucket exists.
+	_, err := api.ObjectAPI.GetBucketInfo(bucket)
+	if err != nil {
+		errorIf(err, "Unable to bucket info.")
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
+		return
+	}
+
+	notificationCfg := eventN.GetBucketNotificationConfig(bucket)
+	if notificationCfg == nil {
+		writeErrorResponse(w, r, ErrARNNotification, r.URL.Path)
+		return
+	}
+
+	// Set SNS notifications only if special "listen" sns is set in bucket
+	// notification configs.
+	if !isMinioSNSConfigured(topicARN, notificationCfg.TopicConfigs) {
+		writeErrorResponse(w, r, ErrARNNotification, r.URL.Path)
+		return
+	}
+
+	// Add all common headers.
+	setCommonHeaders(w)
+
+	// Create a new notification event channel.
+	nEventCh := make(chan []NotificationEvent)
+	// Close the listener channel.
+	defer close(nEventCh)
+
+	// Set sns target.
+	eventN.SetSNSTarget(topicARN, nEventCh)
+	// Remove sns listener after the writer has closed or the client disconnected.
+	defer eventN.RemoveSNSTarget(topicARN, nEventCh)
+
+	// Start sending bucket notifications.
+	sendBucketNotification(w, nEventCh)
+}
+
+// Removes notification.xml for a given bucket, only used during DeleteBucket.
+func removeNotificationConfig(bucket string, objAPI ObjectLayer) error {
+	// Verify bucket is valid.
+	if !IsValidBucketName(bucket) {
+		return BucketNameInvalid{Bucket: bucket}
+	}
+
+	notificationConfigPath := path.Join(bucketConfigPrefix, bucket, bucketNotificationConfig)
+	return objAPI.DeleteObject(minioMetaBucket, notificationConfigPath)
+}
@@ -0,0 +1,90 @@
+package main
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"testing"
+)
+
+// Implement a dummy flush writer.
+type flushWriter struct {
+	io.Writer
+}
+
+// Flush writer is a dummy writer compatible with http.Flusher and http.ResponseWriter.
+func (f *flushWriter) Flush()                            {}
+func (f *flushWriter) Write(b []byte) (n int, err error) { return f.Writer.Write(b) }
+func (f *flushWriter) Header() http.Header               { return http.Header{} }
+func (f *flushWriter) WriteHeader(code int)              {}
+
+func newFlushWriter(writer io.Writer) *flushWriter {
+	return &flushWriter{writer}
+}
+
+// Tests write notification code.
+func TestWriteNotification(t *testing.T) {
+	// Initialize a new test config.
+	root, err := newTestConfig("us-east-1")
+	if err != nil {
+		t.Fatalf("Unable to initialize test config %s", err)
+	}
+	defer removeAll(root)
+
+	var buffer bytes.Buffer
+	// Collection of test cases for each event writer.
+	testCases := []struct {
+		writer *flushWriter
+		event  map[string][]NotificationEvent
+		err    error
+	}{
+		// Invalid input argument with writer `nil` - Test - 1
+		{
+			writer: nil,
+			event:  nil,
+			err:    errInvalidArgument,
+		},
+		// Invalid input argument with event `nil` - Test - 2
+		{
+			writer: newFlushWriter(ioutil.Discard),
+			event:  nil,
+			err:    errInvalidArgument,
+		},
+		// Unmarshal and write, validate last 5 bytes. - Test - 3
+		{
+			writer: newFlushWriter(&buffer),
+			event: map[string][]NotificationEvent{
+				"Records": {newNotificationEvent(eventData{
+					Type:   ObjectCreatedPut,
+					Bucket: "testbucket",
+					ObjInfo: ObjectInfo{
+						Name: "key",
+					},
+					ReqParams: map[string]string{
+						"ip": "10.1.10.1",
+					}}),
+				},
+			},
+			err: nil,
+		},
+	}
+	// Validates all the testcases for writing notification.
+	for _, testCase := range testCases {
+		err := writeNotification(testCase.writer, testCase.event)
+		if err != testCase.err {
+			t.Errorf("Unable to write notification %s", err)
+		}
+		// Validates if the ending string has 'crlf'
+		if err == nil && !bytes.HasSuffix(buffer.Bytes(), crlf) {
+			buf := buffer.Bytes()[buffer.Len()-5 : 0]
+			t.Errorf("Invalid suffix found from the writer last 5 bytes %s, expected `\r\n`", string(buf))
+		}
+		// Not printing 'buf' on purpose, validates look for string '10.1.10.1'.
+		if err == nil && !bytes.Contains(buffer.Bytes(), []byte("10.1.10.1")) {
+			// Enable when debugging)
+			// fmt.Println(string(buffer.Bytes()))
+			t.Errorf("Requested content couldn't be found, expected `10.1.10.1`")
+		}
+	}
+}
@@ -0,0 +1,313 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import "strings"
+
+// List of valid event types.
+var suppportedEventTypes = map[string]struct{}{
+	// Object created event types.
+	"s3:ObjectCreated:*":                       {},
+	"s3:ObjectCreated:Put":                     {},
+	"s3:ObjectCreated:Post":                    {},
+	"s3:ObjectCreated:Copy":                    {},
+	"s3:ObjectCreated:CompleteMultipartUpload": {},
+	// Object removed event types.
+	"s3:ObjectRemoved:*":      {},
+	"s3:ObjectRemoved:Delete": {},
+}
+
+// checkEvent - checks if an event is supported.
+func checkEvent(event string) APIErrorCode {
+	_, ok := suppportedEventTypes[event]
+	if !ok {
+		return ErrEventNotification
+	}
+	return ErrNone
+}
+
+// checkEvents - checks given list of events if all of them are valid.
+// given if one of them is invalid, this function returns an error.
+func checkEvents(events []string) APIErrorCode {
+	for _, event := range events {
+		if s3Error := checkEvent(event); s3Error != ErrNone {
+			return s3Error
+		}
+	}
+	return ErrNone
+}
+
+// Valid if filterName is 'prefix'.
+func isValidFilterNamePrefix(filterName string) bool {
+	return "prefix" == filterName
+}
+
+// Valid if filterName is 'suffix'.
+func isValidFilterNameSuffix(filterName string) bool {
+	return "suffix" == filterName
+}
+
+// Is this a valid filterName? - returns true if valid.
+func isValidFilterName(filterName string) bool {
+	return isValidFilterNamePrefix(filterName) || isValidFilterNameSuffix(filterName)
+}
+
+// checkFilterRules - checks given list of filter rules if all of them are valid.
+func checkFilterRules(filterRules []filterRule) APIErrorCode {
+	ruleSetMap := make(map[string]string)
+	// Validate all filter rules.
+	for _, filterRule := range filterRules {
+		// Unknown filter rule name found, returns an appropriate error.
+		if !isValidFilterName(filterRule.Name) {
+			return ErrFilterNameInvalid
+		}
+
+		// Filter names should not be set twice per notification service
+		// configuration, if found return an appropriate error.
+		if _, ok := ruleSetMap[filterRule.Name]; ok {
+			if isValidFilterNamePrefix(filterRule.Name) {
+				return ErrFilterNamePrefix
+			} else if isValidFilterNameSuffix(filterRule.Name) {
+				return ErrFilterNameSuffix
+			} else {
+				return ErrFilterNameInvalid
+			}
+		}
+
+		// Maximum prefix length can be up to 1,024 characters, validate.
+		if !IsValidObjectPrefix(filterRule.Value) {
+			return ErrFilterPrefixValueInvalid
+		}
+
+		// Set the new rule name to keep track of duplicates.
+		ruleSetMap[filterRule.Name] = filterRule.Value
+	}
+	// Success all prefixes validated.
+	return ErrNone
+}
+
+// checkQueueARN - check if the queue arn is valid.
+func checkQueueARN(queueARN string) APIErrorCode {
+	if !strings.HasPrefix(queueARN, minioSqs) {
+		return ErrARNNotification
+	}
+	if !strings.HasPrefix(queueARN, minioSqs+serverConfig.GetRegion()+":") {
+		return ErrRegionNotification
+	}
+	return ErrNone
+}
+
+// checkTopicARN - check if the topic arn is valid.
+func checkTopicARN(topicARN string) APIErrorCode {
+	if !strings.HasPrefix(topicARN, minioTopic) {
+		return ErrARNNotification
+	}
+	if !strings.HasPrefix(topicARN, minioTopic+serverConfig.GetRegion()+":") {
+		return ErrRegionNotification
+	}
+	return ErrNone
+}
+
+// Returns true if the topicARN is for an Minio sns listen type.
+func isMinioSNS(topicARN arnTopic) bool {
+	return strings.HasSuffix(topicARN.Type, snsTypeMinio)
+}
+
+// isMinioSNSConfigured - verifies if one topic ARN is valid and is enabled.
+func isMinioSNSConfigured(topicARN string, topicConfigs []topicConfig) bool {
+	for _, topicConfig := range topicConfigs {
+		// Validate if topic ARN is already enabled.
+		if topicARN == topicConfig.TopicARN {
+			return true
+		}
+	}
+	return false
+}
+
+// Validate if we recognize the queue type.
+func isValidQueue(sqsARN arnSQS) bool {
+	amqpQ := isAMQPQueue(sqsARN)       // Is amqp queue?.
+	elasticQ := isElasticQueue(sqsARN) // Is elastic queue?.
+	redisQ := isRedisQueue(sqsARN)     // Is redis queue?.
+	return amqpQ || elasticQ || redisQ
+}
+
+// Validate if we recognize the topic type.
+func isValidTopic(topicARN arnTopic) bool {
+	return isMinioSNS(topicARN) // Is minio topic?.
+}
+
+// Validates account id for input queue ARN.
+func isValidQueueID(queueARN string) bool {
+	// Unmarshals QueueARN into structured object.
+	sqsARN := unmarshalSqsARN(queueARN)
+	// AMQP queue.
+	if isAMQPQueue(sqsARN) {
+		amqpN := serverConfig.GetAMQPNotifyByID(sqsARN.AccountID)
+		return amqpN.Enable && amqpN.URL != ""
+	} else if isElasticQueue(sqsARN) { // Elastic queue.
+		elasticN := serverConfig.GetElasticSearchNotifyByID(sqsARN.AccountID)
+		return elasticN.Enable && elasticN.URL != ""
+
+	} else if isRedisQueue(sqsARN) { // Redis queue.
+		redisN := serverConfig.GetRedisNotifyByID(sqsARN.AccountID)
+		return redisN.Enable && redisN.Addr != ""
+	}
+	return false
+}
+
+// Check - validates queue configuration and returns error if any.
+func checkQueueConfig(qConfig queueConfig) APIErrorCode {
+	// Check queue arn is valid.
+	if s3Error := checkQueueARN(qConfig.QueueARN); s3Error != ErrNone {
+		return s3Error
+	}
+
+	// Unmarshals QueueARN into structured object.
+	sqsARN := unmarshalSqsARN(qConfig.QueueARN)
+	// Validate if sqsARN requested any of the known supported queues.
+	if !isValidQueue(sqsARN) {
+		return ErrARNNotification
+	}
+
+	// Validate if the account ID is correct.
+	if !isValidQueueID(qConfig.QueueARN) {
+		return ErrARNNotification
+	}
+
+	// Check if valid events are set in queue config.
+	if s3Error := checkEvents(qConfig.Events); s3Error != ErrNone {
+		return s3Error
+	}
+
+	// Check if valid filters are set in queue config.
+	if s3Error := checkFilterRules(qConfig.Filter.Key.FilterRules); s3Error != ErrNone {
+		return s3Error
+	}
+
+	// Success.
+	return ErrNone
+}
+
+// Check - validates queue configuration and returns error if any.
+func checkTopicConfig(tConfig topicConfig) APIErrorCode {
+	// Check queue arn is valid.
+	if s3Error := checkTopicARN(tConfig.TopicARN); s3Error != ErrNone {
+		return s3Error
+	}
+
+	// Unmarshals QueueARN into structured object.
+	topicARN := unmarshalTopicARN(tConfig.TopicARN)
+	// Validate if topicARN requested any of the known supported queues.
+	if !isValidTopic(topicARN) {
+		return ErrARNNotification
+	}
+
+	// Check if valid events are set in queue config.
+	if s3Error := checkEvents(tConfig.Events); s3Error != ErrNone {
+		return s3Error
+	}
+
+	// Check if valid filters are set in queue config.
+	if s3Error := checkFilterRules(tConfig.Filter.Key.FilterRules); s3Error != ErrNone {
+		return s3Error
+	}
+
+	// Success.
+	return ErrNone
+}
+
+// Validates all incoming queue configs, checkQueueConfig validates if the
+// input fields for each queues is not malformed and has valid configuration
+// information.  If validation fails bucket notifications are not enabled.
+func validateQueueConfigs(queueConfigs []queueConfig) APIErrorCode {
+	for _, qConfig := range queueConfigs {
+		if s3Error := checkQueueConfig(qConfig); s3Error != ErrNone {
+			return s3Error
+		}
+	}
+	// Success.
+	return ErrNone
+}
+
+// Validates all incoming topic configs, checkTopicConfig validates if the
+// input fields for each queues is not malformed and has valid configuration
+// information.  If validation fails bucket notifications are not enabled.
+func validateTopicConfigs(topicConfigs []topicConfig) APIErrorCode {
+	for _, tConfig := range topicConfigs {
+		if s3Error := checkTopicConfig(tConfig); s3Error != ErrNone {
+			return s3Error
+		}
+	}
+	// Success.
+	return ErrNone
+}
+
+// Validates all the bucket notification configuration for their validity,
+// if one of the config is malformed or has invalid data it is rejected.
+// Configuration is never applied partially.
+func validateNotificationConfig(nConfig notificationConfig) APIErrorCode {
+	if s3Error := validateQueueConfigs(nConfig.QueueConfigs); s3Error != ErrNone {
+		return s3Error
+	}
+	if s3Error := validateTopicConfigs(nConfig.TopicConfigs); s3Error != ErrNone {
+		return s3Error
+	}
+
+	// Add validation for other configurations.
+	return ErrNone
+}
+
+// Unmarshals input value of AWS ARN format into minioTopic object.
+// Returned value represents minio topic type, currently supported are
+// - listen
+func unmarshalTopicARN(topicARN string) arnTopic {
+	topic := arnTopic{}
+	if !strings.HasPrefix(topicARN, minioTopic+serverConfig.GetRegion()+":") {
+		return topic
+	}
+	topicType := strings.TrimPrefix(topicARN, minioTopic+serverConfig.GetRegion()+":")
+	switch {
+	case strings.HasSuffix(topicType, snsTypeMinio):
+		topic.Type = snsTypeMinio
+	} // Add more topic here.
+	topic.AccountID = strings.TrimSuffix(topicType, ":"+topic.Type)
+	return topic
+}
+
+// Unmarshals input value of AWS ARN format into minioSqs object.
+// Returned value represents minio sqs types, currently supported are
+// - amqp
+// - elasticsearch
+// - redis
+func unmarshalSqsARN(queueARN string) (mSqs arnSQS) {
+	mSqs = arnSQS{}
+	if !strings.HasPrefix(queueARN, minioSqs+serverConfig.GetRegion()+":") {
+		return mSqs
+	}
+	sqsType := strings.TrimPrefix(queueARN, minioSqs+serverConfig.GetRegion()+":")
+	switch {
+	case strings.HasSuffix(sqsType, queueTypeAMQP):
+		mSqs.Type = queueTypeAMQP
+	case strings.HasSuffix(sqsType, queueTypeElastic):
+		mSqs.Type = queueTypeElastic
+	case strings.HasSuffix(sqsType, queueTypeRedis):
+		mSqs.Type = queueTypeRedis
+	} // Add more queues here.
+	mSqs.AccountID = strings.TrimSuffix(sqsType, ":"+mSqs.Type)
+	return mSqs
+}
@@ -0,0 +1,292 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import "testing"
+
+// Tests filter name validation.
+func TestIsValidFilterName(t *testing.T) {
+	testCases := []struct {
+		filterName string
+		status     bool
+	}{
+		// Validate if 'prefix' is correct.
+		{
+			filterName: "prefix",
+			status:     true,
+		},
+		// Validate if 'suffix' is correct.
+		{
+			filterName: "suffix",
+			status:     true,
+		},
+		// Invalid filter name empty string should return false.
+		{
+			filterName: "",
+			status:     false,
+		},
+		// Invalid filter name random character should return false.
+		{
+			filterName: "unknown",
+			status:     false,
+		},
+	}
+
+	for i, testCase := range testCases {
+		status := isValidFilterName(testCase.filterName)
+		if testCase.status != status {
+			t.Errorf("Test %d: Expected \"%t\", got \"%t\"", i+1, testCase.status, status)
+		}
+	}
+}
+
+// Tests list of valid and invalid events.
+func TestValidEvents(t *testing.T) {
+	testCases := []struct {
+		events  []string
+		errCode APIErrorCode
+	}{
+		// Return error for unknown event element.
+		{
+			events: []string{
+				"s3:UnknownAPI",
+			},
+			errCode: ErrEventNotification,
+		},
+		// Return success for supported event.
+		{
+			events: []string{
+				"s3:ObjectCreated:Put",
+			},
+			errCode: ErrNone,
+		},
+		// Return success for supported events.
+		{
+			events: []string{
+				"s3:ObjectCreated:*",
+				"s3:ObjectRemoved:*",
+			},
+			errCode: ErrNone,
+		},
+		// Return error for empty event list.
+		{
+			events:  []string{""},
+			errCode: ErrEventNotification,
+		},
+	}
+
+	for i, testCase := range testCases {
+		errCode := checkEvents(testCase.events)
+		if testCase.errCode != errCode {
+			t.Errorf("Test %d: Expected \"%d\", got \"%d\"", i+1, testCase.errCode, errCode)
+		}
+	}
+}
+
+// Tests topic arn validation.
+func TestTopicARN(t *testing.T) {
+	rootPath, err := newTestConfig("us-east-1")
+	if err != nil {
+		t.Fatalf("unable initialize config file, %s", err)
+	}
+	defer removeAll(rootPath)
+
+	testCases := []struct {
+		topicARN string
+		errCode  APIErrorCode
+	}{
+		// Valid minio topic with '1' account id.
+		{
+			topicARN: "arn:minio:sns:us-east-1:1:minio",
+			errCode:  ErrNone,
+		},
+		// Valid minio topic with '10' account id.
+		{
+			topicARN: "arn:minio:sns:us-east-1:10:minio",
+			errCode:  ErrNone,
+		},
+		// Invalid empty queue arn.
+		{
+			topicARN: "",
+			errCode:  ErrARNNotification,
+		},
+		// Invalid region 'us-west-1' in queue arn.
+		{
+			topicARN: "arn:minio:sns:us-west-1:1:redis",
+			errCode:  ErrRegionNotification,
+		},
+	}
+
+	for i, testCase := range testCases {
+		errCode := checkTopicARN(testCase.topicARN)
+		if testCase.errCode != errCode {
+			t.Errorf("Test %d: Expected \"%d\", got \"%d\"", i+1, testCase.errCode, errCode)
+		}
+	}
+}
+
+// Tests queue arn validation.
+func TestQueueARN(t *testing.T) {
+	rootPath, err := newTestConfig("us-east-1")
+	if err != nil {
+		t.Fatalf("unable initialize config file, %s", err)
+	}
+	defer removeAll(rootPath)
+
+	testCases := []struct {
+		queueARN string
+		errCode  APIErrorCode
+	}{
+		// Valid redis queue arn.
+		{
+			queueARN: "arn:minio:sqs:us-east-1:1:redis",
+			errCode:  ErrNone,
+		},
+		// Valid elasticsearch queue arn.
+		{
+			queueARN: "arn:minio:sqs:us-east-1:1:elasticsearch",
+			errCode:  ErrNone,
+		},
+		// Valid amqp queue arn.
+		{
+			queueARN: "arn:minio:sqs:us-east-1:1:amqp",
+			errCode:  ErrNone,
+		},
+		// Invalid empty queue arn.
+		{
+			queueARN: "",
+			errCode:  ErrARNNotification,
+		},
+		// Invalid region 'us-west-1' in queue arn.
+		{
+			queueARN: "arn:minio:sqs:us-west-1:1:redis",
+			errCode:  ErrRegionNotification,
+		},
+	}
+
+	for i, testCase := range testCases {
+		errCode := checkQueueARN(testCase.queueARN)
+		if testCase.errCode != errCode {
+			t.Errorf("Test %d: Expected \"%d\", got \"%d\"", i+1, testCase.errCode, errCode)
+		}
+	}
+}
+
+// Test unmarshal topic arn.
+func TestUnmarshalTopicARN(t *testing.T) {
+	rootPath, err := newTestConfig("us-east-1")
+	if err != nil {
+		t.Fatalf("unable initialize config file, %s", err)
+	}
+	defer removeAll(rootPath)
+
+	testCases := []struct {
+		topicARN string
+		Type     string
+	}{
+		// Valid minio topic arn.
+		{
+			topicARN: "arn:minio:sns:us-east-1:1:listen",
+			Type:     "listen",
+		},
+		// Invalid empty topic arn.
+		{
+			topicARN: "",
+			Type:     "",
+		},
+		// Invalid region 'us-west-1' in topic arn.
+		{
+			topicARN: "arn:minio:sns:us-west-1:1:listen",
+			Type:     "",
+		},
+		// Partial topic arn.
+		{
+			topicARN: "arn:minio:sns:",
+			Type:     "",
+		},
+		// Invalid topic service value.
+		{
+			topicARN: "arn:minio:sns:us-east-1:1:*",
+			Type:     "",
+		},
+	}
+
+	for i, testCase := range testCases {
+		topic := unmarshalTopicARN(testCase.topicARN)
+		if testCase.Type != topic.Type {
+			t.Errorf("Test %d: Expected \"%s\", got \"%s\"", i+1, testCase.Type, topic.Type)
+		}
+	}
+}
+
+// Test unmarshal queue arn.
+func TestUnmarshalSqsARN(t *testing.T) {
+	rootPath, err := newTestConfig("us-east-1")
+	if err != nil {
+		t.Fatalf("unable initialize config file, %s", err)
+	}
+	defer removeAll(rootPath)
+
+	testCases := []struct {
+		queueARN string
+		Type     string
+	}{
+		// Valid redis queue arn.
+		{
+			queueARN: "arn:minio:sqs:us-east-1:1:redis",
+			Type:     "redis",
+		},
+		// Valid elasticsearch queue arn.
+		{
+			queueARN: "arn:minio:sqs:us-east-1:1:elasticsearch",
+			Type:     "elasticsearch",
+		},
+		// Valid amqp queue arn.
+		{
+			queueARN: "arn:minio:sqs:us-east-1:1:amqp",
+			Type:     "amqp",
+		},
+		// Invalid empty queue arn.
+		{
+			queueARN: "",
+			Type:     "",
+		},
+		// Invalid region 'us-west-1' in queue arn.
+		{
+			queueARN: "arn:minio:sqs:us-west-1:1:redis",
+			Type:     "",
+		},
+		// Partial queue arn.
+		{
+			queueARN: "arn:minio:sqs:",
+			Type:     "",
+		},
+		// Invalid queue service value.
+		{
+			queueARN: "arn:minio:sqs:us-east-1:1:*",
+			Type:     "",
+		},
+	}
+
+	for i, testCase := range testCases {
+		mSqs := unmarshalSqsARN(testCase.queueARN)
+		if testCase.Type != mSqs.Type {
+			t.Errorf("Test %d: Expected \"%s\", got \"%s\"", i+1, testCase.Type, mSqs.Type)
+		}
+	}
+
+}
@@ -18,12 +18,13 @@ package main

 import (
 	"bytes"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"net/http"
-	"strings"

 	mux "github.com/gorilla/mux"
+	"github.com/minio/minio/pkg/wildcard"
 )

 // maximum supported access policy size.
@@ -71,41 +72,14 @@ func bucketPolicyActionMatch(action string, statement policyStatement) bool {
 	return false
 }

-// Match function matches wild cards in 'pattern' for 'text'.
-func wildCardMatch(pattern, text string) bool {
-	if pattern == "" {
-		return text == pattern
-	}
-	if pattern == "*" {
-		return true
-	}
-	parts := strings.Split(pattern, "*")
-	if len(parts) == 1 {
-		return text == pattern
-	}
-	tGlob := strings.HasSuffix(pattern, "*")
-	end := len(parts) - 1
-	if !strings.HasPrefix(text, parts[0]) {
-		return false
-	}
-	for i := 1; i < end; i++ {
-		if !strings.Contains(text, parts[i]) {
-			return false
-		}
-		idx := strings.Index(text, parts[i]) + len(parts[i])
-		text = text[idx:]
-	}
-	return tGlob || strings.HasSuffix(text, parts[end])
-}
-
 // Match function matches wild cards in 'pattern' for resource.
 func resourceMatch(pattern, resource string) bool {
-	return wildCardMatch(pattern, resource)
+	return wildcard.MatchExtended(pattern, resource)
 }

 // Match function matches wild cards in 'pattern' for action.
 func actionMatch(pattern, action string) bool {
-	return wildCardMatch(pattern, action)
+	return wildcard.Match(pattern, action)
 }

 // Verify if given resource matches with policy statement.
@@ -193,15 +167,15 @@ func (api objectAPIHandlers) PutBucketPolicyHandler(w http.ResponseWriter, r *ht
 	// Read access policy up to maxAccessPolicySize.
 	// http://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html
 	// bucket policies are limited to 20KB in size, using a limit reader.
-	bucketPolicyBuf, err := ioutil.ReadAll(io.LimitReader(r.Body, maxAccessPolicySize))
+	policyBytes, err := ioutil.ReadAll(io.LimitReader(r.Body, maxAccessPolicySize))
 	if err != nil {
-		errorIf(err, "Unable to read bucket policy.")
-		writeErrorResponse(w, r, ErrInternalError, r.URL.Path)
+		errorIf(err, "Unable to read from client.")
+		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
 		return
 	}
-
 	// Parse bucket policy.
-	bucketPolicy, err := parseBucketPolicy(bucketPolicyBuf)
+	var policy = &bucketPolicy{}
+	err = parseBucketPolicy(bytes.NewReader(policyBytes), policy)
 	if err != nil {
 		errorIf(err, "Unable to parse bucket policy.")
 		writeErrorResponse(w, r, ErrInvalidPolicyDocument, r.URL.Path)
@@ -209,13 +183,13 @@ func (api objectAPIHandlers) PutBucketPolicyHandler(w http.ResponseWriter, r *ht
 	}

 	// Parse check bucket policy.
-	if s3Error := checkBucketPolicyResources(bucket, bucketPolicy); s3Error != ErrNone {
+	if s3Error := checkBucketPolicyResources(bucket, policy); s3Error != ErrNone {
 		writeErrorResponse(w, r, s3Error, r.URL.Path)
 		return
 	}

 	// Save bucket policy.
-	if err := writeBucketPolicy(bucket, bucketPolicyBuf); err != nil {
+	if err = writeBucketPolicy(bucket, api.ObjectAPI, bytes.NewReader(policyBytes), int64(len(policyBytes))); err != nil {
 		errorIf(err, "Unable to write bucket policy.")
 		switch err.(type) {
 		case BucketNameInvalid:
@@ -225,6 +199,11 @@ func (api objectAPIHandlers) PutBucketPolicyHandler(w http.ResponseWriter, r *ht
 		}
 		return
 	}
+
+	// Set the bucket policy in memory.
+	globalBucketPolicies.SetBucketPolicy(bucket, policy)
+
+	// Success.
 	writeSuccessNoContent(w)
 }

@@ -249,7 +228,7 @@ func (api objectAPIHandlers) DeleteBucketPolicyHandler(w http.ResponseWriter, r
 	}

 	// Delete bucket access policy.
-	if err := removeBucketPolicy(bucket); err != nil {
+	if err := removeBucketPolicy(bucket, api.ObjectAPI); err != nil {
 		errorIf(err, "Unable to remove bucket policy.")
 		switch err.(type) {
 		case BucketNameInvalid:
@@ -261,6 +240,11 @@ func (api objectAPIHandlers) DeleteBucketPolicyHandler(w http.ResponseWriter, r
 		}
 		return
 	}
+
+	// Remove bucket policy.
+	globalBucketPolicies.RemoveBucketPolicy(bucket)
+
+	// Success.
 	writeSuccessNoContent(w)
 }

@@ -285,7 +269,7 @@ func (api objectAPIHandlers) GetBucketPolicyHandler(w http.ResponseWriter, r *ht
 	}

 	// Read bucket access policy.
-	p, err := readBucketPolicy(bucket)
+	policy, err := readBucketPolicy(bucket, api.ObjectAPI)
 	if err != nil {
 		errorIf(err, "Unable to read bucket policy.")
 		switch err.(type) {
@@ -298,5 +282,7 @@ func (api objectAPIHandlers) GetBucketPolicyHandler(w http.ResponseWriter, r *ht
 		}
 		return
 	}
-	io.Copy(w, bytes.NewReader(p))
+
+	// Write to client.
+	fmt.Fprint(w, policy)
 }
@@ -118,7 +118,7 @@ func TestBucketPolicyActionMatch(t *testing.T) {
 		{"s3:ListBucketMultipartUploads", getWriteOnlyBucketStatement(bucketName, objectPrefix), true},
 		// read-only bucket policy is expected to not allow ListBucketMultipartUploads operation on an anonymous request (Test case 9).
 		// the allowed actions in read-only bucket statement are  "s3:GetBucketLocation","s3:ListBucket",
-		// this shouldnot allow for ListBucketMultipartUploads operations.
+		// this should not allow for ListBucketMultipartUploads operations.
 		{"s3:ListBucketMultipartUploads", getReadOnlyBucketStatement(bucketName, objectPrefix), false},

 		// Any of the object level policy will not allow for s3:ListBucketMultipartUploads (Test cases 10-12).
@@ -136,7 +136,7 @@ func TestBucketPolicyActionMatch(t *testing.T) {
 		{"s3:ListBucket", getReadWriteBucketStatement(bucketName, objectPrefix), true},
 		// write-only  bucket policy is expected to not allow ListBucket operation on an anonymous request (Test case 15).
 		// the allowed actions in write-only  bucket statement are "s3:GetBucketLocation",	"s3:ListBucketMultipartUploads",
-		// this shouldnot allow for ListBucket operations.
+		// this should not allow for ListBucket operations.
 		{"s3:ListBucket", getWriteOnlyBucketStatement(bucketName, objectPrefix), false},

 		// Cases for testing ListBucket access for different Object level access permissions (Test cases 16-18).
@@ -237,78 +237,6 @@ func TestBucketPolicyActionMatch(t *testing.T) {
 	}
 }

-// TestWildCardMatch - Tests validate the logic of wild card matching.
-// Its used to match the action and resources of the policy statement and the request.
-func TestWildCardMatch(t *testing.T) {
-	testCases := []struct {
-		pattern        string
-		text           string
-		expectedResult bool
-	}{
-		// Test case - 1.
-		// Test case with pattern "*". Expected to match any text.
-		{"*", "s3:GetObject", true},
-		// Test case - 2.
-		// Test case with empty pattern. This only matches empty string.
-		{"", "s3:GetObject", false},
-		// Test case - 3.
-		// Test case with empty pattern. This only matches empty string.
-		{"", "", true},
-		// Test case - 4.
-		// Test case with single "*" at the end.
-		{"s3:*", "s3:ListMultipartUploadParts", true},
-		// Test case - 5.
-		// Test case with a no "*". In this case the pattern and text should be the same.
-		{"s3:ListBucketMultipartUploads", "s3:ListBucket", false},
-		// Test case - 6.
-		// Test case with a no "*". In this case the pattern and text should be the same.
-		{"s3:ListBucket", "s3:ListBucket", true},
-		// Test case - 7.
-		// Test case with a no "*". In this case the pattern and text should be the same.
-		{"s3:ListBucketMultipartUploads", "s3:ListBucketMultipartUploads", true},
-		// Test case - 8.
-		// Test case with pattern containing key name with a prefix. Should accept the same text without a "*".
-		{"my-bucket/oo*", "my-bucket/oo", true},
-		// Test case - 9.
-		// Test case with "*" at the end of the pattern.
-		{"my-bucket/In*", "my-bucket/India/Karnataka/", true},
-		// Test case - 10.
-		// Test case with prefixes shuffled.
-		// This should fail.
-		{"my-bucket/In*", "my-bucket/Karnataka/India/", false},
-		// Test case - 11.
-		// Test case with text expanded to the wildcards in the pattern.
-		{"my-bucket/In*/Ka*/Ban", "my-bucket/India/Karnataka/Ban", true},
-		// Test case - 12.
-		// Test case with the  keyname part is repeated as prefix several times.
-		// This is valid.
-		{"my-bucket/In*/Ka*/Ban", "my-bucket/India/Karnataka/Ban/Ban/Ban/Ban/Ban", true},
-		// Test case - 13.
-		// Test case to validate that `*` can be expanded into multiple prefixes.
-		{"my-bucket/In*/Ka*/Ban", "my-bucket/India/Karnataka/Area1/Area2/Area3/Ban", true},
-		// Test case to validate that `*` can be expanded into multiple prefixes.
-		{"my-bucket/In*/Ka*/Ban", "my-bucket/India/State1/State2/Karnataka/Area1/Area2/Area3/Ban", true},
-		// Test case - 14.
-		// Test case where the keyname part of the pattern is expanded in the text.
-		{"my-bucket/In*/Ka*/Ban", "my-bucket/India/Karnataka/Bangalore", false},
-		// Test case - 15.
-		// Test case with prefixes and wildcard expanded for all "*".
-		{"my-bucket/In*/Ka*/Ban*", "my-bucket/India/Karnataka/Bangalore", true},
-		// Test case - 16.
-		// Test case with keyname part being a wildcard in the pattern.
-		{"my-bucket/*", "my-bucket/India", true},
-		// Test case - 17.
-		{"my-bucket/oo*", "my-bucket/odo", false},
-	}
-	// Iterating over the test cases, call the function under test and asert the output.
-	for i, testCase := range testCases {
-		actualResult := wildCardMatch(testCase.pattern, testCase.text)
-		if testCase.expectedResult != actualResult {
-			t.Errorf("Test %d: Expected the result to be `%v`, but instead found it to be `%v`", i+1, testCase.expectedResult, actualResult)
-		}
-	}
-}
-
 // Wrapper for calling Put Bucket Policy HTTP handler tests for both XL multiple disks and single node setup.
 func TestPutBucketPolicyHandler(t *testing.T) {
 	ExecObjectLayerTest(t, testPutBucketPolicyHandler)
@@ -317,6 +245,8 @@ func TestPutBucketPolicyHandler(t *testing.T) {
 // testPutBucketPolicyHandler - Test for Bucket policy end point.
 // TODO: Add exhaustive cases with various combination of statement fields.
 func testPutBucketPolicyHandler(obj ObjectLayer, instanceType string, t TestErrHandler) {
+	initBucketPolicies(obj)
+
 	// get random bucket name.
 	bucketName := getRandomBucketName()
 	// Create bucket.
@@ -329,48 +259,17 @@ func testPutBucketPolicyHandler(obj ObjectLayer, instanceType string, t TestErrH
 	apiRouter := initTestAPIEndPoints(obj, []string{"PutBucketPolicy"})
 	// initialize the server and obtain the credentials and root.
 	// credentials are necessary to sign the HTTP request.
-	credentials, rootPath, err := initTestConfig("us-east-1")
+	rootPath, err := newTestConfig("us-east-1")
 	if err != nil {
 		t.Fatalf("Init Test config failed")
 	}
 	// remove the root folder after the test ends.
 	defer removeAll(rootPath)

+	credentials := serverConfig.GetCredential()
+
 	// template for constructing HTTP request body for PUT bucket policy.
-	bucketPolicyTemplate := `{
-    "Version": "2012-10-17",
-    "Statement": [
-        {
-            "Action": [
-                "s3:GetBucketLocation",
-                "s3:ListBucket"
-            ],
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": [
-                    "*"
-                ]
-            },
-            "Resource": [
-                "arn:aws:s3:::%s"
-            ]
-        },
-        {
-            "Action": [
-                "s3:GetObject"
-            ],
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": [
-                    "*"
-                ]
-            },
-            "Resource": [
-                "arn:aws:s3:::%s/this*"
-            ]
-        }
-    ]
-}`
+	bucketPolicyTemplate := `{"Version":"2012-10-17","Statement":[{"Sid":"","Effect":"Allow","Principal":{"AWS":["*"]},"Action":["s3:GetBucketLocation","s3:ListBucket"],"Resource":["arn:aws:s3:::%s"]},{"Sid":"","Effect":"Allow","Principal":{"AWS":["*"]},"Action":["s3:GetObject"],"Resource":["arn:aws:s3:::%s/this*"]}]}`

 	// test cases with sample input and expected output.
 	testCases := []struct {
@@ -412,6 +311,8 @@ func TestGetBucketPolicyHandler(t *testing.T) {
 // testGetBucketPolicyHandler - Test for end point which fetches the access policy json of the given bucket.
 // TODO: Add exhaustive cases with various combination of statement fields.
 func testGetBucketPolicyHandler(obj ObjectLayer, instanceType string, t TestErrHandler) {
+	initBucketPolicies(obj)
+
 	// get random bucket name.
 	bucketName := getRandomBucketName()
 	// Create bucket.
@@ -425,48 +326,17 @@ func testGetBucketPolicyHandler(obj ObjectLayer, instanceType string, t TestErrH
 	apiRouter := initTestAPIEndPoints(obj, []string{"PutBucketPolicy", "GetBucketPolicy"})
 	// initialize the server and obtain the credentials and root.
 	// credentials are necessary to sign the HTTP request.
-	credentials, rootPath, err := initTestConfig("us-east-1")
+	rootPath, err := newTestConfig("us-east-1")
 	if err != nil {
 		t.Fatalf("Init Test config failed")
 	}
 	// remove the root folder after the test ends.
 	defer removeAll(rootPath)

+	credentials := serverConfig.GetCredential()
+
 	// template for constructing HTTP request body for PUT bucket policy.
-	bucketPolicyTemplate := `{
-    "Version": "2012-10-17",
-    "Statement": [
-        {
-            "Action": [
-                "s3:GetBucketLocation",
-                "s3:ListBucket"
-            ],
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": [
-                    "*"
-                ]
-            },
-            "Resource": [
-                "arn:aws:s3:::%s"
-            ]
-        },
-        {
-            "Action": [
-                "s3:GetObject"
-            ],
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": [
-                    "*"
-                ]
-            },
-            "Resource": [
-                "arn:aws:s3:::%s/this*"
-            ]
-        }
-    ]
-}`
+	bucketPolicyTemplate := `{"Version":"2012-10-17","Statement":[{"Sid":"","Effect":"Allow","Principal":{"AWS":["*"]},"Action":["s3:GetBucketLocation","s3:ListBucket"],"Resource":["arn:aws:s3:::%s"]},{"Sid":"","Effect":"Allow","Principal":{"AWS":["*"]},"Action":["s3:GetObject"],"Resource":["arn:aws:s3:::%s/this*"]}]}`

 	// Writing bucket policy before running test on GetBucketPolicy.
 	putTestPolicies := []struct {
@@ -551,6 +421,8 @@ func TestDeleteBucketPolicyHandler(t *testing.T) {
 // testDeleteBucketPolicyHandler - Test for Delete bucket policy end point.
 // TODO: Add exhaustive cases with various combination of statement fields.
 func testDeleteBucketPolicyHandler(obj ObjectLayer, instanceType string, t TestErrHandler) {
+	initBucketPolicies(obj)
+
 	// get random bucket name.
 	bucketName := getRandomBucketName()
 	// Create bucket.
@@ -559,18 +431,22 @@ func testDeleteBucketPolicyHandler(obj ObjectLayer, instanceType string, t TestE
 		// failed to create newbucket, abort.
 		t.Fatalf("%s : %s", instanceType, err)
 	}
+
 	// Register the API end points with XL/FS object layer.
 	// Registering PutBucketPolicy and DeleteBucketPolicy handlers.
 	apiRouter := initTestAPIEndPoints(obj, []string{"PutBucketPolicy", "DeleteBucketPolicy"})
+
 	// initialize the server and obtain the credentials and root.
 	// credentials are necessary to sign the HTTP request.
-	credentials, rootPath, err := initTestConfig("us-east-1")
+	rootPath, err := newTestConfig("us-east-1")
 	if err != nil {
 		t.Fatalf("Init Test config failed")
 	}
 	// remove the root folder after the test ends.
 	defer removeAll(rootPath)

+	credentials := serverConfig.GetCredential()
+
 	// template for constructing HTTP request body for PUT bucket policy.
 	bucketPolicyTemplate := `{
    "Version": "2012-10-17",
@@ -0,0 +1,83 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const policyJSON = "policy.json"
+
+func getBucketFromPolicyPath(oldPolicyPath string) string {
+	bucketPrefix, _ := filepath.Split(oldPolicyPath)
+	_, bucketName := filepath.Split(strings.TrimSuffix(bucketPrefix, slashSeparator))
+	return bucketName
+}
+
+func cleanupOldBucketPolicyConfigs() error {
+	// Get old bucket policy config directory.
+	oldBucketsConfigDir, err := getOldBucketsConfigPath()
+	fatalIf(err, "Unable to fetch buckets config path to migrate bucket policy")
+
+	// Recursively remove configDir/buckets/ - old bucket policy config location.
+	// N B This is called only if all bucket policies were successfully migrated.
+	return os.RemoveAll(oldBucketsConfigDir)
+}
+
+func migrateBucketPolicyConfig(objAPI ObjectLayer) error {
+	// Get old bucket policy config directory.
+	oldBucketsConfigDir, err := getOldBucketsConfigPath()
+	fatalIf(err, "Unable to fetch buckets config path to migrate bucket policy")
+
+	// Check if config directory holding bucket policy exists before
+	// migration.
+	_, err = os.Stat(oldBucketsConfigDir)
+	if os.IsNotExist(err) {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+
+	// WalkFunc that migrates access-policy.json to
+	// .minio.sys/buckets/bucketName/policy.json on all disks.
+	migrateBucketPolicy := func(policyPath string, fileInfo os.FileInfo, err error) error {
+		// policyFile - e.g /configDir/sample-bucket/access-policy.json
+		if err != nil {
+			return err
+		}
+		// Skip entries that aren't bucket policy files.
+		if fileInfo.Name() != "access-policy.json" {
+			return nil
+		}
+		// Get bucketName from old policy file path.
+		bucketName := getBucketFromPolicyPath(policyPath)
+		// Read bucket policy config from old location.
+		policyBytes, err := ioutil.ReadFile(policyPath)
+		fatalIf(err, "Unable to read bucket policy to migrate bucket policy", policyPath)
+		newPolicyPath := retainSlash(bucketConfigPrefix) + retainSlash(bucketName) + policyJSON
+		// Erasure code the policy config to all the disks.
+		_, err = objAPI.PutObject(minioMetaBucket, newPolicyPath, int64(len(policyBytes)), bytes.NewReader(policyBytes), nil)
+		fatalIf(err, "Unable to write bucket policy during migration.", newPolicyPath)
+		return nil
+	}
+	return filepath.Walk(oldBucketsConfigDir, migrateBucketPolicy)
+}
@@ -22,6 +22,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"path"
 	"sort"
 	"strings"
@@ -71,15 +72,25 @@ type policyStatement struct {
 	Principal  policyUser                   `json:"Principal"`
 	Actions    []string                     `json:"Action"`
 	Resources  []string                     `json:"Resource"`
-	Conditions map[string]map[string]string `json:"Condition"`
+	Conditions map[string]map[string]string `json:"Condition,omitempty"`
 }

-// BucketPolicy - minio policy collection
-type BucketPolicy struct {
+// bucketPolicy - collection of various bucket policy statements.
+type bucketPolicy struct {
 	Version    string            // date in 0000-00-00 format
 	Statements []policyStatement `json:"Statement"`
 }

+// Stringer implementation for the bucket policies.
+func (b bucketPolicy) String() string {
+	bbytes, err := json.Marshal(&b)
+	if err != nil {
+		errorIf(err, "Unable to unmarshal bucket policy into JSON %#v", b)
+		return ""
+	}
+	return string(bbytes)
+}
+
 // supportedEffectMap - supported effects.
 var supportedEffectMap = map[string]struct{}{
 	"Allow": {},
@@ -213,7 +224,7 @@ func resourcePrefix(resource string) string {
 // checkBucketPolicyResources validates Resources in unmarshalled bucket policy structure.
 // First valation of Resources done for given set of Actions.
 // Later its validated for recursive Resources.
-func checkBucketPolicyResources(bucket string, bucketPolicy BucketPolicy) APIErrorCode {
+func checkBucketPolicyResources(bucket string, bucketPolicy *bucketPolicy) APIErrorCode {
 	// Validate statements for special actions and collect resources
 	// for others to validate nesting.
 	var resourceMap = make(map[string]struct{})
@@ -268,44 +279,46 @@ func checkBucketPolicyResources(bucket string, bucketPolicy BucketPolicy) APIErr

 // parseBucketPolicy - parses and validates if bucket policy is of
 // proper JSON and follows allowed restrictions with policy standards.
-func parseBucketPolicy(bucketPolicyBuf []byte) (policy BucketPolicy, err error) {
-	if err = json.Unmarshal(bucketPolicyBuf, &policy); err != nil {
-		return BucketPolicy{}, err
+func parseBucketPolicy(bucketPolicyReader io.Reader, policy *bucketPolicy) (err error) {
+	// Parse bucket policy reader.
+	decoder := json.NewDecoder(bucketPolicyReader)
+	if err = decoder.Decode(&policy); err != nil {
+		return err
 	}

 	// Policy version cannot be empty.
 	if len(policy.Version) == 0 {
 		err = errors.New("Policy version cannot be empty.")
-		return BucketPolicy{}, err
+		return err
 	}

 	// Policy statements cannot be empty.
 	if len(policy.Statements) == 0 {
 		err = errors.New("Policy statement cannot be empty.")
-		return BucketPolicy{}, err
+		return err
 	}

 	// Loop through all policy statements and validate entries.
 	for _, statement := range policy.Statements {
 		// Statement effect should be valid.
 		if err := isValidEffect(statement.Effect); err != nil {
-			return BucketPolicy{}, err
+			return err
 		}
 		// Statement principal should be supported format.
 		if err := isValidPrincipals(statement.Principal.AWS); err != nil {
-			return BucketPolicy{}, err
+			return err
 		}
 		// Statement actions should be valid.
 		if err := isValidActions(statement.Actions); err != nil {
-			return BucketPolicy{}, err
+			return err
 		}
 		// Statement resources should be valid.
 		if err := isValidResources(statement.Resources); err != nil {
-			return BucketPolicy{}, err
+			return err
 		}
 		// Statement conditions should be valid.
 		if err := isValidConditions(statement.Conditions); err != nil {
-			return BucketPolicy{}, err
+			return err
 		}
 	}

@@ -326,5 +339,5 @@ func parseBucketPolicy(bucketPolicyBuf []byte) (policy BucketPolicy, err error)
 	policy.Statements = append(denyStatements, allowStatements...)

 	// Return successfully parsed policy structure.
-	return policy, nil
+	return nil
 }
@@ -16,10 +16,10 @@
 package main

 import (
+	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"reflect"
 	"testing"
 )

@@ -69,7 +69,7 @@ var (
 	}
 )

-// Obtain bucket statement for read-write BucketPolicy.
+// Obtain bucket statement for read-write bucketPolicy.
 func getReadWriteObjectStatement(bucketName, objectPrefix string) policyStatement {
 	objectResourceStatement := policyStatement{}
 	objectResourceStatement.Effect = "Allow"
@@ -79,7 +79,7 @@ func getReadWriteObjectStatement(bucketName, objectPrefix string) policyStatemen
 	return objectResourceStatement
 }

-// Obtain object statement for read-write BucketPolicy.
+// Obtain object statement for read-write bucketPolicy.
 func getReadWriteBucketStatement(bucketName, objectPrefix string) policyStatement {
 	bucketResourceStatement := policyStatement{}
 	bucketResourceStatement.Effect = "Allow"
@@ -89,7 +89,7 @@ func getReadWriteBucketStatement(bucketName, objectPrefix string) policyStatemen
 	return bucketResourceStatement
 }

-// Obtain statements for read-write BucketPolicy.
+// Obtain statements for read-write bucketPolicy.
 func getReadWriteStatement(bucketName, objectPrefix string) []policyStatement {
 	statements := []policyStatement{}
 	// Save the read write policy.
@@ -97,7 +97,7 @@ func getReadWriteStatement(bucketName, objectPrefix string) []policyStatement {
 	return statements
 }

-// Obtain bucket statement for read only BucketPolicy.
+// Obtain bucket statement for read only bucketPolicy.
 func getReadOnlyBucketStatement(bucketName, objectPrefix string) policyStatement {
 	bucketResourceStatement := policyStatement{}
 	bucketResourceStatement.Effect = "Allow"
@@ -107,7 +107,7 @@ func getReadOnlyBucketStatement(bucketName, objectPrefix string) policyStatement
 	return bucketResourceStatement
 }

-// Obtain object statement for read only BucketPolicy.
+// Obtain object statement for read only bucketPolicy.
 func getReadOnlyObjectStatement(bucketName, objectPrefix string) policyStatement {
 	objectResourceStatement := policyStatement{}
 	objectResourceStatement.Effect = "Allow"
@@ -117,7 +117,7 @@ func getReadOnlyObjectStatement(bucketName, objectPrefix string) policyStatement
 	return objectResourceStatement
 }

-// Obtain statements for read only BucketPolicy.
+// Obtain statements for read only bucketPolicy.
 func getReadOnlyStatement(bucketName, objectPrefix string) []policyStatement {
 	statements := []policyStatement{}
 	// Save the read only policy.
@@ -125,7 +125,7 @@ func getReadOnlyStatement(bucketName, objectPrefix string) []policyStatement {
 	return statements
 }

-// Obtain bucket statements for write only BucketPolicy.
+// Obtain bucket statements for write only bucketPolicy.
 func getWriteOnlyBucketStatement(bucketName, objectPrefix string) policyStatement {

 	bucketResourceStatement := policyStatement{}
@@ -136,7 +136,7 @@ func getWriteOnlyBucketStatement(bucketName, objectPrefix string) policyStatemen
 	return bucketResourceStatement
 }

-// Obtain object statements for write only BucketPolicy.
+// Obtain object statements for write only bucketPolicy.
 func getWriteOnlyObjectStatement(bucketName, objectPrefix string) policyStatement {
 	objectResourceStatement := policyStatement{}
 	objectResourceStatement.Effect = "Allow"
@@ -146,7 +146,7 @@ func getWriteOnlyObjectStatement(bucketName, objectPrefix string) policyStatemen
 	return objectResourceStatement
 }

-// Obtain statements for write only BucketPolicy.
+// Obtain statements for write only bucketPolicy.
 func getWriteOnlyStatement(bucketName, objectPrefix string) []policyStatement {
 	statements := []policyStatement{}
 	// Write only policy.
@@ -471,13 +471,13 @@ func TestIsValidConditions(t *testing.T) {
 }

 // Tests validate Policy Action and Resource fields.
-func TestCheckBucketPolicyResources(t *testing.T) {
+func TestCheckbucketPolicyResources(t *testing.T) {
 	// constructing policy statement without invalidPrefixActions (check bucket-policy-parser.go).
 	setValidPrefixActions := func(statements []policyStatement) []policyStatement {
 		statements[0].Actions = []string{"s3:DeleteObject", "s3:PutObject"}
 		return statements
 	}
-	// contructing policy statement with recursive resources.
+	// contracting policy statement with recursive resources.
 	// should result in ErrMalformedPolicy
 	setRecurseResource := func(statements []policyStatement) []policyStatement {
 		statements[0].Resources = []string{"arn:aws:s3:::minio-bucket/Asia/*", "arn:aws:s3:::minio-bucket/Asia/India/*"}
@@ -491,28 +491,28 @@ func TestCheckBucketPolicyResources(t *testing.T) {
 		return statements
 	}

-	// List of BucketPolicy used for tests.
-	bucketAccessPolicies := []BucketPolicy{
-		// BucketPolicy - 1.
+	// List of bucketPolicy used for tests.
+	bucketAccessPolicies := []bucketPolicy{
+		// bucketPolicy - 1.
 		// Contains valid read only policy statement.
 		{Version: "1.0", Statements: getReadOnlyStatement("minio-bucket", "")},
-		// BucketPolicy - 2.
+		// bucketPolicy - 2.
 		// Contains valid read-write only policy statement.
 		{Version: "1.0", Statements: getReadWriteStatement("minio-bucket", "Asia/")},
-		// BucketPolicy - 3.
+		// bucketPolicy - 3.
 		// Contains valid write only policy statement.
 		{Version: "1.0", Statements: getWriteOnlyStatement("minio-bucket", "Asia/India/")},
-		// BucketPolicy - 4.
+		// bucketPolicy - 4.
 		// Contains invalidPrefixActions.
 		// Since resourcePrefix is not to the bucket-name, it return ErrMalformedPolicy.
 		{Version: "1.0", Statements: getReadOnlyStatement("minio-bucket-fail", "Asia/India/")},
-		// BucketPolicy - 5.
+		// bucketPolicy - 5.
 		// constructing policy statement without invalidPrefixActions (check bucket-policy-parser.go).
 		// but bucket part of the resource is not equal to the bucket name.
 		// this results in return of ErrMalformedPolicy.
 		{Version: "1.0", Statements: setValidPrefixActions(getWriteOnlyStatement("minio-bucket-fail", "Asia/India/"))},
-		// BucketPolicy - 6.
-		// contructing policy statement with recursive resources.
+		// bucketPolicy - 6.
+		// contracting policy statement with recursive resources.
 		// should result in ErrMalformedPolicy
 		{Version: "1.0", Statements: setRecurseResource(setValidPrefixActions(getWriteOnlyStatement("minio-bucket", "")))},
 		// BucketPolciy - 7.
@@ -523,7 +523,7 @@ func TestCheckBucketPolicyResources(t *testing.T) {
 	}

 	testCases := []struct {
-		inputPolicy BucketPolicy
+		inputPolicy bucketPolicy
 		// expected results.
 		apiErrCode APIErrorCode
 		// Flag indicating whether the test should pass.
@@ -544,7 +544,7 @@ func TestCheckBucketPolicyResources(t *testing.T) {
 		// Resource prefix bucket part is not equal to the bucket name in this case.
 		{bucketAccessPolicies[4], ErrMalformedPolicy, false},
 		// Test case - 6.
-		// contructing policy statement with recursive resources.
+		// contracting policy statement with recursive resources.
 		// should result in ErrPolicyNesting.
 		{bucketAccessPolicies[5], ErrPolicyNesting, false},
 		// Test case - 7.
@@ -554,7 +554,7 @@ func TestCheckBucketPolicyResources(t *testing.T) {
 		{bucketAccessPolicies[6], ErrNone, true},
 	}
 	for i, testCase := range testCases {
-		apiErrCode := checkBucketPolicyResources("minio-bucket", testCase.inputPolicy)
+		apiErrCode := checkBucketPolicyResources("minio-bucket", &testCase.inputPolicy)
 		if apiErrCode != ErrNone && testCase.shouldPass {
 			t.Errorf("Test %d: Expected to pass, but failed with Errocode %v", i+1, apiErrCode)
 		}
@@ -596,53 +596,53 @@ func TestParseBucketPolicy(t *testing.T) {
 		statements[0].Resources = []string{"my-resource"}
 		return statements
 	}
-	// List of BucketPolicy used for test cases.
-	bucketAccesPolicies := []BucketPolicy{
-		// BucketPolicy - 0.
-		// BucketPolicy statement empty.
+	// List of bucketPolicy used for test cases.
+	bucketAccesPolicies := []bucketPolicy{
+		// bucketPolicy - 0.
+		// bucketPolicy statement empty.
 		{Version: "1.0"},
-		// BucketPolicy - 1.
-		// BucketPolicy version empty.
+		// bucketPolicy - 1.
+		// bucketPolicy version empty.
 		{Version: "", Statements: []policyStatement{}},
-		// BucketPolicy - 2.
-		// Readonly BucketPolicy.
+		// bucketPolicy - 2.
+		// Readonly bucketPolicy.
 		{Version: "1.0", Statements: getReadOnlyStatement("minio-bucket", "")},
-		// BucketPolicy - 3.
+		// bucketPolicy - 3.
 		// Read-Write bucket policy.
 		{Version: "1.0", Statements: getReadWriteStatement("minio-bucket", "Asia/")},
-		// BucketPolicy - 4.
+		// bucketPolicy - 4.
 		// Write only bucket policy.
 		{Version: "1.0", Statements: getWriteOnlyStatement("minio-bucket", "Asia/India/")},
-		// BucketPolicy - 5.
-		// BucketPolicy statement contains unsupported action.
+		// bucketPolicy - 5.
+		// bucketPolicy statement contains unsupported action.
 		{Version: "1.0", Statements: setUnsupportedActions(getReadOnlyStatement("minio-bucket", ""))},
-		// BucketPolicy - 6.
-		// BucketPolicy statement contains unsupported Effect.
+		// bucketPolicy - 6.
+		// bucketPolicy statement contains unsupported Effect.
 		{Version: "1.0", Statements: setUnsupportedEffect(getReadWriteStatement("minio-bucket", "Asia/"))},
-		// BucketPolicy - 7.
-		// BucketPolicy statement contains unsupported Principal.
+		// bucketPolicy - 7.
+		// bucketPolicy statement contains unsupported Principal.
 		{Version: "1.0", Statements: setUnsupportedPrincipals(getWriteOnlyStatement("minio-bucket", "Asia/India/"))},
-		// BucketPolicy - 8.
-		// BucketPolicy statement contains unsupported Resource.
+		// bucketPolicy - 8.
+		// bucketPolicy statement contains unsupported Resource.
 		{Version: "1.0", Statements: setUnsupportedResources(getWriteOnlyStatement("minio-bucket", "Asia/India/"))},
 	}

 	testCases := []struct {
-		inputPolicy BucketPolicy
+		inputPolicy bucketPolicy
 		// expected results.
-		expectedPolicy BucketPolicy
+		expectedPolicy bucketPolicy
 		err            error
 		// Flag indicating whether the test should pass.
 		shouldPass bool
 	}{
 		// Test case - 1.
-		// BucketPolicy statement empty.
-		{bucketAccesPolicies[0], BucketPolicy{}, errors.New("Policy statement cannot be empty."), false},
+		// bucketPolicy statement empty.
+		{bucketAccesPolicies[0], bucketPolicy{}, errors.New("Policy statement cannot be empty."), false},
 		// Test case - 2.
-		// BucketPolicy version empty.
-		{bucketAccesPolicies[1], BucketPolicy{}, errors.New("Policy version cannot be empty."), false},
+		// bucketPolicy version empty.
+		{bucketAccesPolicies[1], bucketPolicy{}, errors.New("Policy version cannot be empty."), false},
 		// Test case - 3.
-		// Readonly BucketPolicy.
+		// Readonly bucketPolicy.
 		{bucketAccesPolicies[2], bucketAccesPolicies[2], nil, true},
 		// Test case - 4.
 		// Read-Write bucket policy.
@@ -651,25 +651,28 @@ func TestParseBucketPolicy(t *testing.T) {
 		// Write only bucket policy.
 		{bucketAccesPolicies[4], bucketAccesPolicies[4], nil, true},
 		// Test case - 6.
-		// BucketPolicy statement contains unsupported action.
+		// bucketPolicy statement contains unsupported action.
 		{bucketAccesPolicies[5], bucketAccesPolicies[5], fmt.Errorf("Unsupported action found: ‘s3:DeleteEverything’, please validate your policy document."), false},
 		// Test case - 7.
-		// BucketPolicy statement contains unsupported Effect.
+		// bucketPolicy statement contains unsupported Effect.
 		{bucketAccesPolicies[6], bucketAccesPolicies[6], fmt.Errorf("Unsupported Effect found: ‘DontAllow’, please validate your policy document."), false},
 		// Test case - 8.
-		// BucketPolicy statement contains unsupported Principal.
+		// bucketPolicy statement contains unsupported Principal.
 		{bucketAccesPolicies[7], bucketAccesPolicies[7], fmt.Errorf("Unsupported principal style found: ‘User1111’, please validate your policy document."), false},
 		// Test case - 9.
-		// BucketPolicy statement contains unsupported Resource.
+		// bucketPolicy statement contains unsupported Resource.
 		{bucketAccesPolicies[8], bucketAccesPolicies[8], fmt.Errorf("Unsupported resource style found: ‘my-resource’, please validate your policy document."), false},
 	}
 	for i, testCase := range testCases {
-		inputPolicyBytes, e := json.Marshal(testCase.inputPolicy)
-		if e != nil {
-			t.Fatalf("Test %d: Couldn't Marshal bucket policy", i+1)
+		var buffer bytes.Buffer
+		encoder := json.NewEncoder(&buffer)
+		err := encoder.Encode(testCase.inputPolicy)
+		if err != nil {
+			t.Fatalf("Test %d: Couldn't Marshal bucket policy %s", i+1, err)
 		}

-		actualAccessPolicy, err := parseBucketPolicy(inputPolicyBytes)
+		var actualAccessPolicy = &bucketPolicy{}
+		err = parseBucketPolicy(&buffer, actualAccessPolicy)
 		if err != nil && testCase.shouldPass {
 			t.Errorf("Test %d: Expected to pass, but failed with: <ERROR> %s", i+1, err.Error())
 		}
@@ -684,7 +687,7 @@ func TestParseBucketPolicy(t *testing.T) {
 		}
 		// Test passes as expected, but the output values are verified for correctness here.
 		if err == nil && testCase.shouldPass {
-			if !reflect.DeepEqual(testCase.expectedPolicy, actualAccessPolicy) {
+			if testCase.expectedPolicy.String() != actualAccessPolicy.String() {
 				t.Errorf("Test %d: The expected statements from resource statement generator doesn't match the actual statements", i+1)
 			}
 		}
@@ -17,112 +17,164 @@
 package main

 import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
+	"bytes"
+	"errors"
+	"io"
+	"path"
+	"sync"
 )

-// getBucketsConfigPath - get buckets path.
-func getBucketsConfigPath() (string, error) {
+// Variable represents bucket policies in memory.
+var globalBucketPolicies *bucketPolicies
+
+// Global bucket policies list, policies are enforced on each bucket looking
+// through the policies here.
+type bucketPolicies struct {
+	rwMutex *sync.RWMutex
+
+	// Collection of 'bucket' policies.
+	bucketPolicyConfigs map[string]*bucketPolicy
+}
+
+// Fetch bucket policy for a given bucket.
+func (bp bucketPolicies) GetBucketPolicy(bucket string) *bucketPolicy {
+	bp.rwMutex.RLock()
+	defer bp.rwMutex.RUnlock()
+	return bp.bucketPolicyConfigs[bucket]
+}
+
+// Set a new bucket policy for a bucket, this operation will overwrite
+// any previous bucketpolicies for the bucket.
+func (bp *bucketPolicies) SetBucketPolicy(bucket string, policy *bucketPolicy) error {
+	bp.rwMutex.Lock()
+	defer bp.rwMutex.Unlock()
+	if policy == nil {
+		return errors.New("invalid argument")
+	}
+	bp.bucketPolicyConfigs[bucket] = policy
+	return nil
+}
+
+// Remove bucket policy for a bucket, from in-memory map.
+func (bp *bucketPolicies) RemoveBucketPolicy(bucket string) {
+	bp.rwMutex.Lock()
+	defer bp.rwMutex.Unlock()
+	delete(bp.bucketPolicyConfigs, bucket)
+}
+
+// Loads all bucket policies from persistent layer.
+func loadAllBucketPolicies(objAPI ObjectLayer) (policies map[string]*bucketPolicy, err error) {
+	// List buckets to proceed loading all notification configuration.
+	buckets, err := objAPI.ListBuckets()
+	if err != nil {
+		return nil, err
+	}
+	policies = make(map[string]*bucketPolicy)
+	// Loads bucket policy.
+	for _, bucket := range buckets {
+		var policy *bucketPolicy
+		policy, err = readBucketPolicy(bucket.Name, objAPI)
+		if err != nil {
+			switch err.(type) {
+			case BucketPolicyNotFound:
+				continue
+			}
+			return nil, err
+		}
+		policies[bucket.Name] = policy
+	}
+
+	// Success.
+	return policies, nil
+
+}
+
+// Intialize all bucket policies.
+func initBucketPolicies(objAPI ObjectLayer) error {
+	if objAPI == nil {
+		return errInvalidArgument
+	}
+	// Read all bucket policies.
+	policies, err := loadAllBucketPolicies(objAPI)
+	if err != nil {
+		return err
+	}
+
+	globalBucketPolicies = &bucketPolicies{
+		rwMutex:             &sync.RWMutex{},
+		bucketPolicyConfigs: policies,
+	}
+	return nil
+}
+
+// getOldBucketsConfigPath - get old buckets config path. (Only used for migrating old bucket policies)
+func getOldBucketsConfigPath() (string, error) {
 	configPath, err := getConfigPath()
 	if err != nil {
 		return "", err
 	}
-	return filepath.Join(configPath, "buckets"), nil
+	return path.Join(configPath, "buckets"), nil
 }

-// getBucketConfigPath - get bucket config path.
-func getBucketConfigPath(bucket string) (string, error) {
-	bucketsConfigPath, err := getBucketsConfigPath()
-	if err != nil {
-		return "", err
-	}
-	return filepath.Join(bucketsConfigPath, bucket), nil
-}
-
-// createBucketConfigPath - create bucket config directory.
-func createBucketConfigPath(bucket string) error {
-	bucketConfigPath, err := getBucketConfigPath(bucket)
-	if err != nil {
-		return err
-	}
-	return os.MkdirAll(bucketConfigPath, 0700)
-}
-
-// readBucketPolicy - read bucket policy.
-func readBucketPolicy(bucket string) ([]byte, error) {
+// readBucketPolicy - reads bucket policy for an input bucket, returns BucketPolicyNotFound
+// if bucket policy is not found. This function also parses the bucket policy into an object.
+func readBucketPolicy(bucket string, objAPI ObjectLayer) (*bucketPolicy, error) {
 	// Verify bucket is valid.
 	if !IsValidBucketName(bucket) {
 		return nil, BucketNameInvalid{Bucket: bucket}
 	}
-
-	bucketConfigPath, err := getBucketConfigPath(bucket)
+	policyPath := pathJoin(bucketConfigPrefix, bucket, policyJSON)
+	objInfo, err := objAPI.GetObjectInfo(minioMetaBucket, policyPath)
 	if err != nil {
-		return nil, err
-	}
-
-	// Get policy file.
-	bucketPolicyFile := filepath.Join(bucketConfigPath, "access-policy.json")
-	if _, err = os.Stat(bucketPolicyFile); err != nil {
-		if os.IsNotExist(err) {
+		if _, ok := err.(ObjectNotFound); ok {
 			return nil, BucketPolicyNotFound{Bucket: bucket}
 		}
 		return nil, err
 	}
-	return ioutil.ReadFile(bucketPolicyFile)
+	var buffer bytes.Buffer
+	err = objAPI.GetObject(minioMetaBucket, policyPath, 0, objInfo.Size, &buffer)
+	if err != nil {
+		if _, ok := err.(ObjectNotFound); ok {
+			return nil, BucketPolicyNotFound{Bucket: bucket}
+		}
+		return nil, err
+	}
+	// Parse the saved policy.
+	var policy = &bucketPolicy{}
+	err = parseBucketPolicy(&buffer, policy)
+	if err != nil {
+		return nil, err
+
+	}
+	return policy, nil
 }

-// removeBucketPolicy - remove bucket policy.
-func removeBucketPolicy(bucket string) error {
+// removeBucketPolicy - removes any previously written bucket policy. Returns BucketPolicyNotFound
+// if no policies are found.
+func removeBucketPolicy(bucket string, objAPI ObjectLayer) error {
 	// Verify bucket is valid.
 	if !IsValidBucketName(bucket) {
 		return BucketNameInvalid{Bucket: bucket}
 	}

-	bucketConfigPath, err := getBucketConfigPath(bucket)
-	if err != nil {
-		return err
-	}
-
-	// Get policy file.
-	bucketPolicyFile := filepath.Join(bucketConfigPath, "access-policy.json")
-	if _, err = os.Stat(bucketPolicyFile); err != nil {
-		if os.IsNotExist(err) {
+	policyPath := pathJoin(bucketConfigPrefix, bucket, policyJSON)
+	if err := objAPI.DeleteObject(minioMetaBucket, policyPath); err != nil {
+		if _, ok := err.(ObjectNotFound); ok {
 			return BucketPolicyNotFound{Bucket: bucket}
 		}
 		return err
 	}
-	if err := os.Remove(bucketPolicyFile); err != nil {
-		return err
-	}
 	return nil
 }

-// writeBucketPolicy - save bucket policy.
-func writeBucketPolicy(bucket string, accessPolicyBytes []byte) error {
+// writeBucketPolicy - save all bucket policies.
+func writeBucketPolicy(bucket string, objAPI ObjectLayer, reader io.Reader, size int64) error {
 	// Verify if bucket path legal
 	if !IsValidBucketName(bucket) {
 		return BucketNameInvalid{Bucket: bucket}
 	}

-	// Create bucket config path.
-	if err := createBucketConfigPath(bucket); err != nil {
-		return err
-	}
-
-	bucketConfigPath, err := getBucketConfigPath(bucket)
-	if err != nil {
-		return err
-	}
-
-	// Get policy file.
-	bucketPolicyFile := filepath.Join(bucketConfigPath, "access-policy.json")
-	if _, err := os.Stat(bucketPolicyFile); err != nil {
-		if !os.IsNotExist(err) {
-			return err
-		}
-	}
-
-	// Write bucket policy.
-	return ioutil.WriteFile(bucketPolicyFile, accessPolicyBytes, 0600)
+	policyPath := pathJoin(bucketConfigPrefix, bucket, policyJSON)
+	_, err := objAPI.PutObject(minioMetaBucket, policyPath, size, reader, nil)
+	return err
 }
@@ -212,7 +212,7 @@ main() {
        echo "Please install them "
        echo "${MISSING}"
        echo
-        echo "Follow https://github.com/minio/minio/blob/master/INSTALLGO.md for further instructions"
+        echo "Follow https://docs.minio.io/docs/how-to-install-golang for further instructions"
        exit 1
    fi
    echo "Done"
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -e
+echo "" > coverage.txt
+
+for d in $(go list ./... | grep -v vendor); do
+    go test -coverprofile=profile.out -covermode=atomic $d
+    if [ -f profile.out ]; then
+        cat profile.out >> coverage.txt
+        rm profile.out
+    fi
+done
@@ -0,0 +1,60 @@
+/*
+ * Minio Cloud Storage, (C) 2015, 2016 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 main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Make sure we have a valid certs path.
+func TestGetCertsPath(t *testing.T) {
+	path, err := getCertsPath()
+	if err != nil {
+		t.Error(err)
+	}
+	if path == "" {
+		t.Errorf("expected path to not be an empty string, got: '%s'", path)
+	}
+	// Ensure it contains some sort of path separator.
+	if !strings.ContainsRune(path, os.PathSeparator) {
+		t.Errorf("expected path to contain file separator")
+	}
+	// It should also be an absolute path.
+	if !filepath.IsAbs(path) {
+		t.Errorf("expected path to be an absolute path")
+	}
+
+	// This will error if something goes wrong, so just call it.
+	mustGetCertsPath()
+}
+
+// Ensure that the certificate and key file getters contain their respective
+// file name and endings.
+func TestGetFiles(t *testing.T) {
+	file := mustGetCertFile()
+	if !strings.Contains(file, globalMinioCertFile) {
+		t.Errorf("CertFile does not contain %s", globalMinioCertFile)
+	}
+
+	file = mustGetKeyFile()
+	if !strings.Contains(file, globalMinioKeyFile) {
+		t.Errorf("KeyFile does not contain %s", globalMinioKeyFile)
+	}
+}
@@ -17,10 +17,8 @@
 package main

 import (
-	"errors"
+	"fmt"
 	"net"
-	"os"
-	"syscall"
 )

 // Make sure that none of the other processes are listening on the
@@ -31,63 +29,20 @@ import (
 // However on Mac OSX Listen() on ":9000" falls back to the IPv6 address.
 // This causes confusion on Mac OSX that minio server is not reachable
 // on 127.0.0.1 even though minio server is running. So before we start
-// the minio server we make sure that the port is free on all the IPs.
-func checkPortAvailability(port int) {
-	isAddrInUse := func(err error) bool {
-		// Check if the syscall error is EADDRINUSE.
-		// EADDRINUSE is the system call error if another process is
-		// already listening at the specified port.
-		neterr, ok := err.(*net.OpError)
-		if !ok {
-			return false
-		}
-		osErr, ok := neterr.Err.(*os.SyscallError)
-		if !ok {
-			return false
-		}
-		sysErr, ok := osErr.Err.(syscall.Errno)
-		if !ok {
-			return false
-		}
-		if sysErr != syscall.EADDRINUSE {
-			return false
-		}
-		return true
-	}
-	ifcs, err := net.Interfaces()
-	if err != nil {
-		fatalIf(err, "Unable to list interfaces.")
-	}
-	for _, ifc := range ifcs {
-		addrs, err := ifc.Addrs()
+// the minio server we make sure that the port is free on each tcp network.
+func checkPortAvailability(port int) error {
+	network := [3]string{"tcp", "tcp4", "tcp6"}
+	for _, n := range network {
+		l, err := net.Listen(n, fmt.Sprintf(":%d", port))
 		if err != nil {
-			fatalIf(err, "Unable to list addresses on interface %s.", ifc.Name)
+			return err
 		}
-		for _, addr := range addrs {
-			ipnet, ok := addr.(*net.IPNet)
-			if !ok {
-				errorIf(errors.New(""), "Failed to assert type on (*net.IPNet) interface.")
-				continue
-			}
-			ip := ipnet.IP
-			network := "tcp4"
-			if ip.To4() == nil {
-				network = "tcp6"
-			}
-			tcpAddr := net.TCPAddr{IP: ip, Port: port, Zone: ifc.Name}
-			l, err := net.ListenTCP(network, &tcpAddr)
-			if err != nil {
-				if isAddrInUse(err) {
-					// Fail if port is already in use.
-					fatalIf(err, "Unable to listen on %s:%.d.", tcpAddr.IP, tcpAddr.Port)
-				} else {
-					// Ignore other errors.
-					continue
-				}
-			}
-			if err = l.Close(); err != nil {
-				fatalIf(err, "Unable to close listener on %s:%.d.", tcpAddr.IP, tcpAddr.Port)
-			}
+
+		// look for error so we don't have dangling connection
+		if err = l.Close(); err != nil {
+			return err
 		}
 	}
+
+	return nil
 }
@@ -0,0 +1,55 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"fmt"
+	"net"
+	"runtime"
+	"testing"
+)
+
+// Tests for port availability logic written for server startup sequence.
+func TestCheckPortAvailability(t *testing.T) {
+	tests := []struct {
+		port int
+	}{
+		{getFreePort()},
+		{getFreePort()},
+	}
+	for _, test := range tests {
+		// This test should pass if the ports are available
+		err := checkPortAvailability(test.port)
+		if err != nil {
+			t.Fatalf("checkPortAvailability test failed for port: %d. Error: %v", test.port, err)
+		}
+
+		// Now use the ports and check again
+		ln, err := net.Listen("tcp", fmt.Sprintf(":%d", test.port))
+		if err != nil {
+			t.Fail()
+		}
+		defer ln.Close()
+
+		err = checkPortAvailability(test.port)
+
+		// Skip if the os is windows due to https://github.com/golang/go/issues/7598
+		if err == nil && runtime.GOOS != "windows" {
+			t.Fatalf("checkPortAvailability should fail for port: %d. Error: %v", test.port, err)
+		}
+	}
+}
@@ -32,6 +32,10 @@ func migrateConfig() {
 	migrateV2ToV3()
 	// Migrate version '3' to '4'.
 	migrateV3ToV4()
+	// Migrate version '4' to '5'.
+	migrateV4ToV5()
+	// Migrate version '5' to '6.
+	migrateV5ToV6()
 }

 // Version '1' is not supported anymore and deprecated, safe to delete.
@@ -124,8 +128,8 @@ func migrateV3ToV4() {
 	}

 	// Save only the new fields, ignore the rest.
-	srvConfig := &serverConfigV4{}
-	srvConfig.Version = globalMinioConfigVersion
+	srvConfig := &configV4{}
+	srvConfig.Version = "4"
 	srvConfig.Credential = cv3.Credential
 	srvConfig.Region = cv3.Region
 	if srvConfig.Region == "" {
@@ -146,3 +150,109 @@ func migrateV3ToV4() {

 	console.Println("Migration from version ‘" + cv3.Version + "’ to ‘" + srvConfig.Version + "’ completed successfully.")
 }
+
+// Version '5' to '6' migrates config, removes previous fields related
+// to backend types and server address. This change further simplifies
+// the config for future additions.
+func migrateV5ToV6() {
+	cv5, err := loadConfigV5()
+	if err != nil && os.IsNotExist(err) {
+		return
+	}
+	fatalIf(err, "Unable to load config version ‘5’.")
+	if cv5.Version != "5" {
+		return
+	}
+
+	// Save only the new fields, ignore the rest.
+	srvConfig := &serverConfigV6{}
+	srvConfig.Version = globalMinioConfigVersion
+	srvConfig.Credential = cv5.Credential
+	srvConfig.Region = cv5.Region
+	if srvConfig.Region == "" {
+		// Region needs to be set for AWS Signature Version 4.
+		srvConfig.Region = "us-east-1"
+	}
+	srvConfig.Logger.Console = cv5.Logger.Console
+	srvConfig.Logger.File = cv5.Logger.File
+	srvConfig.Logger.Syslog = cv5.Logger.Syslog
+	srvConfig.Notify.AMQP = map[string]amqpNotify{
+		"1": {
+			Enable:      cv5.Logger.AMQP.Enable,
+			URL:         cv5.Logger.AMQP.URL,
+			Exchange:    cv5.Logger.AMQP.Exchange,
+			RoutingKey:  cv5.Logger.AMQP.RoutingKey,
+			Mandatory:   cv5.Logger.AMQP.Mandatory,
+			Immediate:   cv5.Logger.AMQP.Immediate,
+			Durable:     cv5.Logger.AMQP.Durable,
+			Internal:    cv5.Logger.AMQP.Internal,
+			NoWait:      cv5.Logger.AMQP.NoWait,
+			AutoDeleted: cv5.Logger.AMQP.AutoDeleted,
+		},
+	}
+	srvConfig.Notify.ElasticSearch = map[string]elasticSearchNotify{
+		"1": {
+			Enable: cv5.Logger.ElasticSearch.Enable,
+			URL:    cv5.Logger.ElasticSearch.URL,
+			Index:  cv5.Logger.ElasticSearch.Index,
+		},
+	}
+	srvConfig.Notify.Redis = map[string]redisNotify{
+		"1": {
+			Enable:   cv5.Logger.Redis.Enable,
+			Addr:     cv5.Logger.Redis.Addr,
+			Password: cv5.Logger.Redis.Password,
+			Key:      cv5.Logger.Redis.Key,
+		},
+	}
+
+	qc, err := quick.New(srvConfig)
+	fatalIf(err, "Unable to initialize the quick config.")
+	configFile, err := getConfigFile()
+	fatalIf(err, "Unable to get config file.")
+
+	err = qc.Save(configFile)
+	fatalIf(err, "Failed to migrate config from ‘"+cv5.Version+"’ to ‘"+srvConfig.Version+"’ failed.")
+
+	console.Println("Migration from version ‘" + cv5.Version + "’ to ‘" + srvConfig.Version + "’ completed successfully.")
+}
+
+// Version '4' to '5' migrates config, removes previous fields related
+// to backend types and server address. This change further simplifies
+// the config for future additions.
+func migrateV4ToV5() {
+	cv4, err := loadConfigV4()
+	if err != nil && os.IsNotExist(err) {
+		return
+	}
+	fatalIf(err, "Unable to load config version ‘4’.")
+	if cv4.Version != "4" {
+		return
+	}
+
+	// Save only the new fields, ignore the rest.
+	srvConfig := &configV5{}
+	srvConfig.Version = globalMinioConfigVersion
+	srvConfig.Credential = cv4.Credential
+	srvConfig.Region = cv4.Region
+	if srvConfig.Region == "" {
+		// Region needs to be set for AWS Signature Version 4.
+		srvConfig.Region = "us-east-1"
+	}
+	srvConfig.Logger.Console = cv4.Logger.Console
+	srvConfig.Logger.File = cv4.Logger.File
+	srvConfig.Logger.Syslog = cv4.Logger.Syslog
+	srvConfig.Logger.AMQP.Enable = false
+	srvConfig.Logger.ElasticSearch.Enable = false
+	srvConfig.Logger.Redis.Enable = false
+
+	qc, err := quick.New(srvConfig)
+	fatalIf(err, "Unable to initialize the quick config.")
+	configFile, err := getConfigFile()
+	fatalIf(err, "Unable to get config file.")
+
+	err = qc.Save(configFile)
+	fatalIf(err, "Failed to migrate config from ‘"+cv4.Version+"’ to ‘"+srvConfig.Version+"’ failed.")
+
+	console.Println("Migration from version ‘" + cv4.Version + "’ to ‘" + srvConfig.Version + "’ completed successfully.")
+}
@@ -145,3 +145,132 @@ func loadConfigV3() (*configV3, error) {
 	}
 	return c, nil
 }
+
+// logger type representing version '4' logger config.
+type loggerV4 struct {
+	Console struct {
+		Enable bool   `json:"enable"`
+		Level  string `json:"level"`
+	} `json:"console"`
+	File struct {
+		Enable   bool   `json:"enable"`
+		Filename string `json:"fileName"`
+		Level    string `json:"level"`
+	} `json:"file"`
+	Syslog struct {
+		Enable bool   `json:"enable"`
+		Addr   string `json:"address"`
+		Level  string `json:"level"`
+	} `json:"syslog"`
+}
+
+// configV4 server configuration version '4'.
+type configV4 struct {
+	Version string `json:"version"`
+
+	// S3 API configuration.
+	Credential credential `json:"credential"`
+	Region     string     `json:"region"`
+
+	// Additional error logging configuration.
+	Logger loggerV4 `json:"logger"`
+}
+
+// loadConfigV4 load config version '4'.
+func loadConfigV4() (*configV4, error) {
+	configFile, err := getConfigFile()
+	if err != nil {
+		return nil, err
+	}
+	if _, err = os.Stat(configFile); err != nil {
+		return nil, err
+	}
+	c := &configV4{}
+	c.Version = "4"
+	qc, err := quick.New(c)
+	if err != nil {
+		return nil, err
+	}
+	if err := qc.Load(configFile); err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
+// logger type representing version '5' logger config.
+type loggerV5 struct {
+	Console struct {
+		Enable bool   `json:"enable"`
+		Level  string `json:"level"`
+	} `json:"console"`
+	File struct {
+		Enable   bool   `json:"enable"`
+		Filename string `json:"fileName"`
+		Level    string `json:"level"`
+	} `json:"file"`
+	Syslog struct {
+		Enable bool   `json:"enable"`
+		Addr   string `json:"address"`
+		Level  string `json:"level"`
+	} `json:"syslog"`
+	AMQP struct {
+		Enable       bool   `json:"enable"`
+		Level        string `json:"level"`
+		URL          string `json:"url"`
+		Exchange     string `json:"exchange"`
+		RoutingKey   string `json:"routingKey"`
+		ExchangeType string `json:"exchangeType"`
+		Mandatory    bool   `json:"mandatory"`
+		Immediate    bool   `json:"immediate"`
+		Durable      bool   `json:"durable"`
+		Internal     bool   `json:"internal"`
+		NoWait       bool   `json:"noWait"`
+		AutoDeleted  bool   `json:"autoDeleted"`
+	} `json:"amqp"`
+	ElasticSearch struct {
+		Enable bool   `json:"enable"`
+		Level  string `json:"level"`
+		URL    string `json:"url"`
+		Index  string `json:"index"`
+	} `json:"elasticsearch"`
+	Redis struct {
+		Enable   bool   `json:"enable"`
+		Level    string `json:"level"`
+		Addr     string `json:"address"`
+		Password string `json:"password"`
+		Key      string `json:"key"`
+	} `json:"redis"`
+}
+
+// configV5 server configuration version '5'.
+type configV5 struct {
+	Version string `json:"version"`
+
+	// S3 API configuration.
+	Credential credential `json:"credential"`
+	Region     string     `json:"region"`
+
+	// Additional error logging configuration.
+	Logger loggerV5 `json:"logger"`
+}
+
+// loadConfigV5 load config version '5'.
+func loadConfigV5() (*configV5, error) {
+	configFile, err := getConfigFile()
+	if err != nil {
+		return nil, err
+	}
+	if _, err = os.Stat(configFile); err != nil {
+		return nil, err
+	}
+	c := &configV5{}
+	c.Version = "5"
+	qc, err := quick.New(c)
+	if err != nil {
+		return nil, err
+	}
+	if err := qc.Load(configFile); err != nil {
+		return nil, err
+	}
+	return c, nil
+}
@@ -23,8 +23,8 @@ import (
 	"github.com/minio/minio/pkg/quick"
 )

-// serverConfigV4 server configuration version '4'.
-type serverConfigV4 struct {
+// serverConfigV6 server configuration version '5'.
+type serverConfigV6 struct {
 	Version string `json:"version"`

 	// S3 API configuration.
@@ -34,6 +34,9 @@ type serverConfigV4 struct {
 	// Additional error logging configuration.
 	Logger logger `json:"logger"`

+	// Notification queue configuration.
+	Notify notifier `json:"notify"`
+
 	// Read Write mutex.
 	rwMutex *sync.RWMutex
 }
@@ -41,28 +44,25 @@ type serverConfigV4 struct {
 // initConfig - initialize server config. config version (called only once).
 func initConfig() error {
 	if !isConfigFileExists() {
-		srvCfg := &serverConfigV4{}
+		// Initialize server config.
+		srvCfg := &serverConfigV6{}
 		srvCfg.Version = globalMinioConfigVersion
 		srvCfg.Region = "us-east-1"
 		srvCfg.Credential = mustGenAccessKeys()
+
 		// Enable console logger by default on a fresh run.
 		srvCfg.Logger.Console = consoleLogger{
 			Enable: true,
 			Level:  "fatal",
 		}
 		srvCfg.rwMutex = &sync.RWMutex{}
+
 		// Create config path.
 		err := createConfigPath()
 		if err != nil {
 			return err
 		}

-		// Create certs path.
-		err = createCertsPath()
-		if err != nil {
-			return err
-		}
-
 		// Save the new config globally.
 		serverConfig = srvCfg

@@ -76,7 +76,7 @@ func initConfig() error {
 	if _, err = os.Stat(configFile); err != nil {
 		return err
 	}
-	srvCfg := &serverConfigV4{}
+	srvCfg := &serverConfigV6{}
 	srvCfg.Version = globalMinioConfigVersion
 	srvCfg.rwMutex = &sync.RWMutex{}
 	qc, err := quick.New(srvCfg)
@@ -90,14 +90,15 @@ func initConfig() error {
 	serverConfig = srvCfg
 	// Set the version properly after the unmarshalled json is loaded.
 	serverConfig.Version = globalMinioConfigVersion
+
 	return nil
 }

 // serverConfig server config.
-var serverConfig *serverConfigV4
+var serverConfig *serverConfigV6

 // GetVersion get current config version.
-func (s serverConfigV4) GetVersion() string {
+func (s serverConfigV6) GetVersion() string {
 	s.rwMutex.RLock()
 	defer s.rwMutex.RUnlock()
 	return s.Version
@@ -105,78 +106,135 @@ func (s serverConfigV4) GetVersion() string {

 /// Logger related.

+func (s *serverConfigV6) SetAMQPNotifyByID(accountID string, amqpn amqpNotify) {
+	s.rwMutex.Lock()
+	defer s.rwMutex.Unlock()
+	s.Notify.AMQP[accountID] = amqpn
+}
+
+func (s serverConfigV6) GetAMQP() map[string]amqpNotify {
+	s.rwMutex.RLock()
+	defer s.rwMutex.RUnlock()
+	return s.Notify.AMQP
+}
+
+// GetAMQPNotify get current AMQP logger.
+func (s serverConfigV6) GetAMQPNotifyByID(accountID string) amqpNotify {
+	s.rwMutex.RLock()
+	defer s.rwMutex.RUnlock()
+	return s.Notify.AMQP[accountID]
+}
+
+func (s *serverConfigV6) SetElasticSearchNotifyByID(accountID string, esNotify elasticSearchNotify) {
+	s.rwMutex.Lock()
+	defer s.rwMutex.Unlock()
+	s.Notify.ElasticSearch[accountID] = esNotify
+}
+
+func (s serverConfigV6) GetElasticSearch() map[string]elasticSearchNotify {
+	s.rwMutex.RLock()
+	defer s.rwMutex.RUnlock()
+	return s.Notify.ElasticSearch
+}
+
+// GetElasticSearchNotify get current ElasicSearch logger.
+func (s serverConfigV6) GetElasticSearchNotifyByID(accountID string) elasticSearchNotify {
+	s.rwMutex.RLock()
+	defer s.rwMutex.RUnlock()
+	return s.Notify.ElasticSearch[accountID]
+}
+
+func (s *serverConfigV6) SetRedisNotifyByID(accountID string, rNotify redisNotify) {
+	s.rwMutex.Lock()
+	defer s.rwMutex.Unlock()
+	s.Notify.Redis[accountID] = rNotify
+}
+
+func (s serverConfigV6) GetRedis() map[string]redisNotify {
+	s.rwMutex.RLock()
+	defer s.rwMutex.RUnlock()
+	return s.Notify.Redis
+}
+
+// GetRedisNotify get current Redis logger.
+func (s serverConfigV6) GetRedisNotifyByID(accountID string) redisNotify {
+	s.rwMutex.RLock()
+	defer s.rwMutex.RUnlock()
+	return s.Notify.Redis[accountID]
+}
+
 // SetFileLogger set new file logger.
-func (s *serverConfigV4) SetFileLogger(flogger fileLogger) {
+func (s *serverConfigV6) SetFileLogger(flogger fileLogger) {
 	s.rwMutex.Lock()
 	defer s.rwMutex.Unlock()
 	s.Logger.File = flogger
 }

 // GetFileLogger get current file logger.
-func (s serverConfigV4) GetFileLogger() fileLogger {
+func (s serverConfigV6) GetFileLogger() fileLogger {
 	s.rwMutex.RLock()
 	defer s.rwMutex.RUnlock()
 	return s.Logger.File
 }

 // SetConsoleLogger set new console logger.
-func (s *serverConfigV4) SetConsoleLogger(clogger consoleLogger) {
+func (s *serverConfigV6) SetConsoleLogger(clogger consoleLogger) {
 	s.rwMutex.Lock()
 	defer s.rwMutex.Unlock()
 	s.Logger.Console = clogger
 }

 // GetConsoleLogger get current console logger.
-func (s serverConfigV4) GetConsoleLogger() consoleLogger {
+func (s serverConfigV6) GetConsoleLogger() consoleLogger {
 	s.rwMutex.RLock()
 	defer s.rwMutex.RUnlock()
 	return s.Logger.Console
 }

 // SetSyslogLogger set new syslog logger.
-func (s *serverConfigV4) SetSyslogLogger(slogger syslogLogger) {
+func (s *serverConfigV6) SetSyslogLogger(slogger syslogLogger) {
 	s.rwMutex.Lock()
 	defer s.rwMutex.Unlock()
 	s.Logger.Syslog = slogger
 }

 // GetSyslogLogger get current syslog logger.
-func (s *serverConfigV4) GetSyslogLogger() syslogLogger {
+func (s *serverConfigV6) GetSyslogLogger() syslogLogger {
 	s.rwMutex.RLock()
 	defer s.rwMutex.RUnlock()
 	return s.Logger.Syslog
 }

 // SetRegion set new region.
-func (s *serverConfigV4) SetRegion(region string) {
+func (s *serverConfigV6) SetRegion(region string) {
 	s.rwMutex.Lock()
 	defer s.rwMutex.Unlock()
 	s.Region = region
 }

 // GetRegion get current region.
-func (s serverConfigV4) GetRegion() string {
+func (s serverConfigV6) GetRegion() string {
 	s.rwMutex.RLock()
 	defer s.rwMutex.RUnlock()
 	return s.Region
 }

 // SetCredentials set new credentials.
-func (s *serverConfigV4) SetCredential(creds credential) {
+func (s *serverConfigV6) SetCredential(creds credential) {
 	s.rwMutex.Lock()
 	defer s.rwMutex.Unlock()
 	s.Credential = creds
 }

 // GetCredentials get current credentials.
-func (s serverConfigV4) GetCredential() credential {
+func (s serverConfigV6) GetCredential() credential {
 	s.rwMutex.RLock()
 	defer s.rwMutex.RUnlock()
 	return s.Credential
 }

 // Save config.
-func (s serverConfigV4) Save() error {
+func (s serverConfigV6) Save() error {
 	s.rwMutex.RLock()
 	defer s.rwMutex.RUnlock()

@@ -0,0 +1,49 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import "net/http"
+
+// Standard cross domain policy information located at https://s3.amazonaws.com/crossdomain.xml
+var crossDomainXML = `<?xml version="1.0"?><!DOCTYPE cross-domain-policy SYSTEM "http://www.adobe.com/xml/dtds/cross-domain-policy.dtd"><cross-domain-policy><allow-access-from domain="*" secure="false" /></cross-domain-policy>`
+
+// Cross domain policy implements http.Handler interface, implementing a custom ServerHTTP.
+type crossDomainPolicy struct {
+	handler http.Handler
+}
+
+// A cross-domain policy file is an XML document that grants a web client, such as Adobe Flash Player
+// or Adobe Acrobat (though not necessarily limited to these), permission to handle data across domains.
+// When clients request content hosted on a particular source domain and that content make requests
+// directed towards a domain other than its own, the remote domain needs to host a cross-domain
+// policy file that grants access to the source domain, allowing the client to continue the transaction.
+func setCrossDomainPolicy(h http.Handler) http.Handler {
+	return crossDomainPolicy{handler: h}
+}
+
+func (c crossDomainPolicy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Look for 'crossdomain.xml' in the incoming request.
+	switch r.URL.Path {
+	case "/crossdomain.xml":
+		// Write the standard cross domain policy xml.
+		w.Write([]byte(crossDomainXML))
+		// Request completed, no need to serve to other handlers.
+		return
+	}
+	// Continue to serve the request further.
+	c.handler.ServeHTTP(w, r)
+}
@@ -0,0 +1,66 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"math"
+	"testing"
+)
+
+// Test minimum function which calculates the minimal value in a list of integers
+func TestMinimum(t *testing.T) {
+	type testCase struct {
+		listval  []int
+		expected int
+		pass     bool
+	}
+	testCases := []testCase{
+		{listval: []int{3, 4, 15}, expected: 3},
+		{listval: []int{}, expected: math.MaxInt32},
+	}
+	// Validate all the test cases.
+	for i, tt := range testCases {
+		val := minimum(tt.listval)
+		if val != tt.expected {
+			t.Errorf("Test %d:, Expected %d, got %d", i+1, tt.expected, val)
+		}
+	}
+}
+
+// Test DamerauLevenshtein which calculates the difference distance between two words
+func TestDamerauLevenshtein(t *testing.T) {
+	type testCase struct {
+		word1    string
+		word2    string
+		distance int
+	}
+	testCases := []testCase{
+		{word1: "", word2: "", distance: 0},
+		{word1: "a", word2: "a", distance: 0},
+		{word1: "a", word2: "b", distance: 1},
+		{word1: "rm", word2: "tm", distance: 1},
+		{word1: "version", word2: "evrsion", distance: 1},
+		{word1: "version", word2: "bersio", distance: 2},
+	}
+	// Validate all the test cases.
+	for i, tt := range testCases {
+		d := DamerauLevenshteinDistance(tt.word1, tt.word2)
+		if d != tt.distance {
+			t.Errorf("Test %d:, Expected %d, got %d", i+1, tt.distance, d)
+		}
+	}
+}
@@ -50,7 +50,7 @@ if [ ! $# -eq 2 ]
 then
 	# exit if commit SHA's are not provided. 
 	echo $#
-	echo "Need Commit SHA's of 2 snapshots to be supplied to run benchmark comparision."
+	echo "Need Commit SHA's of 2 snapshots to be supplied to run benchmark comparison."
 	exit 1
 fi

@@ -5,7 +5,8 @@ Service script for minio service for systemd.
 ```
 mkdir /etc/minio/
 mkdir -p /usr/share/minio/bin/
-wget -o /usr/share/minio/bin/minio http://...
+wget -O /usr/share/minio/bin/minio http://...
+chmod +x /usr/share/minio/bin/minio
 ```

 Create minio user.
@@ -1,28 +1,39 @@
-### Run Minio docker image
+# Minio Docker Quickstart Guide [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/minio/minio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

-## Test Minio Docker Container
+
+## 1. Test Minio Docker Container
 Minio generates new access and secret keys each time you run this command. Container state is lost after you end this session. This mode is only intended for testing purpose.
-```bash
+
+```sh
+
 docker run -p 9000:9000 minio/minio /export
+
 ```

-## Run Minio Docker Container
+## 2. Run Minio Docker Container
+
 Minio container requires a persistent volume to store configuration and application data. Following command maps local persistent directories from the host OS to virtual config `~/.minio` and export `/export` directories. 

-```bash
+```sh
+
 docker run -p 9000:9000 --name minio1 \
  -v /mnt/export/minio1:/export \
  -v /mnt/config/minio1:/root/.minio \
  minio/minio /export
+
 ```

-## Custom Access and Secret Keys
+## 3. Custom Access and Secret Keys
+
 To override Minio's auto-generated keys, you may pass secret and access keys explicitly as environment variables. Minio server also allows regular strings as access and secret keys.
-```bash
+
+```sh
+
 docker run -p 9000:9000 --name minio1 \
  -e "MINIO_ACCESS_KEY=AKIAIOSFODNN7EXAMPLE" \
  -e "MINIO_SECRET_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" \
  -v /mnt/export/minio1:/export \
  -v /mnt/config/minio1:/root/.minio \
  minio/minio /export
+
 ```
@@ -1,59 +1,83 @@
+# Minio FreeBSD Quickstart Guide [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/minio/minio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
 ### Minio with ZFS backend - FreeBSD

 This example assumes that you have a FreeBSD 10.x running

-#### Step *1* 
+#### Step 1.

 As root on the FreeBSD edit `/etc/rc.conf`
-```
+
+```sh
+
 zfs_enable="YES"
+
 ```

 Start ZFS service
-```
+
+```sh
+
 # service zfs start
-```

 ```
+
+```sh
+
 # dd if=/dev/zero of=/zfs bs=1M count=4000
+
 ```

 Configure a loopback device on the `/zfs` file. 
-```
+
+```sh
+
 # mdconfig -a -t vnode -f /zfs
+
 ```

 Create zfs pool
-```
+
+```sh
+
 # zpool create minio-example /dev/md0
-```

 ```
+
+```sh
+
 # df /minio-example
 Filesystem    512-blocks Used   Avail Capacity  Mounted on
 minio-example    7872440   38 7872402     0%    /minio-example
+
 ```

 Verify if it is writable
-```
+
+```sh
+
 # touch /minio-example/testfile
 # ls -l /minio-example/testfile
 -rw-r--r--  1 root  wheel  0 Apr 26 00:51 /minio-example/testfile
+
 ```

-Now you have successfully created a ZFS pool for futher reading please refer to [ZFS Quickstart Guide](https://www.freebsd.org/doc/handbook/zfs-quickstart.html)
+Now you have successfully created a ZFS pool for further reading please refer to [ZFS Quickstart Guide](https://www.freebsd.org/doc/handbook/zfs-quickstart.html)

 However, this pool is not taking advantage of any ZFS features, so let's create a ZFS filesytem on this pool with compression enabled.  ZFS supports many compression algorithms: lzjb, gzip, zle, lz4.  LZ4 is often the most performant algorithm in terms of compression of data versus system overhead.


-```
+```sh
+
 # zfs create minio-example/compressed-objects
 # zfs set compression=lz4 minio-example/compressed-objects
+
 ```

 To keep monitoring your pool use

-```
+```sh
+
 # zpool status
  pool: minio-example
 state: ONLINE
@@ -65,39 +89,45 @@ config:
 	  md0       ONLINE       0     0     0

 errors: No known data errors
+
 ```

-#### Step *2*
+#### Step 2.

 Now start minio server on the ``/minio-example/compressed-objects``, change the permissions such that this directory is accessibly by a normal user

-```
+```sh
+
 # chown -R minio-user:minio-user /minio-example/compressed-objects
+
 ```

 Now login as ``minio-user`` and start minio server. 

-```
+```sh
+
 $ curl https://dl.minio.io/server/minio/release/freebsd-amd64/minio > minio
 $ chmod 755 minio
 $ ./minio server /minio-example/compressed-objects

-AccessKey: X3RU3Q6B4T20TYB281W5  SecretKey: bvp0DF8c+6MzL60UxFqOZGlA5Z8UPfIAATUQuzLS  Region: us-east-1

-Minio Object Storage:
-    http://159.203.234.49:9000
-    http://10.12.0.5:9000
-    http://127.0.0.1:9000
+Endpoint:  http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000
+AccessKey: USWUXHGYZQYFYFFIT3RE
+SecretKey: MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
+Region:    us-east-1

-Minio Browser:
-    http://159.203.234.49:9000
-    http://10.12.0.5:9000
-    http://127.0.0.1:9000
+Browser Access:
+  http://10.0.0.10:9000  http://127.0.0.1:9000  http://172.17.0.1:9000
+
+Command-line Access: https://docs.minio.io/docs/minio-client-quickstart-guide
+  $ mc config host add myminio http://localhost:9000  USWUXHGYZQYFYFFIT3RE MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
+
+Object API (Amazon S3 compatible):
+  Go:         https://docs.minio.io/docs/golang-client-quickstart-guide
+  Java:       https://docs.minio.io/docs/java-client-quickstart-guide
+  Python:     https://docs.minio.io/docs/python-client-quickstart-guide
+  JavaScript: https://docs.minio.io/docs/javascript-client-quickstart-guide

-To configure Minio Client:
-    $ wget https://dl.minio.io/client/mc/release/freebsd-amd64/mc
-    $ chmod 755 mc
-    $ ./mc config host add myminio http://localhost:9000 X3RU3Q6B4T20TYB281W5 bvp0DF8c+6MzL60UxFqOZGlA5Z8UPfIAATUQuzLS
 ```

 Point your browser to http://localhost:9000 and login with the credentials displayed on the command line. 
@@ -106,13 +136,15 @@ Now you have a S3 compatible server running on top of your ZFS backend which tra

 Thanks for using Minio, awaiting feedback :-) 

+
 #### Building Minio Server From Source

 It is possible to build the minio server from source on FreeBSD.  To do this we will used the golang distribution provided by the FreeBSD pkg infrastructure.

 First we will need to install golang as well as GNU make:

-```
+```sh
+
 $ sudo pkg install go gmake
 Updating FreeBSD repository catalogue..
 FreeBSD repository is up-to-date.
@@ -138,19 +170,24 @@ New packages to be INSTALLED:

 Next we need to configure our environment for golang.  Insert the following lines into your ~/.profile file, and be sure to source the file before proceeding to the next step:

-```
+
+```sh
+
 GOPATH=$HOME/golang; export GOPATH
 GOROOT=/usr/local/go/; export GOROOT
+
 ```

 Now we can proceed with the normal build process of minio server as found [here](https://github.com/nomadlogic/minio/blob/master/CONTRIBUTING.md).  The only caveat is we need to specify gmake (GNU make) when building minio server as the current Makefile is not BSD make compatible:

-```
+```sh
+
 $ mkdir -p $GOPATH/src/github.com/minio
 $ cd $GOPATH/src/github.com/minio
 $ git clone <paste saved URL for personal forked minio repo>
 $ cd minio
 $ gmake
+
 ```

 From here you can start the server as you would with a precompiled minio server build.
@@ -1,40 +0,0 @@
-# Server command line SPEC - Fri Apr  1 19:49:56 PDT 2016
-
-## Single disk
-Regular single server, single disk mode.
-```
-$ minio server <disk>
-```
-
-##  Multi disk
-```
-$ minio controller start - Start minio controller.
-```
-Prints a secret token to be used by all parties.
-
-Start all servers without disk with `MINIO_CONTROLLER` env set, start in cluster mode.
-```
-$ MINIO_CONTROLLER=<host>:<token> minio server
-```
-
-## Minio Controller cli.
-
-Set controller host and token.
-```
-$ export MINIO_CONTROLLER=<host>:<token>
-```
-
-Create a cluster from the pool of nodes.
-```
-$ minioctl new <clustername> <ip1>:/mnt/disk1 .. <ip16>:/mnt/disk1
-```
-
-Start the cluster.
-```
-$ minioctl start <clustername>
-```
-
-Stop the cluster
-```
-$ minioctl stop <clustername>
-```
@@ -1,33 +0,0 @@
-## Multipart
-
-Each incoming part is uploaded in the following format.
-
-Placeholder uploads.json to indicate a leaf.
-
- ```EXPORT_DIR/.minio/multipart/BUCKET/PATH/TO/OBJECT/uploads.json```
-
-Incomplete file
-
- ```EXPORT_DIR/.minio/multipart/BUCKET/PATH/TO/OBJECT/UPLOADID/00000.incomplete```
-
-Actual parts
-
- ```EXPORT_DIR/.minio/multipart/BUCKET/PATH/TO/OBJECT/UPLOADID/PART_NUMBER.MD5SUM_STRING```
-
-## FS Format.
-
-Each of these parts are concatenated back to a single contigous file.
-
-```EXPORT_DIR/BUCKET/PATH/TO/OBJECT```
-
-## XL Format.
-
-Each of these parts are kept as is in the following format.
-
-Special json file indicate the metata multipart information, essentially list of parts etc.
-
-```EXPORT_DIR/BUCKET/PATH/TO/OBJECT/00000.minio.multipart```
-
-All the parts that were uploaded.
-
-```EXPORT_DIR/BUCKET/PATH/TO/OBJECT/PART_NUMBER.minio.multipart```
@@ -0,0 +1,6 @@
+## Backends
+
+Minio currently implements two types of backends namely.
+
+- Filesystem layer (fs).
+- ErasureCode layer (XL).
@@ -0,0 +1,25 @@
+### Backend format `fs.json`
+
+```go
+// objectPartInfo Info of each part kept in the multipart metadata
+// file after CompleteMultipartUpload() is called.
+type objectPartInfo struct {
+	Number int    `json:"number"`
+	Name   string `json:"name"`
+	ETag   string `json:"etag"`
+	Size   int64  `json:"size"`
+}
+
+// A fsMetaV1 represents a metadata header mapping keys to sets of values.
+type fsMetaV1 struct {
+	Version string `json:"version"`
+	Format  string `json:"format"`
+	Minio   struct {
+		Release string `json:"release"`
+	} `json:"minio"`
+	// Metadata map for current object `fs.json`.
+	Meta  map[string]string `json:"meta,omitempty"`
+	Parts []objectPartInfo  `json:"parts,omitempty"`
+}
+
+```
@@ -4,6 +4,10 @@
    "minio": {
        "release": "DEVELOPMENT.GOGET"
    },
+    "meta": {
+        "content-type": "binary/octet-stream",
+        "content-encoding": "gzip"
+    },
    "parts": [
        {
            "number": 1,
@@ -0,0 +1,54 @@
+### Backend format `xl.json`
+
+```go
+// objectPartInfo Info of each part kept in the multipart metadata
+// file after CompleteMultipartUpload() is called.
+type objectPartInfo struct {
+	Number int    `json:"number"`
+	Name   string `json:"name"`
+	ETag   string `json:"etag"`
+	Size   int64  `json:"size"`
+}
+
+// checkSumInfo - carries checksums of individual scattered parts per disk.
+type checkSumInfo struct {
+	Name      string `json:"name"`
+	Algorithm string `json:"algorithm"`
+	Hash      string `json:"hash"`
+}
+
+// erasureInfo - carries erasure coding related information, block
+// distribution and checksums.
+type erasureInfo struct {
+	Algorithm    string         `json:"algorithm"`
+	DataBlocks   int            `json:"data"`
+	ParityBlocks int            `json:"parity"`
+	BlockSize    int64          `json:"blockSize"`
+	Index        int            `json:"index"`
+	Distribution []int          `json:"distribution"`
+	Checksum     []checkSumInfo `json:"checksum,omitempty"`
+}
+
+// statInfo - carries stat information of the object.
+type statInfo struct {
+	Size    int64     `json:"size"`    // Size of the object `xl.json`.
+	ModTime time.Time `json:"modTime"` // ModTime of the object `xl.json`.
+}
+
+// A xlMetaV1 represents `xl.json` metadata header.
+type xlMetaV1 struct {
+	Version string   `json:"version"` // Version of the current `xl.json`.
+	Format  string   `json:"format"`  // Format of the current `xl.json`.
+	Stat    statInfo `json:"stat"`    // Stat of the current object `xl.json`.
+	// Erasure coded info for the current object `xl.json`.
+	Erasure erasureInfo `json:"erasure"`
+	// Minio release tag for current object `xl.json`.
+	Minio struct {
+		Release string `json:"release"`
+	} `json:"minio"`
+	// Metadata map for current object `xl.json`.
+	Meta map[string]string `json:"meta,omitempty"`
+	// Captures all the individual object `xl.json`.
+	Parts []objectPartInfo `json:"parts,omitempty"`
+}
+```
@@ -16,7 +16,7 @@
    "meta": {
        "md5Sum": "97586a5290d4f5a41328062d6a7da593-3",
        "content-type": "application\/octet-stream",
-        "content-encoding": ""
+        "content-encoding": "gzip"
    },
    "minio": {
        "release": "DEVELOPMENT.GOGET"
@@ -0,0 +1,58 @@
+# Minio Erasure Code Quickstart Guide [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/minio/minio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Minio protects data against hardware failures and silent data corruption using erasure code and checksums. You may lose  half the number (N/2) of drives and still be able to recover the data.
+
+## 1. Prerequisites:
+
+Install Minio - [Minio Quickstart Guide](https://docs.minio.io/docs/minio)
+
+## What is Erasure Code?
+
+Erasure code is a mathematical algorithm to reconstruct missing or corrupted data. Minio uses Reed-Solomon code to shard objects into N/2 data and N/2 parity blocks. This means that in a 12 drive setup, an object is sharded across as 6 data and 6 parity blocks. You can lose as many as 6 drives (be it parity or data) and still reconstruct the data reliably from the remaining drives. 
+
+## Why is Erasure Code useful?
+
+Erasure code protects data from multiple drives failure unlike RAID or replication. For eg RAID6 can protect against 2 drive failure whereas in Minio erasure code you can lose as many as half number of drives and still the data remains safe. Further Minio's erasure code is at object level and can heal one object at a time. For RAID, healing can only be performed at volume level which translates into huge down time. As Minio encodes each object individually with a high parity count. Storage servers once deployed should not require drive replacement or healing for the lifetime of the server. Minio's erasure coded backend is designed for operational efficiency and takes full advantage of hardware acceleration whenever available.
+
+![Erasure](https://raw.githubusercontent.com/minio/minio/master/docs/screenshots/erasure-code.jpg?raw=true)
+
+## What is Bit Rot protection?
+
+Bit Rot also known as Data Rot or Silent Data Corruption is a serious data loss issue faced by disk drives today. Data on the drive may silently get corrupted without signalling an error has occurred. This makes Bit Rot more dangerous than permanent hard drive failure. 
+
+Minio's erasure coded backend uses high speed [BLAKE2](https://blog.minio.io/accelerating-blake2b-by-4x-using-simd-in-go-assembly-33ef16c8a56b#.jrp1fdwer) hash based checksums to protect against Bit Rot.  
+
+## Deployment Scenarios
+
+Minio server runs on a variety of hardware, operating systems and virtual/container environments. 
+
+Minio erasure code backend is limited by design to a minimum of 6 drives and a maximum of 16 drives. The hard limit of 16 drives comes from operational experience. Failure domain becomes too large beyond 16 drives. If you need to scale beyond 16 drives, you may run multiple instances of Minio server on different ports. 
+
+#### Reference Physical Hardware: 
+
+* [SMC 5018A-AR12L (Intel Atom)](http://www.supermicro.com/products/system/1U/5018/SSG-5018A-AR12L.cfm?parts=SHOW) - SMC 1U SoC Atom C2750 platform with 12x 3.5” drive bays
+* [Quanta Grid D51B-2U (OCP Compliant) ](http://www.qct.io/Product/Servers/Rackmount-Servers/2U/QuantaGrid-D51B-2U-p256c77c70c83c118)- Quanta 2U DP E5-2600v3 platform with 12x 3.5” drive bays
+* [Cisco UCS C240 M4 Rack Server](http://www.cisco.com/c/en/us/products/servers-unified-computing/ucs-c240-m4-rack-server/index.html) - Cisco 2U DP E5-2600v3 platform with 12x 3.5” drive bays
+* [Intel® Server System R2312WTTYSR](http://ark.intel.com/products/88286) - Intel 2U DP E5-2600v3 platform with 12x 3.5” drive bays
+
+#### Reference Cloud Hosting Providers:
+
+* [Packet](https://www.packet.net): Packet is the baremetal cloud provider.
+* [Digital Ocean](https://www.digitalocean.com): Deploy an SSD cloud server in 55 seconds.
+* [OVH](https://www.ovh.com/us): Build your own infrastructure with OVH public cloud.
+* [Onlinetech](http://www.onlinetech.com): Secure, compliant enterprise cloud.
+* [SSD Nodes](https://www.ssdnodes.com): Simple, high performance cloud provider with truly personalized support.
+
+## 2. Run Minio Server with Erasure Code.
+
+Example: Start Minio server in a 12 drives setup.
+
+```sh
+
+$ minio server /mnt/export1/backend /mnt/export2/backend /mnt/export3/backend /mnt/export4/backend /mnt/export5/backend /mnt/export6/backend /mnt/export7/backend /mnt/export8/backend /mnt/export9/backend /mnt/export10/backend /mnt/export11/backend /mnt/export12/backend
+
+```
+
+## 3. Test your setup
+
+You may unplug drives randomly and continue to perform I/O on the system.
@@ -0,0 +1,80 @@
+# How to run multiple Minio server instances on single machine. [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/minio/minio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+![minio_MULTIVERSE](https://github.com/minio/minio/blob/master/docs/screenshots/multiport.jpeg?raw=true)
+
+
+In this document we will illustrate how to set up multiple Minio server instances on single machine. These Minio servers are running on their own port, data directory & configuration directory.
+
+## 1. Prerequisites
+
+* Download Minio server from [here](https://docs.minio.io/docs/minio)
+* Download & Install mc from [here](https://docs.minio.io/docs/minio-client-quickstart-guide)
+* Ports should be available for Minio server's use
+
+## 2. Install and Configure Minio Server
+
+Minio server is running on port 9002, 9003, 9004 with associated data directory and configuration file directory.
+
+**Minio server on port ``9002``**
+
+```sh
+$ ./minio -C /home/minio/minio1/.minio server --address 192.168.1.11:9002 minio1/data1/
+
+Endpoint:  http://192.168.1.11:9002
+AccessKey: XTW9SWKRWYKWE9M9K9RG 
+SecretKey: pZehbS5UNrA9BAhYHnWC/QVvQ7vGVge48WGHzG9t 
+Region:    us-east-1
+```
+
+**Minio server on port ``9003``**
+
+```sh
+$ ./minio -C /home/minio/minio2/.minio server --address 192.168.1.11:9003 minio1/data2/                                                 
+
+Endpoint:  http://192.168.1.11:9003
+AccessKey: UTD2WWPJOK754KMZKHWF 
+SecretKey: DbikDIY4+wItcexJa4nyrwQC0V2r7kLsK5SsRgHb 
+Region:    us-east-1
+```
+
+**Minio server on port ``9004``**
+
+```sh
+$ ./minio -C /home/minio/minio3/.minio server --address 192.168.1.11:9004 minio1/data3/                                                 
+
+Endpoint:  http://192.168.1.11:9004
+AccessKey: KXLOJ908VEJ2K9RGUFHQ 
+SecretKey: LpkeePMtEWAa6payiCovfrNKiFHhABsJhMwGynF8 
+Region:    us-east-1
+```
+
+This is how directory structure will look like for ``minio1``, replace it with your local setup.
+
+```sh
+$ tree -la minio1/
+minio1/
+├── data1
+└── .minio
+    ├── certs
+    ├── config.json
+    └── config.json.old
+
+3 directories, 2 files
+
+```
+**Testing it all**
+
+Using terminal comamnd ``netstat`` we can see ``Minio Server`` is running on different ports on same machine.
+
+```sh
+$ netstat -ntlp | grep minio
+tcp        0      0 192.168.1.11:9002       0.0.0.0:*               LISTEN      29573/minio     
+tcp        0      0 192.168.1.11:9003       0.0.0.0:*               LISTEN      29597/minio     
+tcp        0      0 192.168.1.11:9004       0.0.0.0:*               LISTEN      29631/minio     
+```
+
+
+# Explore Further
+* [Minio Quickstart Guide](https://docs.minio.io/docs/minio-quickstart-guide)
+* [Minio Client Complete Guide](https://docs.minio.io/docs/minio-client-complete-guide)
+
@@ -1,28 +0,0 @@
-### Logging.
-
- `fatalIf` - wrapper function which takes error and prints jsonic error messages.
- `errorIf` - similar to fatalIf but doesn't exit on err != nil.
-
-Supported logging targets.
-
- console
- file
- syslog
-
-Sample logger section from `~/.minio/config.json`
-```
-		"console": {
-			"enable": true,
-			"level": "error"
-		},
-		"file": {
-			"enable": false,
-			"fileName": "",
-			"level": "error"
-		},
-		"syslog": {
-			"enable": false,
-			"address": "",
-			"level": "error"
-		}
-```
@@ -0,0 +1,110 @@
+# Minio Server configuration files Guide [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/minio/minio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+In this document we will walk through the configuration files of Minio Server.
+
+## Minio Server configuration directory
+Minio Server configurations are stored in file name ``.minio``.  It's a hidden file which resides on user's home directory.
+
+**This how the structure of the directory looks like:**
+
+```sh
+$ tree ~/.minio/
+/Users/supernova/.minio/
+├── certs
+├── config.json
+└── config.json.old
+
+1 directory, 2 files
+```
+### Files and directories.
+
+##### ``certs`` directory 
+``certs`` directory stores key & cert information, which are needed to run Minio in ``HTTPS``. You can read more on running Minio with ``HTTPS`` with Let's Encrypt cert with Concert [here](https://docs.minio.io/docs/generate-let-s-encypt-certificate-using-concert-for-minio) 
+
+##### ``config.json``
+config.json is the configuration file for Minio, it gets generated after you install and start Minio.
+
+```sh
+
+$ cat config.json
+{
+	"version": "6",
+	"credential": {
+		"accessKey": "YI7S1CKXB76RGOGT6R8W",
+		"secretKey": "FJ9PWUVNXGPfiI72WMRFepN3LsFgW3MjsxSALroV"
+	},
+	"region": "us-east-1",
+	"logger": {
+		"console": {
+			"enable": true,
+			"level": "fatal"
+		},
+		"file": {
+			"enable": false,
+			"fileName": "",
+			"level": "error"
+		},
+		"syslog": {
+			"enable": false,
+			"address": "",
+			"level": "debug"
+		}
+	},
+	"notify": {
+		"amqp": {
+			"1": {
+				"enable": false,
+				"url": "",
+				"exchange": "",
+				"routingKey": "",
+				"exchangeType": "",
+				"mandatory": false,
+				"immediate": false,
+				"durable": false,
+				"internal": false,
+				"noWait": false,
+				"autoDeleted": false
+			}
+		},
+		"elasticsearch": {
+			"1": {
+				"enable": false,
+				"url": "",
+				"index": ""
+			}
+		},
+		"redis": {
+			"1": {
+				"enable": false,
+				"address": "",
+				"password": "",
+				"key": ""
+			}
+		}
+	}
+}
+
+
+```
+
+``version`` :  Represents `version` number of current configuration file.
+
+``credential`` :  Represents authentication credentials for the server, value is automatically generated upon first server start.
+
+``region`` :  Represents deployment region for the server,  value defaults to `us-east-1`. 
+
+``logger `` : Represents various logging types supported for server error logs, console logger is enabled by default.
+
+``notify``:  Represents various notification types supported. These notification types should be configured prior to using bucket
+
+
+##### ``config.json.old``
+This file keeps previous config file version details.
+
+## Explore Further
+* [Minio Quickstart Guide](https://docs.minio.io/docs/minio-quickstart-guide)
+
+
+
+
+
@@ -0,0 +1,116 @@
+# How to use ``mc mirror`` to setup replication between two sites running Minio. [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/minio/minio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+![minio_MIRROR](https://github.com/minio/minio/blob/master/docs/screenshots/miniomirror.jpeg?raw=true)
+
+
+
+In this document we will illustrate how to set up replication between two Minio servers, `minio1` and `minio2` running on ``192.168.1.11`` and ``192.168.1.12`` respectively. We will mirror the data directory on `minio1` to the bucket on `minio2`.
+
+
+## 1. Prerequisites
+
+* Download Minio server from [here](https://docs.minio.io/docs/minio)
+* Download & Install mc from [here](https://docs.minio.io/docs/minio-client-quickstart-guide)
+* Familiarity with [``mc mirror``](https://docs.minio.io/docs/minio-client-complete-guide#mirror)
+
+## 2. Install and Configure Minio Server
+
+### Setup minio1
+
+```sh
+$ ./minio server minio1-data/
+
+Endpoint:  http://127.0.0.1:9000  http://192.168.1.11:9000
+AccessKey: MURIVYBYNPTYE7O8I779 
+SecretKey: lVbZmz4CvGkBl7JKw5icuL7RCcSvpBJTkAJTFQwz
+Region:    us-east-1
+```
+**mc alias**
+
+Alias is a short name to your cloud storage service  for ``Minio client``. End-point, access and secret keys are supplied by your cloud storage provider. API signature is an optional argument. By default, it is set to ``S3v4``.
+
+```sh
+$ ./mc config host add minio1 http://192.168.1.11:9000 MURIVYBYNPTYE7O8I779 lVbZmz4CvGkBl7JKw5icuL7RCcSvpBJTkAJTFQwz
+```
+
+**Create buckets and add objects**
+
+We have created few buckets using [``mc mb``](https://docs.minio.io/docs/minio-client-complete-guide#mb) and added objects to it using [``mc cp``](https://docs.minio.io/docs/minio-client-complete-guide#cp) Minio client commands. 
+
+```sh
+$ ./mc mb minio1/mybucket
+$ ./mc cp myfile.txt minio1/bucket1
+$ ./mc ls minio1
+[2016-07-31 10:26:55 PDT]     0B bucket1/
+[2016-07-31 09:36:17 PDT]     0B bucket2/
+[2016-07-31 09:38:08 PDT]     0B bucket3/
+```
+
+### Setup minio2 
+
+```sh
+$ ./minio server minio2-data/
+
+Endpoint:  http://127.0.0.1:9000  http://192.168.1.12:9000
+AccessKey: YRDRWWQLEWS9OBJ31GZ2
+SecretKey: y2sSWzx5ytwvkELcxOuSaQ8n3doNqoIilRpb5Kjj
+Region:    us-east-1
+```
+
+```sh
+$ ./mc config host add minio2 http://192.168.1.12:9000 YRDRWWQLEWS9OBJ31GZ2 y2sSWzx5ytwvkELcxOuSaQ8n3doNqoIilRpb5Kjj
+```
+
+**Create bucket**
+
+We are creating destination bucket ``mbucket`` on ``minio2`` and adding ``minio2`` alias. The bucket ``mbucket`` will be used to mirror data directory of ``minio1``. 
+
+```sh
+$ ./mc mb minio1/mbucket
+```
+
+```sh
+$ ./mc config host add minio2 http://192.168.1.12:9000 YRDRWWQLEWS9OBJ31GZ2 y2sSWzx5ytwvkELcxOuSaQ8n3doNqoIilRpb5Kjj
+
+```
+
+## 4. Setup crontab
+Cron is a Unix/Linux system utility by which you can schedule a task process for particular duration, we have tested this setup on Ubuntu Linux.
+
+
+### Script
+
+Add crontab configuration on `minio1` providing path of data directory, ``minio1-data``. 
+
+``--force`` option with ``mc mirror``  overwrites the destination contents, this would keep your contents in sync. 
+
+```sh
+
+#!/bin/bash
+datadir="/home/minio/minio1-data/"
+minio2="minio2/mbucket"
+MC_PATH="/home/minio/mc"
+$MC_PATH --quiet  mirror --force $minio1 $minio2
+
+```
+
+Set executable permissions on the script before adding a cron entry.
+
+```sh
+
+$ chmod 755 /home/minio/minio.sh
+```
+
+Set a new cron entry to run ``minio.sh`` script once every 30mins.
+
+```sh
+
+$ crontab -e
+*/30 * * * * /home/minio/minio.sh 
+```
+
+Note: We are going to introduce continuous replication feature in `mc mirror` which will enable the sites to be in sync without having the need to setup cron job.
+
+# Explore Further
+* [Minio Quickstart Guide](https://docs.minio.io/docs/minio-quickstart-guide)
+* [Minio Client Complete Guide](https://docs.minio.io/docs/minio-client-complete-guide)
@@ -1,41 +0,0 @@
-### file.json
-
-``file.json`` is a special file captured and written by XL storage API layer
-to interpret, manage and extract erasured data from multiple disks.
-
-```json
-{
-    "version": "1.0.0",
-    "stat": {
-        "size": 24256,
-        "modTime": "2016-04-28T00:11:37.843Z",
-        "delete": false,
-        "version": 0
-    },
-    "erasure": {
-        "data": 5,
-        "parity": 5,
-        "blockSize": 4194304
-    ],
-    "minio": {
-        "release": "RELEASE.2016-04-28T00-09-47Z"
-    }
-}
-```
-
-#### JSON meaning.
-
- "version" // Version of the meta json file.
-
- "stat" // Stat value of written file.
-
-  - "size"     // Size of the file.
-  - "modTime"  // Modified time of the file.
-  - "deleted"  // Field to track if the file is deleted when disks are down.
-  - "version"  // File version tracked when disks are down.
-
- "erasure" // Erasure metadata for the written file.
-
-  - "data"       // Data blocks parts of the file.
-  - "parity"     // Parity blocks parts of the file.
-  - "blockSize"  // BlockSize read/write chunk size.
@@ -28,79 +28,59 @@ import (
 // erasureCreateFile - writes an entire stream by erasure coding to
 // all the disks, writes also calculate individual block's checksum
 // for future bit-rot protection.
-func erasureCreateFile(disks []StorageAPI, volume string, path string, partName string, data io.Reader, eInfos []erasureInfo, writeQuorum int) (newEInfos []erasureInfo, size int64, err error) {
-	// Just pick one eInfo.
-	eInfo := pickValidErasureInfo(eInfos)
-
+func erasureCreateFile(disks []StorageAPI, volume, path string, reader io.Reader, blockSize int64, dataBlocks int, parityBlocks int, algo string, writeQuorum int) (bytesWritten int64, checkSums []string, err error) {
 	// Allocated blockSized buffer for reading.
-	buf := make([]byte, eInfo.BlockSize)
-	hashWriters := newHashWriters(len(disks))
+	buf := make([]byte, blockSize)
+
+	hashWriters := newHashWriters(len(disks), algo)

 	// Read until io.EOF, erasure codes data and writes to all disks.
 	for {
 		var blocks [][]byte
-		n, rErr := io.ReadFull(data, buf)
+		n, rErr := io.ReadFull(reader, buf)
 		// FIXME: this is a bug in Golang, n == 0 and err ==
 		// io.ErrUnexpectedEOF for io.ReadFull function.
 		if n == 0 && rErr == io.ErrUnexpectedEOF {
-			return nil, 0, rErr
+			return 0, nil, rErr
 		}
 		if rErr == io.EOF {
 			// We have reached EOF on the first byte read, io.Reader
 			// must be 0bytes, we don't need to erasure code
 			// data. Will create a 0byte file instead.
-			if size == 0 {
+			if bytesWritten == 0 {
 				blocks = make([][]byte, len(disks))
-				rErr = appendFile(disks, volume, path, blocks, eInfo.Distribution, hashWriters, writeQuorum)
+				rErr = appendFile(disks, volume, path, blocks, hashWriters, writeQuorum)
 				if rErr != nil {
-					return nil, 0, rErr
+					return 0, nil, rErr
 				}
 			} // else we have reached EOF after few reads, no need to
 			// add an additional 0bytes at the end.
 			break
 		}
 		if rErr != nil && rErr != io.ErrUnexpectedEOF {
-			return nil, 0, rErr
+			return 0, nil, rErr
 		}
 		if n > 0 {
 			// Returns encoded blocks.
 			var enErr error
-			blocks, enErr = encodeData(buf[0:n], eInfo.DataBlocks, eInfo.ParityBlocks)
+			blocks, enErr = encodeData(buf[0:n], dataBlocks, parityBlocks)
 			if enErr != nil {
-				return nil, 0, enErr
+				return 0, nil, enErr
 			}

 			// Write to all disks.
-			if err = appendFile(disks, volume, path, blocks, eInfo.Distribution, hashWriters, writeQuorum); err != nil {
-				return nil, 0, err
+			if err = appendFile(disks, volume, path, blocks, hashWriters, writeQuorum); err != nil {
+				return 0, nil, err
 			}
-			size += int64(n)
+			bytesWritten += int64(n)
 		}
 	}

-	// Save the checksums.
-	checkSums := make([]checkSumInfo, len(disks))
-	for index := range disks {
-		blockIndex := eInfo.Distribution[index] - 1
-		checkSums[blockIndex] = checkSumInfo{
-			Name:      partName,
-			Algorithm: "blake2b",
-			Hash:      hex.EncodeToString(hashWriters[blockIndex].Sum(nil)),
-		}
+	checkSums = make([]string, len(disks))
+	for i := range checkSums {
+		checkSums[i] = hex.EncodeToString(hashWriters[i].Sum(nil))
 	}
-
-	// Erasure info update for checksum for each disks.
-	newEInfos = make([]erasureInfo, len(disks))
-	for index, eInfo := range eInfos {
-		if eInfo.IsValid() {
-			blockIndex := eInfo.Distribution[index] - 1
-			newEInfos[index] = eInfo
-			newEInfos[index].Checksum = append(newEInfos[index].Checksum, checkSums[blockIndex])
-		}
-	}
-
-	// Return newEInfos.
-	return newEInfos, size, nil
+	return bytesWritten, checkSums, nil
 }

 // encodeData - encodes incoming data buffer into
@@ -128,7 +108,7 @@ func encodeData(dataBuffer []byte, dataBlocks, parityBlocks int) ([][]byte, erro
 }

 // appendFile - append data buffer at path.
-func appendFile(disks []StorageAPI, volume, path string, enBlocks [][]byte, distribution []int, hashWriters []hash.Hash, writeQuorum int) (err error) {
+func appendFile(disks []StorageAPI, volume, path string, enBlocks [][]byte, hashWriters []hash.Hash, writeQuorum int) (err error) {
 	var wg = &sync.WaitGroup{}
 	var wErrs = make([]error, len(disks))
 	// Write encoded data to quorum disks in parallel.
@@ -140,16 +120,14 @@ func appendFile(disks []StorageAPI, volume, path string, enBlocks [][]byte, dist
 		// Write encoded data in routine.
 		go func(index int, disk StorageAPI) {
 			defer wg.Done()
-			// Pick the block from the distribution.
-			blockIndex := distribution[index] - 1
-			wErr := disk.AppendFile(volume, path, enBlocks[blockIndex])
+			wErr := disk.AppendFile(volume, path, enBlocks[index])
 			if wErr != nil {
 				wErrs[index] = wErr
 				return
 			}

 			// Calculate hash for each blocks.
-			hashWriters[blockIndex].Write(enBlocks[blockIndex])
+			hashWriters[index].Write(enBlocks[index])

 			// Successfully wrote.
 			wErrs[index] = nil
@@ -161,7 +139,7 @@ func appendFile(disks []StorageAPI, volume, path string, enBlocks [][]byte, dist

 	// Do we have write quorum?.
 	if !isDiskQuorum(wErrs, writeQuorum) {
-		return toObjectErr(errXLWriteQuorum, volume, path)
+		return errXLWriteQuorum
 	}
 	return nil
 }
@@ -0,0 +1,203 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"bytes"
+	"crypto/rand"
+	"testing"
+
+	"github.com/klauspost/reedsolomon"
+)
+
+// Simulates a faulty disk for AppendFile()
+type AppendDiskDown struct {
+	*posix
+}
+
+func (a AppendDiskDown) AppendFile(volume string, path string, buf []byte) error {
+	return errFaultyDisk
+}
+
+// Test erasureCreateFile()
+func TestErasureCreateFile(t *testing.T) {
+	// Initialize environment needed for the test.
+	dataBlocks := 7
+	parityBlocks := 7
+	blockSize := int64(blockSizeV1)
+	setup, err := newErasureTestSetup(dataBlocks, parityBlocks, blockSize)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer setup.Remove()
+
+	disks := setup.disks
+
+	// Prepare a slice of 1MB with random data.
+	data := make([]byte, 1*1024*1024)
+	_, err = rand.Read(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Test when all disks are up.
+	size, _, err := erasureCreateFile(disks, "testbucket", "testobject1", bytes.NewReader(data), blockSize, dataBlocks, parityBlocks, bitRotAlgo, dataBlocks+1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if size != int64(len(data)) {
+		t.Errorf("erasureCreateFile returned %d, expected %d", size, len(data))
+	}
+
+	// 2 disks down.
+	disks[4] = AppendDiskDown{disks[4].(*posix)}
+	disks[5] = AppendDiskDown{disks[5].(*posix)}
+
+	// Test when two disks are down.
+	size, _, err = erasureCreateFile(disks, "testbucket", "testobject2", bytes.NewReader(data), blockSize, dataBlocks, parityBlocks, bitRotAlgo, dataBlocks+1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if size != int64(len(data)) {
+		t.Errorf("erasureCreateFile returned %d, expected %d", size, len(data))
+	}
+
+	// 4 more disks down. 6 disks down in total.
+	disks[6] = AppendDiskDown{disks[6].(*posix)}
+	disks[7] = AppendDiskDown{disks[7].(*posix)}
+	disks[8] = AppendDiskDown{disks[8].(*posix)}
+	disks[9] = AppendDiskDown{disks[9].(*posix)}
+
+	size, _, err = erasureCreateFile(disks, "testbucket", "testobject3", bytes.NewReader(data), blockSize, dataBlocks, parityBlocks, bitRotAlgo, dataBlocks+1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if size != int64(len(data)) {
+		t.Errorf("erasureCreateFile returned %d, expected %d", size, len(data))
+	}
+
+	// 1 more disk down. 7 disk down in total. Should return quorum error.
+	disks[10] = AppendDiskDown{disks[10].(*posix)}
+	_, _, err = erasureCreateFile(disks, "testbucket", "testobject4", bytes.NewReader(data), blockSize, dataBlocks, parityBlocks, bitRotAlgo, dataBlocks+1)
+	if err != errXLWriteQuorum {
+		t.Errorf("erasureCreateFile returned expected errXLWriteQuorum error, got %s", err)
+	}
+}
+
+// TestErasureEncode checks for encoding for different data sets.
+func TestErasureEncode(t *testing.T) {
+	// Collection of cases for encode cases.
+	testEncodeCases := []struct {
+		inputData         []byte
+		inputDataBlocks   int
+		inputParityBlocks int
+
+		shouldPass  bool
+		expectedErr error
+	}{
+		// TestCase - 1.
+		// Regular data encoded.
+		{
+			[]byte("Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum."),
+			8,
+			8,
+			true,
+			nil,
+		},
+		// TestCase - 2.
+		// Empty data errors out.
+		{
+			[]byte(""),
+			8,
+			8,
+			false,
+			reedsolomon.ErrShortData,
+		},
+		// TestCase - 3.
+		// Single byte encoded.
+		{
+			[]byte("1"),
+			4,
+			4,
+			true,
+			nil,
+		},
+		// TestCase - 4.
+		// test case with negative data block.
+		{
+			[]byte("1"),
+			-1,
+			8,
+			false,
+			reedsolomon.ErrInvShardNum,
+		},
+		// TestCase - 5.
+		// test case with negative parity block.
+		{
+			[]byte("1"),
+			8,
+			-1,
+			false,
+			reedsolomon.ErrInvShardNum,
+		},
+		// TestCase - 6.
+		// test case with zero data block.
+		{
+			[]byte("1"),
+			0,
+			8,
+			false,
+			reedsolomon.ErrInvShardNum,
+		},
+		// TestCase - 7.
+		// test case with zero parity block.
+		{
+			[]byte("1"),
+			8,
+			0,
+			false,
+			reedsolomon.ErrInvShardNum,
+		},
+		// TestCase - 8.
+		// test case with data + parity blocks > 255.
+		// expected to fail with Error Max Shard number.
+		{
+			[]byte("1"),
+			128,
+			128,
+			false,
+			reedsolomon.ErrMaxShardNum,
+		},
+	}
+
+	// Test encode cases.
+	for i, testCase := range testEncodeCases {
+		_, actualErr := encodeData(testCase.inputData, testCase.inputDataBlocks, testCase.inputParityBlocks)
+		if actualErr != nil && testCase.shouldPass {
+			t.Errorf("Test %d: Expected to pass but failed instead with \"%s\"", i+1, actualErr)
+		}
+		if actualErr == nil && !testCase.shouldPass {
+			t.Errorf("Test %d: Expected to fail with error <Error> \"%v\", but instead passed", i+1, testCase.expectedErr)
+		}
+		// Failed as expected, but does it fail for the expected reason.
+		if actualErr != nil && !testCase.shouldPass {
+			if testCase.expectedErr != actualErr {
+				t.Errorf("Test %d: Expected Error to be \"%v\", but instead found \"%v\" ", i+1, testCase.expectedErr, actualErr)
+			}
+		}
+	}
+}
@@ -17,13 +17,13 @@
 package main

 import (
-	"bytes"
 	"encoding/hex"
 	"errors"
 	"io"
 	"sync"

 	"github.com/klauspost/reedsolomon"
+	"github.com/minio/minio/pkg/bpool"
 )

 // isSuccessDecodeBlocks - do we have all the blocks to be
@@ -43,8 +43,8 @@ func isSuccessDecodeBlocks(enBlocks [][]byte, dataBlocks int) bool {
 		} // else { // update parity block count.
 		successParityBlocksCount++
 	}
-	// Returns true if we have atleast dataBlocks + 1 parity.
-	return successDataBlocksCount == dataBlocks || successDataBlocksCount+successParityBlocksCount >= dataBlocks+1
+	// Returns true if we have atleast dataBlocks parity.
+	return successDataBlocksCount == dataBlocks || successDataBlocksCount+successParityBlocksCount >= dataBlocks
 }

 // isSuccessDataBlocks - do we have all the data blocks?
@@ -65,20 +65,6 @@ func isSuccessDataBlocks(enBlocks [][]byte, dataBlocks int) bool {
 	return successDataBlocksCount >= dataBlocks
 }

-// getOrderedDisks - get ordered disks from erasure distribution.
-// returns ordered slice of disks from their actual distribution.
-func getOrderedDisks(distribution []int, disks []StorageAPI, blockCheckSums []checkSumInfo) (orderedDisks []StorageAPI, orderedBlockCheckSums []checkSumInfo) {
-	orderedDisks = make([]StorageAPI, len(disks))
-	orderedBlockCheckSums = make([]checkSumInfo, len(disks))
-	// From disks gets ordered disks.
-	for index := range disks {
-		blockIndex := distribution[index]
-		orderedDisks[blockIndex-1] = disks[index]
-		orderedBlockCheckSums[blockIndex-1] = blockCheckSums[index]
-	}
-	return orderedDisks, orderedBlockCheckSums
-}
-
 // Return readable disks slice from which we can read parallelly.
 func getReadDisks(orderedDisks []StorageAPI, index int, dataBlocks int) (readDisks []StorageAPI, nextIndex int, err error) {
 	readDisks = make([]StorageAPI, len(orderedDisks))
@@ -100,7 +86,7 @@ func getReadDisks(orderedDisks []StorageAPI, index int, dataBlocks int) (readDis
 	if dataDisks == dataBlocks {
 		return nil, 0, errUnexpected
 	}
-	if dataDisks+parityDisks >= dataBlocks+1 {
+	if dataDisks+parityDisks >= dataBlocks {
 		return nil, 0, errUnexpected
 	}

@@ -117,8 +103,7 @@ func getReadDisks(orderedDisks []StorageAPI, index int, dataBlocks int) (readDis
 		readDisks[i] = orderedDisks[i]
 		if dataDisks == dataBlocks {
 			return readDisks, i + 1, nil
-		}
-		if dataDisks+parityDisks == dataBlocks+1 {
+		} else if dataDisks+parityDisks == dataBlocks {
 			return readDisks, i + 1, nil
 		}
 	}
@@ -126,7 +111,7 @@ func getReadDisks(orderedDisks []StorageAPI, index int, dataBlocks int) (readDis
 }

 // parallelRead - reads chunks in parallel from the disks specified in []readDisks.
-func parallelRead(volume, path string, readDisks []StorageAPI, orderedDisks []StorageAPI, enBlocks [][]byte, blockOffset int64, curChunkSize int64, bitRotVerify func(diskIndex int) bool) {
+func parallelRead(volume, path string, readDisks []StorageAPI, orderedDisks []StorageAPI, enBlocks [][]byte, blockOffset int64, curChunkSize int64, bitRotVerify func(diskIndex int) bool, pool *bpool.BytePool) {
 	// WaitGroup to synchronise the read go-routines.
 	wg := &sync.WaitGroup{}

@@ -147,21 +132,20 @@ func parallelRead(volume, path string, readDisks []StorageAPI, orderedDisks []St
 				return
 			}

-			// Chunk writer.
-			chunkWriter := bytes.NewBuffer(make([]byte, 0, curChunkSize))
-
-			// CopyN - copies until current chunk size.
-			err := copyN(chunkWriter, readDisks[index], volume, path, blockOffset, curChunkSize)
+			buf, err := pool.Get()
 			if err != nil {
-				// So that we don't read from this disk for the next block.
+				errorIf(err, "unable to get buffer from byte pool")
 				orderedDisks[index] = nil
 				return
 			}
+			buf = buf[:curChunkSize]

-			// Copy the read blocks.
-			enBlocks[index] = chunkWriter.Bytes()
-
-			// Successfully read.
+			_, err = readDisks[index].ReadFile(volume, path, blockOffset, buf)
+			if err != nil {
+				orderedDisks[index] = nil
+				return
+			}
+			enBlocks[index] = buf
 		}(index)
 	}

@@ -174,26 +158,24 @@ func parallelRead(volume, path string, readDisks []StorageAPI, orderedDisks []St
 // are decoded into a data block. Data block is trimmed for given offset and length,
 // then written to given writer. This function also supports bit-rot detection by
 // verifying checksum of individual block's checksum.
-func erasureReadFile(writer io.Writer, disks []StorageAPI, volume string, path string, partName string, eInfos []erasureInfo, offset int64, length int64, totalLength int64) (int64, error) {
+func erasureReadFile(writer io.Writer, disks []StorageAPI, volume string, path string, offset int64, length int64, totalLength int64, blockSize int64, dataBlocks int, parityBlocks int, checkSums []string, algo string, pool *bpool.BytePool) (int64, error) {
 	// Offset and length cannot be negative.
 	if offset < 0 || length < 0 {
 		return 0, errUnexpected
 	}

-	// Pick one erasure info.
-	eInfo := pickValidErasureInfo(eInfos)
+	// Can't request more data than what is available.
+	if offset+length > totalLength {
+		return 0, errUnexpected
+	}

-	// Gather previously calculated block checksums.
-	blockCheckSums := metaPartBlockChecksums(disks, eInfos, partName)
-
-	// []orderedDisks will have first eInfo.DataBlocks disks as data
-	// disks and rest will be parity.
-	orderedDisks, orderedBlockCheckSums := getOrderedDisks(eInfo.Distribution, disks, blockCheckSums)
+	// chunkSize is the amount of data that needs to be read from each disk at a time.
+	chunkSize := getChunkSize(blockSize, dataBlocks)

 	// bitRotVerify verifies if the file on a particular disk doesn't have bitrot
 	// by verifying the hash of the contents of the file.
 	bitRotVerify := func() func(diskIndex int) bool {
-		verified := make([]bool, len(orderedDisks))
+		verified := make([]bool, len(disks))
 		// Return closure so that we have reference to []verified and
 		// not recalculate the hash on it every time the function is
 		// called for the same disk.
@@ -203,7 +185,7 @@ func erasureReadFile(writer io.Writer, disks []StorageAPI, volume string, path s
 				return true
 			}
 			// Is this a valid block?
-			isValid := isValidBlock(orderedDisks[diskIndex], volume, path, orderedBlockCheckSums[diskIndex])
+			isValid := isValidBlock(disks[diskIndex], volume, path, checkSums[diskIndex], algo)
 			verified[diskIndex] = isValid
 			return isValid
 		}
@@ -212,39 +194,34 @@ func erasureReadFile(writer io.Writer, disks []StorageAPI, volume string, path s
 	// Total bytes written to writer
 	bytesWritten := int64(0)

-	// chunkSize is roughly BlockSize/DataBlocks.
-	// chunkSize is calculated such that chunkSize*DataBlocks accommodates BlockSize bytes.
-	// So chunkSize*DataBlocks can be slightly larger than BlockSize if BlockSize is not divisible by
-	// DataBlocks. The extra space will have 0-padding.
-	chunkSize := getEncodedBlockLen(eInfo.BlockSize, eInfo.DataBlocks)
+	startBlock := offset / blockSize
+	endBlock := (offset + length) / blockSize

-	// Get start and end block, also bytes to be skipped based on the input offset.
-	startBlock, endBlock, bytesToSkip := getBlockInfo(offset, totalLength, eInfo.BlockSize)
+	// curChunkSize = chunk size for the current block in the for loop below.
+	// curBlockSize = block size for the current block in the for loop below.
+	// curChunkSize and curBlockSize can change for the last block if totalLength%blockSize != 0
+	curChunkSize := chunkSize
+	curBlockSize := blockSize

 	// For each block, read chunk from each disk. If we are able to read all the data disks then we don't
 	// need to read parity disks. If one of the data disk is missing we need to read DataBlocks+1 number
 	// of disks. Once read, we Reconstruct() missing data if needed and write it to the given writer.
-	for block := startBlock; bytesWritten < length; block++ {
+	for block := startBlock; block <= endBlock; block++ {
+		// Mark all buffers as unused at the start of the loop so that the buffers
+		// can be reused.
+		pool.Reset()
+
 		// Each element of enBlocks holds curChunkSize'd amount of data read from its corresponding disk.
-		enBlocks := make([][]byte, len(orderedDisks))
+		enBlocks := make([][]byte, len(disks))

-		// enBlocks data can have 0-padding hence we need to figure the exact number
-		// of bytes we want to read from enBlocks.
-		blockSize := eInfo.BlockSize
-
-		// curChunkSize is chunkSize until end block.
-		curChunkSize := chunkSize
-
-		// We have endBlock, verify if we need to have padding.
-		if block == endBlock && (totalLength%eInfo.BlockSize != 0) {
-			// If this is the last block and size of the block is < BlockSize.
-			curChunkSize = getEncodedBlockLen(totalLength%eInfo.BlockSize, eInfo.DataBlocks)
-
-			// For the last block, the block size can be less than BlockSize.
-			blockSize = totalLength % eInfo.BlockSize
+		if ((offset + bytesWritten) / blockSize) == (totalLength / blockSize) {
+			// This is the last block for which curBlockSize and curChunkSize can change.
+			// For ex. if totalLength is 15M and blockSize is 10MB, curBlockSize for
+			// the last block should be 5MB.
+			curBlockSize = totalLength % blockSize
+			curChunkSize = getChunkSize(curBlockSize, dataBlocks)
 		}

-		// Block offset.
 		// NOTE: That for the offset calculation we have to use chunkSize and
 		// not curChunkSize. If we use curChunkSize for offset calculation
 		// then it can result in wrong offset for the last block.
@@ -258,94 +235,89 @@ func erasureReadFile(writer io.Writer, disks []StorageAPI, volume string, path s
 			// readDisks - disks from which we need to read in parallel.
 			var readDisks []StorageAPI
 			var err error
-			readDisks, nextIndex, err = getReadDisks(orderedDisks, nextIndex, eInfo.DataBlocks)
+			// get readable disks slice from which we can read parallelly.
+			readDisks, nextIndex, err = getReadDisks(disks, nextIndex, dataBlocks)
 			if err != nil {
 				return bytesWritten, err
 			}
-			parallelRead(volume, path, readDisks, orderedDisks, enBlocks, blockOffset, curChunkSize, bitRotVerify)
-			if isSuccessDecodeBlocks(enBlocks, eInfo.DataBlocks) {
+			// Issue a parallel read across the disks specified in readDisks.
+			parallelRead(volume, path, readDisks, disks, enBlocks, blockOffset, curChunkSize, bitRotVerify, pool)
+			if isSuccessDecodeBlocks(enBlocks, dataBlocks) {
 				// If enough blocks are available to do rs.Reconstruct()
 				break
 			}
-			if nextIndex == len(orderedDisks) {
+			if nextIndex == len(disks) {
 				// No more disks to read from.
 				return bytesWritten, errXLReadQuorum
 			}
+			// We do not have enough enough data blocks to reconstruct the data
+			// hence continue the for-loop till we have enough data blocks.
 		}

 		// If we have all the data blocks no need to decode, continue to write.
-		if !isSuccessDataBlocks(enBlocks, eInfo.DataBlocks) {
+		if !isSuccessDataBlocks(enBlocks, dataBlocks) {
 			// Reconstruct the missing data blocks.
-			if err := decodeData(enBlocks, eInfo.DataBlocks, eInfo.ParityBlocks); err != nil {
+			if err := decodeData(enBlocks, dataBlocks, parityBlocks); err != nil {
 				return bytesWritten, err
 			}
 		}

-		var outSize, outOffset int64
-		// If this is start block, skip unwanted bytes.
+		// Offset in enBlocks from where data should be read from.
+		enBlocksOffset := int64(0)
+
+		// Total data to be read from enBlocks.
+		enBlocksLength := curBlockSize
+
+		// If this is the start block then enBlocksOffset might not be 0.
 		if block == startBlock {
-			outOffset = bytesToSkip
+			enBlocksOffset = offset % blockSize
+			enBlocksLength -= enBlocksOffset
 		}

-		// Total data to be read.
-		outSize = blockSize
-		if length-bytesWritten < blockSize {
+		remaining := length - bytesWritten
+		if remaining < enBlocksLength {
 			// We should not send more data than what was requested.
-			outSize = length - bytesWritten
+			enBlocksLength = remaining
 		}

 		// Write data blocks.
-		n, err := writeDataBlocks(writer, enBlocks, eInfo.DataBlocks, outOffset, outSize)
+		n, err := writeDataBlocks(writer, enBlocks, dataBlocks, enBlocksOffset, enBlocksLength)
 		if err != nil {
 			return bytesWritten, err
 		}

 		// Update total bytes written.
 		bytesWritten += n
+
+		if bytesWritten == length {
+			// Done writing all the requested data.
+			break
+		}
 	}

 	// Success.
 	return bytesWritten, nil
 }

-// PartObjectChecksum - returns the checksum for the part name from the checksum slice.
-func (e erasureInfo) PartObjectChecksum(partName string) checkSumInfo {
-	for _, checksum := range e.Checksum {
-		if checksum.Name == partName {
-			return checksum
-		}
-	}
-	return checkSumInfo{}
-}
-
-// xlMetaPartBlockChecksums - get block checksums for a given part.
-func metaPartBlockChecksums(disks []StorageAPI, eInfos []erasureInfo, partName string) (blockCheckSums []checkSumInfo) {
-	for index := range disks {
-		if eInfos[index].IsValid() {
-			// Save the read checksums for a given part.
-			blockCheckSums = append(blockCheckSums, eInfos[index].PartObjectChecksum(partName))
-		} else {
-			blockCheckSums = append(blockCheckSums, checkSumInfo{})
-		}
-	}
-	return blockCheckSums
-}
-
 // isValidBlock - calculates the checksum hash for the block and
 // validates if its correct returns true for valid cases, false otherwise.
-func isValidBlock(disk StorageAPI, volume, path string, blockCheckSum checkSumInfo) (ok bool) {
+func isValidBlock(disk StorageAPI, volume, path, checkSum, checkSumAlgo string) (ok bool) {
 	// Disk is not available, not a valid block.
 	if disk == nil {
 		return false
 	}
+	// Checksum not available, not a valid block.
+	if checkSum == "" {
+		return false
+	}
 	// Read everything for a given block and calculate hash.
-	hashWriter := newHash(blockCheckSum.Algorithm)
+	hashWriter := newHash(checkSumAlgo)
 	hashBytes, err := hashSum(disk, volume, path, hashWriter)
 	if err != nil {
 		errorIf(err, "Unable to calculate checksum %s/%s", volume, path)
 		return false
 	}
-	return hex.EncodeToString(hashBytes) == blockCheckSum.Hash
+	return hex.EncodeToString(hashBytes) == checkSum
 }

 // decodeData - decode encoded blocks.
@@ -1,5 +1,5 @@
 /*
- * Minio Cloud Storage, (C) 2015, 2016 Minio, Inc.
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -16,7 +16,14 @@

 package main

-import "testing"
+import (
+	"bytes"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/minio/minio/pkg/bpool"
+)
 import "reflect"

 // Tests getReadDisks which returns readable disks slice from which we can
@@ -30,57 +37,64 @@ func testGetReadDisks(t *testing.T, xl xlObjects) {
 		nextIndex int          // return value from getReadDisks
 		err       error        // error return value from getReadDisks
 	}{
+		// Test case - 1.
+		// When all disks are available, should return data disks.
 		{
 			0,
-			// When all disks are available, should return data disks.
 			[]StorageAPI{d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]},
 			[]StorageAPI{d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], nil, nil, nil, nil, nil, nil, nil, nil},
 			8,
 			nil,
 		},
+		// Test case - 2.
+		// If a parity disk is down, should return all data disks.
 		{
 			0,
-			// If a parity disk is down, should return all data disks.
 			[]StorageAPI{d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], nil, d[10], d[11], d[12], d[13], d[14], d[15]},
 			[]StorageAPI{d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], nil, nil, nil, nil, nil, nil, nil, nil},
 			8,
 			nil,
 		},
+		// Test case - 3.
+		// If a data disk is down, should return 7 data and 1 parity.
 		{
 			0,
-			// If a data disk is down, should return 7 data and 2 parity.
 			[]StorageAPI{nil, d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]},
-			[]StorageAPI{nil, d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], nil, nil, nil, nil, nil, nil},
+			[]StorageAPI{nil, d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], nil, nil, nil, nil, nil, nil, nil},
+			9,
+			nil,
+		},
+		// Test case - 4.
+		// If 7 data disks are down, should return 1 data and 7 parity.
+		{
+			0,
+			[]StorageAPI{nil, nil, nil, nil, nil, nil, nil, d[7], d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]},
+			[]StorageAPI{nil, nil, nil, nil, nil, nil, nil, d[7], d[8], d[9], d[10], d[11], d[12], d[13], d[14], nil},
+			15,
+			nil,
+		},
+		// Test case - 5.
+		// When 2 disks fail during parallelRead, next call to getReadDisks should return 3 disks
+		{
+			8,
+			[]StorageAPI{nil, nil, d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]},
+			[]StorageAPI{nil, nil, nil, nil, nil, nil, nil, nil, d[8], d[9], nil, nil, nil, nil, nil, nil},
 			10,
 			nil,
 		},
-		{
-			0,
-			// If 7 data disks are down, should return 1 data and 8 parity.
-			[]StorageAPI{nil, nil, nil, nil, nil, nil, nil, d[7], d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]},
-			[]StorageAPI{nil, nil, nil, nil, nil, nil, nil, d[7], d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]},
-			16,
-			nil,
-		},
-		{
-			8,
-			// When all disks are available, should return data disks.
-			[]StorageAPI{nil, nil, d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]},
-			[]StorageAPI{nil, nil, nil, nil, nil, nil, nil, nil, d[8], d[9], d[10], nil, nil, nil, nil, nil},
-			11,
-			nil,
-		},
+		// Test case - 6.
+		// If 2 disks again fail from the 3 disks returned previously, return next 2 disks
 		{
 			11,
-			// When all disks are available, should return data disks.
 			[]StorageAPI{nil, nil, d[2], d[3], d[4], d[5], d[6], d[7], nil, nil, d[10], d[11], d[12], d[13], d[14], d[15]},
-			[]StorageAPI{nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, d[11], d[12], nil, nil, nil},
-			13,
+			[]StorageAPI{nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, d[11], nil, nil, nil, nil},
+			12,
 			nil,
 		},
+		// Test case - 7.
+		// No more disks are available for read, return error
 		{
 			13,
-			// When all disks are available, should return data disks.
 			[]StorageAPI{nil, nil, d[2], d[3], d[4], d[5], d[6], d[7], nil, nil, d[10], nil, nil, nil, nil, nil},
 			nil,
 			0,
@@ -99,7 +113,7 @@ func testGetReadDisks(t *testing.T, xl xlObjects) {
 			continue
 		}
 		if reflect.DeepEqual(test.retDisks, disks) == false {
-			t.Errorf("test-case %d : incorrect disks returned. %v", i+1, disks)
+			t.Errorf("test-case %d : incorrect disks returned. expected %+v, got %+v", i+1, test.retDisks, disks)
 			continue
 		}
 	}
@@ -109,9 +123,8 @@ func testGetReadDisks(t *testing.T, xl xlObjects) {
 // actual distribution.
 func testGetOrderedDisks(t *testing.T, xl xlObjects) {
 	disks := xl.storageDisks
-	blockCheckSums := make([]checkSumInfo, len(disks))
 	distribution := []int{16, 14, 12, 10, 8, 6, 4, 2, 1, 3, 5, 7, 9, 11, 13, 15}
-	orderedDisks, _ := getOrderedDisks(distribution, disks, blockCheckSums)
+	orderedDisks := getOrderedDisks(distribution, disks)
 	// From the "distribution" above you can notice that:
 	// 1st data block is in the 9th disk (i.e distribution index 8)
 	// 2nd data block is in the 8th disk (i.e distribution index 7) and so on.
@@ -171,12 +184,21 @@ func TestIsSuccessBlocks(t *testing.T) {
 			true,
 		},
 		{
-			// Not enough disks for reedsolomon.Reconstruct()
+			// When all data disks are not available, enough for reedsolomon.Reconstruct()
 			[][]byte{
 				nil, nil, nil, nil, nil, nil, nil, nil,
 				{'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'},
 			},
 			false,
+			true,
+		},
+		{
+			// Not enough disks for reedsolomon.Reconstruct()
+			[][]byte{
+				nil, nil, nil, nil, nil, nil, nil, nil,
+				nil, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'},
+			},
+			false,
 			false,
 		},
 	}
@@ -194,7 +216,7 @@ func TestIsSuccessBlocks(t *testing.T) {
 }

 // Wrapper function for testGetReadDisks, testGetOrderedDisks.
-func TestErasureReadFile(t *testing.T) {
+func TestErasureReadUtils(t *testing.T) {
 	objLayer, dirs, err := getXLObjectLayer()
 	if err != nil {
 		t.Fatal(err)
@@ -204,3 +226,234 @@ func TestErasureReadFile(t *testing.T) {
 	testGetReadDisks(t, xl)
 	testGetOrderedDisks(t, xl)
 }
+
+// Simulates a faulty disk for ReadFile()
+type ReadDiskDown struct {
+	*posix
+}
+
+func (r ReadDiskDown) ReadFile(volume string, path string, offset int64, buf []byte) (n int64, err error) {
+	return 0, errFaultyDisk
+}
+
+func TestErasureReadFileDiskFail(t *testing.T) {
+	// Initialize environment needed for the test.
+	dataBlocks := 7
+	parityBlocks := 7
+	blockSize := int64(blockSizeV1)
+	setup, err := newErasureTestSetup(dataBlocks, parityBlocks, blockSize)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer setup.Remove()
+
+	disks := setup.disks
+
+	// Prepare a slice of 1MB with random data.
+	data := make([]byte, 1*1024*1024)
+	length := int64(len(data))
+	_, err = rand.Read(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Create a test file to read from.
+	size, checkSums, err := erasureCreateFile(disks, "testbucket", "testobject", bytes.NewReader(data), blockSize, dataBlocks, parityBlocks, bitRotAlgo, dataBlocks+1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if size != length {
+		t.Errorf("erasureCreateFile returned %d, expected %d", size, length)
+	}
+
+	// create byte pool which will be used by erasureReadFile for
+	// reading from disks and erasure decoding.
+	chunkSize := getChunkSize(blockSize, dataBlocks)
+	pool := bpool.NewBytePool(chunkSize, len(disks))
+
+	buf := &bytes.Buffer{}
+	_, err = erasureReadFile(buf, disks, "testbucket", "testobject", 0, length, length, blockSize, dataBlocks, parityBlocks, checkSums, bitRotAlgo, pool)
+	if err != nil {
+		t.Error(err)
+	}
+	if !bytes.Equal(buf.Bytes(), data) {
+		t.Error("Contents of the erasure coded file differs")
+	}
+
+	// 2 disks down. Read should succeed.
+	disks[4] = ReadDiskDown{disks[4].(*posix)}
+	disks[5] = ReadDiskDown{disks[5].(*posix)}
+
+	buf.Reset()
+	_, err = erasureReadFile(buf, disks, "testbucket", "testobject", 0, length, length, blockSize, dataBlocks, parityBlocks, checkSums, bitRotAlgo, pool)
+	if err != nil {
+		t.Error(err)
+	}
+	if !bytes.Equal(buf.Bytes(), data) {
+		t.Error("Contents of the erasure coded file differs")
+	}
+
+	// 4 more disks down. 6 disks down in total. Read should succeed.
+	disks[6] = ReadDiskDown{disks[6].(*posix)}
+	disks[8] = ReadDiskDown{disks[8].(*posix)}
+	disks[9] = ReadDiskDown{disks[9].(*posix)}
+	disks[11] = ReadDiskDown{disks[11].(*posix)}
+
+	buf.Reset()
+	_, err = erasureReadFile(buf, disks, "testbucket", "testobject", 0, length, length, blockSize, dataBlocks, parityBlocks, checkSums, bitRotAlgo, pool)
+	if err != nil {
+		t.Error(err)
+	}
+	if !bytes.Equal(buf.Bytes(), data) {
+		t.Error("Contents of the erasure coded file differs")
+	}
+
+	// 2 more disk down. 8 disks down in total. Read should fail.
+	disks[12] = ReadDiskDown{disks[12].(*posix)}
+	disks[13] = ReadDiskDown{disks[13].(*posix)}
+	buf.Reset()
+	_, err = erasureReadFile(buf, disks, "testbucket", "testobject", 0, length, length, blockSize, dataBlocks, parityBlocks, checkSums, bitRotAlgo, pool)
+	if err != errXLReadQuorum {
+		t.Fatal("expected errXLReadQuorum error")
+	}
+}
+
+func TestErasureReadFileOffsetLength(t *testing.T) {
+	// Initialize environment needed for the test.
+	dataBlocks := 7
+	parityBlocks := 7
+	blockSize := int64(1 * 1024 * 1024)
+	setup, err := newErasureTestSetup(dataBlocks, parityBlocks, blockSize)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer setup.Remove()
+
+	disks := setup.disks
+
+	// Prepare a slice of 5MB with random data.
+	data := make([]byte, 5*1024*1024)
+	length := int64(len(data))
+	_, err = rand.Read(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Create a test file to read from.
+	size, checkSums, err := erasureCreateFile(disks, "testbucket", "testobject", bytes.NewReader(data), blockSize, dataBlocks, parityBlocks, bitRotAlgo, dataBlocks+1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if size != length {
+		t.Errorf("erasureCreateFile returned %d, expected %d", size, length)
+	}
+
+	testCases := []struct {
+		offset, length int64
+	}{
+		// Full file.
+		{0, length},
+		// Read nothing.
+		{length, 0},
+		// 2nd block.
+		{blockSize, blockSize},
+		// Test cases for random offsets and lengths.
+		{blockSize - 1, 2},
+		{blockSize - 1, blockSize + 1},
+		{blockSize + 1, blockSize - 1},
+		{blockSize + 1, blockSize},
+		{blockSize + 1, blockSize + 1},
+		{blockSize*2 - 1, blockSize + 1},
+		{length - 1, 1},
+		{length - blockSize, blockSize},
+		{length - blockSize - 1, blockSize},
+		{length - blockSize - 1, blockSize + 1},
+	}
+	chunkSize := getChunkSize(blockSize, dataBlocks)
+	pool := bpool.NewBytePool(chunkSize, len(disks))
+
+	// Compare the data read from file with "data" byte array.
+	for i, testCase := range testCases {
+		expected := data[testCase.offset:(testCase.offset + testCase.length)]
+		buf := &bytes.Buffer{}
+		_, err = erasureReadFile(buf, disks, "testbucket", "testobject", testCase.offset, testCase.length, length, blockSize, dataBlocks, parityBlocks, checkSums, bitRotAlgo, pool)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+		got := buf.Bytes()
+		if !bytes.Equal(expected, got) {
+			t.Errorf("Test %d : read data is different from what was expected", i+1)
+		}
+	}
+}
+
+// Test erasureReadFile with random offset and lengths.
+// This test is t.Skip()ed as it a long time to run, hence should be run
+// explicitly after commenting out t.Skip()
+func TestErasureReadFileRandomOffsetLength(t *testing.T) {
+	// Comment the following line to run this test.
+	t.SkipNow()
+	// Initialize environment needed for the test.
+	dataBlocks := 7
+	parityBlocks := 7
+	blockSize := int64(1 * 1024 * 1024)
+	setup, err := newErasureTestSetup(dataBlocks, parityBlocks, blockSize)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer setup.Remove()
+
+	disks := setup.disks
+
+	// Prepare a slice of 5MB with random data.
+	data := make([]byte, 5*1024*1024)
+	length := int64(len(data))
+	_, err = rand.Read(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// 10000 iterations with random offsets and lengths.
+	iterations := 10000
+
+	// Create a test file to read from.
+	size, checkSums, err := erasureCreateFile(disks, "testbucket", "testobject", bytes.NewReader(data), blockSize, dataBlocks, parityBlocks, bitRotAlgo, dataBlocks+1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if size != length {
+		t.Errorf("erasureCreateFile returned %d, expected %d", size, length)
+	}
+
+	// To generate random offset/length.
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	// create pool buffer which will be used by erasureReadFile for
+	// reading from disks and erasure decoding.
+	chunkSize := getChunkSize(blockSize, dataBlocks)
+	pool := bpool.NewBytePool(chunkSize, len(disks))
+
+	buf := &bytes.Buffer{}
+
+	// Verify erasureReadFile() for random offsets and lengths.
+	for i := 0; i < iterations; i++ {
+		offset := r.Int63n(length)
+		readLen := r.Int63n(length - offset)
+
+		expected := data[offset : offset+readLen]
+
+		_, err = erasureReadFile(buf, disks, "testbucket", "testobject", offset, readLen, length, blockSize, dataBlocks, parityBlocks, checkSums, bitRotAlgo, pool)
+		if err != nil {
+			t.Fatal(err, offset, readLen)
+		}
+		got := buf.Bytes()
+		if !bytes.Equal(expected, got) {
+			t.Fatalf("read data is different from what was expected, offset=%d length=%d", offset, readLen)
+		}
+		buf.Reset()
+	}
+}
@@ -27,10 +27,10 @@ import (
 )

 // newHashWriters - inititialize a slice of hashes for the disk count.
-func newHashWriters(diskCount int) []hash.Hash {
+func newHashWriters(diskCount int, algo string) []hash.Hash {
 	hashWriters := make([]hash.Hash, diskCount)
 	for index := range hashWriters {
-		hashWriters[index] = newHash("blake2b")
+		hashWriters[index] = newHash(algo)
 	}
 	return hashWriters
 }
@@ -73,9 +73,9 @@ func getDataBlockLen(enBlocks [][]byte, dataBlocks int) int {

 // Writes all the data blocks from encoded blocks until requested
 // outSize length. Provides a way to skip bytes until the offset.
-func writeDataBlocks(dst io.Writer, enBlocks [][]byte, dataBlocks int, outOffset int64, outSize int64) (int64, error) {
+func writeDataBlocks(dst io.Writer, enBlocks [][]byte, dataBlocks int, offset int64, length int64) (int64, error) {
 	// Offset and out size cannot be negative.
-	if outOffset < 0 || outSize < 0 {
+	if offset < 0 || length < 0 {
 		return 0, errUnexpected
 	}

@@ -85,12 +85,12 @@ func writeDataBlocks(dst io.Writer, enBlocks [][]byte, dataBlocks int, outOffset
 	}

 	// Do we have enough data?
-	if int64(getDataBlockLen(enBlocks, dataBlocks)) < outSize {
+	if int64(getDataBlockLen(enBlocks, dataBlocks)) < length {
 		return 0, reedsolomon.ErrShortData
 	}

 	// Counter to decrement total left to write.
-	write := outSize
+	write := length

 	// Counter to increment total written.
 	totalWritten := int64(0)
@@ -98,17 +98,17 @@ func writeDataBlocks(dst io.Writer, enBlocks [][]byte, dataBlocks int, outOffset
 	// Write all data blocks to dst.
 	for _, block := range enBlocks[:dataBlocks] {
 		// Skip blocks until we have reached our offset.
-		if outOffset >= int64(len(block)) {
+		if offset >= int64(len(block)) {
 			// Decrement offset.
-			outOffset -= int64(len(block))
+			offset -= int64(len(block))
 			continue
 		} else {
 			// Skip until offset.
-			block = block[outOffset:]
+			block = block[offset:]

 			// Reset the offset for next iteration to read everything
 			// from subsequent blocks.
-			outOffset = 0
+			offset = 0
 		}
 		// We have written all the blocks, write the last remaining block.
 		if write < int64(len(block)) {
@@ -136,70 +136,12 @@ func writeDataBlocks(dst io.Writer, enBlocks [][]byte, dataBlocks int, outOffset
 	return totalWritten, nil
 }

-// getBlockInfo - find start/end block and bytes to skip for given offset, length and block size.
-func getBlockInfo(offset, length, blockSize int64) (startBlock, endBlock, bytesToSkip int64) {
-	// Calculate start block for given offset and how many bytes to skip to get the offset.
-	startBlock = offset / blockSize
-	bytesToSkip = offset % blockSize
-	endBlock = length / blockSize
-	return
-}
-
-// calculate the blockSize based on input length and total number of
-// data blocks.
-func getEncodedBlockLen(inputLen int64, dataBlocks int) (curEncBlockSize int64) {
-	curEncBlockSize = (inputLen + int64(dataBlocks) - 1) / int64(dataBlocks)
-	return curEncBlockSize
-}
-
-// copyN - copies from disk, volume, path to input writer until length
-// is reached at volume, path or an error occurs. A success copyN returns
-// err == nil, not err == EOF. Additionally offset can be provided to start
-// the read at. copyN returns io.EOF if there aren't enough data to be read.
-func copyN(writer io.Writer, disk StorageAPI, volume string, path string, offset int64, length int64) (err error) {
-	// Use staging buffer to read up to length.
-	bufSize := int64(readSizeV1)
-	if length > 0 && bufSize > length {
-		bufSize = length
-	}
-	buf := make([]byte, int(bufSize))
-
-	// Read into writer until length.
-	for length > 0 {
-		curLength := bufSize
-		if length < bufSize {
-			curLength = length
-		}
-		nr, er := disk.ReadFile(volume, path, offset, buf[:curLength])
-		if nr > 0 {
-			nw, ew := writer.Write(buf[0:nr])
-			if nw > 0 {
-				// Decrement the length.
-				length -= int64(nw)
-
-				// Progress the offset.
-				offset += int64(nw)
-			}
-			if ew != nil {
-				err = ew
-				break
-			}
-			if nr != int64(nw) {
-				err = io.ErrShortWrite
-				break
-			}
-		}
-		if er == io.EOF || er == io.ErrUnexpectedEOF {
-			break
-		}
-		if er != nil {
-			err = er
-			break
-		}
-	}
-
-	// Success.
-	return err
+// chunkSize is roughly BlockSize/DataBlocks.
+// chunkSize is calculated such that chunkSize*DataBlocks accommodates BlockSize bytes.
+// So chunkSize*DataBlocks can be slightly larger than BlockSize if BlockSize is not divisible by
+// DataBlocks. The extra space will have 0-padding.
+func getChunkSize(blockSize int64, dataBlocks int) int64 {
+	return (blockSize + int64(dataBlocks) - 1) / int64(dataBlocks)
 }

 // copyBuffer - copies from disk, volume, path to input writer until either EOF
@@ -221,10 +163,9 @@ func copyBuffer(writer io.Writer, disk StorageAPI, volume string, path string, b
 	for {
 		n, err := disk.ReadFile(volume, path, startOffset, buf)
 		if n > 0 {
-			var m int
-			m, err = writer.Write(buf[:n])
-			if err != nil {
-				return err
+			m, wErr := writer.Write(buf[:n])
+			if wErr != nil {
+				return wErr
 			}
 			if int64(m) != n {
 				return io.ErrShortWrite
@@ -0,0 +1,160 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"testing"
+)
+
+// Test validates the number hash writers returned.
+func TestNewHashWriters(t *testing.T) {
+	diskNum := 8
+	hashWriters := newHashWriters(diskNum, bitRotAlgo)
+	if len(hashWriters) != diskNum {
+		t.Errorf("Expected %d hashWriters, but instead got %d", diskNum, len(hashWriters))
+	}
+
+}
+
+// Tests validate the output of getChunkSize.
+func TestGetChunkSize(t *testing.T) {
+	// Refer to comments on getChunkSize() for details.
+	testCases := []struct {
+		blockSize  int64
+		dataBlocks int
+		// expected result.
+		expectedChunkSize int64
+	}{
+		{
+			10,
+			10,
+			1,
+		},
+		{
+			10,
+			11,
+			1,
+		},
+		{
+			10,
+			9,
+			2,
+		},
+	}
+	// Verify getChunkSize() for the test cases.
+	for i, testCase := range testCases {
+		got := getChunkSize(testCase.blockSize, testCase.dataBlocks)
+		if testCase.expectedChunkSize != got {
+			t.Errorf("Test %d : expected=%d got=%d", i+1, testCase.expectedChunkSize, got)
+		}
+	}
+}
+
+// TestCopyBuffer - Tests validate the result and errors produced when `copyBuffer` is called with sample inputs.
+func TestCopyBuffer(t *testing.T) {
+	// create posix test setup
+	disk, diskPath, err := newPosixTestSetup()
+	if err != nil {
+		t.Fatalf("Unable to create posix test setup, %s", err)
+	}
+	defer removeAll(diskPath)
+
+	volume := "success-vol"
+	// Setup test environment.
+	if err = disk.MakeVol(volume); err != nil {
+		t.Fatalf("Unable to create volume, %s", err)
+	}
+
+	// creating io.Writer for the input to copyBuffer.
+	buffers := []*bytes.Buffer{
+		new(bytes.Buffer),
+		new(bytes.Buffer),
+		new(bytes.Buffer),
+	}
+
+	testFile := "testFile"
+	testContent := []byte("hello, world")
+	err = disk.AppendFile(volume, testFile, testContent)
+	if err != nil {
+		t.Fatalf("AppendFile failed: <ERROR> %s", err)
+	}
+
+	testCases := []struct {
+		writer io.Writer
+		disk   StorageAPI
+		volume string
+		path   string
+		buf    []byte
+
+		expectedResult []byte
+		// flag to indicate whether test case should pass.
+		shouldPass  bool
+		expectedErr error
+	}{
+		// Test case - 1.
+		// case with empty buffer.
+		{nil, nil, "", "", []byte{}, nil, false, errors.New("empty buffer in readBuffer")},
+		// Test case - 2.
+		// Test case with empty volume.
+		{buffers[0], disk, "", "", make([]byte, 5), nil, false, errInvalidArgument},
+		// Test case - 3.
+		// Test case with non existent volume.
+		{buffers[0], disk, "abc", "", make([]byte, 5), nil, false, errVolumeNotFound},
+		// Test case - 4.
+		// Test case with empty filename/path.
+		{buffers[0], disk, volume, "", make([]byte, 5), nil, false, errIsNotRegular},
+		// Test case - 5.
+		// Test case with non existent file name.
+		{buffers[0], disk, volume, "abcd", make([]byte, 5), nil, false, errFileNotFound},
+		// Test case - 6.
+		// Test case where the writer returns EOF.
+		{NewEOFWriter(buffers[0], 3), disk, volume, testFile, make([]byte, 5), nil, false, io.EOF},
+		// Test case - 7.
+		// Test case to produce io.ErrShortWrite, the TruncateWriter returns after writing 3 bytes.
+		{TruncateWriter(buffers[1], 3), disk, volume, testFile, make([]byte, 5), nil, false, io.ErrShortWrite},
+		// Teset case - 8.
+		// Valid case, expected to read till EOF and write the contents into the writer.
+		{buffers[2], disk, volume, testFile, make([]byte, 5), testContent, true, nil},
+	}
+	// iterate over the test cases and call copy Buffer with data.
+	for i, testCase := range testCases {
+		actualErr := copyBuffer(testCase.writer, testCase.disk, testCase.volume, testCase.path, testCase.buf)
+
+		if actualErr != nil && testCase.shouldPass {
+			t.Errorf("Test %d: Expected to pass but failed instead with \"%s\"", i+1, actualErr)
+		}
+
+		if actualErr == nil && !testCase.shouldPass {
+			t.Errorf("Test %d: Expected to fail with error <Error> \"%v\", but instead passed", i+1, testCase.expectedErr)
+		}
+		// Failed as expected, but does it fail for the expected reason.
+		if actualErr != nil && !testCase.shouldPass {
+			if testCase.expectedErr.Error() != actualErr.Error() {
+				t.Errorf("Test %d: Expected Error to be \"%v\", but instead found \"%v\" ", i+1, testCase.expectedErr, actualErr)
+			}
+		}
+		// test passed as expected, asserting the result.
+		if actualErr == nil && testCase.shouldPass {
+			if !bytes.Equal(testCase.expectedResult, buffers[2].Bytes()) {
+				t.Errorf("Test %d: copied buffer differs from the expected one.", i+1)
+			}
+		}
+	}
+}
@@ -79,41 +79,6 @@ var encodingMatrices = []encodingMatrix{
 	{8, 8}, // 8 data, 8 parity blocks.
 }

-// TestErasureEncode checks for encoding for different data sets.
-func TestErasureEncode(t *testing.T) {
-	// Collection of cases for encode cases.
-	testEncodeCases := []struct {
-		inputData  []byte
-		shouldPass bool
-	}{
-		// Regular data encoded.
-		{
-			inputData:  []byte("Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum."),
-			shouldPass: true,
-		},
-		// Empty data errors out.
-		{
-			inputData:  []byte(""),
-			shouldPass: false,
-		},
-		// Single byte encoded.
-		{
-			inputData:  []byte("1"),
-			shouldPass: true,
-		},
-	}
-
-	// Test encode cases.
-	for i, testCase := range testEncodeCases {
-		for _, encodingMatrix := range encodingMatrices {
-			_, err := encodeData(testCase.inputData, encodingMatrix.dataBlocks, encodingMatrix.parityBlocks)
-			if err != nil && testCase.shouldPass {
-				t.Errorf("Test %d: Expected to pass by failed instead with %s, for matrix %v", i+1, err, encodingMatrix)
-			}
-		}
-	}
-}
-
 // Tests erasure decoding functionality for various types of inputs.
 func TestErasureDecode(t *testing.T) {
 	data := []byte("Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.")
@@ -183,3 +148,37 @@ func TestErasureDecode(t *testing.T) {
 		}
 	}
 }
+
+// Setup for erasureCreateFile and erasureReadFile tests.
+type erasureTestSetup struct {
+	dataBlocks   int
+	parityBlocks int
+	blockSize    int64
+	diskPaths    []string
+	disks        []StorageAPI
+}
+
+// Removes the temporary disk directories.
+func (e erasureTestSetup) Remove() {
+	for _, path := range e.diskPaths {
+		removeAll(path)
+	}
+}
+
+// Returns an initialized setup for erasure tests.
+func newErasureTestSetup(dataBlocks int, parityBlocks int, blockSize int64) (*erasureTestSetup, error) {
+	diskPaths := make([]string, dataBlocks+parityBlocks)
+	disks := make([]StorageAPI, len(diskPaths))
+	var err error
+	for i := range diskPaths {
+		disks[i], diskPaths[i], err = newPosixTestSetup()
+		if err != nil {
+			return nil, err
+		}
+		err = disks[i].MakeVol("testbucket")
+		if err != nil {
+			return nil, err
+		}
+	}
+	return &erasureTestSetup{dataBlocks, parityBlocks, blockSize, diskPaths, disks}, nil
+}
@@ -0,0 +1,384 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"bytes"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"net/url"
+	"path"
+	"sync"
+	"time"
+
+	"github.com/Sirupsen/logrus"
+)
+
+// Global event notification queue. This is the queue that would be used to send all notifications.
+type eventNotifier struct {
+	rwMutex *sync.RWMutex
+
+	// Collection of 'bucket' and notification config.
+	notificationConfigs map[string]*notificationConfig
+	snsTargets          map[string][]chan []NotificationEvent
+	queueTargets        map[string]*logrus.Logger
+}
+
+// Represents data to be sent with notification event.
+type eventData struct {
+	Type      EventName
+	Bucket    string
+	ObjInfo   ObjectInfo
+	ReqParams map[string]string
+}
+
+// New notification event constructs a new notification event message from
+// input request metadata which completed successfully.
+func newNotificationEvent(event eventData) NotificationEvent {
+	/// Construct a new object created event.
+	region := serverConfig.GetRegion()
+	tnow := time.Now().UTC()
+	sequencer := fmt.Sprintf("%X", tnow.UnixNano())
+	// Following blocks fills in all the necessary details of s3 event message structure.
+	// http://docs.aws.amazon.com/AmazonS3/latest/dev/notification-content-structure.html
+	nEvent := NotificationEvent{
+		EventVersion:      "2.0",
+		EventSource:       "aws:s3",
+		AwsRegion:         region,
+		EventTime:         tnow.Format(timeFormatAMZ),
+		EventName:         event.Type.String(),
+		UserIdentity:      defaultIdentity(),
+		RequestParameters: event.ReqParams,
+		ResponseElements:  map[string]string{},
+		S3: eventMeta{
+			SchemaVersion:   "1.0",
+			ConfigurationID: "Config",
+			Bucket: bucketMeta{
+				Name:          event.Bucket,
+				OwnerIdentity: defaultIdentity(),
+				ARN:           "arn:aws:s3:::" + event.Bucket,
+			},
+		},
+	}
+
+	escapedObj := url.QueryEscape(event.ObjInfo.Name)
+	// For delete object event type, we do not need to set ETag and Size.
+	if event.Type == ObjectRemovedDelete {
+		nEvent.S3.Object = objectMeta{
+			Key:       escapedObj,
+			Sequencer: sequencer,
+		}
+		return nEvent
+	}
+	// For all other events we should set ETag and Size.
+	nEvent.S3.Object = objectMeta{
+		Key:       escapedObj,
+		ETag:      event.ObjInfo.MD5Sum,
+		Size:      event.ObjInfo.Size,
+		Sequencer: sequencer,
+	}
+	// Success.
+	return nEvent
+}
+
+// Fetch the saved queue target.
+func (en eventNotifier) GetQueueTarget(queueARN string) *logrus.Logger {
+	return en.queueTargets[queueARN]
+}
+
+func (en eventNotifier) GetSNSTarget(snsARN string) []chan []NotificationEvent {
+	en.rwMutex.RLock()
+	defer en.rwMutex.RUnlock()
+	return en.snsTargets[snsARN]
+}
+
+// Set a new sns target for an input sns ARN.
+func (en *eventNotifier) SetSNSTarget(snsARN string, listenerCh chan []NotificationEvent) error {
+	en.rwMutex.Lock()
+	defer en.rwMutex.Unlock()
+	if listenerCh == nil {
+		return errors.New("invalid argument")
+	}
+	en.snsTargets[snsARN] = append(en.snsTargets[snsARN], listenerCh)
+	return nil
+}
+
+// Remove sns target for an input sns ARN.
+func (en *eventNotifier) RemoveSNSTarget(snsARN string, listenerCh chan []NotificationEvent) {
+	en.rwMutex.Lock()
+	defer en.rwMutex.Unlock()
+	snsTarget, ok := en.snsTargets[snsARN]
+	if ok {
+		for i, savedListenerCh := range snsTarget {
+			if listenerCh == savedListenerCh {
+				snsTarget = append(snsTarget[:i], snsTarget[i+1:]...)
+				if len(snsTarget) == 0 {
+					delete(en.snsTargets, snsARN)
+					break
+				}
+				en.snsTargets[snsARN] = snsTarget
+			}
+		}
+	}
+}
+
+// Returns true if bucket notification is set for the bucket, false otherwise.
+func (en *eventNotifier) IsBucketNotificationSet(bucket string) bool {
+	if en == nil {
+		return false
+	}
+	en.rwMutex.RLock()
+	defer en.rwMutex.RUnlock()
+	_, ok := en.notificationConfigs[bucket]
+	return ok
+}
+
+// Fetch bucket notification config for an input bucket.
+func (en eventNotifier) GetBucketNotificationConfig(bucket string) *notificationConfig {
+	en.rwMutex.RLock()
+	defer en.rwMutex.RUnlock()
+	return en.notificationConfigs[bucket]
+}
+
+// Set a new notification config for a bucket, this operation will overwrite any previous
+// notification configs for the bucket.
+func (en *eventNotifier) SetBucketNotificationConfig(bucket string, notificationCfg *notificationConfig) error {
+	en.rwMutex.Lock()
+	defer en.rwMutex.Unlock()
+	if notificationCfg == nil {
+		return errors.New("invalid argument")
+	}
+	en.notificationConfigs[bucket] = notificationCfg
+	return nil
+}
+
+// eventNotify notifies an event to relevant targets based on their
+// bucket notification configs.
+func eventNotify(event eventData) {
+	// Notifies a new event.
+	// List of events reported through this function are
+	//  - s3:ObjectCreated:Put
+	//  - s3:ObjectCreated:Post
+	//  - s3:ObjectCreated:Copy
+	//  - s3:ObjectCreated:CompleteMultipartUpload
+	//  - s3:ObjectRemoved:Delete
+
+	nConfig := eventN.GetBucketNotificationConfig(event.Bucket)
+	// No bucket notifications enabled, drop the event notification.
+	if len(nConfig.QueueConfigs) == 0 && len(nConfig.TopicConfigs) == 0 && len(nConfig.LambdaConfigs) == 0 {
+		return
+	}
+
+	// Event type.
+	eventType := event.Type.String()
+
+	// Object name.
+	objectName := event.ObjInfo.Name
+
+	// Save the notification event to be sent.
+	notificationEvent := []NotificationEvent{newNotificationEvent(event)}
+
+	// Validate if the event and object match the queue configs.
+	for _, qConfig := range nConfig.QueueConfigs {
+		eventMatch := eventMatch(eventType, qConfig.Events)
+		ruleMatch := filterRuleMatch(objectName, qConfig.Filter.Key.FilterRules)
+		if eventMatch && ruleMatch {
+			targetLog := eventN.GetQueueTarget(qConfig.QueueARN)
+			if targetLog != nil {
+				targetLog.WithFields(logrus.Fields{
+					"Records": notificationEvent,
+				}).Info()
+			}
+		}
+	}
+	// Validate if the event and object match the sns configs.
+	for _, topicConfig := range nConfig.TopicConfigs {
+		ruleMatch := filterRuleMatch(objectName, topicConfig.Filter.Key.FilterRules)
+		eventMatch := eventMatch(eventType, topicConfig.Events)
+		if eventMatch && ruleMatch {
+			targetListeners := eventN.GetSNSTarget(topicConfig.TopicARN)
+			for _, listener := range targetListeners {
+				listener <- notificationEvent
+			}
+		}
+	}
+}
+
+// loads notifcation config if any for a given bucket, returns back structured notification config.
+func loadNotificationConfig(bucket string, objAPI ObjectLayer) (*notificationConfig, error) {
+	// Construct the notification config path.
+	notificationConfigPath := path.Join(bucketConfigPrefix, bucket, bucketNotificationConfig)
+	objInfo, err := objAPI.GetObjectInfo(minioMetaBucket, notificationConfigPath)
+	if err != nil {
+		// 'notification.xml' not found return 'errNoSuchNotifications'.
+		// This is default when no bucket notifications are found on the bucket.
+		switch err.(type) {
+		case ObjectNotFound:
+			return nil, errNoSuchNotifications
+		}
+		// Returns error for other errors.
+		return nil, err
+	}
+	var buffer bytes.Buffer
+	err = objAPI.GetObject(minioMetaBucket, notificationConfigPath, 0, objInfo.Size, &buffer)
+	if err != nil {
+		// 'notification.xml' not found return 'errNoSuchNotifications'.
+		// This is default when no bucket notifications are found on the bucket.
+		switch err.(type) {
+		case ObjectNotFound:
+			return nil, errNoSuchNotifications
+		}
+		// Returns error for other errors.
+		return nil, err
+	}
+
+	// Unmarshal notification bytes.
+	notificationConfigBytes := buffer.Bytes()
+	notificationCfg := &notificationConfig{}
+	if err = xml.Unmarshal(notificationConfigBytes, &notificationCfg); err != nil {
+		return nil, err
+	} // Successfully marshalled notification configuration.
+
+	// Return success.
+	return notificationCfg, nil
+}
+
+// loads all bucket notifications if present.
+func loadAllBucketNotifications(objAPI ObjectLayer) (map[string]*notificationConfig, error) {
+	// List buckets to proceed loading all notification configuration.
+	buckets, err := objAPI.ListBuckets()
+	if err != nil {
+		return nil, err
+	}
+
+	configs := make(map[string]*notificationConfig)
+
+	// Loads all bucket notifications.
+	for _, bucket := range buckets {
+		var nCfg *notificationConfig
+		nCfg, err = loadNotificationConfig(bucket.Name, objAPI)
+		if err != nil {
+			if err == errNoSuchNotifications {
+				continue
+			}
+			return nil, err
+		}
+		configs[bucket.Name] = nCfg
+	}
+
+	// Success.
+	return configs, nil
+}
+
+// Loads all queue targets, initializes each queueARNs depending on their config.
+// Each instance of queueARN registers its own logrus to communicate with the
+// queue service. QueueARN once initialized is not initialized again for the
+// same queueARN, instead previous connection is used.
+func loadAllQueueTargets() (map[string]*logrus.Logger, error) {
+	queueTargets := make(map[string]*logrus.Logger)
+	// Load all amqp targets, initialize their respective loggers.
+	for accountID, amqpN := range serverConfig.GetAMQP() {
+		if !amqpN.Enable {
+			continue
+		}
+		// Construct the queue ARN for AMQP.
+		queueARN := minioSqs + serverConfig.GetRegion() + ":" + accountID + ":" + queueTypeAMQP
+		// Queue target if already initialized we move to the next ARN.
+		_, ok := queueTargets[queueARN]
+		if ok {
+			continue
+		}
+		// Using accountID we can now initialize a new AMQP logrus instance.
+		amqpLog, err := newAMQPNotify(accountID)
+		if err != nil {
+			return nil, err
+		}
+		queueTargets[queueARN] = amqpLog
+	}
+	// Load redis targets, initialize their respective loggers.
+	for accountID, redisN := range serverConfig.GetRedis() {
+		if !redisN.Enable {
+			continue
+		}
+		// Construct the queue ARN for Redis.
+		queueARN := minioSqs + serverConfig.GetRegion() + ":" + accountID + ":" + queueTypeRedis
+		// Queue target if already initialized we move to the next ARN.
+		_, ok := queueTargets[queueARN]
+		if ok {
+			continue
+		}
+		// Using accountID we can now initialize a new Redis logrus instance.
+		redisLog, err := newRedisNotify(accountID)
+		if err != nil {
+			return nil, err
+		}
+		queueTargets[queueARN] = redisLog
+	}
+	// Load elastic targets, initialize their respective loggers.
+	for accountID, elasticN := range serverConfig.GetElasticSearch() {
+		if !elasticN.Enable {
+			continue
+		}
+		// Construct the queue ARN for Elastic.
+		queueARN := minioSqs + serverConfig.GetRegion() + ":" + accountID + ":" + queueTypeElastic
+		_, ok := queueTargets[queueARN]
+		if ok {
+			continue
+		}
+		// Using accountID we can now initialize a new ElasticSearch logrus instance.
+		elasticLog, err := newElasticNotify(accountID)
+		if err != nil {
+			return nil, err
+		}
+		queueTargets[queueARN] = elasticLog
+	}
+	// Successfully initialized queue targets.
+	return queueTargets, nil
+}
+
+// Global instance of event notification queue.
+var eventN *eventNotifier
+
+// Initialize event notifier.
+func initEventNotifier(objAPI ObjectLayer) error {
+	if objAPI == nil {
+		return errInvalidArgument
+	}
+
+	// Read all saved bucket notifications.
+	configs, err := loadAllBucketNotifications(objAPI)
+	if err != nil {
+		return err
+	}
+
+	// Initializes all queue targets.
+	queueTargets, err := loadAllQueueTargets()
+	if err != nil {
+		return err
+	}
+
+	// Inititalize event notifier queue.
+	eventN = &eventNotifier{
+		rwMutex:             &sync.RWMutex{},
+		notificationConfigs: configs,
+		queueTargets:        queueTargets,
+		snsTargets:          make(map[string][]chan []NotificationEvent),
+	}
+
+	return nil
+}
@@ -0,0 +1,67 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import "testing"
+
+// Tests various forms of inititalization of event notifier.
+func TestInitEventNotifier(t *testing.T) {
+	fs, disk, err := getSingleNodeObjectLayer()
+	if err != nil {
+		t.Fatal("Unable to initialize FS backend.", err)
+	}
+	xl, disks, err := getXLObjectLayer()
+	if err != nil {
+		t.Fatal("Unable to initialize XL backend.", err)
+	}
+
+	disks = append(disks, disk)
+	for _, d := range disks {
+		defer removeAll(d)
+	}
+
+	// Collection of test cases for inititalizing event notifier.
+	testCases := []struct {
+		objAPI  ObjectLayer
+		configs map[string]*notificationConfig
+		err     error
+	}{
+		// Test 1 - invalid arguments.
+		{
+			objAPI: nil,
+			err:    errInvalidArgument,
+		},
+		// Test 2 - valid FS object layer but no bucket notifications.
+		{
+			objAPI: fs,
+			err:    nil,
+		},
+		// Test 3 - valid XL object layer but no bucket notifications.
+		{
+			objAPI: xl,
+			err:    nil,
+		},
+	}
+
+	// Validate if event notifier is properly initialized.
+	for i, testCase := range testCases {
+		err = initEventNotifier(testCase.objAPI)
+		if err != testCase.err {
+			t.Errorf("Test %d: Expected %s, but got: %s", i+1, testCase.err, err)
+		}
+	}
+}
@@ -0,0 +1,115 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+// Simulates disk returning errFaultyDisk on all methods of StorageAPI
+// interface after successCount number of successes.
+type faultyDisk struct {
+	disk         *posix
+	successCount int
+}
+
+// instantiates a faulty
+func newFaultyDisk(disk *posix, n int) *faultyDisk {
+	return &faultyDisk{disk: disk, successCount: n}
+}
+
+func (f *faultyDisk) MakeVol(volume string) (err error) {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.MakeVol(volume)
+	}
+	return errFaultyDisk
+}
+func (f *faultyDisk) ListVols() (vols []VolInfo, err error) {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.ListVols()
+	}
+	return nil, errFaultyDisk
+}
+
+func (f *faultyDisk) StatVol(volume string) (volInfo VolInfo, err error) {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.StatVol(volume)
+	}
+	return VolInfo{}, errFaultyDisk
+}
+func (f *faultyDisk) DeleteVol(volume string) (err error) {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.DeleteVol(volume)
+	}
+	return errFaultyDisk
+}
+
+func (f *faultyDisk) ListDir(volume, path string) (entries []string, err error) {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.ListDir(volume, path)
+	}
+	return []string{}, errFaultyDisk
+}
+
+func (f *faultyDisk) ReadFile(volume string, path string, offset int64, buf []byte) (n int64, err error) {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.ReadFile(volume, path, offset, buf)
+	}
+	return 0, errFaultyDisk
+}
+
+func (f *faultyDisk) AppendFile(volume, path string, buf []byte) error {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.AppendFile(volume, path, buf)
+	}
+	return errFaultyDisk
+}
+
+func (f *faultyDisk) RenameFile(srcVolume, srcPath, dstVolume, dstPath string) error {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.RenameFile(srcVolume, srcPath, dstVolume, dstPath)
+	}
+	return errFaultyDisk
+}
+
+func (f *faultyDisk) StatFile(volume string, path string) (file FileInfo, err error) {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.StatFile(volume, path)
+	}
+	return FileInfo{}, errFaultyDisk
+}
+
+func (f *faultyDisk) DeleteFile(volume string, path string) (err error) {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.DeleteFile(volume, path)
+	}
+	return errFaultyDisk
+}
+
+func (f *faultyDisk) ReadAll(volume string, path string) (buf []byte, err error) {
+	if f.successCount > 0 {
+		f.successCount--
+		return f.disk.ReadAll(volume, path)
+	}
+	return nil, errFaultyDisk
+}
@@ -20,7 +20,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"strings"
+	"reflect"
 	"sync"
 )

@@ -118,13 +118,19 @@ var errDiskOrderMismatch = errors.New("disk order mismatch")
 func reduceFormatErrs(errs []error, diskCount int) (err error) {
 	var errUnformattedDiskCount = 0
 	var errDiskNotFoundCount = 0
+	var errCorruptedFormatCount = 0
 	for _, dErr := range errs {
 		if dErr == errUnformattedDisk {
 			errUnformattedDiskCount++
 		} else if dErr == errDiskNotFound {
 			errDiskNotFoundCount++
+		} else if dErr == errCorruptedFormat {
+			errCorruptedFormatCount++
 		}
 	}
+	if errCorruptedFormatCount > 0 {
+		return errCorruptedFormat
+	}
 	// Unformatted disks found, we need to figure out if any disks are offline.
 	if errUnformattedDiskCount > 0 {
 		// Returns errUnformattedDisk if all disks report unFormattedDisk.
@@ -222,8 +228,8 @@ func genericFormatCheck(formatConfigs []*formatConfigV1, sErrs []error) (err err
 		return errXLReadQuorum
 	}

-	// One of the disk has corrupt format, return error.
-	if errCorruptFormatCount > 0 {
+	// Check if number of corrupted format under quorum
+	if errCorruptFormatCount > len(formatConfigs)-readQuorum {
 		return errCorruptedFormat
 	}

@@ -296,21 +302,21 @@ func checkDisksConsistency(formatConfigs []*formatConfigV1) error {

 // checkJBODConsistency - validate xl jbod order if they are consistent.
 func checkJBODConsistency(formatConfigs []*formatConfigV1) error {
-	var jbodStr string
+	var sentinelJBOD []string
 	// Extract first valid JBOD.
 	for _, format := range formatConfigs {
 		if format == nil {
 			continue
 		}
-		jbodStr = strings.Join(format.XL.JBOD, ".")
+		sentinelJBOD = format.XL.JBOD
 		break
 	}
 	for _, format := range formatConfigs {
 		if format == nil {
 			continue
 		}
-		savedJBODStr := strings.Join(format.XL.JBOD, ".")
-		if jbodStr != savedJBODStr {
+		currentJBOD := format.XL.JBOD
+		if !reflect.DeepEqual(sentinelJBOD, currentJBOD) {
 			return errors.New("Inconsistent JBOD found.")
 		}
 	}
@@ -412,14 +418,15 @@ func isFormatFound(formats []*formatConfigV1) bool {

 // Heals any missing format.json on the drives. Returns error only for unexpected errors
 // as regular errors can be ignored since there might be enough quorum to be operational.
-func healFormatXL(storageDisks []StorageAPI) error {
+// Heals only fresh disks.
+func healFormatXLFreshDisks(storageDisks []StorageAPI) error {
 	formatConfigs := make([]*formatConfigV1, len(storageDisks))
 	var referenceConfig *formatConfigV1
 	// Loads `format.json` from all disks.
 	for index, disk := range storageDisks {
 		// Disk not found or ignored is a valid case.
 		if disk == nil {
-			// Proceed without healing.
+			// Return nil, one of the disk is offline.
 			return nil
 		}
 		formatXL, err := loadFormat(disk)
@@ -436,6 +443,7 @@ func healFormatXL(storageDisks []StorageAPI) error {
 		} // Success.
 		formatConfigs[index] = formatXL
 	}
+
 	// All `format.json` has been read successfully, previously completed.
 	if isFormatFound(formatConfigs) {
 		// Return success.
@@ -446,6 +454,7 @@ func healFormatXL(storageDisks []StorageAPI) error {
 	if isFormatNotFound(formatConfigs) {
 		return initFormatXL(storageDisks)
 	}
+
 	// Validate format configs for consistency in JBOD and disks.
 	if err := checkFormatXL(formatConfigs); err != nil {
 		return err
@@ -462,40 +471,246 @@ func healFormatXL(storageDisks []StorageAPI) error {
 		}
 	}

+	// Collect new JBOD.
+	newJBOD := referenceConfig.XL.JBOD
+
+	// Reorder the disks based on the JBOD order.
+	orderedDisks, err := reorderDisks(storageDisks, formatConfigs)
+	if err != nil {
+		return err
+	}
+
+	// From ordered disks fill the UUID position.
+	for index, disk := range orderedDisks {
+		if disk == nil {
+			newJBOD[index] = getUUID()
+		}
+	}
+
 	// Collect new format configs.
-	var newFormatConfigs = make([]*formatConfigV1, len(storageDisks))
+	var newFormatConfigs = make([]*formatConfigV1, len(orderedDisks))
+
+	// Collect new format configs that need to be written.
+	for index := range orderedDisks {
+		// New configs are generated since we are going
+		// to re-populate across all disks.
+		config := &formatConfigV1{
+			Version: referenceConfig.Version,
+			Format:  referenceConfig.Format,
+			XL: &xlFormat{
+				Version: referenceConfig.XL.Version,
+				Disk:    newJBOD[index],
+				JBOD:    newJBOD,
+			},
+		}
+		newFormatConfigs[index] = config
+	}
+
+	// Fill in the missing disk back from format configs.
+	// We need to make sure we have kept the previous order
+	// and allowed fresh disks to be arranged anywhere.
+	// Following block facilitates to put fresh disks.
+	for index, format := range formatConfigs {
+		// Format is missing so we go through ordered disks.
+		if format == nil {
+			// At this point when disk is missing the fresh disk
+			// in the stack get it back from storageDisks.
+			for oIndex, disk := range orderedDisks {
+				if disk == nil {
+					orderedDisks[oIndex] = storageDisks[index]
+					break
+				}
+			}
+		}
+	}
+
+	// Save new `format.json` across all disks, in JBOD order.
+	return saveFormatXL(orderedDisks, newFormatConfigs)
+}
+
+// Disks from storageDiks are put in assignedDisks if found in orderedDisks and in unAssignedDisks otherwise
+func splitDisksByUse(storageDisks, orderedDisks []StorageAPI) (assignedDisks []StorageAPI, unAssignedDisks []StorageAPI) {
+	// Populate unAssignDisks
+	for i := range storageDisks {
+		found := false
+		for j := range orderedDisks {
+			if storageDisks[i] == orderedDisks[j] {
+				found = true
+				assignedDisks = append(assignedDisks, storageDisks[i])
+				break
+			}
+		}
+		if !found {
+			unAssignedDisks = append(unAssignedDisks, storageDisks[i])
+		}
+	}
+	return assignedDisks, unAssignedDisks
+}
+
+// Inspect the content of all disks to guess the right order according to the format files.
+// The right order is represented in orderedDisks
+func reorderDisksByInspection(orderedDisks, storageDisks []StorageAPI, formatConfigs []*formatConfigV1) ([]StorageAPI, error) {
+	for index, format := range formatConfigs {
+		if format != nil {
+			continue
+		}
+		vols, err := storageDisks[index].ListVols()
+		if err != nil {
+			return nil, err
+		}
+		if len(vols) == 0 {
+			continue
+		}
+		volName := ""
+		// Avoid picking minioMetaBucket because ListVols() returns a non ordered list
+		for i := range vols {
+			if vols[i].Name != minioMetaBucket {
+				volName = vols[i].Name
+				break
+			}
+		}
+		if volName == "" {
+			continue
+		}
+		objects, err := storageDisks[index].ListDir(volName, "")
+		if err != nil {
+			return nil, err
+		}
+		if len(objects) == 0 {
+			continue
+		}
+		xlData, err := readXLMeta(storageDisks[index], volName, objects[0])
+		if err != nil {
+			if err == errFileNotFound {
+				continue
+			}
+			return nil, err
+		}
+		diskIndex := -1
+		for i, d := range xlData.Erasure.Distribution {
+			if d == xlData.Erasure.Index {
+				diskIndex = i
+			}
+		}
+		// Check for found results
+		if diskIndex == -1 || orderedDisks[diskIndex] != nil {
+			// Some inconsistent data are found, exit immediately.
+			return nil, errCorruptedFormat
+		}
+		orderedDisks[diskIndex] = storageDisks[index]
+	}
+	return orderedDisks, nil
+}
+
+// Heals corrupted format json in all disks
+func healFormatXLCorruptedDisks(storageDisks []StorageAPI) error {
+	formatConfigs := make([]*formatConfigV1, len(storageDisks))
+	var referenceConfig *formatConfigV1
+
+	// Loads `format.json` from all disks.
+	for index, disk := range storageDisks {
+		// Disk not found or ignored is a valid case.
+		if disk == nil {
+			// Return nil, one of the disk is offline.
+			return nil
+		}
+		formatXL, err := loadFormat(disk)
+		if err != nil {
+			if err == errUnformattedDisk || err == errCorruptedFormat {
+				// format.json is missing or corrupted, should be healed.
+				continue
+			} else if err == errDiskNotFound { // Is a valid case we
+				// can proceed without healing.
+				return nil
+			}
+			// Return error for unsupported errors.
+			return err
+		} // Success.
+		formatConfigs[index] = formatXL
+	}
+
+	// All `format.json` has been read successfully, previously completed.
+	if isFormatFound(formatConfigs) {
+		// Return success.
+		return nil
+	}
+
+	// All disks are fresh, format.json will be written by initFormatXL()
+	if isFormatNotFound(formatConfigs) {
+		return initFormatXL(storageDisks)
+	}
+
+	// Validate format configs for consistency in JBOD and disks.
+	if err := checkFormatXL(formatConfigs); err != nil {
+		return err
+	}
+
+	if referenceConfig == nil {
+		// This config will be used to update the drives missing format.json.
+		for _, formatConfig := range formatConfigs {
+			if formatConfig == nil {
+				continue
+			}
+			referenceConfig = formatConfig
+			break
+		}
+	}

 	// Collect new JBOD.
 	newJBOD := referenceConfig.XL.JBOD

-	// This section heals the format.json and updates the fresh disks
-	// by apply a new UUID for all the fresh disks.
-	for index, format := range formatConfigs {
-		if format == nil {
+	// Reorder the disks based on the JBOD order.
+	orderedDisks, err := reorderDisks(storageDisks, formatConfigs)
+	if err != nil {
+		return err
+	}
+
+	// From ordered disks fill the UUID position.
+	for index, disk := range orderedDisks {
+		if disk == nil {
 			newJBOD[index] = getUUID()
 		}
 	}
-	// Collect new format configs that need to be written.
-	for index, format := range formatConfigs {
-		if format == nil {
-			config := &formatConfigV1{
-				Version: referenceConfig.Version,
-				Format:  referenceConfig.Format,
-				XL: &xlFormat{
-					Version: referenceConfig.XL.Version,
-					Disk:    newJBOD[index],
-					JBOD:    newJBOD,
-				},
-			}
-			newFormatConfigs[index] = config
-			continue
-		}
-		newFormatConfigs[index] = format
-		newFormatConfigs[index].XL.JBOD = newJBOD
-		newFormatConfigs[index].XL.Disk = newJBOD[index]
+
+	// For disks with corrupted formats, inspect the disks contents to guess the disks order
+	orderedDisks, err = reorderDisksByInspection(orderedDisks, storageDisks, formatConfigs)
+	if err != nil {
+		return err
 	}
-	// Save new `format.json` across all disks.
-	return saveFormatXL(storageDisks, newFormatConfigs)
+
+	// At this stage, all disks with corrupted formats but with objects inside found their way.
+	// Now take care of unformatted disks, which are the `unAssignedDisks`
+	_, unAssignedDisks := splitDisksByUse(storageDisks, orderedDisks)
+
+	// Assign unassigned disks to nil elements in orderedDisks
+	for i, disk := range orderedDisks {
+		if disk == nil && len(unAssignedDisks) > 0 {
+			orderedDisks[i] = unAssignedDisks[0]
+			unAssignedDisks = unAssignedDisks[1:]
+		}
+	}
+
+	// Collect new format configs.
+	var newFormatConfigs = make([]*formatConfigV1, len(orderedDisks))
+
+	// Collect new format configs that need to be written.
+	for index := range orderedDisks {
+		// New configs are generated since we are going
+		// to re-populate across all disks.
+		config := &formatConfigV1{
+			Version: referenceConfig.Version,
+			Format:  referenceConfig.Format,
+			XL: &xlFormat{
+				Version: referenceConfig.XL.Version,
+				Disk:    newJBOD[index],
+				JBOD:    newJBOD,
+			},
+		}
+		newFormatConfigs[index] = config
+	}
+
+	// Save new `format.json` across all disks, in JBOD order.
+	return saveFormatXL(orderedDisks, newFormatConfigs)
 }

 // loadFormatXL - loads XL `format.json` and returns back properly
@@ -16,7 +16,10 @@

 package main

-import "testing"
+import (
+	"bytes"
+	"testing"
+)

 // generates a valid format.json for XL backend.
 func genFormatXLValid() []*formatConfigV1 {
@@ -142,6 +145,213 @@ func genFormatXLInvalidDisksOrder() []*formatConfigV1 {
 	return formatConfigs
 }

+func TestFormatXLHealFreshDisks(t *testing.T) {
+	// Create an instance of xl backend.
+	obj, fsDirs, err := getXLObjectLayer()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	xl := obj.(xlObjects)
+
+	err = obj.MakeBucket("bucket")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	bucket := "bucket"
+	object := "object"
+
+	_, err = obj.PutObject(bucket, object, int64(len("abcd")), bytes.NewReader([]byte("abcd")), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	/* // Now, remove two format files.. Load them and reorder
+	if err = xl.storageDisks[3].DeleteFile(".minio.sys", "format.json"); err != nil {
+		t.Fatal(err)
+	}
+	if err = xl.storageDisks[11].DeleteFile(".minio.sys", "format.json"); err != nil {
+		t.Fatal(err)
+	} */
+
+	// Remove the content of export dir 10 but preserve .minio.sys because it is automatically
+	// created when minio starts
+	for i := 3; i <= 5; i++ {
+		if err = xl.storageDisks[i].DeleteFile(".minio.sys", "format.json"); err != nil {
+			t.Fatal(err)
+		}
+		if err = xl.storageDisks[i].DeleteFile(".minio.sys", "tmp"); err != nil {
+			t.Fatal(err)
+		}
+		if err = xl.storageDisks[i].DeleteFile(bucket, object+"/xl.json"); err != nil {
+			t.Fatal(err)
+		}
+		if err = xl.storageDisks[i].DeleteFile(bucket, object+"/part.1"); err != nil {
+			t.Fatal(err)
+		}
+		if err = xl.storageDisks[i].DeleteVol(bucket); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	permutedStorageDisks := []StorageAPI{xl.storageDisks[1], xl.storageDisks[4],
+		xl.storageDisks[2], xl.storageDisks[8], xl.storageDisks[6], xl.storageDisks[7],
+		xl.storageDisks[0], xl.storageDisks[15], xl.storageDisks[13], xl.storageDisks[14],
+		xl.storageDisks[3], xl.storageDisks[10], xl.storageDisks[12], xl.storageDisks[9],
+		xl.storageDisks[5], xl.storageDisks[11]}
+
+	// Start healing disks
+	err = healFormatXLFreshDisks(permutedStorageDisks)
+	if err != nil {
+		t.Fatal("healing corrupted disk failed: ", err)
+	}
+
+	// Load again XL format.json to validate it
+	_, err = loadFormatXL(permutedStorageDisks)
+	if err != nil {
+		t.Fatal("loading healed disk failed: ", err)
+	}
+
+	// Clean all
+	removeRoots(fsDirs)
+}
+
+// Simulate XL disks creation, delete some format.json and remove the content of
+// a given disk to test healing a corrupted disk
+func TestFormatXLHealCorruptedDisks(t *testing.T) {
+	// Create an instance of xl backend.
+	obj, fsDirs, err := getXLObjectLayer()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	xl := obj.(xlObjects)
+
+	err = obj.MakeBucket("bucket")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	bucket := "bucket"
+	object := "object"
+
+	_, err = obj.PutObject(bucket, object, int64(len("abcd")), bytes.NewReader([]byte("abcd")), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Now, remove two format files.. Load them and reorder
+	if err = xl.storageDisks[3].DeleteFile(".minio.sys", "format.json"); err != nil {
+		t.Fatal(err)
+	}
+	if err = xl.storageDisks[11].DeleteFile(".minio.sys", "format.json"); err != nil {
+		t.Fatal(err)
+	}
+
+	// Remove the content of export dir 10 but preserve .minio.sys because it is automatically
+	// created when minio starts
+	if err = xl.storageDisks[10].DeleteFile(".minio.sys", "format.json"); err != nil {
+		t.Fatal(err)
+	}
+	if err = xl.storageDisks[10].DeleteFile(".minio.sys", "tmp"); err != nil {
+		t.Fatal(err)
+	}
+	if err = xl.storageDisks[10].DeleteFile(bucket, object+"/xl.json"); err != nil {
+		t.Fatal(err)
+	}
+	if err = xl.storageDisks[10].DeleteFile(bucket, object+"/part.1"); err != nil {
+		t.Fatal(err)
+	}
+	if err = xl.storageDisks[10].DeleteVol(bucket); err != nil {
+		t.Fatal(err)
+	}
+
+	permutedStorageDisks := []StorageAPI{xl.storageDisks[1], xl.storageDisks[4],
+		xl.storageDisks[2], xl.storageDisks[8], xl.storageDisks[6], xl.storageDisks[7],
+		xl.storageDisks[0], xl.storageDisks[15], xl.storageDisks[13], xl.storageDisks[14],
+		xl.storageDisks[3], xl.storageDisks[10], xl.storageDisks[12], xl.storageDisks[9],
+		xl.storageDisks[5], xl.storageDisks[11]}
+
+	// Start healing disks
+	err = healFormatXLCorruptedDisks(permutedStorageDisks)
+	if err != nil {
+		t.Fatal("healing corrupted disk failed: ", err)
+	}
+
+	// Load again XL format.json to validate it
+	_, err = loadFormatXL(permutedStorageDisks)
+	if err != nil {
+		t.Fatal("loading healed disk failed: ", err)
+	}
+
+	// Clean all
+	removeRoots(fsDirs)
+}
+
+// Test on ReorderByInspection by simulating creating disks and removing
+// some of format.json
+func TestFormatXLReorderByInspection(t *testing.T) {
+	// Create an instance of xl backend.
+	obj, fsDirs, err := getXLObjectLayer()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	xl := obj.(xlObjects)
+
+	err = obj.MakeBucket("bucket")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	bucket := "bucket"
+	object := "object"
+
+	_, err = obj.PutObject(bucket, object, int64(len("abcd")), bytes.NewReader([]byte("abcd")), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Now, remove two format files.. Load them and reorder
+	if err = xl.storageDisks[3].DeleteFile(".minio.sys", "format.json"); err != nil {
+		t.Fatal(err)
+	}
+	if err = xl.storageDisks[5].DeleteFile(".minio.sys", "format.json"); err != nil {
+		t.Fatal(err)
+	}
+
+	permutedStorageDisks := []StorageAPI{xl.storageDisks[1], xl.storageDisks[4],
+		xl.storageDisks[2], xl.storageDisks[8], xl.storageDisks[6], xl.storageDisks[7],
+		xl.storageDisks[0], xl.storageDisks[15], xl.storageDisks[13], xl.storageDisks[14],
+		xl.storageDisks[3], xl.storageDisks[10], xl.storageDisks[12], xl.storageDisks[9],
+		xl.storageDisks[5], xl.storageDisks[11]}
+
+	permutedFormatConfigs, _ := loadAllFormats(permutedStorageDisks)
+
+	orderedDisks, err := reorderDisks(permutedStorageDisks, permutedFormatConfigs)
+	if err != nil {
+		t.Fatal("error reordering disks\n")
+	}
+
+	orderedDisks, err = reorderDisksByInspection(orderedDisks, permutedStorageDisks, permutedFormatConfigs)
+	if err != nil {
+		t.Fatal("failed to reorder disk by inspection")
+	}
+
+	// Check disks reordering
+	for i := 0; i <= 15; i++ {
+		if orderedDisks[i] == nil && i != 3 && i != 5 {
+			t.Fatal("should not be nil")
+		}
+		if orderedDisks[i] != nil && orderedDisks[i] != xl.storageDisks[i] {
+			t.Fatal("Disks were not ordered correctly.")
+		}
+	}
+
+	removeRoots(fsDirs)
+}
+
 // Wrapper for calling FormatXL tests - currently validates
 //  - valid format
 //  - unrecognized version number
@@ -0,0 +1,41 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import "io"
+
+func fsCreateFile(disk StorageAPI, reader io.Reader, buf []byte, tmpBucket, tempObj string) (int64, error) {
+	bytesWritten := int64(0)
+	// Read the buffer till io.EOF and append the read data to the temporary file.
+	for {
+		n, rErr := reader.Read(buf)
+		if rErr != nil && rErr != io.EOF {
+			return 0, rErr
+		}
+		bytesWritten += int64(n)
+		if n > 0 {
+			wErr := disk.AppendFile(tmpBucket, tempObj, buf[0:n])
+			if wErr != nil {
+				return 0, wErr
+			}
+		}
+		if rErr == io.EOF {
+			break
+		}
+	}
+	return bytesWritten, nil
+}
@@ -1,9 +1,27 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main

 import (
 	"encoding/json"
+	"os"
 	"path"
 	"sort"
+	"strings"
 )

 const (
@@ -18,7 +36,9 @@ type fsMetaV1 struct {
 	Minio   struct {
 		Release string `json:"release"`
 	} `json:"minio"`
-	Parts []objectPartInfo `json:"parts,omitempty"`
+	// Metadata map for current object `fs.json`.
+	Meta  map[string]string `json:"meta,omitempty"`
+	Parts []objectPartInfo  `json:"parts,omitempty"`
 }

 // ObjectPartIndex - returns the index of matching object part number.
@@ -111,14 +131,44 @@ func writeFSFormatData(storage StorageAPI, fsFormat formatConfigV1) error {
 	return nil
 }

-// writeFSMetadata - writes `fs.json` metadata.
-func (fs fsObjects) writeTempFSMetadata(bucket, path string, fsMeta fsMetaV1) error {
+// writeFSMetadata - writes `fs.json` metadata, marshals fsMeta object into json
+// and saves it to disk.
+func writeFSMetadata(storage StorageAPI, bucket, path string, fsMeta fsMetaV1) error {
 	metadataBytes, err := json.Marshal(fsMeta)
 	if err != nil {
 		return err
 	}
-	if err = fs.storage.AppendFile(bucket, path, metadataBytes); err != nil {
+	if err = storage.AppendFile(bucket, path, metadataBytes); err != nil {
 		return err
 	}
 	return nil
 }
+
+var extendedHeaders = []string{
+	"X-Amz-Meta-",
+	"X-Minio-Meta-",
+	// Add new extended headers.
+}
+
+// isExtendedHeader validates if input string matches extended headers.
+func isExtendedHeader(header string) bool {
+	for _, extendedHeader := range extendedHeaders {
+		if strings.HasPrefix(header, extendedHeader) {
+			return true
+		}
+	}
+	return false
+}
+
+// Return true if extended HTTP headers are set, false otherwise.
+func hasExtendedHeader(metadata map[string]string) bool {
+	if os.Getenv("MINIO_ENABLE_FSMETA") == "1" {
+		return true
+	}
+	for k := range metadata {
+		if isExtendedHeader(k) {
+			return true
+		}
+	}
+	return false
+}
@@ -0,0 +1,66 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"os"
+	"testing"
+)
+
+// Tests scenarios which can occur for hasExtendedHeader function.
+func TestHasExtendedHeader(t *testing.T) {
+	// All test cases concerning hasExtendedHeader function.
+	testCases := []struct {
+		metadata map[string]string
+		has      bool
+	}{
+		// Verifies if X-Amz-Meta is present.
+		{
+			metadata: map[string]string{
+				"X-Amz-Meta-1": "value",
+			},
+			has: true || os.Getenv("MINIO_ENABLE_FSMETA") == "1",
+		},
+		// Verifies if X-Minio-Meta is present.
+		{
+			metadata: map[string]string{
+				"X-Minio-Meta-1": "value",
+			},
+			has: true || os.Getenv("MINIO_ENABLE_FSMETA") == "1",
+		},
+		// Verifies if extended header is not present.
+		{
+			metadata: map[string]string{
+				"md5Sum": "value",
+			},
+			has: false || os.Getenv("MINIO_ENABLE_FSMETA") == "1",
+		},
+		// Verifies if extended header is not present, but with an empty input.
+		{
+			metadata: nil,
+			has:      false || os.Getenv("MINIO_ENABLE_FSMETA") == "1",
+		},
+	}
+
+	// Validate all test cases.
+	for i, testCase := range testCases {
+		has := hasExtendedHeader(testCase.metadata)
+		if has != testCase.has {
+			t.Fatalf("Test case %d: Expected \"%#v\", but got \"%#v\"", i+1, testCase.has, has)
+		}
+	}
+}
@@ -19,7 +19,6 @@ package main
 import (
 	"encoding/json"
 	"path"
-	"strings"
 	"time"
 )

@@ -29,20 +28,6 @@ func (fs fsObjects) isMultipartUpload(bucket, prefix string) bool {
 	return err == nil
 }

-// listUploadsInfo - list all uploads info.
-func (fs fsObjects) listUploadsInfo(prefixPath string) (uploads []uploadInfo, err error) {
-	splitPrefixes := strings.SplitN(prefixPath, "/", 3)
-	uploadIDs, err := readUploadsJSON(splitPrefixes[1], splitPrefixes[2], fs.storage)
-	if err != nil {
-		if err == errFileNotFound {
-			return []uploadInfo{}, nil
-		}
-		return nil, err
-	}
-	uploads = uploadIDs.Uploads
-	return uploads, nil
-}
-
 // Checks whether bucket exists.
 func (fs fsObjects) isBucketExist(bucket string) bool {
 	// Check whether bucket exists.
@@ -72,8 +72,9 @@ func (fs fsObjects) listMultipartUploads(bucket, prefix, keyMarker, uploadIDMark
 		walkResultCh, endWalkCh = fs.listPool.Release(listParams{minioMetaBucket, recursive, multipartMarkerPath, multipartPrefixPath})
 		if walkResultCh == nil {
 			endWalkCh = make(chan struct{})
-			listDir := listDirFactory(fs.isMultipartUpload, fs.storage)
-			walkResultCh = startTreeWalk(minioMetaBucket, multipartPrefixPath, multipartMarkerPath, recursive, listDir, endWalkCh)
+			isLeaf := fs.isMultipartUpload
+			listDir := listDirFactory(isLeaf, fs.storage)
+			walkResultCh = startTreeWalk(minioMetaBucket, multipartPrefixPath, multipartMarkerPath, recursive, listDir, isLeaf, endWalkCh)
 		}
 		for maxUploads > 0 {
 			walkResult, ok := <-walkResultCh
@@ -217,6 +218,10 @@ func (fs fsObjects) ListMultipartUploads(bucket, prefix, keyMarker, uploadIDMark
 func (fs fsObjects) newMultipartUpload(bucket string, object string, meta map[string]string) (uploadID string, err error) {
 	// Initialize `fs.json` values.
 	fsMeta := newFSMetaV1()
+	// Save additional metadata only if extended headers such as "X-Amz-Meta-" are set.
+	if hasExtendedHeader(meta) {
+		fsMeta.Meta = meta
+	}

 	// This lock needs to be held for any changes to the directory contents of ".minio/multipart/object/"
 	nsMutex.Lock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object))
@@ -230,7 +235,7 @@ func (fs fsObjects) newMultipartUpload(bucket string, object string, meta map[st
 	}
 	uploadIDPath := path.Join(mpartMetaPrefix, bucket, object, uploadID)
 	tempFSMetadataPath := path.Join(tmpMetaPrefix, getUUID()+"-"+fsMetaJSONFile)
-	if err = fs.writeTempFSMetadata(minioMetaBucket, tempFSMetadataPath, fsMeta); err != nil {
+	if err = writeFSMetadata(fs.storage, minioMetaBucket, tempFSMetadataPath, fsMeta); err != nil {
 		return "", toObjectErr(err, minioMetaBucket, tempFSMetadataPath)
 	}
 	err = fs.storage.RenameFile(minioMetaBucket, tempFSMetadataPath, minioMetaBucket, path.Join(uploadIDPath, fsMetaJSONFile))
@@ -250,7 +255,6 @@ func (fs fsObjects) newMultipartUpload(bucket string, object string, meta map[st
 //
 // Implements S3 compatible initiate multipart API.
 func (fs fsObjects) NewMultipartUpload(bucket, object string, meta map[string]string) (string, error) {
-	meta = make(map[string]string) // Reset the meta value, we are not going to save headers for fs.
 	// Verify if bucket name is valid.
 	if !IsValidBucketName(bucket) {
 		return "", BucketNameInvalid{Bucket: bucket}
@@ -313,32 +317,22 @@ func (fs fsObjects) PutObjectPart(bucket, object, uploadID string, partID int, s
 		limitDataReader = data
 	}

-	// Allocate buffer for staging buffer.
+	teeReader := io.TeeReader(limitDataReader, md5Writer)
 	bufSize := int64(readSizeV1)
 	if size > 0 && bufSize > size {
 		bufSize = size
 	}
-	var buf = make([]byte, int(bufSize))
-
-	// Read up to required size
-	totalLeft := size
-	for {
-		n, err := io.ReadFull(limitDataReader, buf)
-		if err == io.EOF {
-			break
-		}
-		if err != nil && err != io.ErrUnexpectedEOF {
-			return "", toObjectErr(err, bucket, object)
-		}
-		// Update md5 writer.
-		md5Writer.Write(buf[:n])
-		if err = fs.storage.AppendFile(minioMetaBucket, tmpPartPath, buf[:n]); err != nil {
-			return "", toObjectErr(err, bucket, object)
-		}
-
-		if totalLeft -= int64(n); size >= 0 && totalLeft <= 0 {
-			break
-		}
+	buf := make([]byte, int(bufSize))
+	bytesWritten, cErr := fsCreateFile(fs.storage, teeReader, buf, minioMetaBucket, tmpPartPath)
+	if cErr != nil {
+		fs.storage.DeleteFile(minioMetaBucket, tmpPartPath)
+		return "", toObjectErr(cErr, minioMetaBucket, tmpPartPath)
+	}
+	// Should return IncompleteBody{} error when reader has fewer
+	// bytes than specified in request header.
+	if bytesWritten < size {
+		fs.storage.DeleteFile(minioMetaBucket, tmpPartPath)
+		return "", IncompleteBody{}
 	}

 	// Validate if payload is valid.
@@ -386,7 +380,7 @@ func (fs fsObjects) PutObjectPart(bucket, object, uploadID string, partID int, s
 	}
 	uploadIDPath = path.Join(mpartMetaPrefix, bucket, object, uploadID)
 	tempFSMetadataPath := path.Join(tmpMetaPrefix, getUUID()+"-"+fsMetaJSONFile)
-	if err = fs.writeTempFSMetadata(minioMetaBucket, tempFSMetadataPath, fsMeta); err != nil {
+	if err = writeFSMetadata(fs.storage, minioMetaBucket, tempFSMetadataPath, fsMeta); err != nil {
 		return "", toObjectErr(err, minioMetaBucket, tempFSMetadataPath)
 	}
 	err = fs.storage.RenameFile(minioMetaBucket, tempFSMetadataPath, minioMetaBucket, path.Join(uploadIDPath, fsMetaJSONFile))
@@ -587,9 +581,30 @@ func (fs fsObjects) CompleteMultipartUpload(bucket string, object string, upload
 		return "", toObjectErr(err, bucket, object)
 	}

+	// No need to save part info, since we have concatenated all parts.
+	fsMeta.Parts = nil
+
+	// Save additional metadata only if extended headers such as "X-Amz-Meta-" are set.
+	if hasExtendedHeader(fsMeta.Meta) {
+		if len(fsMeta.Meta) == 0 {
+			fsMeta.Meta = make(map[string]string)
+		}
+		fsMeta.Meta["md5Sum"] = s3MD5
+
+		// Write the metadata to a temp file and rename it to the actual location.
+		tmpMetaPath := path.Join(tmpMetaPrefix, getUUID())
+		if err = writeFSMetadata(fs.storage, minioMetaBucket, tmpMetaPath, fsMeta); err != nil {
+			return "", toObjectErr(err, bucket, object)
+		}
+		fsMetaPath := path.Join(bucketMetaPrefix, bucket, object, fsMetaJSONFile)
+		if err = fs.storage.RenameFile(minioMetaBucket, tmpMetaPath, minioMetaBucket, fsMetaPath); err != nil {
+			return "", toObjectErr(err, bucket, object)
+		}
+	}
+
 	// Cleanup all the parts if everything else has been safely committed.
 	if err = cleanupUploadedParts(bucket, object, uploadID, fs.storage); err != nil {
-		return "", err
+		return "", toObjectErr(err, bucket, object)
 	}

 	// Hold the lock so that two parallel complete-multipart-uploads do not
@@ -62,22 +62,6 @@ func loadFormatFS(storageDisk StorageAPI) (format formatConfigV1, err error) {
 	return format, nil
 }

-// Should be called when process shuts down.
-func shutdownFS(storage StorageAPI) {
-	_, err := storage.ListDir(minioMetaBucket, mpartMetaPrefix)
-	if err != errFileNotFound {
-		// Multipart directory is not empty hence do not remove .minio volume.
-		os.Exit(0)
-	}
-	prefix := ""
-	if err := cleanupDir(storage, minioMetaBucket, prefix); err != nil {
-		os.Exit(0)
-		return
-	}
-	storage.DeleteVol(minioMetaBucket)
-	os.Exit(0)
-}
-
 // newFSObjects - initialize new fs object layer.
 func newFSObjects(disk string) (ObjectLayer, error) {
 	storage, err := newStorageAPI(disk)
@@ -118,17 +102,45 @@ func newFSObjects(disk string) (ObjectLayer, error) {
 		return nil, errFSDiskFormat
 	}

-	// Register the callback that should be called when the process shuts down.
-	registerShutdown(func() {
-		shutdownFS(storage)
-	})
-
-	// Return successfully initialized object layer.
-	return fsObjects{
+	// Initialize fs objects.
+	fs := fsObjects{
 		storage:      storage,
 		physicalDisk: disk,
 		listPool:     newTreeWalkPool(globalLookupTimeout),
-	}, nil
+	}
+
+	// Return successfully initialized object layer.
+	return fs, nil
+}
+
+// Should be called when process shuts down.
+func (fs fsObjects) Shutdown() error {
+	// List if there are any multipart entries.
+	_, err := fs.storage.ListDir(minioMetaBucket, mpartMetaPrefix)
+	if err != errFileNotFound {
+		// Multipart directory is not empty hence do not remove '.minio.sys' volume.
+		return nil
+	}
+	// List if there are any bucket configuration entries.
+	_, err = fs.storage.ListDir(minioMetaBucket, bucketConfigPrefix)
+	if err != errFileNotFound {
+		// Bucket config directory is not empty hence do not remove '.minio.sys' volume.
+		return nil
+	}
+	// Cleanup everything else.
+	prefix := ""
+	if err = cleanupDir(fs.storage, minioMetaBucket, prefix); err != nil {
+		errorIf(err, "Unable to cleanup minio meta bucket")
+		return err
+	}
+	if err = fs.storage.DeleteVol(minioMetaBucket); err != nil {
+		if err != errVolumeNotEmpty {
+			errorIf(err, "Unable to delete minio meta bucket %s", minioMetaBucket)
+			return err
+		}
+	}
+	// Successful.
+	return nil
 }

 // StorageInfo - returns underlying storage statistics.
@@ -184,6 +196,10 @@ func (fs fsObjects) ListBuckets() ([]BucketInfo, error) {
 		if !IsValidBucketName(vol.Name) {
 			continue
 		}
+		// Ignore the volume special bucket.
+		if vol.Name == minioMetaBucket {
+			continue
+		}
 		bucketInfos = append(bucketInfos, BucketInfo{
 			Name:    vol.Name,
 			Created: vol.Created,
@@ -309,23 +325,35 @@ func (fs fsObjects) GetObjectInfo(bucket, object string) (ObjectInfo, error) {
 	if err != nil {
 		return ObjectInfo{}, toObjectErr(err, bucket, object)
 	}
+	fsMeta, err := readFSMetadata(fs.storage, minioMetaBucket, path.Join(bucketMetaPrefix, bucket, object))
+	if err != nil && err != errFileNotFound {
+		return ObjectInfo{}, toObjectErr(err, bucket, object)
+	}
+
+	if len(fsMeta.Meta) == 0 {
+		fsMeta.Meta = make(map[string]string)
+	}

 	// Guess content-type from the extension if possible.
-	contentType := ""
-	if objectExt := filepath.Ext(object); objectExt != "" {
-		if content, ok := mimedb.DB[strings.ToLower(strings.TrimPrefix(objectExt, "."))]; ok {
-			contentType = content.ContentType
+	if fsMeta.Meta["content-type"] == "" {
+		if objectExt := filepath.Ext(object); objectExt != "" {
+			if content, ok := mimedb.DB[strings.ToLower(strings.TrimPrefix(objectExt, "."))]; ok {
+				fsMeta.Meta["content-type"] = content.ContentType
+			}
 		}
 	}

+	// Guess content-type from the extension if possible.
 	return ObjectInfo{
-		Bucket:      bucket,
-		Name:        object,
-		ModTime:     fi.ModTime,
-		Size:        fi.Size,
-		IsDir:       fi.Mode.IsDir(),
-		ContentType: contentType,
-		MD5Sum:      "", // Read from metadata.
+		Bucket:          bucket,
+		Name:            object,
+		ModTime:         fi.ModTime,
+		Size:            fi.Size,
+		IsDir:           fi.Mode.IsDir(),
+		MD5Sum:          fsMeta.Meta["md5Sum"],
+		ContentType:     fsMeta.Meta["content-type"],
+		ContentEncoding: fsMeta.Meta["content-encoding"],
+		UserDefined:     fsMeta.Meta,
 	}, nil
 }

@@ -369,30 +397,24 @@ func (fs fsObjects) PutObject(bucket string, object string, size int64, data io.
 			return "", toObjectErr(err, bucket, object)
 		}
 	} else {
-		// Allocate a buffer to Read() the object upload stream.
+		// Allocate a buffer to Read() from request body
 		bufSize := int64(readSizeV1)
 		if size > 0 && bufSize > size {
 			bufSize = size
 		}
 		buf := make([]byte, int(bufSize))
+		teeReader := io.TeeReader(limitDataReader, md5Writer)
+		bytesWritten, err := fsCreateFile(fs.storage, teeReader, buf, minioMetaBucket, tempObj)
+		if err != nil {
+			fs.storage.DeleteFile(minioMetaBucket, tempObj)
+			return "", toObjectErr(err, bucket, object)
+		}

-		// Read the buffer till io.EOF and append the read data to the temporary file.
-		for {
-			n, rErr := limitDataReader.Read(buf)
-			if rErr != nil && rErr != io.EOF {
-				return "", toObjectErr(rErr, bucket, object)
-			}
-			if n > 0 {
-				// Update md5 writer.
-				md5Writer.Write(buf[0:n])
-				wErr := fs.storage.AppendFile(minioMetaBucket, tempObj, buf[0:n])
-				if wErr != nil {
-					return "", toObjectErr(wErr, bucket, object)
-				}
-			}
-			if rErr == io.EOF {
-				break
-			}
+		// Should return IncompleteBody{} error when reader has fewer
+		// bytes than specified in request header.
+		if bytesWritten < size {
+			fs.storage.DeleteFile(minioMetaBucket, tempObj)
+			return "", IncompleteBody{}
 		}
 	}

@@ -428,10 +450,29 @@ func (fs fsObjects) PutObject(bucket string, object string, size int64, data io.
 		return "", toObjectErr(err, bucket, object)
 	}

+	// Save additional metadata only if extended headers such as "X-Amz-Meta-" are set.
+	if hasExtendedHeader(metadata) {
+		// Initialize `fs.json` values.
+		fsMeta := newFSMetaV1()
+		fsMeta.Meta = metadata
+
+		// Write the metadata to a temp file and rename it to the actual location.
+		tmpMetaPath := path.Join(tmpMetaPrefix, getUUID())
+		fsMetaPath := path.Join(bucketMetaPrefix, bucket, object, fsMetaJSONFile)
+		if err = writeFSMetadata(fs.storage, minioMetaBucket, tmpMetaPath, fsMeta); err != nil {
+			return "", toObjectErr(err, bucket, object)
+		}
+		if err = fs.storage.RenameFile(minioMetaBucket, tmpMetaPath, minioMetaBucket, fsMetaPath); err != nil {
+			return "", toObjectErr(err, bucket, object)
+		}
+	}
+
 	// Return md5sum, successfully wrote object.
 	return newMD5Hex, nil
 }

+// DeleteObject - deletes an object from a bucket, this operation is destructive
+// and there are no rollbacks supported.
 func (fs fsObjects) DeleteObject(bucket, object string) error {
 	// Verify if bucket is valid.
 	if !IsValidBucketName(bucket) {
@@ -440,7 +481,11 @@ func (fs fsObjects) DeleteObject(bucket, object string) error {
 	if !IsValidObjectName(object) {
 		return ObjectNameInvalid{Bucket: bucket, Object: object}
 	}
-	if err := fs.storage.DeleteFile(bucket, object); err != nil {
+	err := fs.storage.DeleteFile(minioMetaBucket, path.Join(bucketMetaPrefix, bucket, object, fsMetaJSONFile))
+	if err != nil && err != errFileNotFound {
+		return toObjectErr(err, bucket, object)
+	}
+	if err = fs.storage.DeleteFile(bucket, object); err != nil {
 		return toObjectErr(err, bucket, object)
 	}
 	return nil
@@ -532,10 +577,14 @@ func (fs fsObjects) listObjects(bucket, prefix, marker, delimiter string, maxKey
 	walkResultCh, endWalkCh := fs.listPool.Release(listParams{bucket, recursive, marker, prefix})
 	if walkResultCh == nil {
 		endWalkCh = make(chan struct{})
-		listDir := listDirFactory(func(bucket, object string) bool {
+		isLeaf := func(bucket, object string) bool {
+			// bucket argument is unused as we don't need to StatFile
+			// to figure if it's a file, just need to check that the
+			// object string does not end with "/".
 			return !strings.HasSuffix(object, slashSeparator)
-		}, fs.storage)
-		walkResultCh = startTreeWalk(bucket, prefix, marker, recursive, listDir, endWalkCh)
+		}
+		listDir := listDirFactory(isLeaf, fs.storage)
+		walkResultCh = startTreeWalk(bucket, prefix, marker, recursive, listDir, isLeaf, endWalkCh)
 	}
 	var fileInfos []FileInfo
 	var eof bool
@@ -574,18 +623,16 @@ func (fs fsObjects) listObjects(bucket, prefix, marker, delimiter string, maxKey

 	result := ListObjectsInfo{IsTruncated: !eof}
 	for _, fileInfo := range fileInfos {
-		// With delimiter set we fill in NextMarker and Prefixes.
-		if delimiter == slashSeparator {
-			result.NextMarker = fileInfo.Name
-			if fileInfo.Mode.IsDir() {
-				result.Prefixes = append(result.Prefixes, fileInfo.Name)
-				continue
-			}
+		result.NextMarker = fileInfo.Name
+		if fileInfo.Mode.IsDir() {
+			result.Prefixes = append(result.Prefixes, fileInfo.Name)
+			continue
 		}
 		result.Objects = append(result.Objects, ObjectInfo{
 			Name:    fileInfo.Name,
 			ModTime: fileInfo.ModTime,
 			Size:    fileInfo.Size,
+			MD5Sum:  fileInfo.MD5Sum,
 			IsDir:   false,
 		})
 	}
@@ -39,6 +39,27 @@ func registerHandlers(mux *router.Router, handlerFns ...HandlerFunc) http.Handle
 	return f
 }

+// Adds limiting body size middleware
+
+// Set the body size limit to 6 Gb = Maximum object size + other possible data
+// in the same request
+const requestMaxBodySize = 1024 * 1024 * 1024 * (5 + 1)
+
+type requestSizeLimitHandler struct {
+	handler     http.Handler
+	maxBodySize int64
+}
+
+func setRequestSizeLimitHandler(h http.Handler) http.Handler {
+	return requestSizeLimitHandler{handler: h, maxBodySize: requestMaxBodySize}
+}
+
+func (h requestSizeLimitHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Restricting read data to a given maximum length
+	r.Body = http.MaxBytesReader(w, r.Body, h.maxBodySize)
+	h.handler.ServeHTTP(w, r)
+}
+
 // Adds redirect rules for incoming requests.
 type redirectHandler struct {
 	handler        http.Handler
@@ -224,8 +245,8 @@ func (h resourceHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		bucketName = splits[0]
 		objectName = splits[1]
 	}
-	// If bucketName is present and not objectName check for bucket
-	// level resource queries.
+
+	// If bucketName is present and not objectName check for bucket level resource queries.
 	if bucketName != "" && objectName == "" {
 		if ignoreNotImplementedBucketResources(r) {
 			writeErrorResponse(w, r, ErrNotImplemented, r.URL.Path)
@@ -244,6 +265,8 @@ func (h resourceHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		writeErrorResponse(w, r, ErrNotImplemented, r.URL.Path)
 		return
 	}
+
+	// Serve HTTP.
 	h.handler.ServeHTTP(w, r)
 }

@@ -275,7 +298,6 @@ var notimplementedBucketResourceNames = map[string]bool{
 	"cors":           true,
 	"lifecycle":      true,
 	"logging":        true,
-	"notification":   true,
 	"replication":    true,
 	"tagging":        true,
 	"versions":       true,
@@ -28,13 +28,12 @@ const (

 // minio configuration related constants.
 const (
-	globalMinioConfigVersion = "4"
+	globalMinioConfigVersion = "6"
 	globalMinioConfigDir     = ".minio"
 	globalMinioCertsDir      = "certs"
 	globalMinioCertFile      = "public.crt"
 	globalMinioKeyFile       = "private.key"
 	globalMinioConfigFile    = "config.json"
-	globalMinioProfilePath   = "profile"
 	// Add new global values here.
 )

@@ -53,10 +52,14 @@ var (
 	// Add new variable global values here.
 )

+var (
+	// Limit fields size (except file) to 1Mib since Policy document
+	// can reach that size according to https://aws.amazon.com/articles/1434
+	maxFormFieldSize = int64(1024 * 1024)
+)
+
 // global colors.
 var (
-	colorWhite     = color.New(color.FgWhite).SprintfFunc()
-	colorWhiteBold = color.New(color.FgWhite, color.Bold).SprintfFunc()
-	colorBlue      = color.New(color.FgBlue).SprintfFunc()
-	colorBold      = color.New(color.Bold).SprintFunc()
+	colorBlue = color.New(color.FgBlue).SprintfFunc()
+	colorBold = color.New(color.Bold).SprintFunc()
 )
@@ -18,37 +18,128 @@ package main

 import (
 	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
 )

-// validates location constraint from the request body.
-// the location value in the request body should match the Region in serverConfig.
-// other values of location are not accepted.
-// make bucket fails in such cases.
-func isValidLocationContraint(reqBody io.Reader, serverRegion string) APIErrorCode {
-	var locationContraint createBucketLocationConfiguration
-	var errCode APIErrorCode
-	errCode = ErrNone
-	e := xmlDecoder(reqBody, &locationContraint)
-	if e != nil {
-		if e == io.EOF {
-			// Do nothing.
-			// failed due to empty body. The location will be set to default value from the serverConfig.
-			// this is valid.
-			errCode = ErrNone
-		} else {
-			// Failed due to malformed configuration.
-			errCode = ErrMalformedXML
-			//writeErrorResponse(w, r, ErrMalformedXML, r.URL.Path)
+// Validates location constraint in PutBucket request body.
+// The location value in the request body should match the
+// region configured at serverConfig, otherwise error is returned.
+func isValidLocationConstraint(r *http.Request) (s3Error APIErrorCode) {
+	serverRegion := serverConfig.GetRegion()
+	// If the request has no body with content-length set to 0,
+	// we do not have to validate location constraint. Bucket will
+	// be created at default region.
+	if r.ContentLength == 0 {
+		return ErrNone
+	}
+	locationConstraint := createBucketLocationConfiguration{}
+	if err := xmlDecoder(r.Body, &locationConstraint, r.ContentLength); err != nil {
+		if err == io.EOF && r.ContentLength == -1 {
+			// EOF is a valid condition here when ContentLength is -1.
+			return ErrNone
 		}
-	} else {
-		// Region obtained from the body.
-		// It should be equal to Region in serverConfig.
-		// Else ErrInvalidRegion returned.
-		// For empty value location will be to set to  default value from the serverConfig.
-		if locationContraint.Location != "" && serverRegion != locationContraint.Location {
-			//writeErrorResponse(w, r, ErrInvalidRegion, r.URL.Path)
-			errCode = ErrInvalidRegion
+		errorIf(err, "Unable to xml decode location constraint")
+		// Treat all other failures as XML parsing errors.
+		return ErrMalformedXML
+	} // Successfully decoded, proceed to verify the region.
+
+	// Once region has been obtained we proceed to verify it.
+	incomingRegion := locationConstraint.Location
+	if incomingRegion == "" {
+		// Location constraint is empty for region "us-east-1",
+		// in accordance with protocol.
+		incomingRegion = "us-east-1"
+	}
+	// Return errInvalidRegion if location constraint does not match
+	// with configured region.
+	s3Error = ErrNone
+	if serverRegion != incomingRegion {
+		s3Error = ErrInvalidRegion
+	}
+	return s3Error
+}
+
+// Supported headers that needs to be extracted.
+var supportedHeaders = []string{
+	"content-type",
+	"cache-control",
+	"content-encoding",
+	"content-disposition",
+	// Add more supported headers here.
+}
+
+// extractMetadataFromHeader extracts metadata from HTTP header.
+func extractMetadataFromHeader(header http.Header) map[string]string {
+	metadata := make(map[string]string)
+	// Save standard supported headers.
+	for _, supportedHeader := range supportedHeaders {
+		canonicalHeader := http.CanonicalHeaderKey(supportedHeader)
+		// HTTP headers are case insensitive, look for both canonical
+		// and non canonical entries.
+		if _, ok := header[canonicalHeader]; ok {
+			metadata[supportedHeader] = header.Get(canonicalHeader)
+		} else if _, ok := header[supportedHeader]; ok {
+			metadata[supportedHeader] = header.Get(supportedHeader)
+		}
+	}
+	// Go through all other headers for any additional headers that needs to be saved.
+	for key := range header {
+		cKey := http.CanonicalHeaderKey(key)
+		if strings.HasPrefix(cKey, "X-Amz-Meta-") {
+			metadata[cKey] = header.Get(cKey)
+		} else if strings.HasPrefix(key, "X-Minio-Meta-") {
+			metadata[cKey] = header.Get(cKey)
+		}
+	}
+	// Return.
+	return metadata
+}
+
+// Extract form fields and file data from a HTTP POST Policy
+func extractPostPolicyFormValues(reader *multipart.Reader) (filePart io.Reader, fileName string, formValues map[string]string, err error) {
+	/// HTML Form values
+	formValues = make(map[string]string)
+	fileName = ""
+	for err == nil {
+		var part *multipart.Part
+		part, err = reader.NextPart()
+		if part != nil {
+			canonicalFormName := http.CanonicalHeaderKey(part.FormName())
+			if canonicalFormName != "File" {
+				var buffer []byte
+				limitReader := io.LimitReader(part, maxFormFieldSize+1)
+				buffer, err = ioutil.ReadAll(limitReader)
+				if err != nil {
+					return nil, "", nil, err
+				}
+				if int64(len(buffer)) > maxFormFieldSize {
+					return nil, "", nil, errSizeUnexpected
+				}
+				formValues[canonicalFormName] = string(buffer)
+			} else {
+				filePart = io.LimitReader(part, maxObjectSize)
+				fileName = part.FileName()
+				// As described in S3 spec, we expect file to be the last form field
+				break
+			}
+		}
+	}
+	return filePart, fileName, formValues, nil
+}
+
+// Send whitespace character, once every 5secs, until CompleteMultipartUpload is done.
+// CompleteMultipartUpload method of the object layer indicates that it's done via doneCh
+func sendWhiteSpaceChars(w http.ResponseWriter, doneCh <-chan struct{}) {
+	for {
+		select {
+		case <-time.After(5 * time.Second):
+			w.Write([]byte(" "))
+		case <-doneCh:
+			return
 		}
 	}
-	return errCode
 }
@@ -21,11 +21,18 @@ import (
 	"encoding/xml"
 	"io/ioutil"
 	"net/http"
+	"reflect"
 	"testing"
 )

 // Tests validate bucket LocationConstraint.
 func TestIsValidLocationContraint(t *testing.T) {
+	path, err := newTestConfig("us-east-1")
+	if err != nil {
+		t.Fatalf("unable initialize config file, %s", err)
+	}
+	defer removeAll(path)
+
 	// generates the input request with XML bucket configuration set to the request body.
 	createExpectedRequest := func(req *http.Request, location string) (*http.Request, error) {
 		createBucketConfig := createBucketLocationConfiguration{}
@@ -37,6 +44,7 @@ func TestIsValidLocationContraint(t *testing.T) {
 		}
 		createBucketConfigBuffer := bytes.NewBuffer(createBucketConfigBytes)
 		req.Body = ioutil.NopCloser(createBucketConfigBuffer)
+		req.ContentLength = int64(createBucketConfigBuffer.Len())
 		return req, nil
 	}

@@ -58,9 +66,43 @@ func TestIsValidLocationContraint(t *testing.T) {
 		if e != nil {
 			t.Fatalf("Test %d: Failed to Marshal bucket configuration", i+1)
 		}
-		actualCode := isValidLocationContraint(inputRequest.Body, testCase.serverConfigRegion)
+		serverConfig.SetRegion(testCase.serverConfigRegion)
+		actualCode := isValidLocationConstraint(inputRequest)
 		if testCase.expectedCode != actualCode {
 			t.Errorf("Test %d: Expected the APIErrCode to be %d, but instead found %d", i+1, testCase.expectedCode, actualCode)
 		}
 	}
 }
+
+// Tests validate metadata extraction from http headers.
+func TestExtractMetadataHeaders(t *testing.T) {
+	testCases := []struct {
+		header   http.Header
+		metadata map[string]string
+	}{
+		// Validate if there a known 'content-type'.
+		{
+			header: http.Header{
+				"Content-Type": []string{"image/png"},
+			},
+			metadata: map[string]string{
+				"content-type": "image/png",
+			},
+		},
+		// Validate if there are no keys to extract.
+		{
+			header: http.Header{
+				"test-1": []string{"123"},
+			},
+			metadata: map[string]string{},
+		},
+	}
+
+	// Validate if the extracting headers.
+	for i, testCase := range testCases {
+		metadata := extractMetadataFromHeader(testCase.header)
+		if !reflect.DeepEqual(metadata, testCase.metadata) {
+			t.Fatalf("Test %d failed: Expected \"%#v\", got \"%#v\"", i+1, testCase.metadata, metadata)
+		}
+	}
+}
@@ -40,8 +40,3 @@ func getIPsFromHosts(hosts []string) (ips []net.IP) {
 	sort.Sort(sort.Reverse(byLastOctet(ips)))
 	return ips
 }
-
-// getHostToIP - parses a host string into net.IP value.
-func getHostToIP(host string) net.IP {
-	return net.ParseIP(host)
-}
@@ -0,0 +1,154 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package leaktest provides tools to detect leaked goroutines in tests.
+// To use it, call "defer leaktest.AfterTest(t)()" at the beginning of each
+// test that may use goroutines.
+package main
+
+import (
+	"runtime"
+	"sort"
+	"strings"
+	"time"
+)
+
+const (
+	// deadline (in seconds) up to which the go routine leak detection has to be retried.
+	leakDetectDeadline = 5
+	// pause time (in milliseconds) between each snapshot at the end of the go routine leak detection.
+	leakDetectPauseTimeMs = 50
+)
+
+// LeakDetect - type with  methods for go routine leak detection.
+type LeakDetect struct {
+	relevantRoutines map[string]bool
+}
+
+// NewLeakDetect - Initialize a LeakDetector with the snapshot of relevant Go routines.
+func NewLeakDetect() LeakDetect {
+	snapshot := LeakDetect{
+		relevantRoutines: make(map[string]bool),
+	}
+	for _, g := range pickRelevantGoroutines() {
+		snapshot.relevantRoutines[g] = true
+	}
+	return snapshot
+}
+
+// CompareCurrentSnapshot - Compares the initial relevant stack trace with the current one (during the time of invocation).
+func (initialSnapShot LeakDetect) CompareCurrentSnapshot() []string {
+	var stackDiff []string
+	for _, g := range pickRelevantGoroutines() {
+		// Identify the Go routines those were not present in the initial snapshot.
+		// In other words a stack diff.
+		if !initialSnapShot.relevantRoutines[g] {
+			stackDiff = append(stackDiff, g)
+		}
+	}
+	return stackDiff
+}
+
+// DetectLeak - Creates a snapshot of runtiem stack and compares it with  the initial stack snapshot.
+func (initialSnapShot LeakDetect) DetectLeak(t TestErrHandler) {
+	if t.Failed() {
+		return
+	}
+	// Loop, waiting for goroutines to shut down.
+	// Wait up to 5 seconds, but finish as quickly as possible.
+	deadline := time.Now().Add(leakDetectDeadline * time.Second)
+	for {
+		// get sack snapshot of relevant go routines.
+		leaked := initialSnapShot.CompareCurrentSnapshot()
+		// current stack snapshot matches the initial one, no leaks, return.
+		if len(leaked) == 0 {
+			return
+		}
+		// wait a test again will deadline.
+		if time.Now().Before(deadline) {
+			time.Sleep(leakDetectPauseTimeMs * time.Millisecond)
+			continue
+		}
+		// after the deadline time report all the difference in the latest snapshot compared with the initial one.
+		for _, g := range leaked {
+			t.Errorf("Leaked goroutine: %v", g)
+		}
+		return
+	}
+}
+
+// DetectTestLeak -  snapshots the currently-running goroutines and returns a
+// function to be run at the end of tests to see whether any
+// goroutines leaked.
+// Usage: `defer DetectTestLeak(t)()` in beginning line of benchmarks or unit tests.
+func DetectTestLeak(t TestErrHandler) func() {
+	initialStackSnapShot := NewLeakDetect()
+	return func() {
+		initialStackSnapShot.DetectLeak(t)
+	}
+}
+
+// list of functions to be ignored from the stack trace.
+// Leak detection is done when tests are run, should ignore the tests related functions,
+// and other runtime functions while identifying leaks.
+var ignoredStackFns = []string{
+	"",
+	// Below are the stacks ignored by the upstream leaktest code.
+	"testing.Main(",
+	"testing.tRunner(",
+	"testing.tRunner(",
+	"runtime.goexit",
+	"created by runtime.gc",
+	// ignore the snapshot function.
+	// since the snapshot is taken here the entry will have the current function too.
+	"pickRelevantGoroutines",
+	"runtime.MHeap_Scavenger",
+	"signal.signal_recv",
+	"sigterm.handler",
+	"runtime_mcall",
+	"goroutine in C code",
+}
+
+// Identify whether the stack trace entry is part of ignoredStackFn .
+func isIgnoredStackFn(stack string) (ok bool) {
+	ok = true
+	for _, stackFn := range ignoredStackFns {
+		if !strings.Contains(stack, stackFn) {
+			ok = false
+			continue
+		}
+		break
+	}
+	return ok
+}
+
+// pickRelevantGoroutines returns all goroutines we care about for the purpose
+// of leak checking. It excludes testing or runtime ones.
+func pickRelevantGoroutines() (gs []string) {
+	// make a large buffer to hold the runtime stack info.
+	buf := make([]byte, 2<<20)
+	buf = buf[:runtime.Stack(buf, true)]
+	// runtime stack of go routines will be listed with 2 blank spaces between each of them, so split on "\n\n" .
+	for _, g := range strings.Split(string(buf), "\n\n") {
+		// Again split on a new line, the first line of the second half contaisn the info about the go routine.
+		sl := strings.SplitN(g, "\n", 2)
+		if len(sl) != 2 {
+			continue
+		}
+		stack := strings.TrimSpace(sl[1])
+		// ignore the testing go routine.
+		// since the tests will be invoking the leaktest it would contain the test go routine.
+		if strings.HasPrefix(stack, "testing.RunTests") {
+			continue
+		}
+		// Ignore the following go routines.
+		// testing and run time go routines should be ignored, only the application generated go routines should be taken into account.
+		if isIgnoredStackFn(stack) {
+			continue
+		}
+		gs = append(gs, g)
+	}
+	sort.Strings(gs)
+	return
+}
@@ -19,15 +19,10 @@ package main
 import (
 	"bufio"
 	"bytes"
-	"os"
-	"reflect"
-	"runtime"
 	"runtime/debug"
-	"strconv"
 	"strings"

 	"github.com/Sirupsen/logrus"
-	"github.com/dustin/go-humanize"
 )

 type fields map[string]interface{}
@@ -40,7 +35,6 @@ var log = logrus.New() // Default console logger.
 //   - console [default]
 //   - file
 //   - syslog
-//
 type logger struct {
 	Console consoleLogger `json:"console"`
 	File    fileLogger    `json:"file"`
@@ -48,27 +42,6 @@ type logger struct {
 	// Add new loggers here.
 }

-// sysInfo returns useful system statistics.
-func sysInfo() map[string]string {
-	host, err := os.Hostname()
-	if err != nil {
-		host = ""
-	}
-	memstats := &runtime.MemStats{}
-	runtime.ReadMemStats(memstats)
-	return map[string]string{
-		"host.name":      host,
-		"host.os":        runtime.GOOS,
-		"host.arch":      runtime.GOARCH,
-		"host.lang":      runtime.Version(),
-		"host.cpus":      strconv.Itoa(runtime.NumCPU()),
-		"mem.used":       humanize.Bytes(memstats.Alloc),
-		"mem.total":      humanize.Bytes(memstats.Sys),
-		"mem.heap.used":  humanize.Bytes(memstats.HeapAlloc),
-		"mem.heap.total": humanize.Bytes(memstats.HeapSys),
-	}
-}
-
 // stackInfo returns printable stack trace.
 func stackInfo() string {
 	// Convert stack-trace bytes to io.Reader.
@@ -91,11 +64,8 @@ func errorIf(err error, msg string, data ...interface{}) {
 	if err == nil {
 		return
 	}
-	sysInfo := sysInfo()
 	fields := logrus.Fields{
-		"cause":   err.Error(),
-		"type":    reflect.TypeOf(err),
-		"sysInfo": sysInfo,
+		"cause": err.Error(),
 	}
 	if globalTrace {
 		fields["stack"] = "\n" + stackInfo()
@@ -108,11 +78,8 @@ func fatalIf(err error, msg string, data ...interface{}) {
 	if err == nil {
 		return
 	}
-	sysInfo := sysInfo()
 	fields := logrus.Fields{
-		"cause":   err.Error(),
-		"type":    reflect.TypeOf(err),
-		"sysInfo": sysInfo,
+		"cause": err.Error(),
 	}
 	if globalTrace {
 		fields["stack"] = "\n" + stackInfo()
@@ -76,7 +76,6 @@ func enableLoggers() {
 	// Enable all loggers here.
 	enableConsoleLogger()
 	enableFileLogger()
-
 	// Add your logger here.
 }

@@ -159,9 +158,6 @@ func main() {
 		// Enable all loggers by now.
 		enableLoggers()

-		// Initialize name space lock.
-		initNSLock()
-
 		// Set global quiet flag.
 		globalQuiet = c.Bool("quiet") || c.GlobalBool("quiet")

@@ -0,0 +1,136 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/minio/minio/pkg/wildcard"
+)
+
+// SQS type.
+const (
+	// Minio sqs ARN prefix.
+	minioSqs = "arn:minio:sqs:"
+
+	// Static string indicating queue type 'amqp'.
+	queueTypeAMQP = "amqp"
+	// Static string indicating queue type 'elasticsearch'.
+	queueTypeElastic = "elasticsearch"
+	// Static string indicating queue type 'redis'.
+	queueTypeRedis = "redis"
+)
+
+// Topic type.
+const (
+	// Minio topic ARN prefix.
+	minioTopic = "arn:minio:sns:"
+
+	// Static string indicating sns type 'listen'.
+	snsTypeMinio = "listen"
+)
+
+var errNotifyNotEnabled = errors.New("requested notifier not enabled")
+
+// Notifier represents collection of supported notification queues.
+type notifier struct {
+	AMQP          map[string]amqpNotify          `json:"amqp"`
+	ElasticSearch map[string]elasticSearchNotify `json:"elasticsearch"`
+	Redis         map[string]redisNotify         `json:"redis"`
+	// Add new notification queues.
+}
+
+// Returns true if queueArn is for an AMQP queue.
+func isAMQPQueue(sqsArn arnSQS) bool {
+	if sqsArn.Type != queueTypeAMQP {
+		return false
+	}
+	amqpL := serverConfig.GetAMQPNotifyByID(sqsArn.AccountID)
+	if !amqpL.Enable {
+		return false
+	}
+	// Connect to amqp server to validate.
+	amqpC, err := dialAMQP(amqpL)
+	if err != nil {
+		errorIf(err, "Unable to connect to amqp service. %#v", amqpL)
+		return false
+	}
+	defer amqpC.Close()
+	return true
+}
+
+// Returns true if queueArn is for an Redis queue.
+func isRedisQueue(sqsArn arnSQS) bool {
+	if sqsArn.Type != queueTypeRedis {
+		return false
+	}
+	rNotify := serverConfig.GetRedisNotifyByID(sqsArn.AccountID)
+	if !rNotify.Enable {
+		return false
+	}
+	// Connect to redis server to validate.
+	rPool, err := dialRedis(rNotify)
+	if err != nil {
+		errorIf(err, "Unable to connect to redis service. %#v", rNotify)
+		return false
+	}
+	defer rPool.Close()
+	return true
+}
+
+// Returns true if queueArn is for an ElasticSearch queue.
+func isElasticQueue(sqsArn arnSQS) bool {
+	if sqsArn.Type != queueTypeElastic {
+		return false
+	}
+	esNotify := serverConfig.GetElasticSearchNotifyByID(sqsArn.AccountID)
+	if !esNotify.Enable {
+		return false
+	}
+	elasticC, err := dialElastic(esNotify)
+	if err != nil {
+		errorIf(err, "Unable to connect to elasticsearch service %#v", esNotify)
+		return false
+	}
+	defer elasticC.Stop()
+	return true
+}
+
+// Match function matches wild cards in 'pattern' for events.
+func eventMatch(eventType string, events []string) (ok bool) {
+	for _, event := range events {
+		ok = wildcard.Match(event, eventType)
+		if ok {
+			break
+		}
+	}
+	return ok
+}
+
+// Filter rule match, matches an object against the filter rules.
+func filterRuleMatch(object string, frs []filterRule) bool {
+	var prefixMatch, suffixMatch = true, true
+	for _, fr := range frs {
+		if isValidFilterNamePrefix(fr.Name) {
+			prefixMatch = strings.HasPrefix(object, fr.Value)
+		} else if isValidFilterNameSuffix(fr.Name) {
+			suffixMatch = strings.HasSuffix(object, fr.Value)
+		}
+	}
+	return prefixMatch && suffixMatch
+}
@@ -0,0 +1,107 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import "testing"
+
+// Tests all event match.
+func TestEventMatch(t *testing.T) {
+	testCases := []struct {
+		eventName EventName
+		events    []string
+		match     bool
+	}{
+		// Valid object created PUT event.
+		{
+			eventName: ObjectCreatedPut,
+			events: []string{
+				"s3:ObjectCreated:Put",
+			},
+			match: true,
+		},
+		// Valid object removed DELETE event.
+		{
+			eventName: ObjectRemovedDelete,
+			events: []string{
+				"s3:ObjectRemoved:Delete",
+			},
+			match: true,
+		},
+		// Invalid events fails to match with empty events.
+		{
+			eventName: ObjectRemovedDelete,
+			events:    []string{""},
+			match:     false,
+		},
+		// Invalid events fails to match with valid events.
+		{
+			eventName: ObjectCreatedCompleteMultipartUpload,
+			events: []string{
+				"s3:ObjectRemoved:*",
+			},
+			match: false,
+		},
+		// Valid events wild card match.
+		{
+			eventName: ObjectCreatedPut,
+			events: []string{
+				"s3:ObjectCreated:*",
+			},
+			match: true,
+		},
+		// Valid events wild card match.
+		{
+			eventName: ObjectCreatedPost,
+			events: []string{
+				"s3:ObjectCreated:*",
+			},
+			match: true,
+		},
+		// Valid events wild card match.
+		{
+			eventName: ObjectCreatedCopy,
+			events: []string{
+				"s3:ObjectCreated:*",
+			},
+			match: true,
+		},
+		// Valid events wild card match.
+		{
+			eventName: ObjectCreatedCompleteMultipartUpload,
+			events: []string{
+				"s3:ObjectCreated:*",
+			},
+			match: true,
+		},
+		// Valid events wild card match.
+		{
+			eventName: ObjectCreatedPut,
+			events: []string{
+				"s3:ObjectCreated:*",
+				"s3:ObjectRemoved:*",
+			},
+			match: true,
+		},
+	}
+
+	for i, testCase := range testCases {
+		ok := eventMatch(testCase.eventName.String(), testCase.events)
+		if testCase.match != ok {
+			t.Errorf("Test %d: Expected \"%t\", got \"%t\"", i+1, testCase.match, ok)
+		}
+	}
+}
@@ -0,0 +1,145 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"io/ioutil"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/streadway/amqp"
+)
+
+// amqpNotify - represents logrus compatible AMQP hook.
+// All fields represent AMQP configuration details.
+type amqpNotify struct {
+	Enable       bool   `json:"enable"`
+	URL          string `json:"url"`
+	Exchange     string `json:"exchange"`
+	RoutingKey   string `json:"routingKey"`
+	ExchangeType string `json:"exchangeType"`
+	Mandatory    bool   `json:"mandatory"`
+	Immediate    bool   `json:"immediate"`
+	Durable      bool   `json:"durable"`
+	Internal     bool   `json:"internal"`
+	NoWait       bool   `json:"noWait"`
+	AutoDeleted  bool   `json:"autoDeleted"`
+}
+
+type amqpConn struct {
+	params amqpNotify
+	*amqp.Connection
+}
+
+// dialAMQP - dials and returns an amqpConnection instance,
+// for sending notifications. Returns error if amqp logger
+// is not enabled.
+func dialAMQP(amqpL amqpNotify) (amqpConn, error) {
+	if !amqpL.Enable {
+		return amqpConn{}, errNotifyNotEnabled
+	}
+	conn, err := amqp.Dial(amqpL.URL)
+	if err != nil {
+		return amqpConn{}, err
+	}
+	return amqpConn{Connection: conn, params: amqpL}, nil
+}
+
+func newAMQPNotify(accountID string) (*logrus.Logger, error) {
+	amqpL := serverConfig.GetAMQPNotifyByID(accountID)
+
+	// Connect to amqp server.
+	amqpC, err := dialAMQP(amqpL)
+	if err != nil {
+		return nil, err
+	}
+
+	amqpLog := logrus.New()
+
+	// Disable writing to console.
+	amqpLog.Out = ioutil.Discard
+
+	// Add a amqp hook.
+	amqpLog.Hooks.Add(amqpC)
+
+	// Set default JSON formatter.
+	amqpLog.Formatter = new(logrus.JSONFormatter)
+
+	// Successfully enabled all AMQPs.
+	return amqpLog, nil
+}
+
+// Fire is called when an event should be sent to the message broker.k
+func (q amqpConn) Fire(entry *logrus.Entry) error {
+	ch, err := q.Connection.Channel()
+	if err != nil {
+		// Any other error other than connection closed, return.
+		if err != amqp.ErrClosed {
+			return err
+		}
+		// Attempt to connect again.
+		var conn *amqp.Connection
+		conn, err = amqp.Dial(q.params.URL)
+		if err != nil {
+			return err
+		}
+		ch, err = conn.Channel()
+		if err != nil {
+			return err
+		}
+	}
+	defer ch.Close()
+
+	err = ch.ExchangeDeclare(
+		q.params.Exchange,
+		q.params.ExchangeType,
+		q.params.Durable,
+		q.params.AutoDeleted,
+		q.params.Internal,
+		q.params.NoWait,
+		nil,
+	)
+	if err != nil {
+		return err
+	}
+
+	body, err := entry.String()
+	if err != nil {
+		return err
+	}
+
+	err = ch.Publish(
+		q.params.Exchange,
+		q.params.RoutingKey,
+		q.params.Mandatory,
+		q.params.Immediate,
+		amqp.Publishing{
+			ContentType: "application/json",
+			Body:        []byte(body),
+		})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Levels is available logging levels.
+func (q amqpConn) Levels() []logrus.Level {
+	return []logrus.Level{
+		logrus.InfoLevel,
+	}
+}
@@ -0,0 +1,112 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"errors"
+	"io/ioutil"
+
+	"github.com/Sirupsen/logrus"
+	"gopkg.in/olivere/elastic.v3"
+)
+
+// elasticQueue is a elasticsearch event notification queue.
+type elasticSearchNotify struct {
+	Enable bool   `json:"enable"`
+	URL    string `json:"url"`
+	Index  string `json:"index"`
+}
+
+type elasticClient struct {
+	*elastic.Client
+	params elasticSearchNotify
+}
+
+// Connects to elastic search instance at URL.
+func dialElastic(esNotify elasticSearchNotify) (*elastic.Client, error) {
+	if !esNotify.Enable {
+		return nil, errNotifyNotEnabled
+	}
+	client, err := elastic.NewClient(elastic.SetURL(esNotify.URL), elastic.SetSniff(false))
+	if err != nil {
+		return nil, err
+	}
+	return client, nil
+}
+
+func newElasticNotify(accountID string) (*logrus.Logger, error) {
+	esNotify := serverConfig.GetElasticSearchNotifyByID(accountID)
+
+	// Dial to elastic search.
+	client, err := dialElastic(esNotify)
+	if err != nil {
+		return nil, err
+	}
+
+	// Use the IndexExists service to check if a specified index exists.
+	exists, err := client.IndexExists(esNotify.Index).Do()
+	if err != nil {
+		return nil, err
+	}
+	// Index does not exist, attempt to create it.
+	if !exists {
+		var createIndex *elastic.IndicesCreateResult
+		createIndex, err = client.CreateIndex(esNotify.Index).Do()
+		if err != nil {
+			return nil, err
+		}
+		if !createIndex.Acknowledged {
+			return nil, errors.New("index not created")
+		}
+	}
+
+	elasticCl := elasticClient{
+		Client: client,
+		params: esNotify,
+	}
+
+	elasticSearchLog := logrus.New()
+
+	// Disable writing to console.
+	elasticSearchLog.Out = ioutil.Discard
+
+	// Add a elasticSearch hook.
+	elasticSearchLog.Hooks.Add(elasticCl)
+
+	// Set default JSON formatter.
+	elasticSearchLog.Formatter = new(logrus.JSONFormatter)
+
+	// Success, elastic search successfully initialized.
+	return elasticSearchLog, nil
+}
+
+// Fire is required to implement logrus hook
+func (q elasticClient) Fire(entry *logrus.Entry) error {
+	_, err := q.Client.Index().Index(q.params.Index).
+		Type("event").
+		BodyJson(entry.Data).
+		Do()
+
+	return err
+}
+
+// Required for logrus hook implementation
+func (q elasticClient) Levels() []logrus.Level {
+	return []logrus.Level{
+		logrus.InfoLevel,
+	}
+}
@@ -0,0 +1,133 @@
+/*
+ * Minio Cloud Storage, (C) 2016 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 main
+
+import (
+	"io/ioutil"
+	"time"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/minio/redigo/redis"
+)
+
+// redisNotify to send logs to Redis server
+type redisNotify struct {
+	Enable   bool   `json:"enable"`
+	Addr     string `json:"address"`
+	Password string `json:"password"`
+	Key      string `json:"key"`
+}
+
+type redisConn struct {
+	*redis.Pool
+	params redisNotify
+}
+
+// Dial a new connection to redis instance at addr, optionally with a password if any.
+func dialRedis(rNotify redisNotify) (*redis.Pool, error) {
+	// Return error if redis not enabled.
+	if !rNotify.Enable {
+		return nil, errNotifyNotEnabled
+	}
+	addr := rNotify.Addr
+	password := rNotify.Password
+	rPool := &redis.Pool{
+		MaxIdle:     3,
+		IdleTimeout: 240 * time.Second,
+		Dial: func() (redis.Conn, error) {
+			c, err := redis.Dial("tcp", addr)
+			if err != nil {
+				return nil, err
+			}
+			if password != "" {
+				if _, derr := c.Do("AUTH", password); derr != nil {
+					c.Close()
+					return nil, derr
+				}
+			}
+			return c, err
+		},
+		TestOnBorrow: func(c redis.Conn, t time.Time) error {
+			_, err := c.Do("PING")
+			return err
+		},
+	}
+
+	// Test if connection with REDIS can be established.
+	rConn := rPool.Get()
+	defer rConn.Close()
+
+	// Check connection.
+	_, err := rConn.Do("PING")
+	if err != nil {
+		return nil, err
+	}
+
+	// Return pool.
+	return rPool, nil
+}
+
+func newRedisNotify(accountID string) (*logrus.Logger, error) {
+	rNotify := serverConfig.GetRedisNotifyByID(accountID)
+
+	// Dial redis.
+	rPool, err := dialRedis(rNotify)
+	if err != nil {
+		return nil, err
+	}
+
+	rrConn := redisConn{
+		Pool:   rPool,
+		params: rNotify,
+	}
+
+	redisLog := logrus.New()
+
+	redisLog.Out = ioutil.Discard
+
+	// Set default JSON formatter.
+	redisLog.Formatter = new(logrus.JSONFormatter)
+
+	redisLog.Hooks.Add(rrConn)
+
+	// Success, redis enabled.
+	return redisLog, nil
+}
+
+// Fire is called when an event should be sent to the message broker.
+func (r redisConn) Fire(entry *logrus.Entry) error {
+	rConn := r.Pool.Get()
+	defer rConn.Close()
+
+	data, err := entry.String()
+	if err != nil {
+		return err
+	}
+
+	_, err = rConn.Do("RPUSH", r.params.Key, data)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Required for logrus hook implementation
+func (r redisConn) Levels() []logrus.Level {
+	return []logrus.Level{
+		logrus.InfoLevel,
+	}
+}
@@ -174,251 +174,327 @@ func testGetObject(obj ObjectLayer, instanceType string, t TestErrHandler) {
 	}
 }

+// Wrapper for calling GetObject tests for both XL multiple disks and single node setup.
+func TestGetObjectDiskNotFound(t *testing.T) {
+	ExecObjectLayerDiskNotFoundTest(t, testGetObjectDiskNotFound)
+}
+
+// ObjectLayer.GetObject is called with series of cases for valid and erroneous inputs and the result is validated.
+// Before the Get Object call XL disks are moved so that the quorum just holds.
+func testGetObjectDiskNotFound(obj ObjectLayer, instanceType string, disks []string, t *testing.T) {
+	// Setup for the tests.
+	bucketName := getRandomBucketName()
+	objectName := "test-object"
+	// create bucket.
+	err := obj.MakeBucket(bucketName)
+	// Stop the test if creation of the bucket fails.
+	if err != nil {
+		t.Fatalf("%s : %s", instanceType, err.Error())
+	}
+
+	// set of byte data for PutObject.
+	// object has to be inserted before running tests for GetObject.
+	// this is required even to assert the GetObject data,
+	// since dataInserted === dataFetched back is a primary criteria for any object storage this assertion is critical.
+	bytesData := []struct {
+		byteData []byte
+	}{
+		{generateBytesData(6 * 1024 * 1024)},
+	}
+	// set of inputs for uploading the objects before tests for downloading is done.
+	putObjectInputs := []struct {
+		bucketName    string
+		objectName    string
+		contentLength int64
+		textData      []byte
+		metaData      map[string]string
+	}{
+		// case - 1.
+		{bucketName, objectName, int64(len(bytesData[0].byteData)), bytesData[0].byteData, make(map[string]string)},
+	}
+	// iterate through the above set of inputs and upkoad the object.
+	for i, input := range putObjectInputs {
+		// uploading the object.
+		_, err = obj.PutObject(input.bucketName, input.objectName, input.contentLength, bytes.NewBuffer(input.textData), input.metaData)
+		// if object upload fails stop the test.
+		if err != nil {
+			t.Fatalf("Put Object case %d:  Error uploading object: <ERROR> %v", i+1, err)
+		}
+	}
+
+	// Take 8 disks down before GetObject is called, one more we loose quorum on 16 disk node.
+	for _, disk := range disks[:8] {
+		removeAll(disk)
+	}
+
+	// set of empty buffers used to fill GetObject data.
+	buffers := []*bytes.Buffer{
+		new(bytes.Buffer),
+		new(bytes.Buffer),
+	}
+
+	// test cases with set of inputs
+	testCases := []struct {
+		bucketName  string
+		objectName  string
+		startOffset int64
+		length      int64
+		// data obtained/fetched from GetObject.
+		getObjectData *bytes.Buffer
+		// writer which governs the write into the `getObjectData`.
+		writer io.Writer
+		// flag indicating whether the test for given ase should pass.
+		shouldPass bool
+		// expected Result.
+		expectedData []byte
+		err          error
+	}{
+		// Test case 1-4.
+		// Cases with invalid bucket names.
+		{".test", "obj", 0, 0, nil, nil, false, []byte(""), fmt.Errorf("%s", "Bucket name invalid: .test")},
+		{"------", "obj", 0, 0, nil, nil, false, []byte(""), fmt.Errorf("%s", "Bucket name invalid: ------")},
+		{"$this-is-not-valid-too", "obj", 0, 0, nil, nil, false,
+			[]byte(""), fmt.Errorf("%s", "Bucket name invalid: $this-is-not-valid-too")},
+		{"a", "obj", 0, 0, nil, nil, false, []byte(""), fmt.Errorf("%s", "Bucket name invalid: a")},
+		// Test case - 5.
+		// Case with invalid object names.
+		{bucketName, "", 0, 0, nil, nil, false, []byte(""), fmt.Errorf("%s", "Object name invalid: "+bucketName+"#")},
+		// Test case - 6.
+		// 	Valid object and bucket names but non-existent bucket.
+		//	{"abc", "def", 0, 0, nil, nil, false, []byte(""), fmt.Errorf("%s", "Bucket not found: abc")},
+		// A custom writer is sent as an argument.
+		// Its designed to return a EOF error after reading `n` bytes, where `n` is the argument when initializing the EOF writer.
+		// This is to simulate the case of cache not filling up completly, since the EOFWriter doesn't allow the write to complete,
+		// the cache gets filled up with partial data. The following up test case will read the object completly, tests the
+		// purging of the cache during the incomplete write.
+		//	Test case - 7.
+		{bucketName, objectName, 0, int64(len(bytesData[0].byteData)), buffers[0], NewEOFWriter(buffers[0], 100), false, []byte{}, io.EOF},
+		// Test case with start offset set to 0 and length set to size of the object.
+		// Fetching the entire object.
+		// 	Test case - 8.
+		{bucketName, objectName, 0, int64(len(bytesData[0].byteData)), buffers[1], buffers[1], true, bytesData[0].byteData, nil},
+		// Test case with content-range 1 to objectSize .
+		// Test case - 9.
+		{bucketName, objectName, 1, int64(len(bytesData[0].byteData) - 1), buffers[1], buffers[1], true, bytesData[0].byteData[1:], nil},
+		// Test case with content-range 100 to objectSize - 100.
+		// Test case - 10.
+		{bucketName, objectName, 100, int64(len(bytesData[0].byteData) - 200), buffers[1], buffers[1], true,
+			bytesData[0].byteData[100 : len(bytesData[0].byteData)-100], nil},
+		// Test case with offset greater than the size of the object
+		// Test case - 11.
+		{bucketName, objectName, int64(len(bytesData[0].byteData) + 1), int64(len(bytesData[0].byteData)), buffers[0],
+			NewEOFWriter(buffers[0], 100), false, []byte{},
+			InvalidRange{int64(len(bytesData[0].byteData) + 1), int64(len(bytesData[0].byteData)), int64(len(bytesData[0].byteData))}},
+		// Test case with offset greater than the size of the object.
+		// Test case - 12.
+		{bucketName, objectName, -1, int64(len(bytesData[0].byteData)), buffers[0], new(bytes.Buffer), false, []byte{}, errUnexpected},
+		// Test case length parameter is more than the object size.
+		// Test case - 13.
+		{bucketName, objectName, 0, int64(len(bytesData[0].byteData) + 1), buffers[1], buffers[1], false, bytesData[0].byteData,
+			InvalidRange{0, int64(len(bytesData[0].byteData) + 1), int64(len(bytesData[0].byteData))}},
+		// Test case with `length` parameter set to a negative value.
+		// Test case - 14.
+		{bucketName, objectName, 0, int64(-1), buffers[1], buffers[1], false, bytesData[0].byteData, errUnexpected},
+		// Test case with offset + length > objectSize parameter set to a negative value.
+		// Test case - 15.
+		{bucketName, objectName, 2, int64(len(bytesData[0].byteData)), buffers[1], buffers[1], false, bytesData[0].byteData,
+			InvalidRange{2, int64(len(bytesData[0].byteData)), int64(len(bytesData[0].byteData))}},
+		// Test case with the writer set to nil.
+		// Test case - 16.
+		{bucketName, objectName, 0, int64(len(bytesData[0].byteData)), buffers[1], nil, false, bytesData[0].byteData, errUnexpected},
+	}
+
+	for i, testCase := range testCases {
+		err = obj.GetObject(testCase.bucketName, testCase.objectName, testCase.startOffset, testCase.length, testCase.writer)
+		if err != nil && testCase.shouldPass {
+			t.Errorf("Test %d: %s:  Expected to pass, but failed with: <ERROR> %s", i+1, instanceType, err.Error())
+		}
+		if err == nil && !testCase.shouldPass {
+			t.Errorf("Test %d: %s: Expected to fail with <ERROR> \"%s\", but passed instead.", i+1, instanceType, testCase.err.Error())
+		}
+		// Failed as expected, but does it fail for the expected reason.
+		if err != nil && !testCase.shouldPass {
+			if !strings.Contains(err.Error(), testCase.err.Error()) {
+				t.Errorf("Test %d: %s: Expected to fail with error \"%s\", but instead failed with error \"%s\" instead.", i+1, instanceType, testCase.err.Error(), err.Error())
+			}
+		}
+		// Since there are cases for which GetObject fails, this is
+		// necessary. Test passes as expected, but the output values
+		// are verified for correctness here.
+		if err == nil && testCase.shouldPass {
+			if !bytes.Equal(testCase.expectedData, testCase.getObjectData.Bytes()) {
+				t.Errorf("Test %d: %s: Data Mismatch: Expected data and the fetched data from GetObject doesn't match.", i+1, instanceType)
+			}
+			// empty the buffer so that it can be used to further cases.
+			testCase.getObjectData.Reset()
+		}
+	}
+}
+
 // Benchmarks for ObjectLayer.GetObject().
-// The intent is to benchamrk GetObject for various sizes ranging from few bytes to 100MB.
+// The intent is to benchmark GetObject for various sizes ranging from few bytes to 100MB.
 // Also each of these Benchmarks are run both XL and FS backends.

 // BenchmarkGetObjectVerySmallFS - Benchmark FS.GetObject() for object size of 10 bytes.
 func BenchmarkGetObjectVerySmallFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(10))
+	benchmarkGetObject(b, "FS", 10)
 }

 // BenchmarkGetObjectVerySmallXL - Benchmark XL.GetObject() for object size of 10 bytes.
 func BenchmarkGetObjectVerySmallXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(10))
+	benchmarkGetObject(b, "XL", 10)
 }

 // BenchmarkGetObject10KbFS - Benchmark FS.GetObject() for object size of 10KB.
 func BenchmarkGetObject10KbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(10*1024))
+	benchmarkGetObject(b, "FS", 10*1024)
 }

 // BenchmarkGetObject10KbXL - Benchmark XL.GetObject() for object size of 10KB.
 func BenchmarkGetObject10KbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(10*1024))
+	benchmarkGetObject(b, "XL", 10*1024)
 }

 // BenchmarkGetObject100KbFS - Benchmark FS.GetObject() for object size of 100KB.
 func BenchmarkGetObject100KbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(100*1024))
+	benchmarkGetObject(b, "FS", 100*1024)
 }

 // BenchmarkGetObject100KbXL - Benchmark XL.GetObject() for object size of 100KB.
 func BenchmarkGetObject100KbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(100*1024))
+	benchmarkGetObject(b, "XL", 100*1024)
 }

 // BenchmarkGetObject1MbFS - Benchmark FS.GetObject() for object size of 1MB.
 func BenchmarkGetObject1MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(1024*1024))
+	benchmarkGetObject(b, "FS", 1024*1024)
 }

 // BenchmarkGetObject1MbXL - Benchmark XL.GetObject() for object size of 1MB.
 func BenchmarkGetObject1MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(1024*1024))
+	benchmarkGetObject(b, "XL", 1024*1024)
 }

 // BenchmarkGetObject5MbFS - Benchmark FS.GetObject() for object size of 5MB.
 func BenchmarkGetObject5MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(5*1024*1024))
+	benchmarkGetObject(b, "FS", 5*1024*1024)
 }

 // BenchmarkGetObject5MbXL - Benchmark XL.GetObject() for object size of 5MB.
 func BenchmarkGetObject5MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(5*1024*1024))
+	benchmarkGetObject(b, "XL", 5*1024*1024)
 }

 // BenchmarkGetObject10MbFS - Benchmark FS.GetObject() for object size of 10MB.
 func BenchmarkGetObject10MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(10*1024*1024))
+	benchmarkGetObject(b, "FS", 10*1024*1024)
 }

 // BenchmarkGetObject10MbXL - Benchmark XL.GetObject() for object size of 10MB.
 func BenchmarkGetObject10MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(10*1024*1024))
+	benchmarkGetObject(b, "XL", 10*1024*1024)
 }

 // BenchmarkGetObject25MbFS - Benchmark FS.GetObject() for object size of 25MB.
 func BenchmarkGetObject25MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(25*1024*1024))
+	benchmarkGetObject(b, "FS", 25*1024*1024)

 }

 // BenchmarkGetObject25MbXL - Benchmark XL.GetObject() for object size of 25MB.
 func BenchmarkGetObject25MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(25*1024*1024))
+	benchmarkGetObject(b, "XL", 25*1024*1024)
 }

 // BenchmarkGetObject50MbFS - Benchmark FS.GetObject() for object size of 50MB.
 func BenchmarkGetObject50MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(50*1024*1024))
+	benchmarkGetObject(b, "FS", 50*1024*1024)
 }

 // BenchmarkGetObject50MbXL - Benchmark XL.GetObject() for object size of 50MB.
 func BenchmarkGetObject50MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(50*1024*1024))
+	benchmarkGetObject(b, "XL", 50*1024*1024)
 }

-// BenchmarkGetObject100MbFS - Benchmark FS.GetObject() for object size of 100MB.
-func BenchmarkGetObject100MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(100*1024*1024))
+// parallel benchmarks for ObjectLayer.GetObject() .
+
+// BenchmarkGetObjectParallelVerySmallFS - Benchmark FS.GetObject() for object size of 10 bytes.
+func BenchmarkGetObjectParallelVerySmallFS(b *testing.B) {
+	benchmarkGetObjectParallel(b, "FS", 10)
 }

-// BenchmarkGetObject100MbXL - Benchmark XL.GetObject() for object size of 100MB.
-func BenchmarkGetObject100MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(100*1024*1024))
+// BenchmarkGetObjectParallelVerySmallXL - Benchmark XL.GetObject() for object size of 10 bytes.
+func BenchmarkGetObjectParallelVerySmallXL(b *testing.B) {
+	benchmarkGetObjectParallel(b, "XL", 10)
 }

-// BenchmarkGetObject200MbFS - Benchmark FS.GetObject() for object size of 200MB.
-func BenchmarkGetObject200MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(200*1024*1024))
+// BenchmarkGetObjectParallel10KbFS - Benchmark FS.GetObject() for object size of 10KB.
+func BenchmarkGetObjectParallel10KbFS(b *testing.B) {
+	benchmarkGetObjectParallel(b, "FS", 10*1024)
 }

-// BenchmarkGetObject200MbXL - Benchmark XL.GetObject() for object size of 200MB.
-func BenchmarkGetObject200MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(200*1024*1024))
+// BenchmarkGetObjectParallel10KbXL - Benchmark XL.GetObject() for object size of 10KB.
+func BenchmarkGetObjectParallel10KbXL(b *testing.B) {
+	benchmarkGetObjectParallel(b, "XL", 10*1024)
 }

-// BenchmarkGetObject500MbFS - Benchmark FS.GetObject() for object size of 500MB.
-func BenchmarkGetObject500MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(500*1024*1024))
+// BenchmarkGetObjectParallel100KbFS - Benchmark FS.GetObject() for object size of 100KB.
+func BenchmarkGetObjectParallel100KbFS(b *testing.B) {
+	benchmarkGetObjectParallel(b, "FS", 100*1024)
 }

-// BenchmarkGetObject500MbXL - Benchmark XL.GetObject() for object size of 500MB.
-func BenchmarkGetObject500MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(500*1024*1024))
+// BenchmarkGetObjectParallel100KbXL - Benchmark XL.GetObject() for object size of 100KB.
+func BenchmarkGetObjectParallel100KbXL(b *testing.B) {
+	benchmarkGetObjectParallel(b, "XL", 100*1024)
 }

-// BenchmarkGetObject1GbFS - Benchmark FS.GetObject() for object size of 1GB.
-func BenchmarkGetObject1GbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmark(1024*1024*1024))
+// BenchmarkGetObjectParallel1MbFS - Benchmark FS.GetObject() for object size of 1MB.
+func BenchmarkGetObjectParallel1MbFS(b *testing.B) {
+	benchmarkGetObjectParallel(b, "FS", 1024*1024)
 }

-// BenchmarkGetObjectGbXL - Benchmark XL.GetObject() for object size of 1GB.
-func BenchmarkGetObject1GbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmark(1024*1024*1024))
+// BenchmarkGetObjectParallel1MbXL - Benchmark XL.GetObject() for object size of 1MB.
+func BenchmarkGetObjectParallel1MbXL(b *testing.B) {
+	benchmarkGetObjectParallel(b, "XL", 1024*1024)
 }

-// The intent is to benchamrk GetObject for various sizes ranging from few bytes to 100MB.
-// Also each of these BenchmarkParallels are run both XL and FS backends.
-
-// BenchmarkParallelGetObjectVerySmallFS - BenchmarkParallel FS.GetObject() for object size of 10 bytes.
-func BenchmarkParallelGetObjectVerySmallFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(10))
+// BenchmarkGetObjectParallel5MbFS - Benchmark FS.GetObject() for object size of 5MB.
+func BenchmarkGetObjectParallel5MbFS(b *testing.B) {
+	benchmarkGetObjectParallel(b, "FS", 5*1024*1024)
 }

-// BenchmarkParallelGetObjectVerySmallXL - BenchmarkParallel XL.GetObject() for object size of 10 bytes.
-func BenchmarkParallelGetObjectVerySmallXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(10))
+// BenchmarkGetObjectParallel5MbXL - Benchmark XL.GetObject() for object size of 5MB.
+func BenchmarkGetObjectParallel5MbXL(b *testing.B) {
+	benchmarkGetObjectParallel(b, "XL", 5*1024*1024)
 }

-// BenchmarkParallelGetObject10KbFS - BenchmarkParallel FS.GetObject() for object size of 10KB.
-func BenchmarkParallelGetObject10KbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(10*1024))
+// BenchmarkGetObjectParallel10MbFS - Benchmark FS.GetObject() for object size of 10MB.
+func BenchmarkGetObjectParallel10MbFS(b *testing.B) {
+	benchmarkGetObjectParallel(b, "FS", 10*1024*1024)
 }

-// BenchmarkParallelGetObject10KbXL - BenchmarkParallel XL.GetObject() for object size of 10KB.
-func BenchmarkParallelGetObject10KbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(10*1024))
+// BenchmarkGetObjectParallel10MbXL - Benchmark XL.GetObject() for object size of 10MB.
+func BenchmarkGetObjectParallel10MbXL(b *testing.B) {
+	benchmarkGetObjectParallel(b, "XL", 10*1024*1024)
 }

-// BenchmarkParallelGetObject100KbFS - BenchmarkParallel FS.GetObject() for object size of 100KB.
-func BenchmarkParallelGetObject100KbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(100*1024))
-}
-
-// BenchmarkParallelGetObject100KbXL - BenchmarkParallel XL.GetObject() for object size of 100KB.
-func BenchmarkParallelGetObject100KbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(100*1024))
-}
-
-// BenchmarkParallelGetObject1MbFS - BenchmarkParallel FS.GetObject() for object size of 1MB.
-func BenchmarkParallelGetObject1MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(1024*1024))
-}
-
-// BenchmarkParallelGetObject1MbXL - BenchmarkParallel XL.GetObject() for object size of 1MB.
-func BenchmarkParallelGetObject1MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(1024*1024))
-}
-
-// BenchmarkParallelGetObject5MbFS - BenchmarkParallel FS.GetObject() for object size of 5MB.
-func BenchmarkParallelGetObject5MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(5*1024*1024))
-}
-
-// BenchmarkParallelGetObject5MbXL - BenchmarkParallel XL.GetObject() for object size of 5MB.
-func BenchmarkParallelGetObject5MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(5*1024*1024))
-}
-
-// BenchmarkParallelGetObject10MbFS - BenchmarkParallel FS.GetObject() for object size of 10MB.
-func BenchmarkParallelGetObject10MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(10*1024*1024))
-}
-
-// BenchmarkParallelGetObject10MbXL - BenchmarkParallel XL.GetObject() for object size of 10MB.
-func BenchmarkParallelGetObject10MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(10*1024*1024))
-}
-
-// BenchmarkParallelGetObject25MbFS - BenchmarkParallel FS.GetObject() for object size of 25MB.
-func BenchmarkParallelGetObject25MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(25*1024*1024))
+// BenchmarkGetObjectParallel25MbFS - Benchmark FS.GetObject() for object size of 25MB.
+func BenchmarkGetObjectParallel25MbFS(b *testing.B) {
+	benchmarkGetObjectParallel(b, "FS", 25*1024*1024)

 }

-// BenchmarkParallelGetObject25MbXL - BenchmarkParallel XL.GetObject() for object size of 25MB.
-func BenchmarkParallelGetObject25MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(25*1024*1024))
+// BenchmarkGetObjectParallel25MbXL - Benchmark XL.GetObject() for object size of 25MB.
+func BenchmarkGetObjectParallel25MbXL(b *testing.B) {
+	benchmarkGetObjectParallel(b, "XL", 25*1024*1024)
 }

-// BenchmarkParallelGetObject50MbFS - BenchmarkParallel FS.GetObject() for object size of 50MB.
-func BenchmarkParallelGetObject50MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(50*1024*1024))
+// BenchmarkGetObjectParallel50MbFS - Benchmark FS.GetObject() for object size of 50MB.
+func BenchmarkGetObjectParallel50MbFS(b *testing.B) {
+	benchmarkGetObjectParallel(b, "FS", 50*1024*1024)
 }

-// BenchmarkParallelGetObject50MbXL - BenchmarkParallel XL.GetObject() for object size of 50MB.
-func BenchmarkParallelGetObject50MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(50*1024*1024))
-}
-
-// BenchmarkParallelGetObject100MbFS - BenchmarkParallel FS.GetObject() for object size of 100MB.
-func BenchmarkParallelGetObject100MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(100*1024*1024))
-}
-
-// BenchmarkParallelGetObject100MbXL - BenchmarkParallel XL.GetObject() for object size of 100MB.
-func BenchmarkParallelGetObject100MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(100*1024*1024))
-}
-
-// BenchmarkParallelGetObject200MbFS - BenchmarkParallel FS.GetObject() for object size of 200MB.
-func BenchmarkParallelGetObject200MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(200*1024*1024))
-}
-
-// BenchmarkParallelGetObject200MbXL - BenchmarkParallel XL.GetObject() for object size of 200MB.
-func BenchmarkParallelGetObject200MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(200*1024*1024))
-}
-
-// BenchmarkParallelGetObject500MbFS - BenchmarkParallel FS.GetObject() for object size of 500MB.
-func BenchmarkParallelGetObject500MbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(500*1024*1024))
-}
-
-// BenchmarkParallelGetObject500MbXL - BenchmarkParallel XL.GetObject() for object size of 500MB.
-func BenchmarkParallelGetObject500MbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(500*1024*1024))
-}
-
-// BenchmarkParallelGetObject1GbFS - BenchmarkParallel FS.GetObject() for object size of 1GB.
-func BenchmarkParallelGetObject1GbFS(b *testing.B) {
-	benchmarkGetObject(b, "FS", returnGetObjectBenchmarkParallel(1024*1024*1024))
-}
-
-// BenchmarkParallelGetObjectGbXL - BenchmarkParallel XL.GetObject() for object size of 1GB.
-func BenchmarkParallelGetObject1GbXL(b *testing.B) {
-	benchmarkGetObject(b, "XL", returnGetObjectBenchmarkParallel(1024*1024*1024))
+// BenchmarkGetObjectParallel50MbXL - Benchmark XL.GetObject() for object size of 50MB.
+func BenchmarkGetObjectParallel50MbXL(b *testing.B) {
+	benchmarkGetObjectParallel(b, "XL", 50*1024*1024)
 }
@@ -20,7 +20,6 @@ import (
 	"bytes"
 	"fmt"
 	"io/ioutil"
-	"os"
 	"strconv"
 	"strings"
 	"testing"
@@ -34,57 +33,41 @@ func TestListObjects(t *testing.T) {
 // Unit test for ListObjects in general.
 func testListObjects(obj ObjectLayer, instanceType string, t TestErrHandler) {

-	// This bucket is used for testing ListObject operations.
-	err := obj.MakeBucket("test-bucket-list-object")
-	if err != nil {
-		t.Fatalf("%s : %s", instanceType, err.Error())
+	testBuckets := []string{
+		// This bucket is used for testing ListObject operations.
+		"test-bucket-list-object",
+		// Will not store any objects in this bucket,
+		// Its to test ListObjects on an empty bucket.
+		"empty-bucket",
 	}
-	// Will not store any objects in this bucket,
-	// Its to test ListObjects on an empty bucket.
-	err = obj.MakeBucket("empty-bucket")
-	if err != nil {
-		t.Fatalf("%s : %s", instanceType, err.Error())
-	}
-
-	tmpfile, err := ioutil.TempFile("", "simple-file.txt")
-	if err != nil {
-		t.Fatalf("%s : %s", instanceType, err.Error())
-	}
-	defer os.Remove(tmpfile.Name()) // clean up
-
-	_, err = obj.PutObject("test-bucket-list-object", "Asia-maps", int64(len("asia-maps")), bytes.NewBufferString("asia-maps"), nil)
-	if err != nil {
-		t.Fatalf("%s : %s", instanceType, err.Error())
-	}
-
-	_, err = obj.PutObject("test-bucket-list-object", "Asia/India/India-summer-photos-1", int64(len("contentstring")), bytes.NewBufferString("contentstring"), nil)
-	if err != nil {
-		t.Fatalf("%s : %s", instanceType, err.Error())
-	}
-
-	_, err = obj.PutObject("test-bucket-list-object", "Asia/India/Karnataka/Bangalore/Koramangala/pics", int64(len("contentstring")), bytes.NewBufferString("contentstring"), nil)
-	if err != nil {
-		t.Fatalf("%s : %s", instanceType, err.Error())
-	}
-
-	for i := 0; i < 2; i++ {
-		key := "newPrefix" + strconv.Itoa(i)
-		_, err = obj.PutObject("test-bucket-list-object", key, int64(len(key)), bytes.NewBufferString(key), nil)
+	for _, bucket := range testBuckets {
+		err := obj.MakeBucket(bucket)
 		if err != nil {
 			t.Fatalf("%s : %s", instanceType, err.Error())
 		}
 	}
-	_, err = obj.PutObject("test-bucket-list-object", "newzen/zen/recurse/again/again/again/pics", int64(len("recurse")), bytes.NewBufferString("recurse"), nil)
-	if err != nil {
-		t.Fatalf("%s : %s", instanceType, err.Error())
-	}

-	for i := 0; i < 3; i++ {
-		key := "obj" + strconv.Itoa(i)
-		_, err = obj.PutObject("test-bucket-list-object", key, int64(len(key)), bytes.NewBufferString(key), nil)
+	var err error
+	testObjects := []struct {
+		name    string
+		content string
+	}{
+		{"Asia-maps", "asis-maps"},
+		{"Asia/India/India-summer-photos-1", "contentstring"},
+		{"Asia/India/Karnataka/Bangalore/Koramangala/pics", "contentstring"},
+		{"newPrefix0", "newPrefix0"},
+		{"newPrefix1", "newPrefix1"},
+		{"newzen/zen/recurse/again/again/again/pics", "recurse"},
+		{"obj0", "obj0"},
+		{"obj1", "obj1"},
+		{"obj2", "obj2"},
+	}
+	for _, object := range testObjects {
+		_, err = obj.PutObject(testBuckets[0], object.name, int64(len(object.content)), bytes.NewBufferString(object.content), nil)
 		if err != nil {
 			t.Fatalf("%s : %s", instanceType, err.Error())
 		}
+
 	}

 	// Formualting the result data set to be expected from ListObjects call inside the tests,
@@ -449,63 +432,63 @@ func testListObjects(obj ObjectLayer, instanceType string, t TestErrHandler) {
 		// Empty string < "" > and forward slash < / > are the ony two valid arguments for delimeter.
 		{"test-bucket-list-object", "", "", "*", 0, ListObjectsInfo{}, fmt.Errorf("delimiter '%s' is not supported", "*"), false},
 		{"test-bucket-list-object", "", "", "-", 0, ListObjectsInfo{}, fmt.Errorf("delimiter '%s' is not supported", "-"), false},
-		// Testing for failure cases with both perfix and marker (13).
+		// Testing for failure cases with both perfix and marker (11).
 		// The prefix and marker combination to be valid it should satisy strings.HasPrefix(marker, prefix).
 		{"test-bucket-list-object", "asia", "europe-object", "", 0, ListObjectsInfo{}, fmt.Errorf("Invalid combination of marker '%s' and prefix '%s'", "europe-object", "asia"), false},
-		// Setting a non-existing directory to be prefix (14-15).
+		// Setting a non-existing directory to be prefix (12-13).
 		{"empty-bucket", "europe/france/", "", "", 1, ListObjectsInfo{}, nil, true},
 		{"empty-bucket", "europe/tunisia/", "", "", 1, ListObjectsInfo{}, nil, true},
-		// Testing on empty bucket, that is, bucket without any objects in it (16).
+		// Testing on empty bucket, that is, bucket without any objects in it (14).
 		{"empty-bucket", "", "", "", 0, ListObjectsInfo{}, nil, true},
-		// Setting maxKeys to negative value (17-18).
+		// Setting maxKeys to negative value (15-16).
 		{"empty-bucket", "", "", "", -1, ListObjectsInfo{}, nil, true},
 		{"empty-bucket", "", "", "", 1, ListObjectsInfo{}, nil, true},
-		// Setting maxKeys to a very large value (19).
+		// Setting maxKeys to a very large value (17).
 		{"empty-bucket", "", "", "", 1111000000000000, ListObjectsInfo{}, nil, true},
-		// Testing for all 7 objects in the bucket (20).
+		// Testing for all 7 objects in the bucket (18).
 		{"test-bucket-list-object", "", "", "", 9, resultCases[0], nil, true},
-		//Testing for negative value of maxKey, this should set maxKeys to listObjectsLimit (21).
+		//Testing for negative value of maxKey, this should set maxKeys to listObjectsLimit (19).
 		{"test-bucket-list-object", "", "", "", -1, resultCases[0], nil, true},
-		// Testing for very large value of maxKey, this should set maxKeys to listObjectsLimit (22).
+		// Testing for very large value of maxKey, this should set maxKeys to listObjectsLimit (20).
 		{"test-bucket-list-object", "", "", "", 1234567891011, resultCases[0], nil, true},
-		// Testing for trancated value (23-26).
+		// Testing for trancated value (21-24).
 		{"test-bucket-list-object", "", "", "", 5, resultCases[1], nil, true},
 		{"test-bucket-list-object", "", "", "", 4, resultCases[2], nil, true},
 		{"test-bucket-list-object", "", "", "", 3, resultCases[3], nil, true},
 		{"test-bucket-list-object", "", "", "", 1, resultCases[4], nil, true},
-		// Testing with prefix (27-30).
+		// Testing with prefix (25-28).
 		{"test-bucket-list-object", "new", "", "", 3, resultCases[5], nil, true},
 		{"test-bucket-list-object", "new", "", "", 4, resultCases[5], nil, true},
 		{"test-bucket-list-object", "new", "", "", 5, resultCases[5], nil, true},
 		{"test-bucket-list-object", "obj", "", "", 3, resultCases[6], nil, true},
-		// Testing with prefix and truncation (31-32).
+		// Testing with prefix and truncation (29-30).
 		{"test-bucket-list-object", "new", "", "", 1, resultCases[7], nil, true},
 		{"test-bucket-list-object", "obj", "", "", 2, resultCases[8], nil, true},
-		// Testing with marker, but without prefix and truncation (33-37).
+		// Testing with marker, but without prefix and truncation (31-35).
 		{"test-bucket-list-object", "", "newPrefix0", "", 5, resultCases[9], nil, true},
 		{"test-bucket-list-object", "", "newPrefix1", "", 4, resultCases[10], nil, true},
 		{"test-bucket-list-object", "", "obj0", "", 2, resultCases[11], nil, true},
 		{"test-bucket-list-object", "", "obj1", "", 1, resultCases[12], nil, true},
 		{"test-bucket-list-object", "", "man", "", 10, resultCases[13], nil, true},
-		// Marker being set to a value which is greater than and all object names when sorted (38).
+		// Marker being set to a value which is greater than and all object names when sorted (36).
 		// Expected to send an empty response in this case.
 		{"test-bucket-list-object", "", "zen", "", 10, ListObjectsInfo{}, nil, true},
-		// Marker being set to a value which is lesser than and all object names when sorted (39).
+		// Marker being set to a value which is lesser than and all object names when sorted (37).
 		// Expected to send all the objects in the bucket in this case.
 		{"test-bucket-list-object", "", "Abc", "", 10, resultCases[14], nil, true},
-		// Marker is to a hierarhical value (40-41).
+		// Marker is to a hierarhical value (38-39).
 		{"test-bucket-list-object", "", "Asia/India/India-summer-photos-1", "", 10, resultCases[15], nil, true},
 		{"test-bucket-list-object", "", "Asia/India/Karnataka/Bangalore/Koramangala/pics", "", 10, resultCases[16], nil, true},
-		// Testing with marker and truncation, but no prefix (42-44).
+		// Testing with marker and truncation, but no prefix (40-42).
 		{"test-bucket-list-object", "", "newPrefix0", "", 3, resultCases[17], nil, true},
 		{"test-bucket-list-object", "", "newPrefix1", "", 1, resultCases[18], nil, true},
 		{"test-bucket-list-object", "", "obj0", "", 1, resultCases[19], nil, true},
-		// Testing with both marker and prefix, but without truncation (45-47).
+		// Testing with both marker and prefix, but without truncation (43-45).
 		// The valid combination of marker and prefix should satisfy strings.HasPrefix(marker, prefix).
 		{"test-bucket-list-object", "obj", "obj0", "", 2, resultCases[20], nil, true},
 		{"test-bucket-list-object", "obj", "obj1", "", 1, resultCases[21], nil, true},
 		{"test-bucket-list-object", "new", "newPrefix0", "", 2, resultCases[22], nil, true},
-		// Testing with maxKeys set to 0 (48-54).
+		// Testing with maxKeys set to 0 (46-52).
 		// The parameters have to valid.
 		{"test-bucket-list-object", "", "obj1", "", 0, ListObjectsInfo{}, nil, true},
 		{"test-bucket-list-object", "", "obj0", "", 0, ListObjectsInfo{}, nil, true},
@@ -516,18 +499,18 @@ func testListObjects(obj ObjectLayer, instanceType string, t TestErrHandler) {
 		{"test-bucket-list-object", "new", "newPrefix0", "", 0, ListObjectsInfo{}, nil, true},
 		// Tests on hierarchical key names as prefix.
 		// Without delimteter the code should recurse into the prefix Dir.
-		// Tests with prefix, but without delimiter (55-56).
+		// Tests with prefix, but without delimiter (53-54).
 		{"test-bucket-list-object", "Asia/India/", "", "", 10, resultCases[23], nil, true},
 		{"test-bucket-list-object", "Asia", "", "", 10, resultCases[24], nil, true},
-		// Tests with prefix and delimiter (57-59).
-		// With delimeter the code shouldnot recurse into the sub-directories of prefix Dir.
+		// Tests with prefix and delimiter (55-57).
+		// With delimeter the code should not recurse into the sub-directories of prefix Dir.
 		{"test-bucket-list-object", "Asia", "", "/", 10, resultCases[25], nil, true},
 		{"test-bucket-list-object", "new", "", "/", 10, resultCases[26], nil, true},
 		{"test-bucket-list-object", "Asia/India/", "", "/", 10, resultCases[27], nil, true},
-		// Test with marker set as hierarhical value and with delimiter. (60-61)
+		// Test with marker set as hierarhical value and with delimiter. (58-59)
 		{"test-bucket-list-object", "", "Asia/India/India-summer-photos-1", "/", 10, resultCases[28], nil, true},
 		{"test-bucket-list-object", "", "Asia/India/Karnataka/Bangalore/Koramangala/pics", "/", 10, resultCases[29], nil, true},
-		// Test with prefix and delimiter set to '/'. (62)
+		// Test with prefix and delimiter set to '/'. (60)
 		{"test-bucket-list-object", "/", "", "/", 10, resultCases[30], nil, true},
 	}

@@ -567,8 +550,14 @@ func testListObjects(obj ObjectLayer, instanceType string, t TestErrHandler) {
 			}

 		}
+		// Take ListObject treeWalk go-routine to completion, if available in the treewalk pool.
+		if result.IsTruncated {
+			_, err = obj.ListObjects(testCase.bucketName, testCase.prefix, result.NextMarker, testCase.delimeter, 1000)
+			if err != nil {
+				t.Fatal(err)
+			}
+		}
 	}
-
 }

 func BenchmarkListObjects(b *testing.B) {
@@ -40,7 +40,7 @@ func testObjectNewMultipartUpload(obj ObjectLayer, instanceType string, t TestEr
 	// opearation expected to fail since the bucket on which NewMultipartUpload is being initiated doesn't exist.
 	uploadID, err := obj.NewMultipartUpload(bucket, object, nil)
 	if err == nil {
-		t.Fatalf("%s: Expected to fail since the NewMultipartUpload is intialized on a non-existant bucket.", instanceType)
+		t.Fatalf("%s: Expected to fail since the NewMultipartUpload is intialized on a non-existent bucket.", instanceType)
 	}
 	if errMsg != err.Error() {
 		t.Errorf("%s, Expected to fail with Error \"%s\", but instead found \"%s\".", instanceType, errMsg, err.Error())
@@ -129,7 +129,7 @@ func testPutObjectPartDiskNotFound(obj ObjectLayer, instanceType string, disks [
 	}

 	// Remove some random disk.
-	for _, disk := range disks[:7] {
+	for _, disk := range disks[:6] {
 		removeAll(disk)
 	}

@@ -165,7 +165,10 @@ func testPutObjectPartDiskNotFound(obj ObjectLayer, instanceType string, disks [
 	}

 	// This causes quorum failure verify.
-	removeAll(disks[len(disks)-1])
+	disks = disks[len(disks)-3:]
+	for _, disk := range disks {
+		removeAll(disk)
+	}

 	// Object part upload should fail with quorum not available.
 	testCase := createPartCases[len(createPartCases)-1]
@@ -265,7 +268,7 @@ func testObjectAPIPutObjectPart(obj ObjectLayer, instanceType string, t TestErrH
 		// Test case - 13.
 		// Input with size more than the size of actual data inside the reader.
 		{bucket, object, uploadID, 1, "abcd", "a35", int64(len("abcd") + 1), false, "",
-			fmt.Errorf("%s", "Bad digest: Expected a35 is not valid with what we calculated e2fc714c4727ee9395f324cd2e7f331f")},
+			IncompleteBody{}},
 		// Test case - 14.
 		// Input with size less than the size of actual data inside the reader.
 		{bucket, object, uploadID, 1, "abcd", "a35", int64(len("abcd") - 1), false, "",
@@ -1873,56 +1876,46 @@ func testObjectCompleteMultipartUpload(obj ObjectLayer, instanceType string, t T
 }

 // Benchmarks for ObjectLayer.PutObjectPart().
-// The intent is to benchamrk PutObjectPart for various sizes ranging from few bytes to 100MB.
+// The intent is to benchmark PutObjectPart for various sizes ranging from few bytes to 100MB.
 // Also each of these Benchmarks are run both XL and FS backends.

 // BenchmarkPutObjectPart5MbFS - Benchmark FS.PutObjectPart() for object size of 5MB.
 func BenchmarkPutObjectPart5MbFS(b *testing.B) {
-	benchmarkPutObjectPart(b, "FS", returnPutObjectPartBenchmark(5*1024*1024))
+	benchmarkPutObjectPart(b, "FS", 5*1024*1024)
 }

 // BenchmarkPutObjectPart5MbXL - Benchmark XL.PutObjectPart() for object size of 5MB.
 func BenchmarkPutObjectPart5MbXL(b *testing.B) {
-	benchmarkPutObjectPart(b, "XL", returnPutObjectPartBenchmark(5*1024*1024))
+	benchmarkPutObjectPart(b, "XL", 5*1024*1024)
 }

 // BenchmarkPutObjectPart10MbFS - Benchmark FS.PutObjectPart() for object size of 10MB.
 func BenchmarkPutObjectPart10MbFS(b *testing.B) {
-	benchmarkPutObjectPart(b, "FS", returnPutObjectPartBenchmark(10*1024*1024))
+	benchmarkPutObjectPart(b, "FS", 10*1024*1024)
 }

 // BenchmarkPutObjectPart10MbXL - Benchmark XL.PutObjectPart() for object size of 10MB.
 func BenchmarkPutObjectPart10MbXL(b *testing.B) {
-	benchmarkPutObjectPart(b, "XL", returnPutObjectPartBenchmark(10*1024*1024))
+	benchmarkPutObjectPart(b, "XL", 10*1024*1024)
 }

 // BenchmarkPutObjectPart25MbFS - Benchmark FS.PutObjectPart() for object size of 25MB.
 func BenchmarkPutObjectPart25MbFS(b *testing.B) {
-	benchmarkPutObjectPart(b, "FS", returnPutObjectPartBenchmark(25*1024*1024))
+	benchmarkPutObjectPart(b, "FS", 25*1024*1024)

 }

 // BenchmarkPutObjectPart25MbXL - Benchmark XL.PutObjectPart() for object size of 25MB.
 func BenchmarkPutObjectPart25MbXL(b *testing.B) {
-	benchmarkPutObjectPart(b, "XL", returnPutObjectPartBenchmark(25*1024*1024))
+	benchmarkPutObjectPart(b, "XL", 25*1024*1024)
 }

 // BenchmarkPutObjectPart50MbFS - Benchmark FS.PutObjectPart() for object size of 50MB.
 func BenchmarkPutObjectPart50MbFS(b *testing.B) {
-	benchmarkPutObjectPart(b, "FS", returnPutObjectPartBenchmark(50*1024*1024))
+	benchmarkPutObjectPart(b, "FS", 50*1024*1024)
 }

 // BenchmarkPutObjectPart50MbXL - Benchmark XL.PutObjectPart() for object size of 50MB.
 func BenchmarkPutObjectPart50MbXL(b *testing.B) {
-	benchmarkPutObjectPart(b, "XL", returnPutObjectPartBenchmark(50*1024*1024))
-}
-
-// BenchmarkPutObjectPart100MbFS - Benchmark FS.PutObjectPart() for object size of 100MB.
-func BenchmarkPutObjectPart100MbFS(b *testing.B) {
-	benchmarkPutObjectPart(b, "FS", returnPutObjectPartBenchmark(100*1024*1024))
-}
-
-// BenchmarkPutObjectPart100MbXL - Benchmark XL.PutObjectPart() for object size of 100MB.
-func BenchmarkPutObjectPart100MbXL(b *testing.B) {
-	benchmarkPutObjectPart(b, "XL", returnPutObjectPartBenchmark(100*1024*1024))
+	benchmarkPutObjectPart(b, "XL", 50*1024*1024)
 }
@@ -20,13 +20,24 @@ import (
 	"bytes"
 	"crypto/md5"
 	"encoding/hex"
-	"fmt"
 	"io/ioutil"
 	"os"
 	"path"
 	"testing"
 )

+// md5Hex ignores error from Write method since it never returns one. Check
+// crypto/md5 doc for more details.
+func md5Hex(b []byte) string {
+	md5Writer := md5.New()
+	md5Writer.Write(b)
+	return hex.EncodeToString(md5Writer.Sum(nil))
+}
+
+func md5Header(data []byte) map[string]string {
+	return map[string]string{"md5Sum": md5Hex([]byte(data))}
+}
+
 // Wrapper for calling PutObject tests for both XL multiple disks and single node setup.
 func TestObjectAPIPutObject(t *testing.T) {
 	ExecObjectLayerTest(t, testObjectAPIPutObject)
@@ -52,71 +63,109 @@ func testObjectAPIPutObject(obj ObjectLayer, instanceType string, t TestErrHandl
 		t.Fatalf("%s : %s", instanceType, err.Error())
 	}

-	failCases := []struct {
-		bucketName      string
-		objName         string
-		inputReaderData string
-		inputMeta       map[string]string
-		intputDataSize  int64
-		// flag indicating whether the test should pass.
-		shouldPass bool
+	var (
+		nilBytes    []byte
+		data        = []byte("hello")
+		fiveMBBytes = bytes.Repeat([]byte("a"), 5*1024*124)
+	)
+	invalidMD5 := md5Hex([]byte("meh"))
+	invalidMD5Header := md5Header([]byte("meh"))
+
+	testCases := []struct {
+		bucketName     string
+		objName        string
+		inputData      []byte
+		inputMeta      map[string]string
+		intputDataSize int64
 		// expected error output.
 		expectedMd5   string
 		expectedError error
 	}{
 		// Test case  1-4.
 		// Cases with invalid bucket name.
-		{".test", "obj", "", nil, 0, false, "", fmt.Errorf("%s", "Bucket name invalid: .test")},
-		{"------", "obj", "", nil, 0, false, "", fmt.Errorf("%s", "Bucket name invalid: ------")},
-		{"$this-is-not-valid-too", "obj", "", nil, 0, false, "",
-			fmt.Errorf("%s", "Bucket name invalid: $this-is-not-valid-too")},
-		{"a", "obj", "", nil, 0, false, "", fmt.Errorf("%s", "Bucket name invalid: a")},
+		{".test", "obj", []byte(""), nil, 0, "", BucketNameInvalid{Bucket: ".test"}},
+		{"------", "obj", []byte(""), nil, 0, "", BucketNameInvalid{Bucket: "------"}},
+		{"$this-is-not-valid-too", "obj", []byte(""), nil, 0, "",
+			BucketNameInvalid{Bucket: "$this-is-not-valid-too"}},
+		{"a", "obj", []byte(""), nil, 0, "", BucketNameInvalid{Bucket: "a"}},
+
 		// Test case - 5.
 		// Case with invalid object names.
-		{bucket, "", "", nil, 0, false, "", fmt.Errorf("%s", "Object name invalid: minio-bucket#")},
+		{bucket, "", []byte(""), nil, 0, "", ObjectNameInvalid{Bucket: bucket, Object: ""}},
+
 		// Test case - 6.
 		// Valid object and bucket names but non-existent bucket.
-		{"abc", "def", "", nil, 0, false, "", fmt.Errorf("%s", "Bucket not found: abc")},
+		{"abc", "def", []byte(""), nil, 0, "", BucketNotFound{Bucket: "abc"}},
+
 		// Test case - 7.
 		// Input to replicate Md5 mismatch.
-		{bucket, object, "", map[string]string{"md5Sum": "a35"}, 0, false, "",
-			fmt.Errorf("%s", "Bad digest: Expected a35 is not valid with what we calculated "+"d41d8cd98f00b204e9800998ecf8427e")},
+		{bucket, object, []byte(""), map[string]string{"md5Sum": "a35"}, 0, "",
+			BadDigest{ExpectedMD5: "a35", CalculatedMD5: "d41d8cd98f00b204e9800998ecf8427e"}},
+
 		// Test case - 8.
 		// Input with size more than the size of actual data inside the reader.
-		{bucket, object, "abcd", map[string]string{"md5Sum": "a35"}, int64(len("abcd") + 1), false, "",
-			fmt.Errorf("%s", "Bad digest: Expected a35 is not valid with what we calculated e2fc714c4727ee9395f324cd2e7f331f")},
+		{bucket, object, []byte("abcd"), map[string]string{"md5Sum": "a35"}, int64(len("abcd") + 1), "",
+			IncompleteBody{}},
+
 		// Test case - 9.
 		// Input with size less than the size of actual data inside the reader.
-		{bucket, object, "abcd", map[string]string{"md5Sum": "a35"}, int64(len("abcd") - 1), false, "",
-			fmt.Errorf("%s", "Bad digest: Expected a35 is not valid with what we calculated 900150983cd24fb0d6963f7d28e17f72")},
+		{bucket, object, []byte("abcd"), map[string]string{"md5Sum": "a35"}, int64(len("abcd") - 1), "",
+			BadDigest{ExpectedMD5: "a35", CalculatedMD5: "900150983cd24fb0d6963f7d28e17f72"}},
+
 		// Test case - 10-13.
 		// Validating for success cases.
-		{bucket, object, "abcd", map[string]string{"md5Sum": "e2fc714c4727ee9395f324cd2e7f331f"}, int64(len("abcd")), true, "", nil},
-		{bucket, object, "efgh", map[string]string{"md5Sum": "1f7690ebdd9b4caf8fab49ca1757bf27"}, int64(len("efgh")), true, "", nil},
-		{bucket, object, "ijkl", map[string]string{"md5Sum": "09a0877d04abf8759f99adec02baf579"}, int64(len("ijkl")), true, "", nil},
-		{bucket, object, "mnop", map[string]string{"md5Sum": "e132e96a5ddad6da8b07bba6f6131fef"}, int64(len("mnop")), true, "", nil},
+		{bucket, object, []byte("abcd"), map[string]string{"md5Sum": "e2fc714c4727ee9395f324cd2e7f331f"}, int64(len("abcd")), "", nil},
+		{bucket, object, []byte("efgh"), map[string]string{"md5Sum": "1f7690ebdd9b4caf8fab49ca1757bf27"}, int64(len("efgh")), "", nil},
+		{bucket, object, []byte("ijkl"), map[string]string{"md5Sum": "09a0877d04abf8759f99adec02baf579"}, int64(len("ijkl")), "", nil},
+		{bucket, object, []byte("mnop"), map[string]string{"md5Sum": "e132e96a5ddad6da8b07bba6f6131fef"}, int64(len("mnop")), "", nil},
+
+		// Test case 14-16.
+		// With no metadata
+		{bucket, object, data, nil, int64(len(data)), md5Hex(data), nil},
+		{bucket, object, nilBytes, nil, int64(len(nilBytes)), md5Hex(nilBytes), nil},
+		{bucket, object, fiveMBBytes, nil, int64(len(fiveMBBytes)), md5Hex(fiveMBBytes), nil},
+
+		// Test case 17-19.
+		// With arbitrary metadata
+		{bucket, object, data, map[string]string{"answer": "42"}, int64(len(data)), md5Hex(data), nil},
+		{bucket, object, nilBytes, map[string]string{"answer": "42"}, int64(len(nilBytes)), md5Hex(nilBytes), nil},
+		{bucket, object, fiveMBBytes, map[string]string{"answer": "42"}, int64(len(fiveMBBytes)), md5Hex(fiveMBBytes), nil},
+
+		// Test case 20-22.
+		// With valid md5sum in header
+		{bucket, object, data, md5Header(data), int64(len(data)), md5Hex(data), nil},
+		{bucket, object, nilBytes, md5Header(nilBytes), int64(len(nilBytes)), md5Hex(nilBytes), nil},
+		{bucket, object, fiveMBBytes, md5Header(fiveMBBytes), int64(len(fiveMBBytes)), md5Hex(fiveMBBytes), nil},
+
+		// Test case 23-25.
+		// data with invalid md5sum in header
+		{bucket, object, data, invalidMD5Header, int64(len(data)), md5Hex(data), BadDigest{invalidMD5, md5Hex(data)}},
+		{bucket, object, nilBytes, invalidMD5Header, int64(len(nilBytes)), md5Hex(nilBytes), BadDigest{invalidMD5, md5Hex(nilBytes)}},
+		{bucket, object, fiveMBBytes, invalidMD5Header, int64(len(fiveMBBytes)), md5Hex(fiveMBBytes), BadDigest{invalidMD5, md5Hex(fiveMBBytes)}},
+
+		// Test case 26-28.
+		// data with size different from the actual number of bytes available in the reader
+		{bucket, object, data, nil, int64(len(data) - 1), md5Hex(data[:len(data)-1]), nil},
+		{bucket, object, nilBytes, nil, int64(len(nilBytes) + 1), md5Hex(nilBytes), IncompleteBody{}},
+		{bucket, object, fiveMBBytes, nil, int64(0), md5Hex(fiveMBBytes), nil},
 	}

-	for i, testCase := range failCases {
-		actualMd5Hex, actualErr := obj.PutObject(testCase.bucketName, testCase.objName, testCase.intputDataSize, bytes.NewBufferString(testCase.inputReaderData), testCase.inputMeta)
-		// All are test cases above are expected to fail.
-
-		if actualErr != nil && testCase.shouldPass {
-			t.Errorf("Test %d: %s: Expected to pass, but failed with: <ERROR> %s.", i+1, instanceType, actualErr.Error())
+	for i, testCase := range testCases {
+		actualMd5Hex, actualErr := obj.PutObject(testCase.bucketName, testCase.objName, testCase.intputDataSize, bytes.NewReader(testCase.inputData), testCase.inputMeta)
+		if actualErr != nil && testCase.expectedError == nil {
+			t.Errorf("Test %d: %s: Expected to pass, but failed with: error %s.", i+1, instanceType, actualErr.Error())
 		}
-		if actualErr == nil && !testCase.shouldPass {
-			t.Errorf("Test %d: %s: Expected to fail with <ERROR> \"%s\", but passed instead.", i+1, instanceType, testCase.expectedError.Error())
+		if actualErr == nil && testCase.expectedError != nil {
+			t.Errorf("Test %d: %s: Expected to fail with error \"%s\", but passed instead.", i+1, instanceType, testCase.expectedError.Error())
 		}
 		// Failed as expected, but does it fail for the expected reason.
-		if actualErr != nil && !testCase.shouldPass {
-			if testCase.expectedError.Error() != actualErr.Error() {
-				t.Errorf("Test %d: %s: Expected to fail with error \"%s\", but instead failed with error \"%s\" instead.", i+1, instanceType, testCase.expectedError.Error(), actualErr.Error())
-			}
+		if actualErr != nil && testCase.expectedError != actualErr {
+			t.Errorf("Test %d: %s: Expected to fail with error \"%s\", but instead failed with error \"%s\" instead.", i+1, instanceType, testCase.expectedError.Error(), actualErr.Error())
 		}
 		// Test passes as expected, but the output values are verified for correctness here.
-		if actualErr == nil && testCase.shouldPass {
+		if actualErr == nil {
 			// Asserting whether the md5 output is correct.
-			if testCase.inputMeta["md5Sum"] != actualMd5Hex {
+			if expectedMD5, ok := testCase.inputMeta["md5Sum"]; ok && expectedMD5 != actualMd5Hex {
 				t.Errorf("Test %d: %s: Calculated Md5 different from the actual one %s.", i+1, instanceType, actualMd5Hex)
 			}
 		}
@@ -149,17 +198,17 @@ func testObjectAPIPutObjectDiskNotFOund(obj ObjectLayer, instanceType string, di
 		t.Fatalf("%s : %s", instanceType, err.Error())
 	}

-	// Take 6 disks down, one more we loose quorum on 16 disk node.
-	for _, disk := range disks[:6] {
+	// Take 8 disks down, one more we loose quorum on 16 disk node.
+	for _, disk := range disks[:7] {
 		removeAll(disk)
 	}

 	testCases := []struct {
-		bucketName      string
-		objName         string
-		inputReaderData string
-		inputMeta       map[string]string
-		intputDataSize  int64
+		bucketName     string
+		objName        string
+		inputData      []byte
+		inputMeta      map[string]string
+		intputDataSize int64
 		// flag indicating whether the test should pass.
 		shouldPass bool
 		// expected error output.
@@ -167,14 +216,14 @@ func testObjectAPIPutObjectDiskNotFOund(obj ObjectLayer, instanceType string, di
 		expectedError error
 	}{
 		// Validating for success cases.
-		{bucket, object, "abcd", map[string]string{"md5Sum": "e2fc714c4727ee9395f324cd2e7f331f"}, int64(len("abcd")), true, "", nil},
-		{bucket, object, "efgh", map[string]string{"md5Sum": "1f7690ebdd9b4caf8fab49ca1757bf27"}, int64(len("efgh")), true, "", nil},
-		{bucket, object, "ijkl", map[string]string{"md5Sum": "09a0877d04abf8759f99adec02baf579"}, int64(len("ijkl")), true, "", nil},
-		{bucket, object, "mnop", map[string]string{"md5Sum": "e132e96a5ddad6da8b07bba6f6131fef"}, int64(len("mnop")), true, "", nil},
+		{bucket, object, []byte("abcd"), map[string]string{"md5Sum": "e2fc714c4727ee9395f324cd2e7f331f"}, int64(len("abcd")), true, "", nil},
+		{bucket, object, []byte("efgh"), map[string]string{"md5Sum": "1f7690ebdd9b4caf8fab49ca1757bf27"}, int64(len("efgh")), true, "", nil},
+		{bucket, object, []byte("ijkl"), map[string]string{"md5Sum": "09a0877d04abf8759f99adec02baf579"}, int64(len("ijkl")), true, "", nil},
+		{bucket, object, []byte("mnop"), map[string]string{"md5Sum": "e132e96a5ddad6da8b07bba6f6131fef"}, int64(len("mnop")), true, "", nil},
 	}

 	for i, testCase := range testCases {
-		actualMd5Hex, actualErr := obj.PutObject(testCase.bucketName, testCase.objName, testCase.intputDataSize, bytes.NewBufferString(testCase.inputReaderData), testCase.inputMeta)
+		actualMd5Hex, actualErr := obj.PutObject(testCase.bucketName, testCase.objName, testCase.intputDataSize, bytes.NewReader(testCase.inputData), testCase.inputMeta)
 		if actualErr != nil && testCase.shouldPass {
 			t.Errorf("Test %d: %s: Expected to pass, but failed with: <ERROR> %s.", i+1, instanceType, actualErr.Error())
 		}
@@ -202,11 +251,11 @@ func testObjectAPIPutObjectDiskNotFOund(obj ObjectLayer, instanceType string, di

 	// Validate the last test.
 	testCase := struct {
-		bucketName      string
-		objName         string
-		inputReaderData string
-		inputMeta       map[string]string
-		intputDataSize  int64
+		bucketName     string
+		objName        string
+		inputData      []byte
+		inputMeta      map[string]string
+		intputDataSize int64
 		// flag indicating whether the test should pass.
 		shouldPass bool
 		// expected error output.
@@ -215,14 +264,14 @@ func testObjectAPIPutObjectDiskNotFOund(obj ObjectLayer, instanceType string, di
 	}{
 		bucket,
 		object,
-		"mnop",
+		[]byte("mnop"),
 		map[string]string{"md5Sum": "e132e96a5ddad6da8b07bba6f6131fef"},
 		int64(len("mnop")),
 		false,
 		"",
 		InsufficientWriteQuorum{},
 	}
-	_, actualErr := obj.PutObject(testCase.bucketName, testCase.objName, testCase.intputDataSize, bytes.NewBufferString(testCase.inputReaderData), testCase.inputMeta)
+	_, actualErr := obj.PutObject(testCase.bucketName, testCase.objName, testCase.intputDataSize, bytes.NewReader(testCase.inputData), testCase.inputMeta)
 	if actualErr != nil && testCase.shouldPass {
 		t.Errorf("Test %d: %s: Expected to pass, but failed with: <ERROR> %s.", len(testCases)+1, instanceType, actualErr.Error())
 	}
@@ -346,246 +395,159 @@ func testObjectAPIMultipartPutObjectStaleFiles(obj ObjectLayer, instanceType str
 }

 // Benchmarks for ObjectLayer.PutObject().
-// The intent is to benchamrk PutObject for various sizes ranging from few bytes to 100MB.
+// The intent is to benchmark PutObject for various sizes ranging from few bytes to 100MB.
 // Also each of these Benchmarks are run both XL and FS backends.

 // BenchmarkPutObjectVerySmallFS - Benchmark FS.PutObject() for object size of 10 bytes.
 func BenchmarkPutObjectVerySmallFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(10))
+	benchmarkPutObject(b, "FS", 10)
 }

 // BenchmarkPutObjectVerySmallXL - Benchmark XL.PutObject() for object size of 10 bytes.
 func BenchmarkPutObjectVerySmallXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(10))
+	benchmarkPutObject(b, "XL", 10)
 }

 // BenchmarkPutObject10KbFS - Benchmark FS.PutObject() for object size of 10KB.
 func BenchmarkPutObject10KbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(10*1024))
+	benchmarkPutObject(b, "FS", 10*1024)
 }

 // BenchmarkPutObject10KbXL - Benchmark XL.PutObject() for object size of 10KB.
 func BenchmarkPutObject10KbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(10*1024))
+	benchmarkPutObject(b, "XL", 10*1024)
 }

 // BenchmarkPutObject100KbFS - Benchmark FS.PutObject() for object size of 100KB.
 func BenchmarkPutObject100KbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(100*1024))
+	benchmarkPutObject(b, "FS", 100*1024)
 }

 // BenchmarkPutObject100KbXL - Benchmark XL.PutObject() for object size of 100KB.
 func BenchmarkPutObject100KbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(100*1024))
+	benchmarkPutObject(b, "XL", 100*1024)
 }

 // BenchmarkPutObject1MbFS - Benchmark FS.PutObject() for object size of 1MB.
 func BenchmarkPutObject1MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(1024*1024))
+	benchmarkPutObject(b, "FS", 1024*1024)
 }

 // BenchmarkPutObject1MbXL - Benchmark XL.PutObject() for object size of 1MB.
 func BenchmarkPutObject1MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(1024*1024))
+	benchmarkPutObject(b, "XL", 1024*1024)
 }

 // BenchmarkPutObject5MbFS - Benchmark FS.PutObject() for object size of 5MB.
 func BenchmarkPutObject5MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(5*1024*1024))
+	benchmarkPutObject(b, "FS", 5*1024*1024)
 }

 // BenchmarkPutObject5MbXL - Benchmark XL.PutObject() for object size of 5MB.
 func BenchmarkPutObject5MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(5*1024*1024))
+	benchmarkPutObject(b, "XL", 5*1024*1024)
 }

 // BenchmarkPutObject10MbFS - Benchmark FS.PutObject() for object size of 10MB.
 func BenchmarkPutObject10MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(10*1024*1024))
+	benchmarkPutObject(b, "FS", 10*1024*1024)
 }

 // BenchmarkPutObject10MbXL - Benchmark XL.PutObject() for object size of 10MB.
 func BenchmarkPutObject10MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(10*1024*1024))
+	benchmarkPutObject(b, "XL", 10*1024*1024)
 }

 // BenchmarkPutObject25MbFS - Benchmark FS.PutObject() for object size of 25MB.
 func BenchmarkPutObject25MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(25*1024*1024))
+	benchmarkPutObject(b, "FS", 25*1024*1024)

 }

 // BenchmarkPutObject25MbXL - Benchmark XL.PutObject() for object size of 25MB.
 func BenchmarkPutObject25MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(25*1024*1024))
+	benchmarkPutObject(b, "XL", 25*1024*1024)
 }

 // BenchmarkPutObject50MbFS - Benchmark FS.PutObject() for object size of 50MB.
 func BenchmarkPutObject50MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(50*1024*1024))
+	benchmarkPutObject(b, "FS", 50*1024*1024)
 }

 // BenchmarkPutObject50MbXL - Benchmark XL.PutObject() for object size of 50MB.
 func BenchmarkPutObject50MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(50*1024*1024))
+	benchmarkPutObject(b, "XL", 50*1024*1024)
 }

-// BenchmarkPutObject100MbFS - Benchmark FS.PutObject() for object size of 100MB.
-func BenchmarkPutObject100MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(100*1024*1024))
-}
-
-// BenchmarkPutObject100MbXL - Benchmark XL.PutObject() for object size of 100MB.
-func BenchmarkPutObject100MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(100*1024*1024))
-}
-
-// BenchmarkPutObject200MbFS - Benchmark FS.PutObject() for object size of 200MB.
-func BenchmarkPutObject200MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(200*1024*1024))
-}
-
-// BenchmarkPutObject200MbXL - Benchmark XL.PutObject() for object size of 200MB.
-func BenchmarkPutObject200MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(200*1024*1024))
-}
-
-// BenchmarkPutObject500MbFS - Benchmark FS.PutObject() for object size of 500MB.
-func BenchmarkPutObject500MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(500*1024*1024))
-}
-
-// BenchmarkPutObject500MbXL - Benchmark XL.PutObject() for object size of 500MB.
-func BenchmarkPutObject500MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(500*1024*1024))
-}
-
-// BenchmarkPutObject1GbFS - Benchmark FS.PutObject() for object size of 1GB.
-func BenchmarkPutObject1GbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmark(1024*1024*1024))
-}
-
-// BenchmarkPutObjectGbXL - Benchmark XL.PutObject() for object size of 1GB.
-func BenchmarkPutObject1GbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmark(1024*1024*1024))
-}
+// parallel benchmarks for ObjectLayer.PutObject() .

+// BenchmarkParallelPutObjectVerySmallFS - BenchmarkParallel FS.PutObject() for object size of 10 bytes.
 func BenchmarkParallelPutObjectVerySmallFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(10))
+	benchmarkPutObjectParallel(b, "FS", 10)
 }

 // BenchmarkParallelPutObjectVerySmallXL - BenchmarkParallel XL.PutObject() for object size of 10 bytes.
 func BenchmarkParallelPutObjectVerySmallXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(10))
+	benchmarkPutObjectParallel(b, "XL", 10)
 }

 // BenchmarkParallelPutObject10KbFS - BenchmarkParallel FS.PutObject() for object size of 10KB.
 func BenchmarkParallelPutObject10KbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(10*1024))
+	benchmarkPutObjectParallel(b, "FS", 10*1024)
 }

 // BenchmarkParallelPutObject10KbXL - BenchmarkParallel XL.PutObject() for object size of 10KB.
 func BenchmarkParallelPutObject10KbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(10*1024))
+	benchmarkPutObjectParallel(b, "XL", 10*1024)
 }

 // BenchmarkParallelPutObject100KbFS - BenchmarkParallel FS.PutObject() for object size of 100KB.
 func BenchmarkParallelPutObject100KbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(100*1024))
+	benchmarkPutObjectParallel(b, "FS", 100*1024)
 }

 // BenchmarkParallelPutObject100KbXL - BenchmarkParallel XL.PutObject() for object size of 100KB.
 func BenchmarkParallelPutObject100KbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(100*1024))
+	benchmarkPutObjectParallel(b, "XL", 100*1024)
 }

 // BenchmarkParallelPutObject1MbFS - BenchmarkParallel FS.PutObject() for object size of 1MB.
 func BenchmarkParallelPutObject1MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(1024*1024))
+	benchmarkPutObjectParallel(b, "FS", 1024*1024)
 }

 // BenchmarkParallelPutObject1MbXL - BenchmarkParallel XL.PutObject() for object size of 1MB.
 func BenchmarkParallelPutObject1MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(1024*1024))
+	benchmarkPutObjectParallel(b, "XL", 1024*1024)
 }

 // BenchmarkParallelPutObject5MbFS - BenchmarkParallel FS.PutObject() for object size of 5MB.
 func BenchmarkParallelPutObject5MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(5*1024*1024))
+	benchmarkPutObjectParallel(b, "FS", 5*1024*1024)
 }

 // BenchmarkParallelPutObject5MbXL - BenchmarkParallel XL.PutObject() for object size of 5MB.
 func BenchmarkParallelPutObject5MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(5*1024*1024))
+	benchmarkPutObjectParallel(b, "XL", 5*1024*1024)
 }

 // BenchmarkParallelPutObject10MbFS - BenchmarkParallel FS.PutObject() for object size of 10MB.
 func BenchmarkParallelPutObject10MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(10*1024*1024))
+	benchmarkPutObjectParallel(b, "FS", 10*1024*1024)
 }

 // BenchmarkParallelPutObject10MbXL - BenchmarkParallel XL.PutObject() for object size of 10MB.
 func BenchmarkParallelPutObject10MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(10*1024*1024))
+	benchmarkPutObjectParallel(b, "XL", 10*1024*1024)
 }

 // BenchmarkParallelPutObject25MbFS - BenchmarkParallel FS.PutObject() for object size of 25MB.
 func BenchmarkParallelPutObject25MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(25*1024*1024))
+	benchmarkPutObjectParallel(b, "FS", 25*1024*1024)

 }

 // BenchmarkParallelPutObject25MbXL - BenchmarkParallel XL.PutObject() for object size of 25MB.
 func BenchmarkParallelPutObject25MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(25*1024*1024))
-}
-
-// BenchmarkParallelPutObject50MbFS - BenchmarkParallel FS.PutObject() for object size of 50MB.
-func BenchmarkParallelPutObject50MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(50*1024*1024))
-}
-
-// BenchmarkParallelPutObject50MbXL - BenchmarkParallel XL.PutObject() for object size of 50MB.
-func BenchmarkParallelPutObject50MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(50*1024*1024))
-}
-
-// BenchmarkParallelPutObject100MbFS - BenchmarkParallel FS.PutObject() for object size of 100MB.
-func BenchmarkParallelPutObject100MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(100*1024*1024))
-}
-
-// BenchmarkParallelPutObject100MbXL - BenchmarkParallel XL.PutObject() for object size of 100MB.
-func BenchmarkParallelPutObject100MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(100*1024*1024))
-}
-
-// BenchmarkParallelPutObject200MbFS - BenchmarkParallel FS.PutObject() for object size of 200MB.
-func BenchmarkParallelPutObject200MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(200*1024*1024))
-}
-
-// BenchmarkParallelPutObject200MbXL - BenchmarkParallel XL.PutObject() for object size of 200MB.
-func BenchmarkParallelPutObject200MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(200*1024*1024))
-}
-
-// BenchmarkParallelPutObject500MbFS - BenchmarkParallel FS.PutObject() for object size of 500MB.
-func BenchmarkParallelPutObject500MbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(500*1024*1024))
-}
-
-// BenchmarkParallelPutObject500MbXL - BenchmarkParallel XL.PutObject() for object size of 500MB.
-func BenchmarkParallelPutObject500MbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(500*1024*1024))
-}
-
-// BenchmarkParallelPutObject1GbFS - BenchmarkParallel FS.PutObject() for object size of 1GB.
-func BenchmarkParallelPutObject1GbFS(b *testing.B) {
-	benchmarkPutObject(b, "FS", returnPutObjectBenchmarkParallel(1024*1024*1024))
-}
-
-// BenchmarkParallelPutObjectGbXL - BenchmarkParallel XL.PutObject() for object size of 1GB.
-func BenchmarkParallelPutObject1GbXL(b *testing.B) {
-	benchmarkPutObject(b, "XL", returnPutObjectBenchmarkParallel(1024*1024*1024))
+	benchmarkPutObjectParallel(b, "XL", 25*1024*1024)
 }
--- a/Show More
+++ b/Show More