chore: update repository cards 2026-10-04

Signed-off-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.github/ISSUE_TEMPLATE.md

@@ -1,13 +0,0 @@
-## Expected behaviour
-
-## Actual behaviour
-
-## Steps to reproduce the behaviour
-
-## Minio version
-- (paste output of `minio version`)
-
-## System information
-
-
-

.gitignore

@@ -1,17 +0,0 @@
-**/*.swp
-cover.out
-*~
-minio
-!*/
-site/
-**/*.test
-**/*.sublime-workspace
-/.idea/
-/Minio.iml
-**/access.log
-build
-vendor/**/*.js
-vendor/**/*.json
-release
-.DS_Store
-*.syso

.mailmap

@@ -1,18 +0,0 @@
-# Generate CONTRIBUTORS.md: contributors.sh
-
-# Tip for finding duplicates (besides scanning the output of CONTRIBUTORS.md for name
-# duplicates that aren't also email duplicates): scan the output of:
-#   git log --format='%aE - %aN' | sort -uf
-#
-# For explanation on this file format: man git-shortlog
-
-Anand Babu (AB) Periasamy <ab@minio.io> Anand Babu (AB) Periasamy <abperiasamy@users.noreply.github.com>
-Anand Babu (AB) Periasamy <ab@minio.io> <ab@unlocksmith.org>
-Anis Elleuch <vadmeste@gmail.com>
-Frederick F. Kautz IV <fkautz@minio.io> <fkautz@alumni.cmu.edu>
-Harshavardhana <harsha@minio.io> <harsha@harshavardhana.net>
-Harshavardhana <harsha@minio.io> <badger@gitter.im>
-Harshavardhana <harsha@minio.io>
-Krishna Srinivas <krishna@minio.io> <krishna.srinivas@gmail.com>
-Matthew Farrellee <matt@cs.wisc.edu>
-Nate Rosenblum <flander@gmail.com>

.mention-bot

@@ -1,4 +0,0 @@
-{
-    "numFilesToCheck": 10,
-    "requiredOrgs": ["minio"]
-}

.travis.yml

@@ -1,25 +0,0 @@
-sudo: required
-dist: trusty
-language: go
-
-os:
-- linux
-# Enable OSX builds when travis service is back.
-#- osx
-
-#osx_image: xcode7.2
-
-env:
-- ARCH=x86_64
-- ARCH=i686
-
-script:
-- make test
-- make test GOFLAGS="-race"
-
-go:
-- 1.6
-
-notifications:
-  slack:
-    secure: K9tsn5MvrCAxuEZTxn+m3Kq1K2NG2xMEJFSv/sTp+RQBW7TslPHzv859GsIvrm8mU1y1btOU9RlOzqrRUczI5cJpE8IL1oljPZbXrIXgetE0kbsw0Wpy99g27UQ2VGp933WDu8tfj7zU4cZv+BI0RltNLwqYO6GWXmcWP0IueCU=

AWS-SDK-GO.md

@@ -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"
-  }
-}
-```

CONTRIBUTING.md

@@ -1,71 +0,0 @@
-### Install Golang
-
-If you do not have a working Golang environment setup please follow [Golang Installation Guide](./INSTALLGO.md).
-
-### Setup your Minio Github Repository
-Fork [Minio upstream](https://github.com/minio/minio/fork) source repository to your own personal repository. Copy the URL for minio from your personal github repo (you will need it for the `git clone` command below).
-```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
-```
-
-### Compiling Minio from source
-Minio uses ``Makefile`` to wrap around some of redundant checks done through command line.
-
-```sh
-$ make
-Checking if proper environment variables are set.. Done
-...
-Checking dependencies for Minio.. Done
-Installed govet
-Building Libraries
-...
-...
-```
-
-### Setting up git remote as ``upstream``
-```sh
-$ cd $GOPATH/src/github.com/minio/minio
-$ git remote add upstream https://github.com/minio/minio
-$ git fetch upstream
-$ git merge upstream/master
-...
-...
-$ make
-Checking if proper environment variables are set.. Done
-...
-Checking dependencies for Minio.. Done
-Installed govet
-Building Libraries
-...
-```
-
-###  Developer Guidelines
-``Minio`` community welcomes your contribution. To make the process as seamless as possible, we ask for the following:
-* Go ahead and fork the project and make your changes. We encourage pull requests to discuss code changes.
-    - Fork it
-    - Create your feature branch (git checkout -b my-new-feature)
-    - Commit your changes (git commit -am 'Add some feature')
-    - 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)
-    - Run `go get foo/bar`
-    - Edit your code to import foo/bar
-    - Run `make pkg-add PKG=foo/bar` from top-level directory
-
-* If you have dependencies for ``Minio`` which needs to be removed
-    - Edit your code to not import foo/bar
-    - Run `make pkg-remove PKG=foo/bar` from top-level directory
-
-* When you're ready to create a pull request, be sure to:
-    - Have test cases for the new code. If you have questions about how to do it, please ask in your pull request.
-    - Run `make verifiers`
-    - Squash your commits into a single commit. `git rebase -i`. It's okay to force update your pull request.
-    - Make sure `go test -race ./...` and `go build` completes.
-
-* Read [Effective Go](https://github.com/golang/go/wiki/CodeReviewComments) article from Golang project
-    - `Minio` project is fully conformant with Golang style
-    - if you happen to observe offending code, please feel free to send a pull request

Caddy.md

@@ -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
-```

Docker.md

@@ -1,28 +0,0 @@
-### Run Minio docker image
-
-## 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
-docker run -p 9000:9000 minio/minio /export
-```
-
-## 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
-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
-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
-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
-```

Dockerfile

@@ -1,15 +0,0 @@
-FROM golang:1.6
-
-RUN mkdir -p /go/src/app
-WORKDIR /go/src/app
-
-COPY . /go/src/app
-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/
-
-EXPOSE 9000
-ENTRYPOINT ["go-wrapper", "run", "server"]
-CMD ["/export"]

FreeBSD.md

@@ -1,156 +0,0 @@
-### Minio with ZFS backend - FreeBSD
-
-This example assumes that you have a FreeBSD 10.x running
-
-#### Step *1* 
-
-As root on the FreeBSD edit `/etc/rc.conf`
-```
-zfs_enable="YES"
-```
-
-Start ZFS service
-```
-# service zfs start
-```
-
-```
-# dd if=/dev/zero of=/zfs bs=1M count=4000
-```
-
-Configure a loopback device on the `/zfs` file. 
-```
-# mdconfig -a -t vnode -f /zfs
-```
-
-Create zfs pool
-```
-# zpool create minio-example /dev/md0
-```
-
-```
-# df /minio-example
-Filesystem    512-blocks Used   Avail Capacity  Mounted on
-minio-example    7872440   38 7872402     0%    /minio-example
-```
-
-Verify if it is writable
-```
-# 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)
-
-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.
-
-
-```
-# zfs create minio-example/compressed-objects
-# zfs set compression=lz4 minio-example/compressed-objects
-```
-
-To keep monitoring your pool use
-
-```
-# zpool status
-  pool: minio-example
- state: ONLINE
-  scan: none requested
-config:
-
-	NAME        STATE     READ WRITE CKSUM
-	minio-example  ONLINE       0     0     0
-	  md0       ONLINE       0     0     0
-
-errors: No known data errors
-```
-
-#### 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
-
-```
-# chown -R minio-user:minio-user /minio-example/compressed-objects
-```
-
-Now login as ``minio-user`` and start minio server. 
-
-```
-$ 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
-
-Minio Browser:
-    http://159.203.234.49:9000
-    http://10.12.0.5:9000
-    http://127.0.0.1:9000
-
-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. 
-
-Now you have a S3 compatible server running on top of your ZFS backend which transparently provides disk level compression for your uploaded objects.
-
-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:
-
-```
-$ sudo pkg install go gmake
-Updating FreeBSD repository catalogue..
-FreeBSD repository is up-to-date.
-All repositories are up-to-date.
-The following 1 package(s) will be affected (of 0 checked):
-
-New packages to be INSTALLED:
-        go: 1.6.2,1
-        gmake: 4.1_2
-
-        The process will require 261 MiB more space.
-        40 MiB to be downloaded.
-
-        Proceed with this action? [y/N]: y
-        Fetching go-1.6.2,1.txz: 100%   40 MiB  10.4MB/s    00:04
-        Fetching gmake-4.1_2.txz: 100%  363 KiB 372.2kB/s    00:01
-        Checking integrity... done (0 conflicting)
-        [1/2] Installing go-1.6.2,1...
-        [1/2] Extracting go-1.6.2,1: 100%
-        [2/2] Installing gmake-4.1_2...
-        [2/2] Extracting gmake-4.1_2: 100%
-```
-
-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:
-
-```
-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:
-
-```
-$ 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.

INSTALLGO.md

@@ -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
-```

LICENSE

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.

MAINTAINERS.md

@@ -1,37 +0,0 @@
-# For maintainers only
-
-### Setup your minio Github Repository
-
-Fork [minio upstream](https://github.com/minio/minio/fork) source repository to your own personal repository.
-```bash
-$ mkdir -p $GOPATH/src/github.com/minio
-$ cd $GOPATH/src/github.com/minio
-$ git clone https://github.com/$USER_ID/minio
-$ 
-```
-
-``minio`` uses [govendor](https://github.com/kardianos/govendor) for its dependency management.
-
-### To manage dependencies
-
-#### Add new dependencies
-
-  - Run `go get foo/bar`
-  - Edit your code to import foo/bar
-  - Run `govendor add foo/bar` from top-level folder
-
-#### Remove dependencies 
-
-  - Run `govendor remove foo/bar`
-
-#### Update dependencies
-
-  - Run `govendor remove +vendor`
-  - Run to update the dependent package `go get -u foo/bar`
-  - Run `govendor add +external`
-
-### Making new releases 
-
-`minio` doesn't follow semantic versioning style, `minio` instead uses the release date and time as the release versions.
-
-`make release` will generate new binary into `release` directory.

Makefile

@@ -1,142 +0,0 @@
-LDFLAGS := $(shell go run buildscripts/gen-ldflags.go)
-PWD := $(shell pwd)
-GOPATH := $(shell go env GOPATH)
-BUILD_LDFLAGS := '$(LDFLAGS)'
-TAG := latest
-
-HOST ?= $(shell uname)
-CPU ?= $(shell uname -m)
-
-# if no host is identifed (no uname tool)
-# we assume a Linux-64bit build
-ifeq ($(HOST),)
-  HOST = Linux
-endif
-
-# identify CPU
-ifeq ($(CPU), x86_64)
-  HOST := $(HOST)64
-else
-ifeq ($(CPU), amd64)
-  HOST := $(HOST)64
-else
-ifeq ($(CPU), i686)
-  HOST := $(HOST)32
-endif
-endif
-endif
-
-
-#############################################
-# now we find out the target OS for
-# which we are going to compile in case
-# the caller didn't yet define OS himself
-ifndef (OS)
-  ifeq ($(HOST), Linux64)
-    arch = gcc
-  else
-  ifeq ($(HOST), Linux32)
-    arch = 32
-  else
-  ifeq ($(HOST), Darwin64)
-    arch = clang
-  else
-  ifeq ($(HOST), Darwin32)
-    arch = clang
-  else
-  ifeq ($(HOST), FreeBSD64)
-    arch = gcc
-  endif
-  endif
-  endif
-  endif
-  endif
-endif
-
-all: install
-
-checks:
-	@echo "Checking deps:"
-	@(env bash $(PWD)/buildscripts/checkdeps.sh)
-	@(env bash $(PWD)/buildscripts/checkgopath.sh)
-
-getdeps: checks
-	@go get -u github.com/golang/lint/golint && echo "Installed golint:"
-	@go get -u github.com/fzipp/gocyclo && echo "Installed gocyclo:"
-	@go get -u github.com/remyoudompheng/go-misc/deadcode && echo "Installed deadcode:"
-	@go get -u github.com/client9/misspell/cmd/misspell && echo "Installed misspell:"
-	@go get -u github.com/gordonklaus/ineffassign && echo "Installed ineffassign:"
-
-verifiers: vet fmt lint cyclo spelling
-
-vet:
-	@echo "Running $@:"
-	@GO15VENDOREXPERIMENT=1 go tool vet -all *.go
-	@GO15VENDOREXPERIMENT=1 go tool vet -all ./pkg
-	@GO15VENDOREXPERIMENT=1 go tool vet -shadow=true *.go
-	@GO15VENDOREXPERIMENT=1 go tool vet -shadow=true ./pkg
-
-fmt:
-	@echo "Running $@:"
-	@GO15VENDOREXPERIMENT=1 gofmt -s -l *.go
-	@GO15VENDOREXPERIMENT=1 gofmt -s -l pkg
-
-lint:
-	@echo "Running $@:"
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/golint *.go
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/golint github.com/minio/minio/pkg...
-
-ineffassign:
-	@echo "Running $@:"
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/ineffassign .
-
-cyclo:
-	@echo "Running $@:"
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/gocyclo -over 65 *.go
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/gocyclo -over 65 pkg
-
-build: getdeps verifiers $(UI_ASSETS)
-
-deadcode:
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/deadcode
-
-spelling:
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/misspell *.go
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/misspell pkg/**/*
-
-test: build
-	@echo "Running all minio testing:"
-	@GO15VENDOREXPERIMENT=1 go test $(GOFLAGS) .
-	@GO15VENDOREXPERIMENT=1 go test $(GOFLAGS) github.com/minio/minio/pkg...
-
-gomake-all: build
-	@echo "Installing minio:"
-	@GO15VENDOREXPERIMENT=1 go build --ldflags $(BUILD_LDFLAGS) -o $(GOPATH)/bin/minio
-
-pkg-add:
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/govendor add $(PKG)
-
-pkg-update:
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/govendor update $(PKG)
-
-pkg-remove:
-	@GO15VENDOREXPERIMENT=1 ${GOPATH}/bin/govendor remove $(PKG)
-
-pkg-list:
-	@GO15VENDOREXPERIMENT=1 $(GOPATH)/bin/govendor list
-
-install: gomake-all
-
-release: verifiers
-	@MINIO_RELEASE=RELEASE ./buildscripts/build.sh
-
-experimental: verifiers
-	@MINIO_RELEASE=EXPERIMENTAL ./buildscripts/build.sh
-
-clean:
-	@echo "Cleaning up all the generated files:"
-	@rm -fv minio minio.test cover.out
-	@find . -name '*.test' | xargs rm -fv
-	@rm -rf isa-l
-	@rm -rf build
-	@rm -rf release

NOTICE

@@ -1,9 +0,0 @@
-Minio Cloud Storage, (C) 2014,2015 Minio, Inc.
-
-This product includes software developed at Minio, Inc.
-(https://minio.io/).
-
-The Minio project contains unmodified/modified subcomponents too with
-separate copyright notices and license terms. Your use of the source
-code for these subcomponents is subject to the terms and conditions
-of the following licenses.

README.md

@@ -1,261 +1,15 @@
-## 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)
+# SILO repository cards
 
-Minio is an object storage server compatible with Amazon S3 and licensed under [Apache license 2.0](./LICENSE).
+Generated by [Repository Cards](https://github.com/pgsty/silo/actions/workflows/repository-cards.yml)
+at 00:00 UTC daily (08:00 Asia/Shanghai). GitHub may queue scheduled runs.
 
-## Description
+Snapshot: 2026-10-04. 3,818 stars; 58 community contributors.
 
-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.
+- `contributors-light.svg` / `contributors-dark.svg`: human issue and PR authors across the SILO project scope, plus reviewed acknowledgements. Bots are excluded. Gold rings follow the reviewed companion-site roster; new authors are collected automatically.
+- `star-history-light.svg` / `star-history-dark.svg`: initial history reconstructed from the then-current stargazers; later points are daily observed totals, including decreases. Missing days are not fabricated.
+- `curated.json`: a cache of reviewed contributor credit from `pgsty/silo.pgsty.com/data/home/contributors.yaml`. The approved initial preview may be newer than the published site; a newer reviewed snapshot is retained until the site catches up.
+- `contributors.json`: generated contributor data and embedded raster avatars. Failed avatar refreshes use the previous image, or an initial when no image is available.
+- `history.json`: persistent daily totals. Keep this file when regenerating images.
 
-Minio currently implements two backends
-
-  - Filesystem (FS) - is available and ready for general purpose use.
-  - ErasureCoded (XL) - is available, but it is not ready for general purpose use.
-
-## Minio Client
-
-[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)
-
-### 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.
-
-~~~
-$ 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-quick-start-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.
-
-```
-$ 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
-```
-
-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
-```
-
-To make a bucket.
-```
-$ aws --endpoint-url http://localhost:9000 s3 mb s3://mybucket
-make_bucket: s3://mybucket/
-```
-
-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
-```
-
-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
-```
-
-Remove a bucket.
-```
-$ aws --endpoint-url http://localhost:9000 s3 rb s3://mybucket
-remove_bucket: s3://mybucket/
-```
-
-#### How to use AWS SDK with Minio?
-
-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
-```
-
-To make a bucket.
-```
-$ s3cmd mb s3://mybucket
-Bucket 's3://mybucket/' created
-```
-
-To copy an object to bucket.
-```
-$ s3cmd put newfile s3://testbucket
-upload: 'newfile' -> 's3://testbucket/newfile'
-```
-
-To copy an object to local system.
-```
-$ s3cmd get s3://testbucket/newfile
-download: 's3://testbucket/newfile' -> './newfile'
-```
-
-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'
-```
-
-To list buckets.
-```
-$ s3cmd ls s3://
-2015-12-09 16:12  s3://testbbucket
-```
-
-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.
+The SVGs are self-contained. Source and instructions live on the default branch;
+this branch contains generated assets only. Do not merge it into `main`.

access-key.go

@@ -1,86 +0,0 @@
-/*
- * 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 (
-	"crypto/rand"
-	"encoding/base64"
-	"regexp"
-)
-
-// credential container for access and secret keys.
-type credential struct {
-	AccessKeyID     string `json:"accessKey"`
-	SecretAccessKey string `json:"secretKey"`
-}
-
-const (
-	minioAccessID = 20
-	minioSecretID = 40
-)
-
-// isValidSecretKey - validate secret key.
-var isValidSecretKey = regexp.MustCompile(`^.{8,40}$`)
-
-// isValidAccessKey - validate access key.
-var isValidAccessKey = regexp.MustCompile(`^[a-zA-Z0-9\\-\\.\\_\\~]{5,20}$`)
-
-// mustGenAccessKeys - must generate access credentials.
-func mustGenAccessKeys() (creds credential) {
-	creds, err := genAccessKeys()
-	fatalIf(err, "Unable to generate access keys.")
-	return creds
-}
-
-// genAccessKeys - generate access credentials.
-func genAccessKeys() (credential, error) {
-	accessKeyID, err := genAccessKeyID()
-	if err != nil {
-		return credential{}, err
-	}
-	secretAccessKey, err := genSecretAccessKey()
-	if err != nil {
-		return credential{}, err
-	}
-	creds := credential{
-		AccessKeyID:     string(accessKeyID),
-		SecretAccessKey: string(secretAccessKey),
-	}
-	return creds, nil
-}
-
-// genAccessKeyID - generate random alpha numeric value using only uppercase characters
-// takes input as size in integer
-func genAccessKeyID() ([]byte, error) {
-	alpha := make([]byte, minioAccessID)
-	if _, err := rand.Read(alpha); err != nil {
-		return nil, err
-	}
-	for i := 0; i < minioAccessID; i++ {
-		alpha[i] = alphaNumericTable[alpha[i]%byte(len(alphaNumericTable))]
-	}
-	return alpha, nil
-}
-
-// genSecretAccessKey - generate random base64 numeric value from a random seed.
-func genSecretAccessKey() ([]byte, error) {
-	rb := make([]byte, minioSecretID)
-	if _, err := rand.Read(rb); err != nil {
-		return nil, err
-	}
-	return []byte(base64.StdEncoding.EncodeToString(rb))[:minioSecretID], nil
-}

accesslog-handler.go

@@ -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}
-}

api-datatypes.go

@@ -1,41 +0,0 @@
-/*
- * 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 (
-	"encoding/xml"
-)
-
-// ObjectIdentifier carries key name for the object to delete.
-type ObjectIdentifier struct {
-	ObjectName string `xml:"Key"`
-}
-
-// createBucketConfiguration container for bucket configuration request from client.
-// Used for parsing the location from the request body for MakeBucketbucket.
-type createBucketLocationConfiguration struct {
-	XMLName  xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CreateBucketConfiguration" json:"-"`
-	Location string   `xml:"LocationConstraint"`
-}
-
-// DeleteObjectsRequest - xml carrying the object key names which needs to be deleted.
-type DeleteObjectsRequest struct {
-	// Element to enable quiet mode for the request
-	Quiet bool
-	// List of objects to be deleted
-	Objects []ObjectIdentifier `xml:"Object"`
-}

api-errors.go

@@ -1,528 +0,0 @@
-/*
- * Minio Cloud 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/xml"
-	"net/http"
-)
-
-// APIError structure
-type APIError struct {
-	Code           string
-	Description    string
-	HTTPStatusCode int
-}
-
-// APIErrorResponse - error response format
-type APIErrorResponse struct {
-	XMLName    xml.Name `xml:"Error" json:"-"`
-	Code       string
-	Message    string
-	Key        string
-	BucketName string
-	Resource   string
-	RequestID  string `xml:"RequestId"`
-	HostID     string `xml:"HostId"`
-}
-
-// APIErrorCode type of error status.
-type APIErrorCode int
-
-// Error codes, non exhaustive list - http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html
-const (
-	ErrNone APIErrorCode = iota
-	ErrAccessDenied
-	ErrBadDigest
-	ErrBucketAlreadyExists
-	ErrEntityTooSmall
-	ErrEntityTooLarge
-	ErrIncompleteBody
-	ErrInternalError
-	ErrInvalidAccessKeyID
-	ErrInvalidBucketName
-	ErrInvalidDigest
-	ErrInvalidRange
-	ErrInvalidMaxKeys
-	ErrInvalidMaxUploads
-	ErrInvalidMaxParts
-	ErrInvalidPartNumberMarker
-	ErrInvalidRequestBody
-	ErrInvalidCopySource
-	ErrInvalidCopyDest
-	ErrInvalidPolicyDocument
-	ErrMalformedXML
-	ErrMissingContentLength
-	ErrMissingContentMD5
-	ErrMissingRequestBodyError
-	ErrNoSuchBucket
-	ErrNoSuchBucketPolicy
-	ErrNoSuchKey
-	ErrNoSuchUpload
-	ErrNotImplemented
-	ErrPreconditionFailed
-	ErrRequestTimeTooSkewed
-	ErrSignatureDoesNotMatch
-	ErrMethodNotAllowed
-	ErrInvalidPart
-	ErrInvalidPartOrder
-	ErrAuthorizationHeaderMalformed
-	ErrMalformedPOSTRequest
-	ErrSignatureVersionNotSupported
-	ErrBucketNotEmpty
-	ErrAllAccessDisabled
-	ErrMalformedPolicy
-	ErrMissingFields
-	ErrMissingCredTag
-	ErrCredMalformed
-	ErrInvalidRegion
-	ErrInvalidService
-	ErrInvalidRequestVersion
-	ErrMissingSignTag
-	ErrMissingSignHeadersTag
-	ErrPolicyAlreadyExpired
-	ErrMalformedDate
-	ErrMalformedExpires
-	ErrAuthHeaderEmpty
-	ErrExpiredPresignRequest
-	ErrMissingDateHeader
-	ErrInvalidQuerySignatureAlgo
-	ErrInvalidQueryParams
-	ErrBucketAlreadyOwnedByYou
-	// Add new error codes here.
-
-	// S3 extended errors.
-	ErrContentSHA256Mismatch
-	// Add new extended error codes here.
-
-	// Minio extended errors.
-	ErrReadQuorum
-	ErrWriteQuorum
-	ErrStorageFull
-	ErrObjectExistsAsDirectory
-	ErrPolicyNesting
-	ErrInvalidObjectName
-	// Add new extended error codes here.
-	// Please open a https://github.com/minio/minio/issues before adding
-	// new error codes here.
-)
-
-// error code to APIError structure, these fields carry respective
-// descriptions for all the error responses.
-var errorCodeResponse = map[APIErrorCode]APIError{
-	ErrInvalidCopyDest: {
-		Code:           "InvalidRequest",
-		Description:    "This copy request is illegal because it is trying to copy an object to itself.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidCopySource: {
-		Code:           "InvalidArgument",
-		Description:    "Copy Source must mention the source bucket and key: sourcebucket/sourcekey.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidRequestBody: {
-		Code:           "InvalidArgument",
-		Description:    "Body shouldn't be set for this request.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidMaxUploads: {
-		Code:           "InvalidArgument",
-		Description:    "Argument max-uploads must be an integer between 0 and 2147483647",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidMaxKeys: {
-		Code:           "InvalidArgument",
-		Description:    "Argument maxKeys must be an integer between 0 and 2147483647",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidMaxParts: {
-		Code:           "InvalidArgument",
-		Description:    "Argument max-parts must be an integer between 0 and 2147483647",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidPartNumberMarker: {
-		Code:           "InvalidArgument",
-		Description:    "Argument partNumberMarker must be an integer.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidPolicyDocument: {
-		Code:           "InvalidPolicyDocument",
-		Description:    "The content of the form does not meet the conditions specified in the policy document.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrAccessDenied: {
-		Code:           "AccessDenied",
-		Description:    "Access Denied.",
-		HTTPStatusCode: http.StatusForbidden,
-	},
-	ErrBadDigest: {
-		Code:           "BadDigest",
-		Description:    "The Content-Md5 you specified did not match what we received.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrBucketAlreadyExists: {
-		Code:           "BucketAlreadyExists",
-		Description:    "The requested bucket name is not available.",
-		HTTPStatusCode: http.StatusConflict,
-	},
-	ErrEntityTooSmall: {
-		Code:           "EntityTooSmall",
-		Description:    "Your proposed upload is smaller than the minimum allowed object size.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrEntityTooLarge: {
-		Code:           "EntityTooLarge",
-		Description:    "Your proposed upload exceeds the maximum allowed object size.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrIncompleteBody: {
-		Code:           "IncompleteBody",
-		Description:    "You did not provide the number of bytes specified by the Content-Length HTTP header.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInternalError: {
-		Code:           "InternalError",
-		Description:    "We encountered an internal error, please try again.",
-		HTTPStatusCode: http.StatusInternalServerError,
-	},
-	ErrInvalidAccessKeyID: {
-		Code:           "InvalidAccessKeyID",
-		Description:    "The access key ID you provided does not exist in our records.",
-		HTTPStatusCode: http.StatusForbidden,
-	},
-	ErrInvalidBucketName: {
-		Code:           "InvalidBucketName",
-		Description:    "The specified bucket is not valid.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidDigest: {
-		Code:           "InvalidDigest",
-		Description:    "The Content-Md5 you specified is not valid.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidRange: {
-		Code:           "InvalidRange",
-		Description:    "The requested range is not satisfiable",
-		HTTPStatusCode: http.StatusRequestedRangeNotSatisfiable,
-	},
-	ErrMalformedXML: {
-		Code:           "MalformedXML",
-		Description:    "The XML you provided was not well-formed or did not validate against our published schema.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMissingContentLength: {
-		Code:           "MissingContentLength",
-		Description:    "You must provide the Content-Length HTTP header.",
-		HTTPStatusCode: http.StatusLengthRequired,
-	},
-	ErrMissingContentMD5: {
-		Code:           "MissingContentMD5",
-		Description:    "Missing required header for this request: Content-Md5.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMissingRequestBodyError: {
-		Code:           "MissingRequestBodyError",
-		Description:    "Request body is empty.",
-		HTTPStatusCode: http.StatusLengthRequired,
-	},
-	ErrNoSuchBucket: {
-		Code:           "NoSuchBucket",
-		Description:    "The specified bucket does not exist",
-		HTTPStatusCode: http.StatusNotFound,
-	},
-	ErrNoSuchBucketPolicy: {
-		Code:           "NoSuchBucketPolicy",
-		Description:    "The specified bucket does not have a bucket policy.",
-		HTTPStatusCode: http.StatusNotFound,
-	},
-	ErrNoSuchKey: {
-		Code:           "NoSuchKey",
-		Description:    "The specified key does not exist.",
-		HTTPStatusCode: http.StatusNotFound,
-	},
-	ErrNoSuchUpload: {
-		Code:           "NoSuchUpload",
-		Description:    "The specified multipart upload does not exist.",
-		HTTPStatusCode: http.StatusNotFound,
-	},
-	ErrNotImplemented: {
-		Code:           "NotImplemented",
-		Description:    "A header you provided implies functionality that is not implemented",
-		HTTPStatusCode: http.StatusNotImplemented,
-	},
-	ErrPreconditionFailed: {
-		Code:           "PreconditionFailed",
-		Description:    "At least one of the pre-conditions you specified did not hold",
-		HTTPStatusCode: http.StatusPreconditionFailed,
-	},
-	ErrRequestTimeTooSkewed: {
-		Code:           "RequestTimeTooSkewed",
-		Description:    "The difference between the request time and the server's time is too large.",
-		HTTPStatusCode: http.StatusForbidden,
-	},
-	ErrSignatureDoesNotMatch: {
-		Code:           "SignatureDoesNotMatch",
-		Description:    "The request signature we calculated does not match the signature you provided. Check your key and signing method.",
-		HTTPStatusCode: http.StatusForbidden,
-	},
-	ErrMethodNotAllowed: {
-		Code:           "MethodNotAllowed",
-		Description:    "The specified method is not allowed against this resource.",
-		HTTPStatusCode: http.StatusMethodNotAllowed,
-	},
-	ErrInvalidPart: {
-		Code:           "InvalidPart",
-		Description:    "One or more of the specified parts could not be found.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidPartOrder: {
-		Code:           "InvalidPartOrder",
-		Description:    "The list of parts was not in ascending order. The parts list must be specified in order by part number.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrAuthorizationHeaderMalformed: {
-		Code:           "AuthorizationHeaderMalformed",
-		Description:    "The authorization header is malformed; the region is wrong; expecting 'us-east-1'.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMalformedPOSTRequest: {
-		Code:           "MalformedPOSTRequest",
-		Description:    "The body of your POST request is not well-formed multipart/form-data.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrSignatureVersionNotSupported: {
-		Code:           "InvalidRequest",
-		Description:    "The authorization mechanism you have provided is not supported. Please use AWS4-HMAC-SHA256.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrBucketNotEmpty: {
-		Code:           "BucketNotEmpty",
-		Description:    "The bucket you tried to delete is not empty.",
-		HTTPStatusCode: http.StatusConflict,
-	},
-	ErrAllAccessDisabled: {
-		Code:           "AllAccessDisabled",
-		Description:    "All access to this bucket has been disabled.",
-		HTTPStatusCode: http.StatusForbidden,
-	},
-	ErrMalformedPolicy: {
-		Code:           "MalformedPolicy",
-		Description:    "Policy has invalid resource.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMissingFields: {
-		Code:           "MissingFields",
-		Description:    "Missing fields in request.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMissingCredTag: {
-		Code:           "InvalidRequest",
-		Description:    "Missing Credential field for this request.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrCredMalformed: {
-		Code:           "CredentialMalformed",
-		Description:    "Credential field malformed does not follow accessKeyID/credScope.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMalformedDate: {
-		Code:           "MalformedDate",
-		Description:    "Invalid date format header, expected to be in ISO8601, RFC1123 or RFC1123Z time format.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidRegion: {
-		Code:           "InvalidRegion",
-		Description:    "Region does not match.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidService: {
-		Code:           "AccessDenied",
-		Description:    "Service scope should be of value 's3'.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidRequestVersion: {
-		Code:           "AccessDenied",
-		Description:    "Request scope should be of value 'aws4_request'.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMissingSignTag: {
-		Code:           "AccessDenied",
-		Description:    "Signature header missing Signature field.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMissingSignHeadersTag: {
-		Code:           "InvalidArgument",
-		Description:    "Signature header missing SignedHeaders field.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrPolicyAlreadyExpired: {
-		Code:           "AccessDenied",
-		Description:    "Invalid according to Policy: Policy expired.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMalformedExpires: {
-		Code:           "MalformedExpires",
-		Description:    "Malformed expires header, expected non-zero number.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrAuthHeaderEmpty: {
-		Code:           "InvalidArgument",
-		Description:    "Authorization header is invalid -- one and only one ' ' (space) required.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrMissingDateHeader: {
-		Code:           "AccessDenied",
-		Description:    "AWS authentication requires a valid Date or x-amz-date header",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidQuerySignatureAlgo: {
-		Code:           "AuthorizationQueryParametersError",
-		Description:    "X-Amz-Algorithm only supports \"AWS4-HMAC-SHA256\".",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrExpiredPresignRequest: {
-		Code:           "AccessDenied",
-		Description:    "Request has expired.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrInvalidQueryParams: {
-		Code:           "AuthorizationQueryParametersError",
-		Description:    "Query-string authentication version 4 requires the X-Amz-Algorithm, X-Amz-Credential, X-Amz-Signature, X-Amz-Date, X-Amz-SignedHeaders, and X-Amz-Expires parameters.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	ErrBucketAlreadyOwnedByYou: {
-		Code:           "BucketAlreadyOwnedByYou",
-		Description:    "Your previous request to create the named bucket succeeded and you already own it.",
-		HTTPStatusCode: http.StatusConflict,
-	},
-
-	/// S3 extensions.
-	ErrContentSHA256Mismatch: {
-		Code:           "XAmzContentSHA256Mismatch",
-		Description:    "The provided 'x-amz-content-sha256' header does not match what was computed.",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-
-	/// Minio extensions.
-	ErrStorageFull: {
-		Code:           "XMinioStorageFull",
-		Description:    "Storage backend has reached its minimum free disk threshold. Please delete few objects to proceed.",
-		HTTPStatusCode: http.StatusInternalServerError,
-	},
-	ErrObjectExistsAsDirectory: {
-		Code:           "XMinioObjectExistsAsDirectory",
-		Description:    "Object name already exists as a directory.",
-		HTTPStatusCode: http.StatusConflict,
-	},
-	ErrReadQuorum: {
-		Code:           "XMinioReadQuorum",
-		Description:    "Multiple disk failures, unable to reconstruct data.",
-		HTTPStatusCode: http.StatusServiceUnavailable,
-	},
-	ErrWriteQuorum: {
-		Code:           "XMinioWriteQuorum",
-		Description:    "Multiple disks failures, unable to write data.",
-		HTTPStatusCode: http.StatusServiceUnavailable,
-	},
-	ErrPolicyNesting: {
-		Code:           "XMinioPolicyNesting",
-		Description:    "Policy nesting conflict has occurred.",
-		HTTPStatusCode: http.StatusConflict,
-	},
-	ErrInvalidObjectName: {
-		Code:           "XMinioInvalidObjectName",
-		Description:    "Object name contains unsupported characters. Unsupported characters are `^*|\\\"",
-		HTTPStatusCode: http.StatusBadRequest,
-	},
-	// Add your error structure here.
-}
-
-// toAPIErrorCode - Converts embedded errors. Convenience
-// function written to handle all cases where we have known types of
-// errors returned by underlying layers.
-func toAPIErrorCode(err error) (apiErr APIErrorCode) {
-	if err == nil {
-		return ErrNone
-	}
-	// Verify if the underlying error is signature mismatch.
-	switch err {
-	case errSignatureMismatch:
-		apiErr = ErrSignatureDoesNotMatch
-	case errContentSHA256Mismatch:
-		apiErr = ErrContentSHA256Mismatch
-	}
-	if apiErr != ErrNone {
-		// If there was a match in the above switch case.
-		return apiErr
-	}
-	switch err.(type) {
-	case StorageFull:
-		apiErr = ErrStorageFull
-	case BadDigest:
-		apiErr = ErrBadDigest
-	case IncompleteBody:
-		apiErr = ErrIncompleteBody
-	case ObjectExistsAsDirectory:
-		apiErr = ErrObjectExistsAsDirectory
-	case BucketNameInvalid:
-		apiErr = ErrInvalidBucketName
-	case BucketNotFound:
-		apiErr = ErrNoSuchBucket
-	case BucketNotEmpty:
-		apiErr = ErrBucketNotEmpty
-	case BucketExists:
-		apiErr = ErrBucketAlreadyOwnedByYou
-	case ObjectNotFound:
-		apiErr = ErrNoSuchKey
-	case ObjectNameInvalid:
-		apiErr = ErrInvalidObjectName
-	case InvalidUploadID:
-		apiErr = ErrNoSuchUpload
-	case InvalidPart:
-		apiErr = ErrInvalidPart
-	case InsufficientWriteQuorum:
-		apiErr = ErrWriteQuorum
-	case InsufficientReadQuorum:
-		apiErr = ErrReadQuorum
-	case PartTooSmall:
-		apiErr = ErrEntityTooSmall
-	default:
-		apiErr = ErrInternalError
-	}
-	return apiErr
-}
-
-// getAPIError provides API Error for input API error code.
-func getAPIError(code APIErrorCode) APIError {
-	return errorCodeResponse[code]
-}
-
-// getErrorResponse gets in standard error and resource value and
-// provides a encodable populated response values
-func getAPIErrorResponse(err APIError, resource string) APIErrorResponse {
-	var data = APIErrorResponse{}
-	data.Code = err.Code
-	data.Message = err.Description
-	if resource != "" {
-		data.Resource = resource
-	}
-	// TODO implement this in future
-	data.RequestID = "3L137"
-	data.HostID = "3L137"
-
-	return data
-}

api-headers.go

@@ -1,89 +0,0 @@
-/*
- * Minio Cloud 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 (
-	"bytes"
-	"crypto/rand"
-	"encoding/xml"
-	"net/http"
-	"runtime"
-	"strconv"
-	"strings"
-)
-
-//// helpers
-
-// Static alphaNumeric table used for generating unique request ids
-var alphaNumericTable = []byte("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ")
-
-// generateRequestID - Generate request id
-func generateRequestID() []byte {
-	alpha := make([]byte, 16)
-	rand.Read(alpha)
-	for i := 0; i < 16; i++ {
-		alpha[i] = alphaNumericTable[alpha[i]%byte(len(alphaNumericTable))]
-	}
-	return alpha
-}
-
-// Write http common headers
-func setCommonHeaders(w http.ResponseWriter) {
-	// Set unique request ID for each reply.
-	w.Header().Set("X-Amz-Request-Id", string(generateRequestID()))
-	w.Header().Set("Server", ("Minio/" + minioReleaseTag + " (" + runtime.GOOS + "; " + runtime.GOARCH + ")"))
-	w.Header().Set("Accept-Ranges", "bytes")
-}
-
-// Encodes the response headers into XML format.
-func encodeResponse(response interface{}) []byte {
-	var bytesBuffer bytes.Buffer
-	bytesBuffer.WriteString(xml.Header)
-	e := xml.NewEncoder(&bytesBuffer)
-	e.Encode(response)
-	return bytesBuffer.Bytes()
-}
-
-// Write object header
-func setObjectHeaders(w http.ResponseWriter, objInfo ObjectInfo, contentRange *httpRange) {
-	// set common headers
-	setCommonHeaders(w)
-
-	// set object-related metadata headers
-	lastModified := objInfo.ModTime.UTC().Format(http.TimeFormat)
-	w.Header().Set("Last-Modified", lastModified)
-
-	w.Header().Set("Content-Type", objInfo.ContentType)
-	if objInfo.MD5Sum != "" {
-		w.Header().Set("ETag", "\""+objInfo.MD5Sum+"\"")
-	}
-
-	w.Header().Set("Content-Length", strconv.FormatInt(objInfo.Size, 10))
-	for k, v := range objInfo.UserDefined {
-		if strings.HasPrefix(k, "X-Amz-Meta-") {
-			w.Header().Set(k, v)
-		}
-	}
-
-	// for providing ranged content
-	if contentRange != nil && contentRange.offsetBegin > -1 {
-		// Override content-length
-		w.Header().Set("Content-Length", strconv.FormatInt(contentRange.getLength(), 10))
-		w.Header().Set("Content-Range", contentRange.String())
-		w.WriteHeader(http.StatusPartialContent)
-	}
-}

api-headers_test.go

@@ -1,40 +0,0 @@
-/*
- * 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 (
-	"testing"
-)
-
-func TestGenerateRequestID(t *testing.T) {
-	// Ensure that it returns an alphanumeric result of length 16.
-	var id = generateRequestID()
-
-	if len(id) != 16 {
-		t.Fail()
-	}
-
-	var e rune
-	for _, char := range id {
-		e = rune(char)
-
-		// Ensure that it is alphanumeric, in this case, between 0-9 and A-Z.
-		if !(('0' <= e && e <= '9') || ('A' <= e && e <= 'Z')) {
-			t.Fail()
-		}
-	}
-}

api-resources.go

@@ -1,79 +0,0 @@
-/*
- * Minio Cloud 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 (
-	"net/url"
-	"strconv"
-)
-
-// Parse bucket url queries
-func getListObjectsV1Args(values url.Values) (prefix, marker, delimiter string, maxkeys int, encodingType string) {
-	prefix = values.Get("prefix")
-	marker = values.Get("marker")
-	delimiter = values.Get("delimiter")
-	if values.Get("max-keys") != "" {
-		maxkeys, _ = strconv.Atoi(values.Get("max-keys"))
-	} else {
-		maxkeys = maxObjectList
-	}
-	encodingType = values.Get("encoding-type")
-	return
-}
-
-// Parse bucket url queries for ListObjects V2.
-func getListObjectsV2Args(values url.Values) (prefix, token, startAfter, delimiter string, maxkeys int, encodingType string) {
-	prefix = values.Get("prefix")
-	startAfter = values.Get("start-after")
-	delimiter = values.Get("delimiter")
-	if values.Get("max-keys") != "" {
-		maxkeys, _ = strconv.Atoi(values.Get("max-keys"))
-	} else {
-		maxkeys = maxObjectList
-	}
-	encodingType = values.Get("encoding-type")
-	token = values.Get("continuation-token")
-	return
-}
-
-// Parse bucket url queries for ?uploads
-func getBucketMultipartResources(values url.Values) (prefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int, encodingType string) {
-	prefix = values.Get("prefix")
-	keyMarker = values.Get("key-marker")
-	uploadIDMarker = values.Get("upload-id-marker")
-	delimiter = values.Get("delimiter")
-	if values.Get("max-uploads") != "" {
-		maxUploads, _ = strconv.Atoi(values.Get("max-uploads"))
-	} else {
-		maxUploads = maxUploadsList
-	}
-	encodingType = values.Get("encoding-type")
-	return
-}
-
-// Parse object url queries
-func getObjectResources(values url.Values) (uploadID string, partNumberMarker, maxParts int, encodingType string) {
-	uploadID = values.Get("uploadId")
-	partNumberMarker, _ = strconv.Atoi(values.Get("part-number-marker"))
-	if values.Get("max-parts") != "" {
-		maxParts, _ = strconv.Atoi(values.Get("max-parts"))
-	} else {
-		maxParts = maxPartsList
-	}
-	encodingType = values.Get("encoding-type")
-	return
-}

api-response-multipart.go

@@ -1,54 +0,0 @@
-/*
- * 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.
- */
-
-// File carries any specific responses constructed/necessary in
-// multipart operations.
-package main
-
-import "net/http"
-
-// writeErrorResponsePartTooSmall - function is used specifically to
-// construct a proper error response during CompleteMultipartUpload
-// when one of the parts is < 5MB.
-// The requirement comes due to the fact that generic ErrorResponse
-// XML doesn't carry the additional fields required to send this
-// error. So we construct a new type which lies well within the scope
-// of this function.
-func writePartSmallErrorResponse(w http.ResponseWriter, r *http.Request, err PartTooSmall) {
-	// Represents additional fields necessary for ErrPartTooSmall S3 error.
-	type completeMultipartAPIError struct {
-		// Proposed size represents uploaded size of the part.
-		ProposedSize int64
-		// Minimum size allowed epresents the minimum size allowed per
-		// part. Defaults to 5MB.
-		MinSizeAllowed int64
-		// Part number of the part which is incorrect.
-		PartNumber int
-		// ETag of the part which is incorrect.
-		PartETag string
-		// Other default XML error responses.
-		APIErrorResponse
-	}
-	// Generate complete multipart error response.
-	errorResponse := getAPIErrorResponse(getAPIError(toAPIErrorCode(err)), r.URL.Path)
-	cmpErrResp := completeMultipartAPIError{err.PartSize, int64(5242880), err.PartNumber, err.PartETag, errorResponse}
-	encodedErrorResponse := encodeResponse(cmpErrResp)
-	// Write error body
-	w.Write(encodedErrorResponse)
-	w.(http.Flusher).Flush()
-}
-
-// Add any other multipart specific responses here.

api-response.go

@@ -1,519 +0,0 @@
-/*
- * 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 (
-	"encoding/xml"
-	"net/http"
-	"path"
-	"time"
-)
-
-const (
-	timeFormatAMZ  = "2006-01-02T15:04:05.000Z" // Reply date format
-	maxObjectList  = 1000                       // Limit number of objects in a listObjectsResponse.
-	maxUploadsList = 1000                       // Limit number of uploads in a listUploadsResponse.
-	maxPartsList   = 1000                       // Limit number of parts in a listPartsResponse.
-)
-
-// LocationResponse - format for location response.
-type LocationResponse struct {
-	XMLName  xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ LocationConstraint" json:"-"`
-	Location string   `xml:",chardata"`
-}
-
-// ListObjectsResponse - format for list objects response.
-type ListObjectsResponse struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListBucketResult" json:"-"`
-
-	CommonPrefixes []CommonPrefix
-	Contents       []Object
-
-	Delimiter string
-
-	// Encoding type used to encode object keys in the response.
-	EncodingType string
-
-	// A flag that indicates whether or not ListObjects returned all of the results
-	// that satisfied the search criteria.
-	IsTruncated bool
-	Marker      string
-	MaxKeys     int
-	Name        string
-
-	// When response is truncated (the IsTruncated element value in the response
-	// is true), you can use the key name in this field as marker in the subsequent
-	// request to get next set of objects. Server lists objects in alphabetical
-	// order Note: This element is returned only if you have delimiter request parameter
-	// specified. If response does not include the NextMaker and it is truncated,
-	// you can use the value of the last Key in the response as the marker in the
-	// subsequent request to get the next set of object keys.
-	NextMarker string
-	Prefix     string
-}
-
-// ListObjectsV2Response - format for list objects response.
-type ListObjectsV2Response struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListBucketResult" json:"-"`
-
-	CommonPrefixes []CommonPrefix
-	Contents       []Object
-
-	Delimiter string
-
-	// Encoding type used to encode object keys in the response.
-	EncodingType string
-
-	// A flag that indicates whether or not ListObjects returned all of the results
-	// that satisfied the search criteria.
-	IsTruncated bool
-	StartAfter  string
-	MaxKeys     int
-	Name        string
-
-	// When response is truncated (the IsTruncated element value in the response
-	// is true), you can use the key name in this field as marker in the subsequent
-	// request to get next set of objects. Server lists objects in alphabetical
-	// order Note: This element is returned only if you have delimiter request parameter
-	// specified. If response does not include the NextMaker and it is truncated,
-	// you can use the value of the last Key in the response as the marker in the
-	// subsequent request to get the next set of object keys.
-	ContinuationToken     string
-	NextContinuationToken string
-	Prefix                string
-}
-
-// Part container for part metadata.
-type Part struct {
-	PartNumber   int
-	ETag         string
-	LastModified string
-	Size         int64
-}
-
-// ListPartsResponse - format for list parts response.
-type ListPartsResponse struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListPartsResult" json:"-"`
-
-	Bucket   string
-	Key      string
-	UploadID string `xml:"UploadId"`
-
-	Initiator Initiator
-	Owner     Owner
-
-	// The class of storage used to store the object.
-	StorageClass string
-
-	PartNumberMarker     int
-	NextPartNumberMarker int
-	MaxParts             int
-	IsTruncated          bool
-
-	// List of parts.
-	Parts []Part `xml:"Part"`
-}
-
-// ListMultipartUploadsResponse - format for list multipart uploads response.
-type ListMultipartUploadsResponse struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListMultipartUploadsResult" json:"-"`
-
-	Bucket             string
-	KeyMarker          string
-	UploadIDMarker     string `xml:"UploadIdMarker"`
-	NextKeyMarker      string
-	NextUploadIDMarker string `xml:"NextUploadIdMarker"`
-	EncodingType       string
-	MaxUploads         int
-	IsTruncated        bool
-	Uploads            []Upload `xml:"Upload"`
-	Prefix             string
-	Delimiter          string
-	CommonPrefixes     []CommonPrefix
-}
-
-// ListBucketsResponse - format for list buckets response
-type ListBucketsResponse struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListAllMyBucketsResult" json:"-"`
-	// Container for one or more buckets.
-	Buckets struct {
-		Buckets []Bucket `xml:"Bucket"`
-	} // Buckets are nested
-	Owner Owner
-}
-
-// Upload container for in progress multipart upload
-type Upload struct {
-	Key          string
-	UploadID     string `xml:"UploadId"`
-	Initiator    Initiator
-	Owner        Owner
-	StorageClass string
-	Initiated    string
-}
-
-// CommonPrefix container for prefix response in ListObjectsResponse
-type CommonPrefix struct {
-	Prefix string
-}
-
-// Bucket container for bucket metadata
-type Bucket struct {
-	Name         string
-	CreationDate string // time string of format "2006-01-02T15:04:05.000Z"
-}
-
-// Object container for object metadata
-type Object struct {
-	ETag         string
-	Key          string
-	LastModified string // time string of format "2006-01-02T15:04:05.000Z"
-	Size         int64
-
-	Owner Owner
-
-	// The class of storage used to store the object.
-	StorageClass string
-}
-
-// CopyObjectResponse container returns ETag and LastModified of the
-// successfully copied object
-type CopyObjectResponse struct {
-	XMLName      xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CopyObjectResult" json:"-"`
-	ETag         string
-	LastModified string // time string of format "2006-01-02T15:04:05.000Z"
-}
-
-// Initiator inherit from Owner struct, fields are same
-type Initiator Owner
-
-// Owner - bucket owner/principal
-type Owner struct {
-	ID          string
-	DisplayName string
-}
-
-// InitiateMultipartUploadResponse container for InitiateMultiPartUpload response, provides uploadID to start MultiPart upload
-type InitiateMultipartUploadResponse struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ InitiateMultipartUploadResult" json:"-"`
-
-	Bucket   string
-	Key      string
-	UploadID string `xml:"UploadId"`
-}
-
-// CompleteMultipartUploadResponse container for completed multipart upload response
-type CompleteMultipartUploadResponse struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CompleteMultipartUploadResult" json:"-"`
-
-	Location string
-	Bucket   string
-	Key      string
-	ETag     string
-}
-
-// PostResponse container for completed post upload response
-type PostResponse struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ PostResponse" json:"-"`
-
-	Location string
-	Bucket   string
-	Key      string
-	ETag     string
-}
-
-// DeleteError structure.
-type DeleteError struct {
-	Code    string
-	Message string
-	Key     string
-}
-
-// DeleteObjectsResponse container for multiple object deletes.
-type DeleteObjectsResponse struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ DeleteResult" json:"-"`
-
-	// Collection of all deleted objects
-	DeletedObjects []ObjectIdentifier `xml:"Deleted,omitempty"`
-
-	// Collection of errors deleting certain objects.
-	Errors []DeleteError `xml:"Error,omitempty"`
-}
-
-// getLocation get URL location.
-func getLocation(r *http.Request) string {
-	return path.Clean(r.URL.Path) // Clean any trailing slashes.
-}
-
-// getObjectLocation gets the relative URL for an object
-func getObjectLocation(bucketName string, key string) string {
-	return "/" + bucketName + "/" + key
-}
-
-// takes an array of Bucketmetadata information for serialization
-// input:
-// array of bucket metadata
-//
-// output:
-// populated struct that can be serialized to match xml and json api spec output
-func generateListBucketsResponse(buckets []BucketInfo) ListBucketsResponse {
-	var listbuckets []Bucket
-	var data = ListBucketsResponse{}
-	var owner = Owner{}
-
-	owner.ID = "minio"
-	owner.DisplayName = "minio"
-
-	for _, bucket := range buckets {
-		var listbucket = Bucket{}
-		listbucket.Name = bucket.Name
-		listbucket.CreationDate = bucket.Created.Format(timeFormatAMZ)
-		listbuckets = append(listbuckets, listbucket)
-	}
-
-	data.Owner = owner
-	data.Buckets.Buckets = listbuckets
-
-	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 {
-	var contents []Object
-	var prefixes []CommonPrefix
-	var owner = Owner{}
-	var data = ListObjectsResponse{}
-
-	owner.ID = "minio"
-	owner.DisplayName = "minio"
-
-	for _, object := range resp.Objects {
-		var content = Object{}
-		if object.Name == "" {
-			continue
-		}
-		content.Key = object.Name
-		content.LastModified = object.ModTime.UTC().Format(timeFormatAMZ)
-		if object.MD5Sum != "" {
-			content.ETag = "\"" + object.MD5Sum + "\""
-		}
-		content.Size = object.Size
-		content.StorageClass = "STANDARD"
-		content.Owner = owner
-		contents = append(contents, content)
-	}
-	// TODO - support EncodingType in xml decoding
-	data.Name = bucket
-	data.Contents = contents
-
-	data.Prefix = prefix
-	data.Marker = marker
-	data.Delimiter = delimiter
-	data.MaxKeys = maxKeys
-
-	data.NextMarker = resp.NextMarker
-	data.IsTruncated = resp.IsTruncated
-	for _, prefix := range resp.Prefixes {
-		var prefixItem = CommonPrefix{}
-		prefixItem.Prefix = prefix
-		prefixes = append(prefixes, prefixItem)
-	}
-	data.CommonPrefixes = prefixes
-	return data
-}
-
-// generates an ListObjects 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
-	var owner = Owner{}
-	var data = ListObjectsV2Response{}
-
-	owner.ID = "minio"
-	owner.DisplayName = "minio"
-
-	for _, object := range resp.Objects {
-		var content = Object{}
-		if object.Name == "" {
-			continue
-		}
-		content.Key = object.Name
-		content.LastModified = object.ModTime.UTC().Format(timeFormatAMZ)
-		if object.MD5Sum != "" {
-			content.ETag = "\"" + object.MD5Sum + "\""
-		}
-		content.Size = object.Size
-		content.StorageClass = "STANDARD"
-		content.Owner = owner
-		contents = append(contents, content)
-	}
-	// TODO - support EncodingType in xml decoding
-	data.Name = bucket
-	data.Contents = contents
-
-	data.StartAfter = startAfter
-	data.Delimiter = delimiter
-	data.Prefix = prefix
-	data.MaxKeys = maxKeys
-	data.ContinuationToken = token
-	data.NextContinuationToken = resp.NextMarker
-	data.IsTruncated = resp.IsTruncated
-	for _, prefix := range resp.Prefixes {
-		var prefixItem = CommonPrefix{}
-		prefixItem.Prefix = prefix
-		prefixes = append(prefixes, prefixItem)
-	}
-	data.CommonPrefixes = prefixes
-	return data
-}
-
-// generateCopyObjectResponse
-func generateCopyObjectResponse(etag string, lastModified time.Time) CopyObjectResponse {
-	return CopyObjectResponse{
-		ETag:         "\"" + etag + "\"",
-		LastModified: lastModified.UTC().Format(timeFormatAMZ),
-	}
-}
-
-// generateInitiateMultipartUploadResponse
-func generateInitiateMultipartUploadResponse(bucket, key, uploadID string) InitiateMultipartUploadResponse {
-	return InitiateMultipartUploadResponse{
-		Bucket:   bucket,
-		Key:      key,
-		UploadID: uploadID,
-	}
-}
-
-// generateCompleteMultipartUploadResponse
-func generateCompleteMultpartUploadResponse(bucket, key, location, etag string) CompleteMultipartUploadResponse {
-	return CompleteMultipartUploadResponse{
-		Location: location,
-		Bucket:   bucket,
-		Key:      key,
-		ETag:     etag,
-	}
-}
-
-// generateListPartsResult
-func generateListPartsResponse(partsInfo ListPartsInfo) ListPartsResponse {
-	// TODO - support EncodingType in xml decoding
-	listPartsResponse := ListPartsResponse{}
-	listPartsResponse.Bucket = partsInfo.Bucket
-	listPartsResponse.Key = partsInfo.Object
-	listPartsResponse.UploadID = partsInfo.UploadID
-	listPartsResponse.StorageClass = "STANDARD"
-	listPartsResponse.Initiator.ID = "minio"
-	listPartsResponse.Initiator.DisplayName = "minio"
-	listPartsResponse.Owner.ID = "minio"
-	listPartsResponse.Owner.DisplayName = "minio"
-
-	listPartsResponse.MaxParts = partsInfo.MaxParts
-	listPartsResponse.PartNumberMarker = partsInfo.PartNumberMarker
-	listPartsResponse.IsTruncated = partsInfo.IsTruncated
-	listPartsResponse.NextPartNumberMarker = partsInfo.NextPartNumberMarker
-
-	listPartsResponse.Parts = make([]Part, len(partsInfo.Parts))
-	for index, part := range partsInfo.Parts {
-		newPart := Part{}
-		newPart.PartNumber = part.PartNumber
-		newPart.ETag = "\"" + part.ETag + "\""
-		newPart.Size = part.Size
-		newPart.LastModified = part.LastModified.UTC().Format(timeFormatAMZ)
-		listPartsResponse.Parts[index] = newPart
-	}
-	return listPartsResponse
-}
-
-// generateListMultipartUploadsResponse
-func generateListMultipartUploadsResponse(bucket string, multipartsInfo ListMultipartsInfo) ListMultipartUploadsResponse {
-	listMultipartUploadsResponse := ListMultipartUploadsResponse{}
-	listMultipartUploadsResponse.Bucket = bucket
-	listMultipartUploadsResponse.Delimiter = multipartsInfo.Delimiter
-	listMultipartUploadsResponse.IsTruncated = multipartsInfo.IsTruncated
-	listMultipartUploadsResponse.EncodingType = multipartsInfo.EncodingType
-	listMultipartUploadsResponse.Prefix = multipartsInfo.Prefix
-	listMultipartUploadsResponse.KeyMarker = multipartsInfo.KeyMarker
-	listMultipartUploadsResponse.NextKeyMarker = multipartsInfo.NextKeyMarker
-	listMultipartUploadsResponse.MaxUploads = multipartsInfo.MaxUploads
-	listMultipartUploadsResponse.NextUploadIDMarker = multipartsInfo.NextUploadIDMarker
-	listMultipartUploadsResponse.UploadIDMarker = multipartsInfo.UploadIDMarker
-	listMultipartUploadsResponse.CommonPrefixes = make([]CommonPrefix, len(multipartsInfo.CommonPrefixes))
-	for index, commonPrefix := range multipartsInfo.CommonPrefixes {
-		listMultipartUploadsResponse.CommonPrefixes[index] = CommonPrefix{
-			Prefix: commonPrefix,
-		}
-	}
-	listMultipartUploadsResponse.Uploads = make([]Upload, len(multipartsInfo.Uploads))
-	for index, upload := range multipartsInfo.Uploads {
-		newUpload := Upload{}
-		newUpload.UploadID = upload.UploadID
-		newUpload.Key = upload.Object
-		newUpload.Initiated = upload.Initiated.UTC().Format(timeFormatAMZ)
-		listMultipartUploadsResponse.Uploads[index] = newUpload
-	}
-	return listMultipartUploadsResponse
-}
-
-// generate multi objects delete response.
-func generateMultiDeleteResponse(quiet bool, deletedObjects []ObjectIdentifier, errs []DeleteError) DeleteObjectsResponse {
-	deleteResp := DeleteObjectsResponse{}
-	if !quiet {
-		deleteResp.DeletedObjects = deletedObjects
-	}
-	deleteResp.Errors = errs
-	return deleteResp
-}
-
-// writeSuccessResponse write success headers and response if any.
-func writeSuccessResponse(w http.ResponseWriter, response []byte) {
-	setCommonHeaders(w)
-	if response == nil {
-		w.WriteHeader(http.StatusOK)
-		return
-	}
-	w.Write(response)
-	w.(http.Flusher).Flush()
-}
-
-// writeSuccessNoContent write success headers with http status 204
-func writeSuccessNoContent(w http.ResponseWriter) {
-	setCommonHeaders(w)
-	w.WriteHeader(http.StatusNoContent)
-}
-
-// writeErrorRespone write error headers
-func writeErrorResponse(w http.ResponseWriter, req *http.Request, errorCode APIErrorCode, resource string) {
-	error := getAPIError(errorCode)
-	// set common headers
-	setCommonHeaders(w)
-	// write Header
-	w.WriteHeader(error.HTTPStatusCode)
-	writeErrorResponseNoHeader(w, req, errorCode, resource)
-}
-
-func writeErrorResponseNoHeader(w http.ResponseWriter, req *http.Request, errorCode APIErrorCode, resource string) {
-	error := getAPIError(errorCode)
-	// Generate error response.
-	errorResponse := getAPIErrorResponse(error, resource)
-	encodedErrorResponse := encodeResponse(errorResponse)
-	// HEAD should have no body, do not attempt to write to it
-	if req.Method != "HEAD" {
-		// write error body
-		w.Write(encodedErrorResponse)
-		w.(http.Flusher).Flush()
-	}
-}

api-router.go

@@ -1,86 +0,0 @@
-/*
- * 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 router "github.com/gorilla/mux"
-
-// objectAPIHandler implements and provides http handlers for S3 API.
-type objectAPIHandlers struct {
-	ObjectAPI ObjectLayer
-}
-
-// registerAPIRouter - registers S3 compatible APIs.
-func registerAPIRouter(mux *router.Router, api objectAPIHandlers) {
-	// API Router
-	apiRouter := mux.NewRoute().PathPrefix("/").Subrouter()
-
-	// Bucket router
-	bucket := apiRouter.PathPrefix("/{bucket}").Subrouter()
-
-	/// Object operations
-
-	// HeadObject
-	bucket.Methods("HEAD").Path("/{object:.+}").HandlerFunc(api.HeadObjectHandler)
-	// PutObjectPart
-	bucket.Methods("PUT").Path("/{object:.+}").HandlerFunc(api.PutObjectPartHandler).Queries("partNumber", "{partNumber:[0-9]+}", "uploadId", "{uploadId:.*}")
-	// ListObjectPxarts
-	bucket.Methods("GET").Path("/{object:.+}").HandlerFunc(api.ListObjectPartsHandler).Queries("uploadId", "{uploadId:.*}")
-	// CompleteMultipartUpload
-	bucket.Methods("POST").Path("/{object:.+}").HandlerFunc(api.CompleteMultipartUploadHandler).Queries("uploadId", "{uploadId:.*}")
-	// NewMultipartUpload
-	bucket.Methods("POST").Path("/{object:.+}").HandlerFunc(api.NewMultipartUploadHandler).Queries("uploads", "")
-	// AbortMultipartUpload
-	bucket.Methods("DELETE").Path("/{object:.+}").HandlerFunc(api.AbortMultipartUploadHandler).Queries("uploadId", "{uploadId:.*}")
-	// GetObject
-	bucket.Methods("GET").Path("/{object:.+}").HandlerFunc(api.GetObjectHandler)
-	// CopyObject
-	bucket.Methods("PUT").Path("/{object:.+}").HeadersRegexp("X-Amz-Copy-Source", ".*?(\\/|%2F).*?").HandlerFunc(api.CopyObjectHandler)
-	// PutObject
-	bucket.Methods("PUT").Path("/{object:.+}").HandlerFunc(api.PutObjectHandler)
-	// DeleteObject
-	bucket.Methods("DELETE").Path("/{object:.+}").HandlerFunc(api.DeleteObjectHandler)
-
-	/// Bucket operations
-
-	// GetBucketLocation
-	bucket.Methods("GET").HandlerFunc(api.GetBucketLocationHandler).Queries("location", "")
-	// GetBucketPolicy
-	bucket.Methods("GET").HandlerFunc(api.GetBucketPolicyHandler).Queries("policy", "")
-	// ListMultipartUploads
-	bucket.Methods("GET").HandlerFunc(api.ListMultipartUploadsHandler).Queries("uploads", "")
-	// ListObjects
-	bucket.Methods("GET").HandlerFunc(api.ListObjectsHandler)
-	// PutBucketPolicy
-	bucket.Methods("PUT").HandlerFunc(api.PutBucketPolicyHandler).Queries("policy", "")
-	// PutBucket
-	bucket.Methods("PUT").HandlerFunc(api.PutBucketHandler)
-	// HeadBucket
-	bucket.Methods("HEAD").HandlerFunc(api.HeadBucketHandler)
-	// PostPolicy
-	bucket.Methods("POST").HeadersRegexp("Content-Type", "multipart/form-data*").HandlerFunc(api.PostPolicyBucketHandler)
-	// DeleteMultipleObjects
-	bucket.Methods("POST").HandlerFunc(api.DeleteMultipleObjectsHandler)
-	// DeleteBucketPolicy
-	bucket.Methods("DELETE").HandlerFunc(api.DeleteBucketPolicyHandler).Queries("policy", "")
-	// DeleteBucket
-	bucket.Methods("DELETE").HandlerFunc(api.DeleteBucketHandler)
-
-	/// Root operation
-
-	// ListBuckets
-	apiRouter.Methods("GET").HandlerFunc(api.ListBucketsHandler)
-}

appveyor.yml

@@ -1,37 +0,0 @@
-# version format
-version: "{build}"
-
-# Operating system (build VM template)
-os: Windows Server 2012 R2
-
-# Platform.
-platform: x64
-
-clone_folder: c:\gopath\src\github.com\minio\minio
-
-# environment variables
-environment:
-  GOPATH: c:\gopath
-  GO15VENDOREXPERIMENT: 1
-
-# scripts that run after cloning repository
-install:
-  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
-  - go version
-  - go env
-
-# 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 run buildscripts/gen-ldflags.go > temp.txt
-  - set /p BUILD_LDFLAGS=<temp.txt
-  - go build -ldflags="%BUILD_LDFLAGS%" -o %GOPATH%\bin\minio.exe
-
-# to disable automatic tests
-test: off
-
-# to disable deployment
-deploy: off

auth-handler.go

@@ -1,180 +0,0 @@
-/*
- * Minio Cloud 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 (
-	"bytes"
-	"crypto/md5"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/hex"
-	"io/ioutil"
-	"net/http"
-	"strings"
-)
-
-// Verify if the request http Header "x-amz-content-sha256" == "UNSIGNED-PAYLOAD"
-func isRequestUnsignedPayload(r *http.Request) bool {
-	return r.Header.Get("x-amz-content-sha256") == unsignedPayload
-}
-
-// 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
-}
-
-// 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
-}
-
-// Verify if request has AWS Presignature Version '4'.
-func isRequestPresignedSignatureV4(r *http.Request) bool {
-	if _, ok := r.URL.Query()["X-Amz-Credential"]; ok {
-		return true
-	}
-	return false
-}
-
-// 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
-}
-
-// Authorization type.
-type authType int
-
-// List of all supported auth types.
-const (
-	authTypeUnknown authType = iota
-	authTypeAnonymous
-	authTypePresigned
-	authTypePostPolicy
-	authTypeSigned
-	authTypeJWT
-)
-
-// Get request authentication type.
-func getRequestAuthType(r *http.Request) authType {
-	if isRequestSignatureV4(r) {
-		return authTypeSigned
-	} else if isRequestPresignedSignatureV4(r) {
-		return authTypePresigned
-	} else if isRequestJWT(r) {
-		return authTypeJWT
-	} else if isRequestPostPolicySignatureV4(r) {
-		return authTypePostPolicy
-	} else if _, ok := r.Header["Authorization"]; !ok {
-		return authTypeAnonymous
-	}
-	return authTypeUnknown
-}
-
-// sum256 calculate sha256 sum for an input byte array
-func sum256(data []byte) []byte {
-	hash := sha256.New()
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-// sumMD5 calculate md5 sum for an input byte array
-func sumMD5(data []byte) []byte {
-	hash := md5.New()
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-// Verify if request has valid AWS Signature Version '4'.
-func isReqAuthenticated(r *http.Request) (s3Error APIErrorCode) {
-	if r == nil {
-		return ErrInternalError
-	}
-	payload, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		return ErrInternalError
-	}
-	// Verify Content-Md5, if payload is set.
-	if r.Header.Get("Content-Md5") != "" {
-		if r.Header.Get("Content-Md5") != base64.StdEncoding.EncodeToString(sumMD5(payload)) {
-			return ErrBadDigest
-		}
-	}
-	// Populate back the payload.
-	r.Body = ioutil.NopCloser(bytes.NewReader(payload))
-	validateRegion := true // Validate region.
-	var sha256sum string
-	// Skips calculating sha256 on the payload on server,
-	// if client requested for it.
-	if skipContentSha256Cksum(r) {
-		sha256sum = unsignedPayload
-	} else {
-		sha256sum = hex.EncodeToString(sum256(payload))
-	}
-	if isRequestSignatureV4(r) {
-		return doesSignatureMatch(sha256sum, r, validateRegion)
-	} else if isRequestPresignedSignatureV4(r) {
-		return doesPresignedSignatureMatch(sha256sum, r, validateRegion)
-	}
-	return ErrAccessDenied
-}
-
-// authHandler - handles all the incoming authorization headers and
-// validates them if possible.
-type authHandler struct {
-	handler http.Handler
-}
-
-// setAuthHandler to validate authorization header for the incoming request.
-func setAuthHandler(h http.Handler) http.Handler {
-	return authHandler{h}
-}
-
-// 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.
-		a.handler.ServeHTTP(w, r)
-		return
-	case 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
-	}
-}

benchmark-utils_test.go

@@ -1,384 +0,0 @@
-/*
- * 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/md5"
-	"encoding/hex"
-	"io/ioutil"
-	"math"
-	"math/rand"
-	"strconv"
-	"testing"
-	"time"
-)
-
-// Benchmark utility functions for ObjectLayer.PutObject().
-// Creates Object layer setup ( MakeBucket ) and then runs the PutObject benchmark.
-func runPutObjectBenchmark(b *testing.B, obj ObjectLayer, objSize int) {
-	var err error
-	// obtains random bucket name.
-	bucket := getRandomBucketName()
-	// create bucket.
-	err = obj.MakeBucket(bucket)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	// PutObject returns md5Sum of the object inserted.
-	// md5Sum variable is assigned with that value.
-	var md5Sum string
-	// get text data generated for number of bytes equal to object size.
-	textData := generateBytesData(objSize)
-	// generate md5sum for the generated data.
-	// md5sum of the data to written is required as input for PutObject.
-	hasher := md5.New()
-	hasher.Write([]byte(textData))
-	metadata := make(map[string]string)
-	metadata["md5Sum"] = hex.EncodeToString(hasher.Sum(nil))
-	// benchmark utility which helps obtain number of allocations and bytes allocated per ops.
-	b.ReportAllocs()
-	// the actual benchmark for PutObject starts here. Reset the benchmark timer.
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		// insert the object.
-		md5Sum, err = obj.PutObject(bucket, "object"+strconv.Itoa(i), int64(len(textData)), bytes.NewBuffer(textData), metadata)
-		if err != nil {
-			b.Fatal(err)
-		}
-		if md5Sum != metadata["md5Sum"] {
-			b.Fatalf("Write no: %d: Md5Sum mismatch during object write into the bucket: Expected %s, got %s", i+1, md5Sum, metadata["md5Sum"])
-		}
-	}
-	// Benchmark ends here. Stop timer.
-	b.StopTimer()
-}
-
-// Benchmark utility functions for ObjectLayer.PutObjectPart().
-// Creates Object layer setup ( MakeBucket ) and then runs the PutObjectPart benchmark.
-func runPutObjectPartBenchmark(b *testing.B, obj ObjectLayer, partSize int) {
-	var err error
-	// obtains random bucket name.
-	bucket := getRandomBucketName()
-	object := getRandomObjectName()
-
-	// create bucket.
-	err = obj.MakeBucket(bucket)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	objSize := 128 * 1024 * 1024
-
-	// PutObjectPart returns md5Sum of the object inserted.
-	// md5Sum variable is assigned with that value.
-	var md5Sum, uploadID string
-	// get text data generated for number of bytes equal to object size.
-	textData := generateBytesData(objSize)
-	// generate md5sum for the generated data.
-	// md5sum of the data to written is required as input for NewMultipartUpload.
-	hasher := md5.New()
-	hasher.Write([]byte(textData))
-	metadata := make(map[string]string)
-	metadata["md5Sum"] = hex.EncodeToString(hasher.Sum(nil))
-	uploadID, err = obj.NewMultipartUpload(bucket, object, metadata)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	var textPartData []byte
-	// benchmark utility which helps obtain number of allocations and bytes allocated per ops.
-	b.ReportAllocs()
-	// the actual benchmark for PutObjectPart starts here. Reset the benchmark timer.
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		// insert the object.
-		totalPartsNR := int(math.Ceil(float64(objSize) / float64(partSize)))
-		for j := 0; j < totalPartsNR; j++ {
-			hasher.Reset()
-			if j < totalPartsNR-1 {
-				textPartData = textData[j*partSize : (j+1)*partSize-1]
-			} else {
-				textPartData = textData[j*partSize:]
-			}
-			hasher.Write([]byte(textPartData))
-			metadata := make(map[string]string)
-			metadata["md5Sum"] = hex.EncodeToString(hasher.Sum(nil))
-			md5Sum, err = obj.PutObjectPart(bucket, object, uploadID, j, int64(len(textPartData)), bytes.NewBuffer(textPartData), metadata["md5Sum"])
-			if err != nil {
-				b.Fatal(err)
-			}
-			if md5Sum != metadata["md5Sum"] {
-				b.Fatalf("Write no: %d: Md5Sum mismatch during object write into the bucket: Expected %s, got %s", i+1, md5Sum, metadata["md5Sum"])
-			}
-		}
-	}
-	// Benchmark ends here. Stop timer.
-	b.StopTimer()
-}
-
-// 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)) {
-	// 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)
-	// 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)
-	}
-}
-
-// 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)) {
-	// 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)
-	// 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 returnPutObjectBenchmark(objSize int) func(*testing.B, ObjectLayer) {
-	// FIXME: Avoid closure.
-	return func(b *testing.B, obj ObjectLayer) {
-		runPutObjectBenchmark(b, obj, objSize)
-	}
-}
-
-// Benchmark utility functions for ObjectLayer.GetObject().
-// Creates Object layer setup ( MakeBucket, PutObject) and then runs the benchmark.
-func runGetObjectBenchmark(b *testing.B, obj ObjectLayer, objSize int) {
-	var err error
-	// obtains random bucket name.
-	bucket := getRandomBucketName()
-	// create bucket.
-	err = obj.MakeBucket(bucket)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	// PutObject returns md5Sum of the object inserted.
-	// md5Sum variable is assigned with that value.
-	var md5Sum string
-	for i := 0; i < 10; i++ {
-		// get text data generated for number of bytes equal to object size.
-		textData := generateBytesData(objSize)
-		// generate md5sum for the generated data.
-		// md5sum of the data to written is required as input for PutObject.
-		// PutObject is the functions which writes the data onto the FS/XL backend.
-		hasher := md5.New()
-		hasher.Write([]byte(textData))
-		metadata := make(map[string]string)
-		metadata["md5Sum"] = hex.EncodeToString(hasher.Sum(nil))
-		// insert the object.
-		md5Sum, err = obj.PutObject(bucket, "object"+strconv.Itoa(i), int64(len(textData)), bytes.NewBuffer(textData), metadata)
-		if err != nil {
-			b.Fatal(err)
-		}
-		if md5Sum != metadata["md5Sum"] {
-			b.Fatalf("Write no: %d: Md5Sum mismatch during object write into the bucket: Expected %s, got %s", i+1, md5Sum, metadata["md5Sum"])
-		}
-	}
-
-	// benchmark utility which helps obtain number of allocations and bytes allocated per ops.
-	b.ReportAllocs()
-	// the actual benchmark for GetObject starts here. Reset the benchmark timer.
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		var buffer = new(bytes.Buffer)
-		err = obj.GetObject(bucket, "object"+strconv.Itoa(i%10), 0, int64(objSize), buffer)
-		if err != nil {
-			b.Error(err)
-		}
-	}
-	// Benchmark ends here. Stop timer.
-	b.StopTimer()
-
-}
-
-// randomly picks a character and returns its equivalent byte array.
-func getRandomByte() []byte {
-	const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-	// seeding the random number generator.
-	rand.Seed(time.Now().UnixNano())
-	var b byte
-	// pick a character randomly.
-	b = letterBytes[rand.Intn(len(letterBytes))]
-	return []byte{b}
-}
-
-// picks a random byte and repeats it to size bytes.
-func generateBytesData(size int) []byte {
-	// repeat the random character chosen size
-	return bytes.Repeat(getRandomByte(), size)
-}
-
-// 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)) {
-	// 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)
-	// calling runGetObjectBenchmark which uses *testing.B and the object Layer to run the benchmark.
-	runBenchMark(b, objLayer)
-}
-
-// 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)
-	}
-}
-
-// Parallel benchmark utility functions for ObjectLayer.PutObject().
-// Creates Object layer setup ( MakeBucket ) and then runs the PutObject benchmark.
-func runPutObjectBenchmarkParallel(b *testing.B, obj ObjectLayer, objSize int) {
-	var err error
-	// obtains random bucket name.
-	bucket := getRandomBucketName()
-	// create bucket.
-	err = obj.MakeBucket(bucket)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	// PutObject returns md5Sum of the object inserted.
-	// md5Sum variable is assigned with that value.
-	var md5Sum string
-	// get text data generated for number of bytes equal to object size.
-	textData := generateBytesData(objSize)
-	// generate md5sum for the generated data.
-	// md5sum of the data to written is required as input for PutObject.
-	hasher := md5.New()
-	hasher.Write([]byte(textData))
-	metadata := make(map[string]string)
-	metadata["md5Sum"] = hex.EncodeToString(hasher.Sum(nil))
-	// benchmark utility which helps obtain number of allocations and bytes allocated per ops.
-	b.ReportAllocs()
-	// the actual benchmark for PutObject starts here. Reset the benchmark timer.
-	b.ResetTimer()
-
-	b.RunParallel(func(pb *testing.PB) {
-		i := 0
-		for pb.Next() {
-			// insert the object.
-			md5Sum, err = obj.PutObject(bucket, "object"+strconv.Itoa(i), int64(len(textData)), bytes.NewBuffer(textData), metadata)
-			if err != nil {
-				b.Fatal(err)
-			}
-			if md5Sum != metadata["md5Sum"] {
-				b.Fatalf("Write no: Md5Sum mismatch during object write into the bucket: Expected %s, got %s", md5Sum, metadata["md5Sum"])
-			}
-			i++
-		}
-	})
-
-	// Benchmark ends here. Stop timer.
-	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) {
-	var err error
-	// obtains random bucket name.
-	bucket := getRandomBucketName()
-	// create bucket.
-	err = obj.MakeBucket(bucket)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	// PutObject returns md5Sum of the object inserted.
-	// md5Sum variable is assigned with that value.
-	var md5Sum string
-	for i := 0; i < 10; i++ {
-		// get text data generated for number of bytes equal to object size.
-		textData := generateBytesData(objSize)
-		// generate md5sum for the generated data.
-		// md5sum of the data to written is required as input for PutObject.
-		// PutObject is the functions which writes the data onto the FS/XL backend.
-		hasher := md5.New()
-		hasher.Write([]byte(textData))
-		metadata := make(map[string]string)
-		metadata["md5Sum"] = hex.EncodeToString(hasher.Sum(nil))
-		// insert the object.
-		md5Sum, err = obj.PutObject(bucket, "object"+strconv.Itoa(i), int64(len(textData)), bytes.NewBuffer(textData), metadata)
-		if err != nil {
-			b.Fatal(err)
-		}
-		if md5Sum != metadata["md5Sum"] {
-			b.Fatalf("Write no: %d: Md5Sum mismatch during object write into the bucket: Expected %s, got %s", i+1, md5Sum, metadata["md5Sum"])
-		}
-	}
-
-	// benchmark utility which helps obtain number of allocations and bytes allocated per ops.
-	b.ReportAllocs()
-	// the actual benchmark for GetObject starts here. Reset the benchmark timer.
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		i := 0
-		for pb.Next() {
-			err = obj.GetObject(bucket, "object"+strconv.Itoa(i), 0, int64(objSize), ioutil.Discard)
-			if err != nil {
-				b.Error(err)
-			}
-			i++
-			if i == 10 {
-				i = 0
-			}
-		}
-	})
-	// Benchmark ends here. Stop timer.
-	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)
-	}
-}

bucket-handlers.go

@@ -1,603 +0,0 @@
-/*
- * 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 (
-	"bytes"
-	"encoding/base64"
-	"encoding/hex"
-	"encoding/xml"
-	"io"
-	"io/ioutil"
-	"mime/multipart"
-	"net/http"
-	"net/url"
-	"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
-		}
-	}
-	// Parse the saved policy.
-	bucketPolicy, err := parseBucketPolicy(policy)
-	if err != nil {
-		errorIf(err, "Unable to parse bucket policy.")
-		return ErrAccessDenied
-	}
-
-	// Construct resource in 'arn:aws:s3:::examplebucket/object' format.
-	resource := AWSResourcePrefix + strings.TrimPrefix(reqURL.Path, "/")
-
-	// Get conditions for policy verification.
-	conditions := make(map[string]string)
-	for queryParam := range reqURL.Query() {
-		conditions[queryParam] = reqURL.Query().Get(queryParam)
-	}
-
-	// Validate action, resource and conditions with current policy statements.
-	if !bucketPolicyEvalStatements(action, resource, conditions, bucketPolicy.Statements) {
-		return ErrAccessDenied
-	}
-	return ErrNone
-}
-
-// GetBucketLocationHandler - GET Bucket location.
-// -------------------------
-// This operation returns bucket location.
-func (api objectAPIHandlers) GetBucketLocationHandler(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:GetBucketLocation", bucket, 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 {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-
-	if _, err := api.ObjectAPI.GetBucketInfo(bucket); err != nil {
-		errorIf(err, "Unable to fetch bucket info.")
-		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
-		return
-	}
-
-	// Generate response.
-	encodedSuccessResponse := encodeResponse(LocationResponse{})
-	// Get current region.
-	region := serverConfig.GetRegion()
-	if region != "us-east-1" {
-		encodedSuccessResponse = encodeResponse(LocationResponse{
-			Location: region,
-		})
-	}
-	setCommonHeaders(w) // Write headers.
-	writeSuccessResponse(w, encodedSuccessResponse)
-}
-
-// ListMultipartUploadsHandler - GET Bucket (List Multipart uploads)
-// -------------------------
-// This operation lists in-progress multipart uploads. An in-progress
-// multipart upload is a multipart upload that has been initiated,
-// using the Initiate Multipart Upload request, but has not yet been
-// completed or aborted. This operation returns at most 1,000 multipart
-// uploads in the response.
-//
-func (api objectAPIHandlers) ListMultipartUploadsHandler(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/mpuAndPermissions.html
-		if s3Error := enforceBucketPolicy("s3:ListBucketMultipartUploads", bucket, r.URL); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	case authTypePresigned, authTypeSigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-
-	prefix, keyMarker, uploadIDMarker, delimiter, maxUploads, _ := getBucketMultipartResources(r.URL.Query())
-	if maxUploads < 0 {
-		writeErrorResponse(w, r, ErrInvalidMaxUploads, r.URL.Path)
-		return
-	}
-	if keyMarker != "" {
-		// Marker not common with prefix is not implemented.
-		if !strings.HasPrefix(keyMarker, prefix) {
-			writeErrorResponse(w, r, ErrNotImplemented, r.URL.Path)
-			return
-		}
-	}
-
-	listMultipartsInfo, err := api.ObjectAPI.ListMultipartUploads(bucket, prefix, keyMarker, uploadIDMarker, delimiter, maxUploads)
-	if err != nil {
-		errorIf(err, "Unable to list multipart uploads.")
-		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
-		return
-	}
-	// generate response
-	response := generateListMultipartUploadsResponse(bucket, listMultipartsInfo)
-	encodedSuccessResponse := encodeResponse(response)
-	// write headers.
-	setCommonHeaders(w)
-	// write success response.
-	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)
-		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)
-		return
-	}
-	errorIf(err, "Unable to list buckets.")
-	writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
-}
-
-// DeleteMultipleObjectsHandler - deletes multiple objects.
-func (api objectAPIHandlers) DeleteMultipleObjectsHandler(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:DeleteObject", bucket, r.URL); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	case authTypePresigned, authTypeSigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-
-	// Content-Length is required and should be non-zero
-	// http://docs.aws.amazon.com/AmazonS3/latest/API/multiobjectdeleteapi.html
-	if r.ContentLength <= 0 {
-		writeErrorResponse(w, r, ErrMissingContentLength, r.URL.Path)
-		return
-	}
-
-	// Content-Md5 is requied should be set
-	// http://docs.aws.amazon.com/AmazonS3/latest/API/multiobjectdeleteapi.html
-	if _, ok := r.Header["Content-Md5"]; !ok {
-		writeErrorResponse(w, r, ErrMissingContentMD5, r.URL.Path)
-		return
-	}
-
-	// Allocate incoming content length bytes.
-	deleteXMLBytes := make([]byte, r.ContentLength)
-
-	// Read incoming body XML bytes.
-	if _, err := io.ReadFull(r.Body, deleteXMLBytes); err != nil {
-		errorIf(err, "Unable to read HTTP body.")
-		writeErrorResponse(w, r, ErrInternalError, r.URL.Path)
-		return
-	}
-
-	// Unmarshal list of keys to be deleted.
-	deleteObjects := &DeleteObjectsRequest{}
-	if err := xml.Unmarshal(deleteXMLBytes, deleteObjects); err != nil {
-		errorIf(err, "Unable to unmarshal delete objects request XML.")
-		writeErrorResponse(w, r, ErrMalformedXML, r.URL.Path)
-		return
-	}
-
-	var deleteErrors []DeleteError
-	var deletedObjects []ObjectIdentifier
-	// Loop through all the objects and delete them sequentially.
-	for _, object := range deleteObjects.Objects {
-		err := api.ObjectAPI.DeleteObject(bucket, object.ObjectName)
-		if err == nil {
-			deletedObjects = append(deletedObjects, ObjectIdentifier{
-				ObjectName: object.ObjectName,
-			})
-		} else {
-			errorIf(err, "Unable to delete object.")
-			deleteErrors = append(deleteErrors, DeleteError{
-				Code:    errorCodeResponse[toAPIErrorCode(err)].Code,
-				Message: errorCodeResponse[toAPIErrorCode(err)].Description,
-				Key:     object.ObjectName,
-			})
-		}
-	}
-	// Generate response
-	response := generateMultiDeleteResponse(deleteObjects.Quiet, deletedObjects, deleteErrors)
-	encodedSuccessResponse := encodeResponse(response)
-	// Write headers
-	setCommonHeaders(w)
-	// Write success response.
-	writeSuccessResponse(w, encodedSuccessResponse)
-}
-
-// PutBucketHandler - PUT Bucket
-// ----------
-// This implementation of the PUT operation creates a new bucket for authenticated request
-func (api objectAPIHandlers) PutBucketHandler(w http.ResponseWriter, r *http.Request) {
-	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
-		}
-	}
-
-	// 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.
-	err := api.ObjectAPI.MakeBucket(bucket)
-	if err != nil {
-		errorIf(err, "Unable to create a bucket.")
-		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
-		return
-	}
-	// Make sure to add Location information here only for bucket
-	w.Header().Set("Location", getLocation(r))
-	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
-// signature policy in multipart/form-data
-func (api objectAPIHandlers) PostPolicyBucketHandler(w http.ResponseWriter, r *http.Request) {
-	// Here the parameter is the size of the form data that should
-	// be loaded in memory, the remaining being put in temporary files.
-	reader, err := r.MultipartReader()
-	if err != nil {
-		errorIf(err, "Unable to initialize multipart reader.")
-		writeErrorResponse(w, r, ErrMalformedPOSTRequest, r.URL.Path)
-		return
-	}
-
-	fileBody, formValues, err := extractHTTPFormValues(reader)
-	if err != nil {
-		errorIf(err, "Unable to parse form values.")
-		writeErrorResponse(w, r, ErrMalformedPOSTRequest, r.URL.Path)
-		return
-	}
-	bucket := mux.Vars(r)["bucket"]
-	formValues["Bucket"] = bucket
-	object := formValues["Key"]
-
-	// Verify policy signature.
-	apiErr := doesPolicySignatureMatch(formValues)
-	if apiErr != ErrNone {
-		writeErrorResponse(w, r, apiErr, r.URL.Path)
-		return
-	}
-	if apiErr = checkPostPolicy(formValues); apiErr != ErrNone {
-		writeErrorResponse(w, r, apiErr, r.URL.Path)
-		return
-	}
-
-	// Save metadata.
-	metadata := make(map[string]string)
-	// Nothing to store right now.
-
-	md5Sum, err := api.ObjectAPI.PutObject(bucket, object, -1, fileBody, metadata)
-	if err != nil {
-		errorIf(err, "Unable to create object.")
-		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
-		return
-	}
-	if md5Sum != "" {
-		w.Header().Set("ETag", "\""+md5Sum+"\"")
-	}
-	encodedSuccessResponse := encodeResponse(PostResponse{
-		Location: getObjectLocation(bucket, object), // TODO Full URL is preferred
-		Bucket:   bucket,
-		Key:      object,
-		ETag:     md5Sum,
-	})
-	setCommonHeaders(w)
-	writeSuccessResponse(w, encodedSuccessResponse)
-}
-
-// HeadBucketHandler - HEAD Bucket
-// ----------
-// This operation is useful to determine if a bucket exists.
-// The operation returns a 200 OK if the bucket exists and you
-// have permission to access it. Otherwise, the operation might
-// return responses such as 404 Not Found and 403 Forbidden.
-func (api objectAPIHandlers) HeadBucketHandler(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 authTypePresigned, authTypeSigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-
-	if _, err := api.ObjectAPI.GetBucketInfo(bucket); err != nil {
-		errorIf(err, "Unable to fetch bucket info.")
-		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
-		return
-	}
-	writeSuccessResponse(w, nil)
-}
-
-// DeleteBucketHandler - Delete bucket
-func (api objectAPIHandlers) DeleteBucketHandler(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 authTypePresigned, authTypeSigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-
-	if err := api.ObjectAPI.DeleteBucket(bucket); err != nil {
-		errorIf(err, "Unable to delete a bucket.")
-		writeErrorResponse(w, r, toAPIErrorCode(err), r.URL.Path)
-		return
-	}
-
-	// Delete bucket access policy, if present - ignore any errors.
-	removeBucketPolicy(bucket)
-
-	// Write success response.
-	writeSuccessNoContent(w)
-}

bucket-policy-handlers.go

@@ -1,302 +0,0 @@
-/*
- * 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 (
-	"bytes"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"strings"
-
-	mux "github.com/gorilla/mux"
-)
-
-// maximum supported access policy size.
-const maxAccessPolicySize = 20 * 1024 // 20KiB.
-
-// Verify if a given action is valid for the url path based on the
-// existing bucket access policy.
-func bucketPolicyEvalStatements(action string, resource string, conditions map[string]string, statements []policyStatement) bool {
-	for _, statement := range statements {
-		if bucketPolicyMatchStatement(action, resource, conditions, statement) {
-			if statement.Effect == "Allow" {
-				return true
-			}
-			// Do not uncomment kept here for readability.
-			// else statement.Effect == "Deny"
-			return false
-		}
-	}
-	// None match so deny.
-	return false
-}
-
-// Verify if action, resource and conditions match input policy statement.
-func bucketPolicyMatchStatement(action string, resource string, conditions map[string]string, statement policyStatement) bool {
-	// Verify if action matches.
-	if bucketPolicyActionMatch(action, statement) {
-		// Verify if resource matches.
-		if bucketPolicyResourceMatch(resource, statement) {
-			// Verify if condition matches.
-			if bucketPolicyConditionMatch(conditions, statement) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// Verify if given action matches with policy statement.
-func bucketPolicyActionMatch(action string, statement policyStatement) bool {
-	for _, policyAction := range statement.Actions {
-		if matched := actionMatch(policyAction, action); matched {
-			return true
-		}
-	}
-	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)
-}
-
-// Match function matches wild cards in 'pattern' for action.
-func actionMatch(pattern, action string) bool {
-	return wildCardMatch(pattern, action)
-}
-
-// Verify if given resource matches with policy statement.
-func bucketPolicyResourceMatch(resource string, statement policyStatement) bool {
-	for _, resourcep := range statement.Resources {
-		// the resource rule for object could contain "*" wild card.
-		// the requested object can be given access based on the already set bucket policy if
-		// the match is successful.
-		// More info: http://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html .
-		if matched := resourceMatch(resourcep, resource); matched {
-			return true
-		}
-	}
-	return false
-}
-
-// Verify if given condition matches with policy statement.
-func bucketPolicyConditionMatch(conditions map[string]string, statement policyStatement) bool {
-	// Supports following conditions.
-	// - StringEquals
-	// - StringNotEquals
-	//
-	// Supported applicable condition keys for each conditions.
-	// - s3:prefix
-	// - s3:max-keys
-	var conditionMatches = true
-	for condition, conditionKeys := range statement.Conditions {
-		if condition == "StringEquals" {
-			if conditionKeys["s3:prefix"] != conditions["prefix"] {
-				conditionMatches = false
-				break
-			}
-			if conditionKeys["s3:max-keys"] != conditions["max-keys"] {
-				conditionMatches = false
-				break
-			}
-		} else if condition == "StringNotEquals" {
-			if conditionKeys["s3:prefix"] == conditions["prefix"] {
-				conditionMatches = false
-				break
-			}
-			if conditionKeys["s3:max-keys"] == conditions["max-keys"] {
-				conditionMatches = false
-				break
-			}
-		}
-	}
-	return conditionMatches
-}
-
-// PutBucketPolicyHandler - PUT Bucket policy
-// -----------------
-// This implementation of the PUT operation uses the policy
-// subresource to add to or replace a policy on a bucket
-func (api objectAPIHandlers) PutBucketPolicyHandler(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 authTypePresigned, authTypeSigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-
-	// If Content-Length is unknown or zero, deny the
-	// request. PutBucketPolicy always needs a Content-Length if
-	// incoming request is not chunked.
-	if !contains(r.TransferEncoding, "chunked") {
-		if r.ContentLength == -1 || r.ContentLength == 0 {
-			writeErrorResponse(w, r, ErrMissingContentLength, r.URL.Path)
-			return
-		}
-		// If Content-Length is greater than maximum allowed policy size.
-		if r.ContentLength > maxAccessPolicySize {
-			writeErrorResponse(w, r, ErrEntityTooLarge, r.URL.Path)
-			return
-		}
-	}
-
-	// 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))
-	if err != nil {
-		errorIf(err, "Unable to read bucket policy.")
-		writeErrorResponse(w, r, ErrInternalError, r.URL.Path)
-		return
-	}
-
-	// Parse bucket policy.
-	bucketPolicy, err := parseBucketPolicy(bucketPolicyBuf)
-	if err != nil {
-		errorIf(err, "Unable to parse bucket policy.")
-		writeErrorResponse(w, r, ErrInvalidPolicyDocument, r.URL.Path)
-		return
-	}
-
-	// Parse check bucket policy.
-	if s3Error := checkBucketPolicyResources(bucket, bucketPolicy); s3Error != ErrNone {
-		writeErrorResponse(w, r, s3Error, r.URL.Path)
-		return
-	}
-
-	// Save bucket policy.
-	if err := writeBucketPolicy(bucket, bucketPolicyBuf); err != nil {
-		errorIf(err, "Unable to write bucket policy.")
-		switch err.(type) {
-		case BucketNameInvalid:
-			writeErrorResponse(w, r, ErrInvalidBucketName, r.URL.Path)
-		default:
-			writeErrorResponse(w, r, ErrInternalError, r.URL.Path)
-		}
-		return
-	}
-	writeSuccessNoContent(w)
-}
-
-// DeleteBucketPolicyHandler - DELETE Bucket policy
-// -----------------
-// This implementation of the DELETE operation uses the policy
-// subresource to add to remove a policy on a bucket.
-func (api objectAPIHandlers) DeleteBucketPolicyHandler(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 authTypePresigned, authTypeSigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-
-	// Delete bucket access policy.
-	if err := removeBucketPolicy(bucket); err != nil {
-		errorIf(err, "Unable to remove bucket policy.")
-		switch err.(type) {
-		case BucketNameInvalid:
-			writeErrorResponse(w, r, ErrInvalidBucketName, r.URL.Path)
-		case BucketPolicyNotFound:
-			writeErrorResponse(w, r, ErrNoSuchBucketPolicy, r.URL.Path)
-		default:
-			writeErrorResponse(w, r, ErrInternalError, r.URL.Path)
-		}
-		return
-	}
-	writeSuccessNoContent(w)
-}
-
-// GetBucketPolicyHandler - GET Bucket policy
-// -----------------
-// This operation uses the policy
-// subresource to return the policy of a specified bucket.
-func (api objectAPIHandlers) GetBucketPolicyHandler(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 authTypePresigned, authTypeSigned:
-		if s3Error := isReqAuthenticated(r); s3Error != ErrNone {
-			writeErrorResponse(w, r, s3Error, r.URL.Path)
-			return
-		}
-	}
-
-	// Read bucket access policy.
-	p, err := readBucketPolicy(bucket)
-	if err != nil {
-		errorIf(err, "Unable to read bucket policy.")
-		switch err.(type) {
-		case BucketNameInvalid:
-			writeErrorResponse(w, r, ErrInvalidBucketName, r.URL.Path)
-		case BucketPolicyNotFound:
-			writeErrorResponse(w, r, ErrNoSuchBucketPolicy, r.URL.Path)
-		default:
-			writeErrorResponse(w, r, ErrInternalError, r.URL.Path)
-		}
-		return
-	}
-	io.Copy(w, bytes.NewReader(p))
-}

bucket-policy-handlers_test.go

@@ -1,671 +0,0 @@
-/*
- * 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 (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-// Tests validate Bucket policy resource matcher.
-func TestBucketPolicyResourceMatch(t *testing.T) {
-
-	// generates statement with given resource..
-	generateStatement := func(resource string) policyStatement {
-		statement := policyStatement{}
-		statement.Resources = []string{resource}
-		return statement
-	}
-
-	// generates resource prefix.
-	generateResource := func(bucketName, objectName string) string {
-		return AWSResourcePrefix + bucketName + "/" + objectName
-	}
-
-	testCases := []struct {
-		resourceToMatch       string
-		statement             policyStatement
-		expectedResourceMatch bool
-	}{
-		// Test case 1-4.
-		// Policy with resource ending with bucket/* allows access to all objects inside the given bucket.
-		{generateResource("minio-bucket", ""), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix, "minio-bucket"+"/*")), true},
-		{generateResource("minio-bucket", ""), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix, "minio-bucket"+"/*")), true},
-		{generateResource("minio-bucket", ""), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix, "minio-bucket"+"/*")), true},
-		{generateResource("minio-bucket", ""), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix, "minio-bucket"+"/*")), true},
-		// Test case - 5.
-		// Policy with resource ending with bucket/oo* should not allow access to bucket/output.txt.
-		{generateResource("minio-bucket", "output.txt"), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix, "minio-bucket"+"/oo*")), false},
-		// Test case - 6.
-		// Policy with resource ending with bucket/oo* should allow access to bucket/ootput.txt.
-		{generateResource("minio-bucket", "ootput.txt"), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix, "minio-bucket"+"/oo*")), true},
-		// Test case - 7.
-		// Policy with resource ending with bucket/oo* allows access to all subfolders starting with "oo" inside given bucket.
-		{generateResource("minio-bucket", "oop-bucket/my-file"), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix, "minio-bucket"+"/oo*")), true},
-		// Test case - 8.
-		{generateResource("minio-bucket", "Asia/India/1.pjg"), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix, "minio-bucket"+"/Asia/Japan/*")), false},
-		// Test case - 9.
-		{generateResource("minio-bucket", "Asia/India/1.pjg"), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix, "minio-bucket"+"/Asia/Japan/*")), false},
-		// Test case - 10.
-		// Proves that the name space is flat.
-		{generateResource("minio-bucket", "Africa/Bihar/India/design_info.doc/Bihar"), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix,
-			"minio-bucket"+"/*/India/*/Bihar")), true},
-		// Test case - 11.
-		// Proves that the name space is flat.
-		{generateResource("minio-bucket", "Asia/China/India/States/Bihar/output.txt"), generateStatement(fmt.Sprintf("%s%s", AWSResourcePrefix,
-			"minio-bucket"+"/*/India/*/Bihar/*")), true},
-	}
-	for i, testCase := range testCases {
-		actualResourceMatch := bucketPolicyResourceMatch(testCase.resourceToMatch, testCase.statement)
-		if testCase.expectedResourceMatch != actualResourceMatch {
-			t.Errorf("Test %d: Expected Resource match to be `%v`, but instead found it to be `%v`", i+1, testCase.expectedResourceMatch, actualResourceMatch)
-		}
-	}
-}
-
-// TestBucketPolicyActionMatch - Test validates whether given action on the
-// bucket/object matches the allowed actions in policyStatement.
-// This test preserves the allowed actions for all 3 sets of policies, that is read-write,read-only, write-only.
-// The intention of the test is to catch any changes made to allowed action for on eof the above 3 major policy groups mentioned.
-func TestBucketPolicyActionMatch(t *testing.T) {
-	bucketName := getRandomBucketName()
-	objectPrefix := "test-object"
-
-	testCases := []struct {
-		action         string
-		statement      policyStatement
-		expectedResult bool
-	}{
-		// s3:GetBucketLocation is the action necessary to be present in the bucket policy to allow
-		// fetching of bucket location on an Anonymous/unsigned request.
-
-		//r ead-write bucket policy is expected to allow GetBucketLocation operation on an anonymous request (Test case - 1).
-		{"s3:GetBucketLocation", getReadWriteBucketStatement(bucketName, objectPrefix), true},
-		//	write-only bucket policy is expected to allow GetBucketLocation operation on an anonymous request (Test case - 2).
-		{"s3:GetBucketLocation", getWriteOnlyBucketStatement(bucketName, objectPrefix), true},
-		//	read-only bucket policy is expected to allow GetBucketLocation operation on an anonymous request (Test case - 3).
-		{"s3:GetBucketLocation", getReadOnlyBucketStatement(bucketName, objectPrefix), true},
-
-		// Any of the Object level access permissions shouldn't allow for GetBucketLocation operation  on an Anonymous/unsigned request (Test cases 4-6).
-		{"s3:GetBucketLocation", getReadWriteObjectStatement(bucketName, objectPrefix), false},
-		{"s3:GetBucketLocation", getWriteOnlyObjectStatement(bucketName, objectPrefix), false},
-		{"s3:GetBucketLocation", getReadOnlyObjectStatement(bucketName, objectPrefix), false},
-
-		// s3:ListBucketMultipartUploads is the action necessary to be present in the bucket policy to allow
-		// Listing of multipart uploads in a given bucket for an Anonymous/unsigned request.
-
-		//read-write bucket policy is expected to allow  ListBucketMultipartUploads operation on an anonymous request (Test case 7).
-		{"s3:ListBucketMultipartUploads", getReadWriteBucketStatement(bucketName, objectPrefix), true},
-		//	write-only bucket policy is expected to allow  ListBucketMultipartUploads operation on an anonymous request (Test case 8).
-		{"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.
-		{"s3:ListBucketMultipartUploads", getReadOnlyBucketStatement(bucketName, objectPrefix), false},
-
-		// Any of the object level policy will not allow for s3:ListBucketMultipartUploads (Test cases 10-12).
-		{"s3:ListBucketMultipartUploads", getReadWriteObjectStatement(bucketName, objectPrefix), false},
-		{"s3:ListBucketMultipartUploads", getWriteOnlyObjectStatement(bucketName, objectPrefix), false},
-		{"s3:ListBucketMultipartUploads", getReadOnlyObjectStatement(bucketName, objectPrefix), false},
-
-		// s3:ListBucket is the action necessary to be present in the bucket policy to allow
-		// listing of all objects inside a given bucket on an Anonymous/unsigned request.
-
-		// Cases for testing ListBucket access for different Bucket level access permissions.
-		// read-only bucket policy is expected to allow ListBucket operation on an anonymous request (Test case 13).
-		{"s3:ListBucket", getReadOnlyBucketStatement(bucketName, objectPrefix), true},
-		// read-write bucket policy is expected to allow ListBucket operation on an anonymous request (Test case 14).
-		{"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.
-		{"s3:ListBucket", getWriteOnlyBucketStatement(bucketName, objectPrefix), false},
-
-		// Cases for testing ListBucket access for different Object level access permissions (Test cases 16-18).
-		// Any of the Object level access permissions shouldn't allow for ListBucket operation  on an Anonymous/unsigned request.
-		{"s3:ListBucket", getReadOnlyObjectStatement(bucketName, objectPrefix), false},
-		{"s3:ListBucket", getReadWriteObjectStatement(bucketName, objectPrefix), false},
-		{"s3:ListBucket", getWriteOnlyObjectStatement(bucketName, objectPrefix), false},
-
-		// s3:DeleteObject is the action necessary to be present in the bucket policy to allow
-		// deleting/removal of  objects inside a given bucket for an Anonymous/unsigned request.
-
-		// Cases for testing DeleteObject access for different Bucket level access permissions (Test cases 19-21).
-		// Any of the Bucket level access permissions shouldn't allow for DeleteObject operation  on an Anonymous/unsigned request.
-		{"s3:DeleteObject", getReadOnlyBucketStatement(bucketName, objectPrefix), false},
-		{"s3:DeleteObject", getReadWriteBucketStatement(bucketName, objectPrefix), false},
-		{"s3:DeleteObject", getWriteOnlyBucketStatement(bucketName, objectPrefix), false},
-
-		// Cases for testing DeleteObject access for different Object level access permissions (Test cases 22).
-		// read-only bucket policy is expected to not allow Delete Object operation on an anonymous request.
-		{"s3:DeleteObject", getReadOnlyObjectStatement(bucketName, objectPrefix), false},
-		// read-write bucket policy is expected to allow Delete Bucket operation on an anonymous request (Test cases 23).
-		{"s3:DeleteObject", getReadWriteObjectStatement(bucketName, objectPrefix), true},
-		// write-only  bucket policy is expected to allow Delete Object operation on an anonymous request (Test cases 24).
-		{"s3:DeleteObject", getWriteOnlyObjectStatement(bucketName, objectPrefix), true},
-
-		// s3:AbortMultipartUpload is the action necessary to be present in the bucket policy to allow
-		// cancelling or abortion of an already initiated multipart upload operation for an Anonymous/unsigned request.
-
-		// Cases for testing AbortMultipartUpload access for different Bucket level access permissions (Test cases 25-27).
-		// Any of the Bucket level access permissions shouldn't allow for AbortMultipartUpload operation on an Anonymous/unsigned request.
-		{"s3:AbortMultipartUpload", getReadOnlyBucketStatement(bucketName, objectPrefix), false},
-		{"s3:AbortMultipartUpload", getReadWriteBucketStatement(bucketName, objectPrefix), false},
-		{"s3:AbortMultipartUpload", getWriteOnlyBucketStatement(bucketName, objectPrefix), false},
-
-		// Cases for testing AbortMultipartUpload access for different Object level access permissions.
-		// read-only object policy is expected to not allow AbortMultipartUpload operation on an anonymous request (Test case 28).
-		{"s3:AbortMultipartUpload", getReadOnlyObjectStatement(bucketName, objectPrefix), false},
-		// read-write object policy is expected to allow AbortMultipartUpload operation on an anonymous request (Test case 29).
-		{"s3:AbortMultipartUpload", getReadWriteObjectStatement(bucketName, objectPrefix), true},
-		// write-only object policy is expected to allow AbortMultipartUpload operation on an anonymous request (Test case 30).
-		{"s3:AbortMultipartUpload", getWriteOnlyObjectStatement(bucketName, objectPrefix), true},
-
-		// s3:PutObject is the action necessary to be present in the bucket policy to allow
-		// uploading of an object for an Anonymous/unsigned request.
-
-		// Cases for testing PutObject access for different Bucket level access permissions (Test cases 31-33).
-		// Any of the Bucket level access permissions shouldn't allow for PutObject operation on an Anonymous/unsigned request.
-		{"s3:PutObject", getReadOnlyBucketStatement(bucketName, objectPrefix), false},
-		{"s3:PutObject", getReadWriteBucketStatement(bucketName, objectPrefix), false},
-		{"s3:PutObject", getWriteOnlyBucketStatement(bucketName, objectPrefix), false},
-
-		// Cases for testing PutObject access for different Object level access permissions.
-		// read-only object policy is expected to not allow PutObject operation on an anonymous request (Test case 34).
-		{"s3:PutObject", getReadOnlyObjectStatement(bucketName, objectPrefix), false},
-		// read-write object policy is expected to allow PutObject operation on an anonymous request (Test case 35).
-		{"s3:PutObject", getReadWriteObjectStatement(bucketName, objectPrefix), true},
-		// write-only  object policy is expected to allow PutObject operation on an anonymous request (Test case 36).
-		{"s3:PutObject", getWriteOnlyObjectStatement(bucketName, objectPrefix), true},
-
-		// s3:GetObject is the action necessary to be present in the bucket policy to allow
-		// downloading of an object for an Anonymous/unsigned request.
-
-		// Cases for testing GetObject access for different Bucket level access permissions (Test cases 37-39).
-		// Any of the Bucket level access permissions shouldn't allow for GetObject operation on an Anonymous/unsigned request.
-		{"s3:GetObject", getReadOnlyBucketStatement(bucketName, objectPrefix), false},
-		{"s3:GetObject", getReadWriteBucketStatement(bucketName, objectPrefix), false},
-		{"s3:GetObject", getWriteOnlyBucketStatement(bucketName, objectPrefix), false},
-
-		// Cases for testing GetObject access for different Object level access permissions.
-		// read-only bucket policy is expected to allow  downloading of an Object on an anonymous request (Test case 40).
-		{"s3:GetObject", getReadOnlyObjectStatement(bucketName, objectPrefix), true},
-		// read-write bucket policy is expected to allow  downloading of an Object on an anonymous request (Test case 41).
-		{"s3:GetObject", getReadWriteObjectStatement(bucketName, objectPrefix), true},
-		// write-only  bucket policy is expected to not allow  downloading of an Object on an anonymous request (Test case 42).
-		{"s3:GetObject", getWriteOnlyObjectStatement(bucketName, objectPrefix), false},
-
-		// s3:ListMultipartUploadParts is the action necessary to be present in the bucket policy to allow
-		// Listing of uploaded parts for an Anonymous/unsigned request.
-
-		// Any of the Bucket level access permissions shouldn't allow for ListMultipartUploadParts operation on an Anonymous/unsigned request.
-		// read-only bucket policy is expected to not allow ListMultipartUploadParts operation on an anonymous request (Test cases 43-45).
-		{"s3:ListMultipartUploadParts", getReadOnlyBucketStatement(bucketName, objectPrefix), false},
-		{"s3:ListMultipartUploadParts", getReadWriteBucketStatement(bucketName, objectPrefix), false},
-		{"s3:ListMultipartUploadParts", getWriteOnlyBucketStatement(bucketName, objectPrefix), false},
-
-		// read-only object policy is expected to not allow ListMultipartUploadParts operation on an anonymous request (Test case 46).
-		{"s3:ListMultipartUploadParts", getReadOnlyObjectStatement(bucketName, objectPrefix), false},
-		// read-write object policy is expected to allow ListMultipartUploadParts operation on an anonymous request (Test case 47).
-		{"s3:ListMultipartUploadParts", getReadWriteObjectStatement(bucketName, objectPrefix), true},
-		// write-only  object policy is expected to allow ListMultipartUploadParts operation on an anonymous request (Test case 48).
-		{"s3:ListMultipartUploadParts", getWriteOnlyObjectStatement(bucketName, objectPrefix), true},
-	}
-	for i, testCase := range testCases {
-		actualResult := bucketPolicyActionMatch(testCase.action, testCase.statement)
-		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)
-		}
-	}
-}
-
-// 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)
-}
-
-// 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) {
-	// get random bucket name.
-	bucketName := getRandomBucketName()
-	// Create bucket.
-	err := obj.MakeBucket(bucketName)
-	if err != nil {
-		// failed to create newbucket, abort.
-		t.Fatalf("%s : %s", instanceType, err)
-	}
-	// Register the API end points with XL/FS object layer.
-	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")
-	if err != nil {
-		t.Fatalf("Init Test config failed")
-	}
-	// remove the root folder after the test ends.
-	defer removeAll(rootPath)
-
-	// 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*"
-            ]
-        }
-    ]
-}`
-
-	// test cases with sample input and expected output.
-	testCases := []struct {
-		bucketName string
-		accessKey  string
-		secretKey  string
-		// expected Response.
-		expectedRespStatus int
-	}{
-		{bucketName, credentials.AccessKeyID, credentials.SecretAccessKey, http.StatusNoContent},
-	}
-
-	// Iterating over the test cases, calling the function under test and asserting the response.
-	for i, testCase := range testCases {
-		// obtain the put bucket policy request body.
-		bucketPolicyStr := fmt.Sprintf(bucketPolicyTemplate, testCase.bucketName, testCase.bucketName)
-		// initialize HTTP NewRecorder, this records any mutations to response writer inside the handler.
-		rec := httptest.NewRecorder()
-		// construct HTTP request for PUT bucket policy endpoint.
-		req, err := newTestSignedRequest("PUT", getPutPolicyURL("", testCase.bucketName),
-			int64(len(bucketPolicyStr)), bytes.NewReader([]byte(bucketPolicyStr)), testCase.accessKey, testCase.secretKey)
-		if err != nil {
-			t.Fatalf("Test %d: Failed to create HTTP request for PutBucketPolicyHandler: <ERROR> %v", i+1, err)
-		}
-		// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic ofthe handler.
-		// Call the ServeHTTP to execute the handler.
-		apiRouter.ServeHTTP(rec, req)
-		if rec.Code != testCase.expectedRespStatus {
-			t.Errorf("Test %d: Expected the response status to be `%d`, but instead found `%d`", i+1, testCase.expectedRespStatus, rec.Code)
-		}
-	}
-}
-
-// Wrapper for calling Get Bucket Policy HTTP handler tests for both XL multiple disks and single node setup.
-func TestGetBucketPolicyHandler(t *testing.T) {
-	ExecObjectLayerTest(t, testGetBucketPolicyHandler)
-}
-
-// 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) {
-	// get random bucket name.
-	bucketName := getRandomBucketName()
-	// Create bucket.
-	err := obj.MakeBucket(bucketName)
-	if err != nil {
-		// failed to create newbucket, abort.
-		t.Fatalf("%s : %s", instanceType, err)
-	}
-	// Register the API end points with XL/FS object layer.
-	// Registering only the PutBucketPolicy and GetBucketPolicy handlers.
-	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")
-	if err != nil {
-		t.Fatalf("Init Test config failed")
-	}
-	// remove the root folder after the test ends.
-	defer removeAll(rootPath)
-
-	// 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*"
-            ]
-        }
-    ]
-}`
-
-	// Writing bucket policy before running test on GetBucketPolicy.
-	putTestPolicies := []struct {
-		bucketName string
-		accessKey  string
-		secretKey  string
-		// expected Response.
-		expectedRespStatus int
-	}{
-		{bucketName, credentials.AccessKeyID, credentials.SecretAccessKey, http.StatusNoContent},
-	}
-
-	// Iterating over the cases and writing the bucket policy.
-	// its required to write the policies first before running tests on GetBucketPolicy.
-	for i, testPolicy := range putTestPolicies {
-		// obtain the put bucket policy request body.
-		bucketPolicyStr := fmt.Sprintf(bucketPolicyTemplate, testPolicy.bucketName, testPolicy.bucketName)
-		// initialize HTTP NewRecorder, this records any mutations to response writer inside the handler.
-		rec := httptest.NewRecorder()
-		// construct HTTP request for PUT bucket policy endpoint.
-		req, err := newTestSignedRequest("PUT", getPutPolicyURL("", testPolicy.bucketName),
-			int64(len(bucketPolicyStr)), bytes.NewReader([]byte(bucketPolicyStr)), testPolicy.accessKey, testPolicy.secretKey)
-		if err != nil {
-			t.Fatalf("Test %d: Failed to create HTTP request for PutBucketPolicyHandler: <ERROR> %v", i+1, err)
-		}
-		// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic ofthe handler.
-		// Call the ServeHTTP to execute the handler.
-		apiRouter.ServeHTTP(rec, req)
-		if rec.Code != testPolicy.expectedRespStatus {
-			t.Fatalf("Case %d: Expected the response status to be `%d`, but instead found `%d`", i+1, testPolicy.expectedRespStatus, rec.Code)
-		}
-	}
-
-	// test cases with inputs and expected result for GetBucketPolicyHandler.
-	testCases := []struct {
-		bucketName string
-		accessKey  string
-		secretKey  string
-		// expected output.
-		expectedBucketPolicy string
-		expectedRespStatus   int
-	}{
-		{bucketName, credentials.AccessKeyID, credentials.SecretAccessKey, bucketPolicyTemplate, http.StatusOK},
-	}
-	// Iterating over the cases, fetching the policy and validating the response.
-	for i, testCase := range testCases {
-		// expected bucket policy json string.
-		expectedBucketPolicyStr := fmt.Sprintf(testCase.expectedBucketPolicy, testCase.bucketName, testCase.bucketName)
-		// initialize HTTP NewRecorder, this records any mutations to response writer inside the handler.
-		rec := httptest.NewRecorder()
-		// construct HTTP request for PUT bucket policy endpoint.
-		req, err := newTestSignedRequest("GET", getGetPolicyURL("", testCase.bucketName),
-			0, nil, testCase.accessKey, testCase.secretKey)
-
-		if err != nil {
-			t.Fatalf("Test %d: Failed to create HTTP request for GetBucketPolicyHandler: <ERROR> %v", i+1, err)
-		}
-		// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic of the handler.
-		// Call the ServeHTTP to execute the handler, GetBucketPolicyHandler handles the request.
-		apiRouter.ServeHTTP(rec, req)
-		// Assert the response code with the expected status.
-		if rec.Code != testCase.expectedRespStatus {
-			t.Fatalf("Case %d: Expected the response status to be `%d`, but instead found `%d`", i+1, testCase.expectedRespStatus, rec.Code)
-		}
-		// read the response body.
-		bucketPolicyReadBuf, err := ioutil.ReadAll(rec.Body)
-		if err != nil {
-			t.Fatalf("Test %d: %s: Failed parsing response body: <ERROR> %v", i+1, instanceType, err)
-		}
-		// Verify whether the bucket policy fetched is same as the one inserted.
-		if expectedBucketPolicyStr != string(bucketPolicyReadBuf) {
-			t.Errorf("Test %d: %s: Bucket policy differs from expected value.", i+1, instanceType)
-		}
-	}
-}
-
-// Wrapper for calling Delete Bucket Policy HTTP handler tests for both XL multiple disks and single node setup.
-func TestDeleteBucketPolicyHandler(t *testing.T) {
-	ExecObjectLayerTest(t, testDeleteBucketPolicyHandler)
-}
-
-// 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) {
-	// get random bucket name.
-	bucketName := getRandomBucketName()
-	// Create bucket.
-	err := obj.MakeBucket(bucketName)
-	if err != nil {
-		// 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")
-	if err != nil {
-		t.Fatalf("Init Test config failed")
-	}
-	// remove the root folder after the test ends.
-	defer removeAll(rootPath)
-
-	// 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*"
-            ]
-        }
-    ]
-}`
-
-	// Writing bucket policy before running test on DeleteBucketPolicy.
-	putTestPolicies := []struct {
-		bucketName string
-		accessKey  string
-		secretKey  string
-		// expected Response.
-		expectedRespStatus int
-	}{
-		{bucketName, credentials.AccessKeyID, credentials.SecretAccessKey, http.StatusNoContent},
-	}
-
-	// Iterating over the cases and writing the bucket policy.
-	// its required to write the policies first before running tests on GetBucketPolicy.
-	for i, testPolicy := range putTestPolicies {
-		// obtain the put bucket policy request body.
-		bucketPolicyStr := fmt.Sprintf(bucketPolicyTemplate, testPolicy.bucketName, testPolicy.bucketName)
-		// initialize HTTP NewRecorder, this records any mutations to response writer inside the handler.
-		rec := httptest.NewRecorder()
-		// construct HTTP request for PUT bucket policy endpoint.
-		req, err := newTestSignedRequest("PUT", getPutPolicyURL("", testPolicy.bucketName),
-			int64(len(bucketPolicyStr)), bytes.NewReader([]byte(bucketPolicyStr)), testPolicy.accessKey, testPolicy.secretKey)
-		if err != nil {
-			t.Fatalf("Test %d: Failed to create HTTP request for PutBucketPolicyHandler: <ERROR> %v", i+1, err)
-		}
-		// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic of the handler.
-		// Call the ServeHTTP to execute the handler.
-		apiRouter.ServeHTTP(rec, req)
-		if rec.Code != testPolicy.expectedRespStatus {
-			t.Fatalf("Case %d: Expected the response status to be `%d`, but instead found `%d`", i+1, testPolicy.expectedRespStatus, rec.Code)
-		}
-	}
-	// testcases with input and expected output for DeleteBucketPolicyHandler.
-	testCases := []struct {
-		bucketName string
-		accessKey  string
-		secretKey  string
-		// expected Response.
-		expectedRespStatus int
-	}{
-		{bucketName, credentials.AccessKeyID, credentials.SecretAccessKey, http.StatusNoContent},
-	}
-	// Iterating over the cases and deleting the bucket policy and then asserting response.
-	for i, testCase := range testCases {
-		// initialize HTTP NewRecorder, this records any mutations to response writer inside the handler.
-		rec := httptest.NewRecorder()
-		// construct HTTP request for Delete bucket policy endpoint.
-		req, err := newTestSignedRequest("DELETE", getDeletePolicyURL("", testCase.bucketName),
-			0, nil, testCase.accessKey, testCase.secretKey)
-
-		if err != nil {
-			t.Fatalf("Test %d: Failed to create HTTP request for GetBucketPolicyHandler: <ERROR> %v", i+1, err)
-		}
-		// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic of the handler.
-		// Call the ServeHTTP to execute the handler, DeleteBucketPolicyHandler  handles the request.
-		apiRouter.ServeHTTP(rec, req)
-		// Assert the response code with the expected status.
-		if rec.Code != testCase.expectedRespStatus {
-			t.Fatalf("Case %d: Expected the response status to be `%d`, but instead found `%d`", i+1, testCase.expectedRespStatus, rec.Code)
-		}
-
-	}
-}

bucket-policy-parser.go

@@ -1,330 +0,0 @@
-/*
- * 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.
- */
-
-// This file implements AWS Access Policy Language parser in
-// accordance with http://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"path"
-	"sort"
-	"strings"
-)
-
-const (
-	// AWSResourcePrefix - bucket policy resource prefix.
-	AWSResourcePrefix = "arn:aws:s3:::"
-)
-
-// supportedActionMap - lists all the actions supported by minio.
-var supportedActionMap = map[string]struct{}{
-	"*":                             {},
-	"s3:*":                          {},
-	"s3:GetObject":                  {},
-	"s3:ListBucket":                 {},
-	"s3:PutObject":                  {},
-	"s3:GetBucketLocation":          {},
-	"s3:DeleteObject":               {},
-	"s3:AbortMultipartUpload":       {},
-	"s3:ListBucketMultipartUploads": {},
-	"s3:ListMultipartUploadParts":   {},
-}
-
-// supported Conditions type.
-var supportedConditionsType = map[string]struct{}{
-	"StringEquals":    {},
-	"StringNotEquals": {},
-}
-
-// Validate s3:prefix, s3:max-keys are present if not
-// supported keys for the conditions.
-var supportedConditionsKey = map[string]struct{}{
-	"s3:prefix":   {},
-	"s3:max-keys": {},
-}
-
-// User - canonical users list.
-type policyUser struct {
-	AWS []string
-}
-
-// Statement - minio policy statement
-type policyStatement struct {
-	Sid        string
-	Effect     string
-	Principal  policyUser                   `json:"Principal"`
-	Actions    []string                     `json:"Action"`
-	Resources  []string                     `json:"Resource"`
-	Conditions map[string]map[string]string `json:"Condition"`
-}
-
-// BucketPolicy - minio policy collection
-type BucketPolicy struct {
-	Version    string            // date in 0000-00-00 format
-	Statements []policyStatement `json:"Statement"`
-}
-
-// supportedEffectMap - supported effects.
-var supportedEffectMap = map[string]struct{}{
-	"Allow": {},
-	"Deny":  {},
-}
-
-// isValidActions - are actions valid.
-func isValidActions(actions []string) (err error) {
-	// Statement actions cannot be empty.
-	if len(actions) == 0 {
-		err = errors.New("Action list cannot be empty.")
-		return err
-	}
-	for _, action := range actions {
-		if _, ok := supportedActionMap[action]; !ok {
-			err = errors.New("Unsupported action found: ‘" + action + "’, please validate your policy document.")
-			return err
-		}
-	}
-	return nil
-}
-
-// isValidEffect - is effect valid.
-func isValidEffect(effect string) error {
-	// Statement effect cannot be empty.
-	if len(effect) == 0 {
-		err := errors.New("Policy effect cannot be empty.")
-		return err
-	}
-	_, ok := supportedEffectMap[effect]
-	if !ok {
-		err := errors.New("Unsupported Effect found: ‘" + effect + "’, please validate your policy document.")
-		return err
-	}
-	return nil
-}
-
-// isValidResources - are valid resources.
-func isValidResources(resources []string) (err error) {
-	// Statement resources cannot be empty.
-	if len(resources) == 0 {
-		err = errors.New("Resource list cannot be empty.")
-		return err
-	}
-	for _, resource := range resources {
-		if !strings.HasPrefix(resource, AWSResourcePrefix) {
-			err = errors.New("Unsupported resource style found: ‘" + resource + "’, please validate your policy document.")
-			return err
-		}
-		resourceSuffix := strings.SplitAfter(resource, AWSResourcePrefix)[1]
-		if len(resourceSuffix) == 0 || strings.HasPrefix(resourceSuffix, "/") {
-			err = errors.New("Invalid resource style found: ‘" + resource + "’, please validate your policy document.")
-			return err
-		}
-	}
-	return nil
-}
-
-// isValidPrincipals - are valid principals.
-func isValidPrincipals(principals []string) (err error) {
-	// Statement principal should have a value.
-	if len(principals) == 0 {
-		err = errors.New("Principal cannot be empty.")
-		return err
-	}
-	for _, principal := range principals {
-		// Minio does not support or implement IAM, "*" is the only valid value.
-		// Amazon s3 doc on principals: http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Principal
-		if principal != "*" {
-			err = fmt.Errorf("Unsupported principal style found: ‘%s’, please validate your policy document.", principal)
-			return err
-		}
-	}
-	return nil
-}
-
-// isValidConditions - are valid conditions.
-func isValidConditions(conditions map[string]map[string]string) (err error) {
-	// Returns true if string 'a' is found in the list.
-	findString := func(a string, list []string) bool {
-		for _, b := range list {
-			if b == a {
-				return true
-			}
-		}
-		return false
-	}
-	conditionKeyVal := make(map[string][]string)
-	// Verify conditions should be valid.
-	// Validate if stringEquals, stringNotEquals are present
-	// if not throw an error.
-	for conditionType := range conditions {
-		_, validType := supportedConditionsType[conditionType]
-		if !validType {
-			err = fmt.Errorf("Unsupported condition type '%s', please validate your policy document.", conditionType)
-			return err
-		}
-		for key := range conditions[conditionType] {
-			_, validKey := supportedConditionsKey[key]
-			if !validKey {
-				err = fmt.Errorf("Unsupported condition key '%s', please validate your policy document.", conditionType)
-				return err
-			}
-			conditionArray, ok := conditionKeyVal[key]
-			if ok && findString(conditions[conditionType][key], conditionArray) {
-				err = fmt.Errorf("Ambigious condition values for key '%s', please validate your policy document.", key)
-				return err
-			}
-			conditionKeyVal[key] = append(conditionKeyVal[key], conditions[conditionType][key])
-		}
-	}
-	return nil
-}
-
-// List of actions for which prefixes are not allowed.
-var invalidPrefixActions = map[string]struct{}{
-	"s3:GetBucketLocation":          {},
-	"s3:ListBucket":                 {},
-	"s3:ListBucketMultipartUploads": {},
-	// Add actions which do not honor prefixes.
-}
-
-// resourcePrefix - provides the prefix removing any wildcards.
-func resourcePrefix(resource string) string {
-	if strings.HasSuffix(resource, "*") {
-		resource = strings.TrimSuffix(resource, "*")
-	}
-	return path.Clean(resource)
-}
-
-// 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 {
-	// Validate statements for special actions and collect resources
-	// for others to validate nesting.
-	var resourceMap = make(map[string]struct{})
-	for _, statement := range bucketPolicy.Statements {
-		for _, action := range statement.Actions {
-			for _, resource := range statement.Resources {
-				resourcePrefix := strings.SplitAfter(resource, AWSResourcePrefix)[1]
-				if _, ok := invalidPrefixActions[action]; ok {
-					// Resource prefix is not equal to bucket for
-					// prefix invalid actions, reject them.
-					if resourcePrefix != bucket {
-						return ErrMalformedPolicy
-					}
-				} else {
-					// For all other actions validate if resourcePrefix begins
-					// with bucket name, if not reject them.
-					if strings.Split(resourcePrefix, "/")[0] != bucket {
-						return ErrMalformedPolicy
-					}
-					// All valid resources collect them separately to verify nesting.
-					resourceMap[resourcePrefix] = struct{}{}
-				}
-			}
-		}
-	}
-
-	var resources []string
-	for resource := range resourceMap {
-		resources = append(resources, resourcePrefix(resource))
-	}
-
-	// Sort strings as shorter first.
-	sort.Strings(resources)
-
-	for len(resources) > 1 {
-		var resource string
-		resource, resources = resources[0], resources[1:]
-		// Loop through all resources, if one of them matches with
-		// previous shorter one, it means we have detected
-		// nesting. Reject such rules.
-		for _, otherResource := range resources {
-			// Common prefix reject such rules.
-			if strings.HasPrefix(otherResource, resource) {
-				return ErrPolicyNesting
-			}
-		}
-	}
-
-	// No errors found.
-	return ErrNone
-}
-
-// 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
-	}
-
-	// Policy version cannot be empty.
-	if len(policy.Version) == 0 {
-		err = errors.New("Policy version cannot be empty.")
-		return BucketPolicy{}, err
-	}
-
-	// Policy statements cannot be empty.
-	if len(policy.Statements) == 0 {
-		err = errors.New("Policy statement cannot be empty.")
-		return BucketPolicy{}, 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
-		}
-		// Statement principal should be supported format.
-		if err := isValidPrincipals(statement.Principal.AWS); err != nil {
-			return BucketPolicy{}, err
-		}
-		// Statement actions should be valid.
-		if err := isValidActions(statement.Actions); err != nil {
-			return BucketPolicy{}, err
-		}
-		// Statement resources should be valid.
-		if err := isValidResources(statement.Resources); err != nil {
-			return BucketPolicy{}, err
-		}
-		// Statement conditions should be valid.
-		if err := isValidConditions(statement.Conditions); err != nil {
-			return BucketPolicy{}, err
-		}
-	}
-
-	// Separate deny and allow statements, so that we can apply deny
-	// statements in the beginning followed by Allow statements.
-	var denyStatements []policyStatement
-	var allowStatements []policyStatement
-	for _, statement := range policy.Statements {
-		if statement.Effect == "Deny" {
-			denyStatements = append(denyStatements, statement)
-			continue
-		}
-		// else if statement.Effect == "Allow"
-		allowStatements = append(allowStatements, statement)
-	}
-
-	// Deny statements are enforced first once matched.
-	policy.Statements = append(denyStatements, allowStatements...)
-
-	// Return successfully parsed policy structure.
-	return policy, nil
-}

bucket-policy-parser_test.go

@@ -1,692 +0,0 @@
-/*
- * 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 (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"reflect"
-	"testing"
-)
-
-var (
-	readWriteBucketActions = []string{
-		"s3:GetBucketLocation",
-		"s3:ListBucket",
-		"s3:ListBucketMultipartUploads",
-		// Add more bucket level read-write actions here.
-	}
-	readWriteObjectActions = []string{
-		"s3:AbortMultipartUpload",
-		"s3:DeleteObject",
-		"s3:GetObject",
-		"s3:ListMultipartUploadParts",
-		"s3:PutObject",
-		// Add more object level read-write actions here.
-	}
-)
-
-// Write only actions.
-var (
-	writeOnlyBucketActions = []string{
-		"s3:GetBucketLocation",
-		"s3:ListBucketMultipartUploads",
-		// Add more bucket level write actions here.
-	}
-	writeOnlyObjectActions = []string{
-		"s3:AbortMultipartUpload",
-		"s3:DeleteObject",
-		"s3:ListMultipartUploadParts",
-		"s3:PutObject",
-		// Add more object level write actions here.
-	}
-)
-
-// Read only actions.
-var (
-	readOnlyBucketActions = []string{
-		"s3:GetBucketLocation",
-		"s3:ListBucket",
-		// Add more bucket level read actions here.
-	}
-	readOnlyObjectActions = []string{
-		"s3:GetObject",
-		// Add more object level read actions here.
-	}
-)
-
-// Obtain bucket statement for read-write BucketPolicy.
-func getReadWriteObjectStatement(bucketName, objectPrefix string) policyStatement {
-	objectResourceStatement := policyStatement{}
-	objectResourceStatement.Effect = "Allow"
-	objectResourceStatement.Principal.AWS = []string{"*"}
-	objectResourceStatement.Resources = []string{fmt.Sprintf("%s%s", AWSResourcePrefix, bucketName+"/"+objectPrefix+"*")}
-	objectResourceStatement.Actions = readWriteObjectActions
-	return objectResourceStatement
-}
-
-// Obtain object statement for read-write BucketPolicy.
-func getReadWriteBucketStatement(bucketName, objectPrefix string) policyStatement {
-	bucketResourceStatement := policyStatement{}
-	bucketResourceStatement.Effect = "Allow"
-	bucketResourceStatement.Principal.AWS = []string{"*"}
-	bucketResourceStatement.Resources = []string{fmt.Sprintf("%s%s", AWSResourcePrefix, bucketName)}
-	bucketResourceStatement.Actions = readWriteBucketActions
-	return bucketResourceStatement
-}
-
-// Obtain statements for read-write BucketPolicy.
-func getReadWriteStatement(bucketName, objectPrefix string) []policyStatement {
-	statements := []policyStatement{}
-	// Save the read write policy.
-	statements = append(statements, getReadWriteBucketStatement(bucketName, objectPrefix), getReadWriteObjectStatement(bucketName, objectPrefix))
-	return statements
-}
-
-// Obtain bucket statement for read only BucketPolicy.
-func getReadOnlyBucketStatement(bucketName, objectPrefix string) policyStatement {
-	bucketResourceStatement := policyStatement{}
-	bucketResourceStatement.Effect = "Allow"
-	bucketResourceStatement.Principal.AWS = []string{"*"}
-	bucketResourceStatement.Resources = []string{fmt.Sprintf("%s%s", AWSResourcePrefix, bucketName)}
-	bucketResourceStatement.Actions = readOnlyBucketActions
-	return bucketResourceStatement
-}
-
-// Obtain object statement for read only BucketPolicy.
-func getReadOnlyObjectStatement(bucketName, objectPrefix string) policyStatement {
-	objectResourceStatement := policyStatement{}
-	objectResourceStatement.Effect = "Allow"
-	objectResourceStatement.Principal.AWS = []string{"*"}
-	objectResourceStatement.Resources = []string{fmt.Sprintf("%s%s", AWSResourcePrefix, bucketName+"/"+objectPrefix+"*")}
-	objectResourceStatement.Actions = readOnlyObjectActions
-	return objectResourceStatement
-}
-
-// Obtain statements for read only BucketPolicy.
-func getReadOnlyStatement(bucketName, objectPrefix string) []policyStatement {
-	statements := []policyStatement{}
-	// Save the read only policy.
-	statements = append(statements, getReadOnlyBucketStatement(bucketName, objectPrefix), getReadOnlyObjectStatement(bucketName, objectPrefix))
-	return statements
-}
-
-// Obtain bucket statements for write only BucketPolicy.
-func getWriteOnlyBucketStatement(bucketName, objectPrefix string) policyStatement {
-
-	bucketResourceStatement := policyStatement{}
-	bucketResourceStatement.Effect = "Allow"
-	bucketResourceStatement.Principal.AWS = []string{"*"}
-	bucketResourceStatement.Resources = []string{fmt.Sprintf("%s%s", AWSResourcePrefix, bucketName)}
-	bucketResourceStatement.Actions = writeOnlyBucketActions
-	return bucketResourceStatement
-}
-
-// Obtain object statements for write only BucketPolicy.
-func getWriteOnlyObjectStatement(bucketName, objectPrefix string) policyStatement {
-	objectResourceStatement := policyStatement{}
-	objectResourceStatement.Effect = "Allow"
-	objectResourceStatement.Principal.AWS = []string{"*"}
-	objectResourceStatement.Resources = []string{fmt.Sprintf("%s%s", AWSResourcePrefix, bucketName+"/"+objectPrefix+"*")}
-	objectResourceStatement.Actions = writeOnlyObjectActions
-	return objectResourceStatement
-}
-
-// Obtain statements for write only BucketPolicy.
-func getWriteOnlyStatement(bucketName, objectPrefix string) []policyStatement {
-	statements := []policyStatement{}
-	// Write only policy.
-	// Save the write only policy.
-	statements = append(statements, getWriteOnlyBucketStatement(bucketName, objectPrefix), getWriteOnlyBucketStatement(bucketName, objectPrefix))
-	return statements
-}
-
-// Tests validate Action validator.
-func TestIsValidActions(t *testing.T) {
-	testCases := []struct {
-		// input.
-		actions []string
-		// expected output.
-		err error
-		// flag indicating whether the test should pass.
-		shouldPass bool
-	}{
-		// Inputs with unsupported Action.
-		// Test case - 1.
-		// "s3:ListObject" is an invalid Action.
-		{[]string{"s3:GetObject", "s3:ListObject", "s3:RemoveObject"}, errors.New("Unsupported action found: ‘s3:ListObject’, please validate your policy document."), false},
-		// Test case - 2.
-		// Empty Actions.
-		{[]string{}, errors.New("Action list cannot be empty."), false},
-		// Test case - 3.
-		// "s3:DeleteEverything"" is an invalid Action.
-		{[]string{"s3:GetObject", "s3:ListBucket", "s3:PutObject", "s3:DeleteEverything"},
-			errors.New("Unsupported action found: ‘s3:DeleteEverything’, please validate your policy document."), false},
-
-		// Inputs with valid Action.
-		// Test Case - 4.
-		{[]string{"s3:*", "*", "s3:GetObject", "s3:ListBucket",
-			"s3:PutObject", "s3:GetBucketLocation", "s3:DeleteObject", "s3:AbortMultipartUpload", "s3:ListBucketMultipartUploads", "s3:ListMultipartUploadParts"}, nil, true},
-	}
-	for i, testCase := range testCases {
-		err := isValidActions(testCase.actions)
-		if err != nil && testCase.shouldPass {
-			t.Errorf("Test %d: Expected to pass, but failed with: <ERROR> %s", i+1, err.Error())
-		}
-		if err == nil && !testCase.shouldPass {
-			t.Errorf("Test %d: Expected to fail with <ERROR> \"%s\", but passed instead", i+1, testCase.err.Error())
-		}
-		// Failed as expected, but does it fail for the expected reason.
-		if err != nil && !testCase.shouldPass {
-			if err.Error() != testCase.err.Error() {
-				t.Errorf("Test %d: Expected to fail with error \"%s\", but instead failed with error \"%s\"", i+1, testCase.err.Error(), err.Error())
-			}
-		}
-
-	}
-}
-
-// Tests validate Effect validator.
-func TestIsValidEffect(t *testing.T) {
-	testCases := []struct {
-		// input.
-		effect string
-		// expected output.
-		err error
-		// flag indicating whether the test should pass.
-		shouldPass bool
-	}{
-		// Inputs with unsupported Effect.
-		// Test case - 1.
-		{"DontAllow", errors.New("Unsupported Effect found: ‘DontAllow’, please validate your policy document."), false},
-		// Test case - 2.
-		{"NeverAllow", errors.New("Unsupported Effect found: ‘NeverAllow’, please validate your policy document."), false},
-		// Test case - 3.
-		{"AllowAlways", errors.New("Unsupported Effect found: ‘AllowAlways’, please validate your policy document."), false},
-
-		// Inputs with valid Effect.
-		// Test Case - 4.
-		{"Allow", nil, true},
-		// Test Case - 5.
-		{"Deny", nil, true},
-	}
-	for i, testCase := range testCases {
-		err := isValidEffect(testCase.effect)
-		if err != nil && testCase.shouldPass {
-			t.Errorf("Test %d: Expected to pass, but failed with: <ERROR> %s", i+1, err.Error())
-		}
-		if err == nil && !testCase.shouldPass {
-			t.Errorf("Test %d: Expected to fail with <ERROR> \"%s\", but passed instead", i+1, testCase.err.Error())
-		}
-		// Failed as expected, but does it fail for the expected reason.
-		if err != nil && !testCase.shouldPass {
-			if err.Error() != testCase.err.Error() {
-				t.Errorf("Test %d: Expected to fail with error \"%s\", but instead failed with error \"%s\"", i+1, testCase.err.Error(), err.Error())
-			}
-		}
-	}
-}
-
-// Tests validate Resources validator.
-func TestIsValidResources(t *testing.T) {
-	testCases := []struct {
-		// input.
-		resources []string
-		// expected output.
-		err error
-		// flag indicating whether the test should pass.
-		shouldPass bool
-	}{
-		// Inputs with unsupported Action.
-		// Test case - 1.
-		// Empty Resources.
-		{[]string{}, errors.New("Resource list cannot be empty."), false},
-		// Test case - 2.
-		// A valid resource should have prefix "arn:aws:s3:::".
-		{[]string{"my-resource"}, errors.New("Unsupported resource style found: ‘my-resource’, please validate your policy document."), false},
-		// Test case - 3.
-		// A Valid resource should have bucket name followed by "arn:aws:s3:::".
-		{[]string{"arn:aws:s3:::"}, errors.New("Invalid resource style found: ‘arn:aws:s3:::’, please validate your policy document."), false},
-		// Test Case - 4.
-		// Valid resource shouldn't have slash('/') followed by "arn:aws:s3:::".
-		{[]string{"arn:aws:s3:::/"}, errors.New("Invalid resource style found: ‘arn:aws:s3:::/’, please validate your policy document."), false},
-
-		// Test cases with valid Resources.
-		{[]string{"arn:aws:s3:::my-bucket"}, nil, true},
-		{[]string{"arn:aws:s3:::my-bucket/Asia/*"}, nil, true},
-		{[]string{"arn:aws:s3:::my-bucket/Asia/India/*"}, nil, true},
-	}
-	for i, testCase := range testCases {
-		err := isValidResources(testCase.resources)
-		if err != nil && testCase.shouldPass {
-			t.Errorf("Test %d: Expected to pass, but failed with: <ERROR> %s", i+1, err.Error())
-		}
-		if err == nil && !testCase.shouldPass {
-			t.Errorf("Test %d: Expected to fail with <ERROR> \"%s\", but passed instead", i+1, testCase.err.Error())
-		}
-		// Failed as expected, but does it fail for the expected reason.
-		if err != nil && !testCase.shouldPass {
-			if err.Error() != testCase.err.Error() {
-				t.Errorf("Test %d: Expected to fail with error \"%s\", but instead failed with error \"%s\"", i+1, testCase.err.Error(), err.Error())
-			}
-		}
-	}
-}
-
-// Tests validate principals validator.
-func TestIsValidPrincipals(t *testing.T) {
-	testCases := []struct {
-		// input.
-		principals []string
-		// expected output.
-		err error
-		// flag indicating whether the test should pass.
-		shouldPass bool
-	}{
-		// Inputs with unsupported Principals.
-		// Test case - 1.
-		// Empty Principals list.
-		{[]string{}, errors.New("Principal cannot be empty."), false},
-		// Test case - 2.
-		// "*" is the only valid principal.
-		{[]string{"my-principal"}, errors.New("Unsupported principal style found: ‘my-principal’, please validate your policy document."), false},
-		// Test case - 3.
-		{[]string{"*", "111122233"}, errors.New("Unsupported principal style found: ‘111122233’, please validate your policy document."), false},
-
-		// Test case - 4.
-		// Test case with valid principal value.
-		{[]string{"*"}, nil, true},
-	}
-	for i, testCase := range testCases {
-		err := isValidPrincipals(testCase.principals)
-		if err != nil && testCase.shouldPass {
-			t.Errorf("Test %d: Expected to pass, but failed with: <ERROR> %s", i+1, err.Error())
-		}
-		if err == nil && !testCase.shouldPass {
-			t.Errorf("Test %d: Expected to fail with <ERROR> \"%s\", but passed instead", i+1, testCase.err.Error())
-		}
-		// Failed as expected, but does it fail for the expected reason.
-		if err != nil && !testCase.shouldPass {
-			if err.Error() != testCase.err.Error() {
-				t.Errorf("Test %d: Expected to fail with error \"%s\", but instead failed with error \"%s\"", i+1, testCase.err.Error(), err.Error())
-			}
-		}
-	}
-}
-
-// Tests validate policyStatement condition validator.
-func TestIsValidConditions(t *testing.T) {
-	// returns empty conditions map.
-	setEmptyConditions := func() map[string]map[string]string {
-		return make(map[string]map[string]string)
-	}
-
-	// returns map with the "StringEquals" set to empty map.
-	setEmptyStringEquals := func() map[string]map[string]string {
-		emptyMap := make(map[string]string)
-		conditions := make(map[string]map[string]string)
-		conditions["StringEquals"] = emptyMap
-		return conditions
-
-	}
-
-	// returns map with the "StringNotEquals" set to empty map.
-	setEmptyStringNotEquals := func() map[string]map[string]string {
-		emptyMap := make(map[string]string)
-		conditions := make(map[string]map[string]string)
-		conditions["StringNotEquals"] = emptyMap
-		return conditions
-
-	}
-	// Generate conditions.
-	generateConditions := func(key1, key2, value string) map[string]map[string]string {
-		innerMap := make(map[string]string)
-		innerMap[key2] = value
-		conditions := make(map[string]map[string]string)
-		conditions[key1] = innerMap
-		return conditions
-	}
-
-	// generate ambigious conditions.
-	generateAmbigiousConditions := func() map[string]map[string]string {
-		innerMap := make(map[string]string)
-		innerMap["s3:prefix"] = "Asia/"
-		conditions := make(map[string]map[string]string)
-		conditions["StringEquals"] = innerMap
-		conditions["StringNotEquals"] = innerMap
-		return conditions
-	}
-
-	// generate valid and non valid type in the condition map.
-	generateValidInvalidConditions := func() map[string]map[string]string {
-		innerMap := make(map[string]string)
-		innerMap["s3:prefix"] = "Asia/"
-		conditions := make(map[string]map[string]string)
-		conditions["StringEquals"] = innerMap
-		conditions["InvalidType"] = innerMap
-		return conditions
-	}
-
-	// generate valid and invalid keys for valid types in the same condition map.
-	generateValidInvalidConditionKeys := func() map[string]map[string]string {
-		innerMapValid := make(map[string]string)
-		innerMapValid["s3:prefix"] = "Asia/"
-		innerMapInValid := make(map[string]string)
-		innerMapInValid["s3:invalid"] = "Asia/"
-		conditions := make(map[string]map[string]string)
-		conditions["StringEquals"] = innerMapValid
-		conditions["StringEquals"] = innerMapInValid
-		return conditions
-	}
-
-	// List of Conditions used for test cases.
-	testConditions := []map[string]map[string]string{
-		generateConditions("StringValues", "s3:max-keys", "100"),
-		generateConditions("StringEquals", "s3:Object", "100"),
-		generateAmbigiousConditions(),
-		generateValidInvalidConditions(),
-		generateValidInvalidConditionKeys(),
-		setEmptyConditions(),
-		setEmptyStringEquals(),
-		setEmptyStringNotEquals(),
-		generateConditions("StringEquals", "s3:prefix", "Asia/"),
-		generateConditions("StringEquals", "s3:max-keys", "100"),
-		generateConditions("StringNotEquals", "s3:prefix", "Asia/"),
-		generateConditions("StringNotEquals", "s3:max-keys", "100"),
-	}
-
-	testCases := []struct {
-		inputCondition map[string]map[string]string
-		// expected result.
-		expectedErr error
-		// flag indicating whether test should pass.
-		shouldPass bool
-	}{
-		// Malformed conditions.
-		// Test case - 1.
-		// "StringValues" is an invalid type.
-		{testConditions[0], fmt.Errorf("Unsupported condition type 'StringValues', " +
-			"please validate your policy document."), false},
-		// Test case - 2.
-		// "s3:Object" is an invalid key.
-		{testConditions[1], fmt.Errorf("Unsupported condition key " +
-			"'StringEquals', please validate your policy document."), false},
-		// Test case - 3.
-		// Test case with Ambigious conditions set.
-		{testConditions[2], fmt.Errorf("Ambigious condition values for key 's3:prefix', " +
-			"please validate your policy document."), false},
-		// Test case - 4.
-		// Test case with valid and invalid condition types.
-		{testConditions[3], fmt.Errorf("Unsupported condition type 'InvalidType', " +
-			"please validate your policy document."), false},
-		// Test case - 5.
-		// Test case with valid and invalid condition keys.
-		{testConditions[4], fmt.Errorf("Unsupported condition key 'StringEquals', " +
-			"please validate your policy document."), false},
-		// Test cases with valid conditions.
-		// Test case - 6.
-		{testConditions[5], nil, true},
-		// Test case - 7.
-		{testConditions[6], nil, true},
-		// Test case - 8.
-		{testConditions[7], nil, true},
-		// Test case - 9.
-		{testConditions[8], nil, true},
-		// Test case - 10.
-		{testConditions[9], nil, true},
-		// Test case - 11.
-		{testConditions[10], nil, true},
-		// Test case 10.
-		{testConditions[11], nil, true},
-	}
-	for i, testCase := range testCases {
-		actualErr := isValidConditions(testCase.inputCondition)
-		if actualErr != nil && testCase.shouldPass {
-			t.Errorf("Test %d: Expected to pass, but failed with: <ERROR> %s", i+1, actualErr.Error())
-		}
-		if actualErr == nil && !testCase.shouldPass {
-			t.Errorf("Test %d: Expected to fail with <ERROR> \"%s\", but passed instead", i+1, testCase.expectedErr.Error())
-		}
-		// Failed as expected, but does it fail for the expected reason.
-		if actualErr != nil && !testCase.shouldPass {
-			if actualErr.Error() != testCase.expectedErr.Error() {
-				t.Errorf("Test %d: Expected to fail with error \"%s\", but instead failed with error \"%s\"", i+1, testCase.expectedErr.Error(), actualErr.Error())
-			}
-		}
-	}
-}
-
-// Tests validate Policy Action and Resource fields.
-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.
-	// 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/*"}
-		return statements
-	}
-
-	// constructing policy statement with lexically close characters.
-	// should not result in ErrMalformedPolicy
-	setResourceLexical := func(statements []policyStatement) []policyStatement {
-		statements[0].Resources = []string{"arn:aws:s3:::minio-bucket/op*", "arn:aws:s3:::minio-bucket/oo*"}
-		return statements
-	}
-
-	// 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.
-		// Contains valid read-write only policy statement.
-		{Version: "1.0", Statements: getReadWriteStatement("minio-bucket", "Asia/")},
-		// BucketPolicy - 3.
-		// Contains valid write only policy statement.
-		{Version: "1.0", Statements: getWriteOnlyStatement("minio-bucket", "Asia/India/")},
-		// 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.
-		// 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.
-		// should result in ErrMalformedPolicy
-		{Version: "1.0", Statements: setRecurseResource(setValidPrefixActions(getWriteOnlyStatement("minio-bucket", "")))},
-		// BucketPolciy - 7.
-		// constructing policy statement with non recursive but
-		// lexically close resources.
-		// should result in ErrNone.
-		{Version: "1.0", Statements: setResourceLexical(setValidPrefixActions(getWriteOnlyStatement("minio-bucket", "oo")))},
-	}
-
-	testCases := []struct {
-		inputPolicy BucketPolicy
-		// expected results.
-		apiErrCode APIErrorCode
-		// Flag indicating whether the test should pass.
-		shouldPass bool
-	}{
-		// Test case - 1.
-		{bucketAccessPolicies[0], ErrNone, true},
-		// Test case - 2.
-		{bucketAccessPolicies[1], ErrNone, true},
-		// Test case - 3.
-		{bucketAccessPolicies[2], ErrNone, true},
-		// Test case - 4.
-		// contains invalidPrefixActions (check bucket-policy-parser.go).
-		// Resource prefix will not be equal to the bucket name in this case.
-		{bucketAccessPolicies[3], ErrMalformedPolicy, false},
-		// Test case - 5.
-		// actions contain invalidPrefixActions (check bucket-policy-parser.go).
-		// 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.
-		// should result in ErrPolicyNesting.
-		{bucketAccessPolicies[5], ErrPolicyNesting, false},
-		// Test case - 7.
-		// constructing policy statement with lexically close
-		// characters.
-		// should result in ErrNone.
-		{bucketAccessPolicies[6], ErrNone, true},
-	}
-	for i, testCase := range testCases {
-		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)
-		}
-		if apiErrCode == ErrNone && !testCase.shouldPass {
-			t.Errorf("Test %d: Expected to fail with ErrCode %v, but passed instead", i+1, testCase.apiErrCode)
-		}
-		// Failed as expected, but does it fail for the expected reason.
-		if apiErrCode != ErrNone && !testCase.shouldPass {
-			if testCase.apiErrCode != apiErrCode {
-				t.Errorf("Test %d: Expected to fail with error code %v, but instead failed with error code %v", i+1, testCase.apiErrCode, apiErrCode)
-			}
-		}
-	}
-}
-
-// Tests validate parsing of BucketAccessPolicy.
-func TestParseBucketPolicy(t *testing.T) {
-	// set Unsupported Actions.
-	setUnsupportedActions := func(statements []policyStatement) []policyStatement {
-		// "s3:DeleteEverything"" is an Unsupported Action.
-		statements[0].Actions = []string{"s3:GetObject", "s3:ListBucket", "s3:PutObject", "s3:DeleteEverything"}
-		return statements
-	}
-	// set unsupported Effect.
-	setUnsupportedEffect := func(statements []policyStatement) []policyStatement {
-		// Effect "Don't allow" is Unsupported.
-		statements[0].Effect = "DontAllow"
-		return statements
-	}
-	// set unsupported principals.
-	setUnsupportedPrincipals := func(statements []policyStatement) []policyStatement {
-		// "User1111"" is an Unsupported Principal.
-		statements[0].Principal.AWS = []string{"*", "User1111"}
-		return statements
-	}
-	// set unsupported Resources.
-	setUnsupportedResources := func(statements []policyStatement) []policyStatement {
-		// "s3:DeleteEverything"" is an Unsupported Action.
-		statements[0].Resources = []string{"my-resource"}
-		return statements
-	}
-	// List of BucketPolicy used for test cases.
-	bucketAccesPolicies := []BucketPolicy{
-		// BucketPolicy - 0.
-		// BucketPolicy statement empty.
-		{Version: "1.0"},
-		// BucketPolicy - 1.
-		// BucketPolicy version empty.
-		{Version: "", Statements: []policyStatement{}},
-		// BucketPolicy - 2.
-		// Readonly BucketPolicy.
-		{Version: "1.0", Statements: getReadOnlyStatement("minio-bucket", "")},
-		// BucketPolicy - 3.
-		// Read-Write bucket policy.
-		{Version: "1.0", Statements: getReadWriteStatement("minio-bucket", "Asia/")},
-		// BucketPolicy - 4.
-		// Write only bucket policy.
-		{Version: "1.0", Statements: getWriteOnlyStatement("minio-bucket", "Asia/India/")},
-		// BucketPolicy - 5.
-		// BucketPolicy statement contains unsupported action.
-		{Version: "1.0", Statements: setUnsupportedActions(getReadOnlyStatement("minio-bucket", ""))},
-		// BucketPolicy - 6.
-		// BucketPolicy statement contains unsupported Effect.
-		{Version: "1.0", Statements: setUnsupportedEffect(getReadWriteStatement("minio-bucket", "Asia/"))},
-		// BucketPolicy - 7.
-		// BucketPolicy statement contains unsupported Principal.
-		{Version: "1.0", Statements: setUnsupportedPrincipals(getWriteOnlyStatement("minio-bucket", "Asia/India/"))},
-		// BucketPolicy - 8.
-		// BucketPolicy statement contains unsupported Resource.
-		{Version: "1.0", Statements: setUnsupportedResources(getWriteOnlyStatement("minio-bucket", "Asia/India/"))},
-	}
-
-	testCases := []struct {
-		inputPolicy BucketPolicy
-		// expected results.
-		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},
-		// Test case - 2.
-		// BucketPolicy version empty.
-		{bucketAccesPolicies[1], BucketPolicy{}, errors.New("Policy version cannot be empty."), false},
-		// Test case - 3.
-		// Readonly BucketPolicy.
-		{bucketAccesPolicies[2], bucketAccesPolicies[2], nil, true},
-		// Test case - 4.
-		// Read-Write bucket policy.
-		{bucketAccesPolicies[3], bucketAccesPolicies[3], nil, true},
-		// Test case - 5.
-		// Write only bucket policy.
-		{bucketAccesPolicies[4], bucketAccesPolicies[4], nil, true},
-		// Test case - 6.
-		// 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.
-		{bucketAccesPolicies[6], bucketAccesPolicies[6], fmt.Errorf("Unsupported Effect found: ‘DontAllow’, please validate your policy document."), false},
-		// Test case - 8.
-		// 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.
-		{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)
-		}
-
-		actualAccessPolicy, err := parseBucketPolicy(inputPolicyBytes)
-		if err != nil && testCase.shouldPass {
-			t.Errorf("Test %d: Expected to pass, but failed with: <ERROR> %s", i+1, err.Error())
-		}
-		if err == nil && !testCase.shouldPass {
-			t.Errorf("Test %d: Expected to fail with <ERROR> \"%s\", but passed instead", i+1, testCase.err.Error())
-		}
-		// Failed as expected, but does it fail for the expected reason.
-		if err != nil && !testCase.shouldPass {
-			if err.Error() != testCase.err.Error() {
-				t.Errorf("Test %d: Expected to fail with error \"%s\", but instead failed with error \"%s\"", i+1, testCase.err.Error(), err.Error())
-			}
-		}
-		// Test passes as expected, but the output values are verified for correctness here.
-		if err == nil && testCase.shouldPass {
-			if !reflect.DeepEqual(testCase.expectedPolicy, actualAccessPolicy) {
-				t.Errorf("Test %d: The expected statements from resource statement generator doesn't match the actual statements", i+1)
-			}
-		}
-	}
-}

bucket-policy.go

@@ -1,128 +0,0 @@
-/*
- * 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 (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-)
-
-// getBucketsConfigPath - get buckets path.
-func getBucketsConfigPath() (string, error) {
-	configPath, err := getConfigPath()
-	if err != nil {
-		return "", err
-	}
-	return filepath.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) {
-	// Verify bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return nil, BucketNameInvalid{Bucket: bucket}
-	}
-
-	bucketConfigPath, err := getBucketConfigPath(bucket)
-	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) {
-			return nil, BucketPolicyNotFound{Bucket: bucket}
-		}
-		return nil, err
-	}
-	return ioutil.ReadFile(bucketPolicyFile)
-}
-
-// removeBucketPolicy - remove bucket policy.
-func removeBucketPolicy(bucket string) 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) {
-			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 {
-	// 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)
-}

build-constants.go

@@ -1,33 +0,0 @@
-/*
- * Minio Cloud 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
-
-// DO NOT EDIT THIS FILE DIRECTLY. These are build-time constants
-// set through ‘buildscripts/gen-ldflags.go’.
-var (
-	// minioGOPATH - GOPATH value at the time of build.
-	minioGOPATH = ""
-
-	// minioVersion - version time.RFC3339.
-	minioVersion = "DEVELOPMENT.GOGET"
-	// minioReleaseTag - release tag in TAG.%Y-%m-%dT%H-%M-%SZ.
-	minioReleaseTag = "DEVELOPMENT.GOGET"
-	// minioCommitID - latest commit id.
-	minioCommitID = "DEVELOPMENT.GOGET"
-	// minioShortCommitID - first 12 characters from minioCommitID.
-	minioShortCommitID = minioCommitID[:12]
-)

buildscripts/build.sh

@@ -1,84 +0,0 @@
-#!/bin/bash
-
-_init() {
-    # Save release LDFLAGS
-    LDFLAGS=$(go run buildscripts/gen-ldflags.go)
-
-    # Extract release tag
-    release_tag=$(echo $LDFLAGS | awk {'print $4'} | cut -f2 -d=)
-
-    # Verify release tag.
-    if [ -z "$release_tag" ]; then
-        echo "Release tag cannot be empty. Please check return value of \`go run buildscripts/gen-ldflags.go\`"
-        exit 1;
-    fi
-
-    # Extract release string.
-    release_str=$(echo $MINIO_RELEASE | tr '[:upper:]' '[:lower:]')
-
-    # Verify release string.
-    if [ -z "$release_str" ]; then
-        echo "Release string cannot be empty. Please set \`MINIO_RELEASE\` env variable."
-        exit 1;
-    fi
-
-    # List of supported architectures
-    SUPPORTED_OSARCH='linux/386 linux/amd64 linux/arm windows/386 windows/amd64 darwin/amd64 freebsd/amd64'
-
-    ## System binaries
-    CP=`which cp`
-    SHASUM=`which shasum`
-    SED=`which sed`
-}
-
-go_build() {
-    local osarch=$1
-    os=$(echo $osarch | cut -f1 -d'/')
-    arch=$(echo $osarch | cut -f2 -d'/')
-    package=$(go list -f '{{.ImportPath}}')
-    echo -n "-->"
-    printf "%15s:%s\n" "${osarch}" "${package}"
-
-    # Release binary name
-    release_bin="$release_str/$os-$arch/$(basename $package).$release_tag"
-    # Release binary downloadable name
-    release_real_bin="$release_str/$os-$arch/$(basename $package)"
-    # Release shasum name
-    release_shasum="$release_str/$os-$arch/$(basename $package).shasum"
-
-    # Go build to build the binary.
-    GOOS=$os GOARCH=$arch go build --ldflags "${LDFLAGS}" -o $release_bin
-
-    # Create copy
-    if [ $os == "windows" ]; then
-        $CP -p $release_bin ${release_real_bin}.exe
-    else
-        $CP -p $release_bin $release_real_bin
-    fi
-
-    # Calculate shasum
-    shasum_str=$(${SHASUM} ${release_bin})
-    echo ${shasum_str} | $SED "s/$release_str\/$os-$arch\///g" > $release_shasum
-}
-
-main() {
-    # Build releases.
-    echo "Executing $release_str builds for OS: ${SUPPORTED_OSARCH}"
-    echo  "Choose an OS Arch from the below"
-    for osarch in ${SUPPORTED_OSARCH}; do
-        echo ${osarch}
-    done
-
-    read -p "If you want to build for all, Just press Enter: " chosen_osarch
-    if [ "$chosen_osarch" = "" ]; then
-        for each_osarch in ${SUPPORTED_OSARCH}; do
-            go_build ${each_osarch}
-        done
-    else
-        go_build ${chosen_osarch}
-    fi
-
-}
-
-# Run main.
-_init && main

buildscripts/checkdeps.sh

@@ -1,221 +0,0 @@
-#!/usr/bin/env bash
-#
-# Minio Cloud 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.
-#
-
-_init() {
-
-    shopt -s extglob
-
-    ## Minimum required versions for build dependencies
-    GIT_VERSION="1.0"
-    GO_VERSION="1.6"
-    OSX_VERSION="10.8"
-    UNAME=$(uname -sm)
-
-    ## Check all dependencies are present
-    MISSING=""
-}
-
-readlink() {
-    TARGET_FILE=$1
-
-    cd `dirname $TARGET_FILE`
-    TARGET_FILE=`basename $TARGET_FILE`
-
-    # Iterate down a (possible) chain of symlinks
-    while [ -L "$TARGET_FILE" ]
-    do
-        TARGET_FILE=$(env readlink $TARGET_FILE)
-        cd `dirname $TARGET_FILE`
-        TARGET_FILE=`basename $TARGET_FILE`
-    done
-
-    # Compute the canonicalized name by finding the physical path
-    # for the directory we're in and appending the target file.
-    PHYS_DIR=`pwd -P`
-    RESULT=$PHYS_DIR/$TARGET_FILE
-    echo $RESULT
-}
-
-###
-#
-# Takes two arguments
-# arg1: version number in `x.x.x` format
-# arg2: version number in `x.x.x` format
-#
-# example: check_version "$version1" "$version2"
-#
-# returns:
-# 0 - Installed version is equal to required
-# 1 - Installed version is greater than required
-# 2 - Installed version is lesser than required
-# 3 - If args have length zero
-#
-####
-check_version() {
-    ## validate args
-    [[ -z "$1" ]] && return 3
-    [[ -z "$2" ]] && return 3
-
-    if [[ $1 == $2 ]]; then
-        return 0
-    fi
-
-    local IFS=.
-    local i ver1=($1) ver2=($2)
-    # fill empty fields in ver1 with zeros
-    for ((i=${#ver1[@]}; i<${#ver2[@]}; i++)); do
-        ver1[i]=0
-    done
-    for ((i=0; i<${#ver1[@]}; i++)); do
-        if [[ -z ${ver2[i]} ]]; then
-            # fill empty fields in ver2 with zeros
-            ver2[i]=0
-        fi
-        if ((10#${ver1[i]} > 10#${ver2[i]})); then
-
-            return 1
-        fi
-        if ((10#${ver1[i]} < 10#${ver2[i]})); then
-            ## Installed version is lesser than required - Bad condition
-            return 2
-        fi
-    done
-    return 0
-}
-
-check_golang_env() {
-    echo ${GOROOT:?} 2>&1 >/dev/null
-    if [ $? -eq 1 ]; then
-        echo "ERROR"
-        echo "GOROOT environment variable missing, please refer to Go installation document"
-        echo "https://github.com/minio/minio/blob/master/INSTALLGO.md#install-go-13"
-        exit 1
-    fi
-
-    echo ${GOPATH:?} 2>&1 >/dev/null
-    if [ $? -eq 1 ]; then
-        echo "ERROR"
-        echo "GOPATH environment variable missing, please refer to Go installation document"
-        echo "https://github.com/minio/minio/blob/master/INSTALLGO.md#install-go-13"
-        exit 1
-    fi
-
-    local go_binary_path=$(which go)
-
-    if [ -z "${go_binary_path}" ] ; then
-        echo "Cannot find go binary in your PATH configuration, please refer to Go installation document"
-        echo "https://github.com/minio/minio/blob/master/INSTALLGO.md#install-go-13"
-        exit -1
-    fi
-
-    local new_go_binary_path=${go_binary_path}
-    if [ -h "${go_binary_path}" ]; then
-        new_go_binary_path=$(readlink ${go_binary_path})
-    fi
-
-    if [[ !"$(dirname ${new_go_binary_path})" =~ *"${GOROOT%%*(/)}"* ]] ; then
-        echo "The go binary found in your PATH configuration does not belong to the Go installation pointed by your GOROOT environment," \
-            "please refer to Go installation document"
-        echo "https://github.com/minio/minio/blob/master/INSTALLGO.md#install-go-13"
-        exit -1
-    fi
-}
-
-is_supported_os() {
-    case ${UNAME%% *} in
-        "Linux")
-            os="linux"
-            ;;
-        "FreeBSD")
-            os="freebsd"
-            ;;
-        "Darwin")
-            osx_host_version=$(env sw_vers -productVersion)
-            check_version "${osx_host_version}" "${OSX_VERSION}"
-            [[ $? -ge 2 ]] && die "Minimum OSX version supported is ${OSX_VERSION}"
-            ;;
-        "*")
-            echo "Exiting.. unsupported operating system found"
-            exit 1;
-    esac
-}
-
-is_supported_arch() {
-    local supported
-    case ${UNAME##* } in
-        "x86_64" | "amd64")
-            supported=1
-            ;;
-        "arm"*)
-            supported=1
-            ;;
-        *)
-            supported=0
-            ;;
-    esac
-    if [ $supported -eq 0 ]; then
-        echo "Invalid arch: ${UNAME} not supported, please use x86_64/amd64"
-        exit 1;
-    fi
-}
-
-check_deps() {
-    check_version "$(env go version 2>/dev/null | sed 's/^.* go\([0-9.]*\).*$/\1/')" "${GO_VERSION}"
-    if [ $? -ge 2 ]; then
-        MISSING="${MISSING} golang(${GO_VERSION})"
-    fi
-
-    check_version "$(env git --version 2>/dev/null | sed -e 's/^.* \([0-9.\].*\).*$/\1/' -e 's/^\([0-9.\]*\).*/\1/g')" "${GIT_VERSION}"
-    if [ $? -ge 2 ]; then
-        MISSING="${MISSING} git"
-    fi
-}
-
-main() {
-    echo -n "Check for supported arch.. "
-    is_supported_arch
-
-    echo -n "Check for supported os.. "
-    is_supported_os
-
-    echo -n "Checking if proper environment variables are set.. "
-    check_golang_env
-
-    echo "Done"
-    echo "Using GOPATH=${GOPATH} and GOROOT=${GOROOT}"
-
-    echo -n "Checking dependencies for Minio.. "
-    check_deps
-
-    ## If dependencies are missing, warn the user and abort
-    if [ "x${MISSING}" != "x" ]; then
-        echo "ERROR"
-        echo
-        echo "The following build tools are missing:"
-        echo
-        echo "** ${MISSING} **"
-        echo
-        echo "Please install them "
-        echo "${MISSING}"
-        echo
-        echo "Follow https://github.com/minio/minio/blob/master/INSTALLGO.md for further instructions"
-        exit 1
-    fi
-    echo "Done"
-}
-
-_init && main "$@"

buildscripts/checkgopath.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-#
-# 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.
-#
-
-_init() {
-
-    shopt -s extglob
-
-    PWD=$(pwd -P)
-    GOPATH=$(cd "$(go env GOPATH)" ; env pwd -P)
-}
-
-main() {
-    echo "Checking if project is at ${GOPATH}"
-    for minio in $(echo ${GOPATH} | tr ':' ' '); do
-        if [ ! -d ${minio}/src/github.com/minio/minio ]; then
-            echo "Project not found in ${minio}, please follow instructions provided at https://github.com/minio/minio/blob/master/CONTRIBUTING.md#setup-your-minio-github-repository" \
-                && exit 1
-        fi
-        if [ "x${minio}/src/github.com/minio/minio" != "x${PWD}" ]; then
-            echo "Build outside of ${minio}, two source checkouts found. Exiting." && exit 1
-        fi
-    done
-}
-
-_init && main
-

buildscripts/gen-ldflags.go

@@ -1,71 +0,0 @@
-// +build ignore
-
-/*
- * Minio Cloud 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 (
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-	"time"
-)
-
-func genLDFlags(version string) string {
-	var ldflagsStr string
-	ldflagsStr = "-X main.minioVersion=" + version
-	ldflagsStr += " -X main.minioReleaseTag=" + releaseTag(version)
-	ldflagsStr += " -X main.minioCommitID=" + commitID()
-	ldflagsStr += " -X main.minioShortCommitID=" + commitID()[:12]
-	ldflagsStr += " -X main.minioGOPATH=" + os.Getenv("GOPATH")
-	return ldflagsStr
-}
-
-// genReleaseTag prints release tag to the console for easy git tagging.
-func releaseTag(version string) string {
-	relPrefix := "DEVELOPMENT"
-	if prefix := os.Getenv("MINIO_RELEASE"); prefix != "" {
-		relPrefix = prefix
-	}
-
-	relTag := strings.Replace(version, " ", "-", -1)
-	relTag = strings.Replace(relTag, ":", "-", -1)
-	relTag = strings.Replace(relTag, ",", "", -1)
-	return relPrefix + "." + relTag
-}
-
-// commitID returns the abbreviated commit-id hash of the last commit.
-func commitID() string {
-	// git log --format="%h" -n1
-	var (
-		commit []byte
-		e      error
-	)
-	cmdName := "git"
-	cmdArgs := []string{"log", "--format=%H", "-n1"}
-	if commit, e = exec.Command(cmdName, cmdArgs...).Output(); e != nil {
-		fmt.Fprintln(os.Stderr, "Error generating git commit-id: ", e)
-		os.Exit(1)
-	}
-
-	return strings.TrimSpace(string(commit))
-}
-
-func main() {
-	fmt.Println(genLDFlags(time.Now().UTC().Format(time.RFC3339)))
-}

certs.go

@@ -1,89 +0,0 @@
-/*
- * 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"
-)
-
-// createCertsPath create certs path.
-func createCertsPath() error {
-	certsPath, err := getCertsPath()
-	if err != nil {
-		return err
-	}
-	return os.MkdirAll(certsPath, 0700)
-}
-
-// getCertsPath get certs path.
-func getCertsPath() (string, error) {
-	var certsPath string
-	configDir, err := getConfigPath()
-	if err != nil {
-		return "", err
-	}
-	certsPath = filepath.Join(configDir, globalMinioCertsDir)
-	return certsPath, nil
-}
-
-// mustGetCertsPath must get certs path.
-func mustGetCertsPath() string {
-	certsPath, err := getCertsPath()
-	fatalIf(err, "Failed to get certificate path.")
-	return certsPath
-}
-
-// mustGetCertFile must get cert file.
-func mustGetCertFile() string {
-	return filepath.Join(mustGetCertsPath(), globalMinioCertFile)
-}
-
-// mustGetKeyFile must get key file.
-func mustGetKeyFile() string {
-	return filepath.Join(mustGetCertsPath(), globalMinioKeyFile)
-}
-
-// isCertFileExists verifies if cert file exists, returns true if
-// found, false otherwise.
-func isCertFileExists() bool {
-	st, e := os.Stat(filepath.Join(mustGetCertsPath(), globalMinioCertFile))
-	// If file exists and is regular return true.
-	if e == nil && st.Mode().IsRegular() {
-		return true
-	}
-	return false
-}
-
-// isKeyFileExists verifies if key file exists, returns true if found,
-// false otherwise.
-func isKeyFileExists() bool {
-	st, e := os.Stat(filepath.Join(mustGetCertsPath(), globalMinioKeyFile))
-	// If file exists and is regular return true.
-	if e == nil && st.Mode().IsRegular() {
-		return true
-	}
-	return false
-}
-
-// isSSL - returns true with both cert and key exists.
-func isSSL() bool {
-	if isCertFileExists() && isKeyFileExists() {
-		return true
-	}
-	return false
-}

checkport.go

@@ -1,93 +0,0 @@
-/*
- * 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"
-	"net"
-	"os"
-	"syscall"
-)
-
-// Make sure that none of the other processes are listening on the
-// specified port on any of the interfaces.
-//
-// On linux if a process is listening on 127.0.0.1:9000 then Listen()
-// on ":9000" fails with the error "port already in use".
-// 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()
-		if err != nil {
-			fatalIf(err, "Unable to list addresses on interface %s.", ifc.Name)
-		}
-		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)
-			}
-		}
-	}
-}

commands.go

@@ -1,44 +0,0 @@
-/*
- * Minio Cloud 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 "github.com/minio/cli"
-
-// Collection of minio commands currently supported are.
-var commands = []cli.Command{}
-
-// Collection of minio commands currently supported in a trie tree.
-var commandsTree = newTrie()
-
-// Collection of minio flags currently supported.
-var globalFlags = []cli.Flag{
-	cli.StringFlag{
-		Name:  "config-dir, C",
-		Value: mustGetConfigPath(),
-		Usage: "Path to configuration folder.",
-	},
-	cli.BoolFlag{
-		Name:  "quiet",
-		Usage: "Suppress chatty output.",
-	},
-}
-
-// registerCommand registers a cli command.
-func registerCommand(command cli.Command) {
-	commands = append(commands, command)
-	commandsTree.Insert(command.Name)
-}

config-migrate.go

@@ -1,148 +0,0 @@
-/*
- * 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"
-	"os"
-	"path/filepath"
-
-	"github.com/minio/mc/pkg/console"
-	"github.com/minio/minio/pkg/quick"
-)
-
-func migrateConfig() {
-	// Purge all configs with version '1'.
-	purgeV1()
-	// Migrate version '2' to '3'.
-	migrateV2ToV3()
-	// Migrate version '3' to '4'.
-	migrateV3ToV4()
-}
-
-// Version '1' is not supported anymore and deprecated, safe to delete.
-func purgeV1() {
-	cv1, err := loadConfigV1()
-	if err != nil && os.IsNotExist(err) {
-		return
-	}
-	fatalIf(err, "Unable to load config version ‘1’.")
-
-	if cv1.Version == "1" {
-		console.Println("Removed unsupported config version ‘1’.")
-		/// Purge old fsUsers.json file
-		configPath, err := getConfigPath()
-		fatalIf(err, "Unable to retrieve config path.")
-
-		configFile := filepath.Join(configPath, "fsUsers.json")
-		removeAll(configFile)
-	}
-	fatalIf(errors.New(""), "Failed to migrate unrecognized config version ‘"+cv1.Version+"’.")
-}
-
-// Version '2' to '3' config migration adds new fields and re-orders
-// previous fields. Simplifies config for future additions.
-func migrateV2ToV3() {
-	cv2, err := loadConfigV2()
-	if err != nil && os.IsNotExist(err) {
-		return
-	}
-	fatalIf(err, "Unable to load config version ‘2’.")
-	if cv2.Version != "2" {
-		return
-	}
-	srvConfig := &configV3{}
-	srvConfig.Version = "3"
-	srvConfig.Addr = ":9000"
-	srvConfig.Credential = credential{
-		AccessKeyID:     cv2.Credentials.AccessKeyID,
-		SecretAccessKey: cv2.Credentials.SecretAccessKey,
-	}
-	srvConfig.Region = cv2.Credentials.Region
-	if srvConfig.Region == "" {
-		// Region needs to be set for AWS Signature V4.
-		srvConfig.Region = "us-east-1"
-	}
-	srvConfig.Logger.Console = consoleLogger{
-		Enable: true,
-		Level:  "fatal",
-	}
-	flogger := fileLogger{}
-	flogger.Level = "error"
-	if cv2.FileLogger.Filename != "" {
-		flogger.Enable = true
-		flogger.Filename = cv2.FileLogger.Filename
-	}
-	srvConfig.Logger.File = flogger
-
-	slogger := syslogLogger{}
-	slogger.Level = "debug"
-	if cv2.SyslogLogger.Addr != "" {
-		slogger.Enable = true
-		slogger.Addr = cv2.SyslogLogger.Addr
-	}
-	srvConfig.Logger.Syslog = slogger
-
-	qc, err := quick.New(srvConfig)
-	fatalIf(err, "Unable to initialize config.")
-
-	configFile, err := getConfigFile()
-	fatalIf(err, "Unable to get config file.")
-
-	// Migrate the config.
-	err = qc.Save(configFile)
-	fatalIf(err, "Failed to migrate config from ‘"+cv2.Version+"’ to ‘"+srvConfig.Version+"’ failed.")
-
-	console.Println("Migration from version ‘" + cv2.Version + "’ to ‘" + srvConfig.Version + "’ completed successfully.")
-}
-
-// Version '3' to '4' migrates config, removes previous fields related
-// to backend types and server address. This change further simplifies
-// the config for future additions.
-func migrateV3ToV4() {
-	cv3, err := loadConfigV3()
-	if err != nil && os.IsNotExist(err) {
-		return
-	}
-	fatalIf(err, "Unable to load config version ‘3’.")
-	if cv3.Version != "3" {
-		return
-	}
-
-	// Save only the new fields, ignore the rest.
-	srvConfig := &serverConfigV4{}
-	srvConfig.Version = globalMinioConfigVersion
-	srvConfig.Credential = cv3.Credential
-	srvConfig.Region = cv3.Region
-	if srvConfig.Region == "" {
-		// Region needs to be set for AWS Signature Version 4.
-		srvConfig.Region = "us-east-1"
-	}
-	srvConfig.Logger.Console = cv3.Logger.Console
-	srvConfig.Logger.File = cv3.Logger.File
-	srvConfig.Logger.Syslog = cv3.Logger.Syslog
-
-	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 ‘"+cv3.Version+"’ to ‘"+srvConfig.Version+"’ failed.")
-
-	console.Println("Migration from version ‘" + cv3.Version + "’ to ‘" + srvConfig.Version + "’ completed successfully.")
-}

config-old.go

@@ -1,147 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/minio/minio/pkg/quick"
-)
-
-/////////////////// Config V1 ///////////////////
-type configV1 struct {
-	Version         string `json:"version"`
-	AccessKeyID     string `json:"accessKeyId"`
-	SecretAccessKey string `json:"secretAccessKey"`
-}
-
-// loadConfigV1 load config
-func loadConfigV1() (*configV1, error) {
-	configPath, err := getConfigPath()
-	if err != nil {
-		return nil, err
-	}
-	configFile := filepath.Join(configPath, "fsUsers.json")
-	if _, err = os.Stat(configFile); err != nil {
-		return nil, err
-	}
-	c := &configV1{}
-	c.Version = "1"
-	qc, err := quick.New(c)
-	if err != nil {
-		return nil, err
-	}
-	if err := qc.Load(configFile); err != nil {
-		return nil, err
-	}
-	return c, nil
-}
-
-/////////////////// Config V2 ///////////////////
-type configV2 struct {
-	Version     string `json:"version"`
-	Credentials struct {
-		AccessKeyID     string `json:"accessKeyId"`
-		SecretAccessKey string `json:"secretAccessKey"`
-		Region          string `json:"region"`
-	} `json:"credentials"`
-	MongoLogger struct {
-		Addr       string `json:"addr"`
-		DB         string `json:"db"`
-		Collection string `json:"collection"`
-	} `json:"mongoLogger"`
-	SyslogLogger struct {
-		Network string `json:"network"`
-		Addr    string `json:"addr"`
-	} `json:"syslogLogger"`
-	FileLogger struct {
-		Filename string `json:"filename"`
-	} `json:"fileLogger"`
-}
-
-// loadConfigV2 load config version '2'.
-func loadConfigV2() (*configV2, error) {
-	configFile, err := getConfigFile()
-	if err != nil {
-		return nil, err
-	}
-	if _, err = os.Stat(configFile); err != nil {
-		return nil, err
-	}
-	c := &configV2{}
-	c.Version = "2"
-	qc, err := quick.New(c)
-	if err != nil {
-		return nil, err
-	}
-	if err := qc.Load(configFile); err != nil {
-		return nil, err
-	}
-	return c, nil
-}
-
-/////////////////// Config V3 ///////////////////
-
-// backendV3 type.
-type backendV3 struct {
-	Type  string   `json:"type"`
-	Disk  string   `json:"disk,omitempty"`
-	Disks []string `json:"disks,omitempty"`
-}
-
-// loggerV3 type.
-type loggerV3 struct {
-	Console struct {
-		Enable bool   `json:"enable"`
-		Level  string `json:"level"`
-	}
-	File struct {
-		Enable   bool   `json:"enable"`
-		Filename string `json:"fileName"`
-		Level    string `json:"level"`
-	}
-	Syslog struct {
-		Enable bool   `json:"enable"`
-		Addr   string `json:"address"`
-		Level  string `json:"level"`
-	} `json:"syslog"`
-	// Add new loggers here.
-}
-
-// configV3 server configuration version '3'.
-type configV3 struct {
-	Version string `json:"version"`
-
-	// Backend configuration.
-	Backend backendV3 `json:"backend"`
-
-	// http Server configuration.
-	Addr string `json:"address"`
-
-	// S3 API configuration.
-	Credential credential `json:"credential"`
-	Region     string     `json:"region"`
-
-	// Additional error logging configuration.
-	Logger loggerV3 `json:"logger"`
-}
-
-// loadConfigV3 load config version '3'.
-func loadConfigV3() (*configV3, error) {
-	configFile, err := getConfigFile()
-	if err != nil {
-		return nil, err
-	}
-	if _, err = os.Stat(configFile); err != nil {
-		return nil, err
-	}
-	c := &configV3{}
-	c.Version = "3"
-	qc, err := quick.New(c)
-	if err != nil {
-		return nil, err
-	}
-	if err := qc.Load(configFile); err != nil {
-		return nil, err
-	}
-	return c, nil
-}

config-v4.go

@@ -1,197 +0,0 @@
-/*
- * 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"
-	"sync"
-
-	"github.com/minio/minio/pkg/quick"
-)
-
-// serverConfigV4 server configuration version '4'.
-type serverConfigV4 struct {
-	Version string `json:"version"`
-
-	// S3 API configuration.
-	Credential credential `json:"credential"`
-	Region     string     `json:"region"`
-
-	// Additional error logging configuration.
-	Logger logger `json:"logger"`
-
-	// Read Write mutex.
-	rwMutex *sync.RWMutex
-}
-
-// initConfig - initialize server config. config version (called only once).
-func initConfig() error {
-	if !isConfigFileExists() {
-		srvCfg := &serverConfigV4{}
-		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
-
-		// Save config into file.
-		return serverConfig.Save()
-	}
-	configFile, err := getConfigFile()
-	if err != nil {
-		return err
-	}
-	if _, err = os.Stat(configFile); err != nil {
-		return err
-	}
-	srvCfg := &serverConfigV4{}
-	srvCfg.Version = globalMinioConfigVersion
-	srvCfg.rwMutex = &sync.RWMutex{}
-	qc, err := quick.New(srvCfg)
-	if err != nil {
-		return err
-	}
-	if err := qc.Load(configFile); err != nil {
-		return err
-	}
-	// Save the loaded config globally.
-	serverConfig = srvCfg
-	// Set the version properly after the unmarshalled json is loaded.
-	serverConfig.Version = globalMinioConfigVersion
-	return nil
-}
-
-// serverConfig server config.
-var serverConfig *serverConfigV4
-
-// GetVersion get current config version.
-func (s serverConfigV4) GetVersion() string {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-	return s.Version
-}
-
-/// Logger related.
-
-// SetFileLogger set new file logger.
-func (s *serverConfigV4) SetFileLogger(flogger fileLogger) {
-	s.rwMutex.Lock()
-	defer s.rwMutex.Unlock()
-	s.Logger.File = flogger
-}
-
-// GetFileLogger get current file logger.
-func (s serverConfigV4) GetFileLogger() fileLogger {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-	return s.Logger.File
-}
-
-// SetConsoleLogger set new console logger.
-func (s *serverConfigV4) SetConsoleLogger(clogger consoleLogger) {
-	s.rwMutex.Lock()
-	defer s.rwMutex.Unlock()
-	s.Logger.Console = clogger
-}
-
-// GetConsoleLogger get current console logger.
-func (s serverConfigV4) GetConsoleLogger() consoleLogger {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-	return s.Logger.Console
-}
-
-// SetSyslogLogger set new syslog logger.
-func (s *serverConfigV4) SetSyslogLogger(slogger syslogLogger) {
-	s.rwMutex.Lock()
-	defer s.rwMutex.Unlock()
-	s.Logger.Syslog = slogger
-}
-
-// GetSyslogLogger get current syslog logger.
-func (s *serverConfigV4) GetSyslogLogger() syslogLogger {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-	return s.Logger.Syslog
-}
-
-// SetRegion set new region.
-func (s *serverConfigV4) SetRegion(region string) {
-	s.rwMutex.Lock()
-	defer s.rwMutex.Unlock()
-	s.Region = region
-}
-
-// GetRegion get current region.
-func (s serverConfigV4) GetRegion() string {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-	return s.Region
-}
-
-// SetCredentials set new credentials.
-func (s *serverConfigV4) SetCredential(creds credential) {
-	s.rwMutex.Lock()
-	defer s.rwMutex.Unlock()
-	s.Credential = creds
-}
-
-// GetCredentials get current credentials.
-func (s serverConfigV4) GetCredential() credential {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-	return s.Credential
-}
-
-// Save config.
-func (s serverConfigV4) Save() error {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-
-	// get config file.
-	configFile, err := getConfigFile()
-	if err != nil {
-		return err
-	}
-
-	// initialize quick.
-	qc, err := quick.New(&s)
-	if err != nil {
-		return err
-	}
-
-	// Save config file.
-	return qc.Save(configFile)
-}

config.go

@@ -1,88 +0,0 @@
-/*
- * 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"
-
-	"github.com/minio/go-homedir"
-)
-
-// configPath for custom config path only for testing purposes
-var customConfigPath string
-
-// Sets a new config path.
-func setGlobalConfigPath(configPath string) {
-	customConfigPath = configPath
-}
-
-// getConfigPath get server config path
-func getConfigPath() (string, error) {
-	if customConfigPath != "" {
-		return customConfigPath, nil
-	}
-	homeDir, err := homedir.Dir()
-	if err != nil {
-		return "", err
-	}
-	configPath := filepath.Join(homeDir, globalMinioConfigDir)
-	return configPath, nil
-}
-
-// mustGetConfigPath must get server config path.
-func mustGetConfigPath() string {
-	configPath, err := getConfigPath()
-	fatalIf(err, "Unable to get config path.")
-	return configPath
-}
-
-// createConfigPath create server config path.
-func createConfigPath() error {
-	configPath, err := getConfigPath()
-	if err != nil {
-		return err
-	}
-	return os.MkdirAll(configPath, 0700)
-}
-
-// isConfigFileExists - returns true if config file exists.
-func isConfigFileExists() bool {
-	st, err := os.Stat(mustGetConfigFile())
-	// If file exists and is regular return true.
-	if err == nil && st.Mode().IsRegular() {
-		return true
-	}
-	return false
-}
-
-// mustGetConfigFile must get server config file.
-func mustGetConfigFile() string {
-	configFile, err := getConfigFile()
-	fatalIf(err, "Unable to get config file.")
-
-	return configFile
-}
-
-// getConfigFile get server config file.
-func getConfigFile() (string, error) {
-	configPath, err := getConfigPath()
-	if err != nil {
-		return "", err
-	}
-	return filepath.Join(configPath, globalMinioConfigFile), nil
-}

curated.json

@@ -0,0 +1,370 @@
+{
+  "updated": "2026-09-16T08:13:18+00:00",
+  "revision": "24ba6c3743dfe323ff937b39cde50e363f517d1b",
+  "repositories": [
+    "pgsty/silo",
+    "pgsty/silo-console",
+    "pgsty/mc",
+    "pgsty/silo-pkg",
+    "pgsty/silo-go",
+    "pgsty/kes",
+    "pgsty/silo.pgsty.com",
+    "pgsty/minio-docs"
+  ],
+  "bots": [
+    "Copilot",
+    "dependabot[bot]"
+  ],
+  "people": [
+    {
+      "handle": "Vonng",
+      "group": "code",
+      "featured": true,
+      "what": "Maintains SILO, Console, mcli, shared packages, releases, and documentation",
+      "firstContribution": "2026-04-14"
+    },
+    {
+      "handle": "ZouhairCharef",
+      "group": "code",
+      "featured": true,
+      "what": "Patched CVE-2026-34986 in go-jose",
+      "firstContribution": "2026-04-06"
+    },
+    {
+      "handle": "mfredenhagen",
+      "group": "code",
+      "featured": true,
+      "what": "Patched CVE-2026-39883 in OpenTelemetry",
+      "firstContribution": "2026-04-10"
+    },
+    {
+      "handle": "pinginfo",
+      "group": "code",
+      "featured": true,
+      "what": "Repaired bucket notification streaming",
+      "firstContribution": "2026-05-02"
+    },
+    {
+      "handle": "ycjlin",
+      "group": "code",
+      "featured": true,
+      "what": "Fixed missing-bucket ListObjects semantics",
+      "firstContribution": "2026-06-28"
+    },
+    {
+      "handle": "waterkip",
+      "group": "code",
+      "featured": true,
+      "what": "Repointed documentation links to the SILO portal",
+      "firstContribution": "2026-07-16"
+    },
+    {
+      "handle": "Dansyuqri",
+      "group": "code",
+      "featured": true,
+      "what": "Added ChecksumType to multipart completion responses",
+      "firstContribution": "2026-08-09"
+    },
+    {
+      "handle": "mrjavadseydi",
+      "group": "code",
+      "featured": true,
+      "what": "Fixed bucket quota metrics; contributed access-frequency ILM and S3-compatible multipart listing proposals",
+      "firstContribution": "2026-08-15"
+    },
+    {
+      "handle": "h5vx",
+      "group": "code",
+      "featured": true,
+      "what": "Implemented per-bucket CORS configuration and enforcement",
+      "firstContribution": "2026-08-25"
+    },
+    {
+      "handle": "nikitapogromsky",
+      "group": "code",
+      "featured": true,
+      "what": "Fixed duplicate logger targets that broke Metrics V3 collection",
+      "firstContribution": "2026-09-07"
+    },
+    {
+      "handle": "Aeirx",
+      "group": "code",
+      "featured": true,
+      "what": "Preserved Object Lock legal-hold headers in federated CopyObject",
+      "firstContribution": "2026-09-09"
+    },
+    {
+      "handle": "magicxor",
+      "group": "proposed",
+      "featured": true,
+      "what": "Reported and proposed conditional DELETE support for If-Match",
+      "firstContribution": "2026-03-21"
+    },
+    {
+      "handle": "davinkevin",
+      "group": "proposed",
+      "featured": true,
+      "what": "Proposed the distroless container image and dependency automation",
+      "firstContribution": "2026-04-10"
+    },
+    {
+      "handle": "metaneutrons",
+      "group": "proposed",
+      "featured": true,
+      "what": "Reported and proposed explicit-version delete authorization",
+      "firstContribution": "2026-08-15"
+    },
+    {
+      "handle": "mikemikimike",
+      "group": "proposed",
+      "featured": true,
+      "what": "Contributed the replicated SSE-C plaintext part-size fix",
+      "firstContribution": "2026-09-05"
+    },
+    {
+      "handle": "julienlau",
+      "group": "proposed",
+      "featured": true,
+      "what": "Reported MRF queue and delete-marker retry defects; contributed repair proposals, tests, and documentation",
+      "firstContribution": "2026-09-07"
+    },
+    {
+      "handle": "chodorenko",
+      "group": "proposed",
+      "featured": true,
+      "what": "Reported and contributed the fix for aws-chunked leaking into replica metadata",
+      "firstContribution": "2026-09-14"
+    },
+    {
+      "handle": "sulin37392",
+      "group": "proposed",
+      "featured": false,
+      "what": "Proposed dependency updates",
+      "firstContribution": "2026-03-17"
+    },
+    {
+      "handle": "lem21h",
+      "group": "proposed",
+      "featured": false,
+      "what": "Proposed robustness and goroutine improvements",
+      "firstContribution": "2026-06-24"
+    },
+    {
+      "handle": "vampywiz17",
+      "group": "reports",
+      "featured": true,
+      "what": "Reported LDAP TLS and Console login regressions",
+      "firstContribution": "2026-03-23"
+    },
+    {
+      "handle": "cbornet",
+      "group": "reports",
+      "featured": true,
+      "what": "Reported multipart and streaming checksum defects and missing-bucket semantics",
+      "firstContribution": "2026-04-24"
+    },
+    {
+      "handle": "orenyomtov",
+      "group": "reports",
+      "featured": true,
+      "what": "Reported the unsigned-header CopyObject cross-object read (SN-2026-011)",
+      "firstContribution": "9999-12-31"
+    },
+    {
+      "handle": "jiri-pejchal",
+      "group": "reports",
+      "featured": true,
+      "what": "Reported the RabbitMQ client vulnerability and the Console share proxy's exposure of internal metrics",
+      "firstContribution": "2026-09-10"
+    },
+    {
+      "handle": "AEGEGE",
+      "group": "reports",
+      "featured": true,
+      "what": "Reported the slow-HTTP denial-of-service vulnerability",
+      "firstContribution": "2026-09-14"
+    },
+    {
+      "handle": "mosesdd",
+      "group": "reports",
+      "featured": false,
+      "what": "Requested a maintained Helm chart",
+      "firstContribution": "2026-03-03"
+    },
+    {
+      "handle": "Xavier-777",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported Console lifecycle management and file preview gaps",
+      "firstContribution": "2026-03-04"
+    },
+    {
+      "handle": "jiadzh",
+      "group": "reports",
+      "featured": false,
+      "what": "Requested Windows build guidance",
+      "firstContribution": "2026-03-05"
+    },
+    {
+      "handle": "AntonOfTheWoods",
+      "group": "reports",
+      "featured": false,
+      "what": "Asked for clarity on Helm chart and operator options",
+      "firstContribution": "2026-03-10"
+    },
+    {
+      "handle": "TLINDEN",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported the missing client in release tarballs",
+      "firstContribution": "2026-03-10"
+    },
+    {
+      "handle": "zylpsrs",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported missing Console tiering and site replication",
+      "firstContribution": "2026-03-12"
+    },
+    {
+      "handle": "nsanitate",
+      "group": "reports",
+      "featured": false,
+      "what": "Proposed CNCF Sandbox governance",
+      "firstContribution": "2026-03-13"
+    },
+    {
+      "handle": "makinikm",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported the missing client in the container image",
+      "firstContribution": "2026-03-20"
+    },
+    {
+      "handle": "spaceg00se-r",
+      "group": "reports",
+      "featured": false,
+      "what": "Requested cpuv1 support and reported a workflow token failure",
+      "firstContribution": "2026-03-21"
+    },
+    {
+      "handle": "heroes1412",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported the unusable profiling option",
+      "firstContribution": "2026-03-22"
+    },
+    {
+      "handle": "chalukyaj",
+      "group": "reports",
+      "featured": false,
+      "what": "Proposed making the SILO Operator easier to discover",
+      "firstContribution": "2026-04-19"
+    },
+    {
+      "handle": "jvasile",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported missing user, group, and defaults in Debian packages",
+      "firstContribution": "2026-04-27"
+    },
+    {
+      "handle": "Kesavaambati",
+      "group": "reports",
+      "featured": false,
+      "what": "Asked about community support and image maintenance",
+      "firstContribution": "2026-05-21"
+    },
+    {
+      "handle": "redfoxfox",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported Chinese documentation availability",
+      "firstContribution": "2026-07-06"
+    },
+    {
+      "handle": "kuldeep-link11",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported NATS JWT credentials and target reload issues",
+      "firstContribution": "2026-07-08"
+    },
+    {
+      "handle": "meesudzu",
+      "group": "reports",
+      "featured": false,
+      "what": "Requested the migration guide from upstream MinIO",
+      "firstContribution": "2026-07-21"
+    },
+    {
+      "handle": "pmezhuev",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported missing RPM package signatures",
+      "firstContribution": "2026-07-21"
+    },
+    {
+      "handle": "kh0mka",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported inter-node I/O timeouts and OIDC configuration-fetch failures",
+      "firstContribution": "2026-08-03"
+    },
+    {
+      "handle": "bagutzu",
+      "group": "reports",
+      "featured": false,
+      "what": "Requested KES-compatible external KMS and OpenBao support",
+      "firstContribution": "2026-08-17"
+    },
+    {
+      "handle": "liuhaodongliu990-cmyk",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported indeterminate progress for prefix downloads",
+      "firstContribution": "2026-08-21"
+    },
+    {
+      "handle": "DestroyLee",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported the missing documentation navigation",
+      "firstContribution": "2026-08-26"
+    },
+    {
+      "handle": "sargarass",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported ListMultipartUploads prefix and pagination semantics",
+      "firstContribution": "2026-08-28"
+    },
+    {
+      "handle": "mumu-lab",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported bucket quota metrics reading a deprecated field",
+      "firstContribution": "2026-09-03"
+    },
+    {
+      "handle": "haiming236",
+      "group": "reports",
+      "featured": false,
+      "what": "Proposed a built-in image processing pipeline",
+      "firstContribution": "2026-09-08"
+    },
+    {
+      "handle": "tiredenzo",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported inconsistent documentation for two-drive EC:1 support",
+      "firstContribution": "2026-09-15"
+    },
+    {
+      "handle": "aschyolkin",
+      "group": "reports",
+      "featured": false,
+      "what": "Reported a data race in CPU metrics collection",
+      "firstContribution": "2026-09-16"
+    }
+  ]
+}

damerau-levenshtein.go

@@ -1,66 +0,0 @@
-/*
- * Minio Client (C) 2014-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"
-)
-
-// Returns the minimum value of a slice of integers
-func minimum(integers []int) (minVal int) {
-	minVal = math.MaxInt32
-	for _, v := range integers {
-		if v < minVal {
-			minVal = v
-		}
-	}
-	return
-}
-
-// DamerauLevenshteinDistance calculates distance between two strings using an algorithm
-// described in https://en.wikipedia.org/wiki/Damerau-Levenshtein_distance
-func DamerauLevenshteinDistance(a string, b string) int {
-	d := make([][]int, len(a)+1)
-	for i := 1; i <= len(a)+1; i++ {
-		d[i-1] = make([]int, len(b)+1)
-	}
-	for i := 0; i <= len(a); i++ {
-		d[i][0] = i
-	}
-	for j := 0; j <= len(b); j++ {
-		d[0][j] = j
-	}
-	for i := 1; i <= len(a); i++ {
-		for j := 1; j <= len(b); j++ {
-			cost := 0
-			if a[i-1] == b[j-1] {
-				cost = 0
-			} else {
-				cost = 1
-			}
-			d[i][j] = minimum([]int{
-				d[i-1][j] + 1,
-				d[i][j-1] + 1,
-				d[i-1][j-1] + cost,
-			})
-			if i > 1 && j > 1 && a[i-1] == b[j-2] && a[i-2] == b[j-1] {
-				d[i][j] = minimum([]int{d[i][j], d[i-2][j-2] + cost}) // transposition
-			}
-		}
-	}
-	return d[len(a)][len(b)]
-}

dist/benchmark/benchcmp.sh

@@ -1,67 +0,0 @@
-#!/bin/bash          
-
-# usage: ./benchcmp.sh <commit-sha1> <commit-sha2>
-# Exit on any non zero return value on execution of a command. 
-set -e 
-
-# path of benchcmp. 
-benchcmp=${GOPATH}/bin/benchcmp
-
-# function which runs the benchmark comparison. 
-RunBenchCmp () {
-	# Path for storing output of benchmark at commit 1. 
-	commit1Bench=/tmp/minio-$1.bench
-	# Path for storing output of benchmark at commit 2. 
-	commit2Bench=/tmp/minio-$2.bench
-	# switch to commit $1. 
-	git checkout $1
-	# Check if the benchmark results for given commit 1 already exists. 
-	# Benchmarks are time/resource consuming operations, run only if the the results doesn't exist. 
-	if [[ ! -f $commit1Bench  ]]
-	then
-
-		echo "Running benchmarks at $1"
-		go test -run=NONE -bench=. | tee $commit1Bench 
-	fi
-	# get back to the commit from which it was started. 
-	git checkout -
-	echo "Checking into commit $2"
-	# switch to commit $2 
-	git checkout $2
-	# Check if the benchmark results for given commit 2 already exists. 
-	# Benchmarks are time/resource consuming operations, run only if the the results doesn't exist. 
-	if [[ ! -f $commit2Bench  ]]
-	then
-	# Running benchmarks at $2.
-		echo "Running benchmarks at $2"
-		go test -run=NONE -bench=. | tee $commit2Bench 
-	fi
-	
-	# get back to the commit from which it was started. 
-	git checkout - 
-	# Comparing the benchmarks.
-	echo "Running benchmark comparison between $1 and $2 ..."
-	$benchcmp $commit1Bench $commit2Bench 
-	echo "Done."
-}
-
-# check if 2 commit SHA's of snapshots of code for which benchmp has to be done is provided. 
-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."
-	exit 1
-fi
-
-# check if benchcmp exists. 
-if [[ -x "$benchcmp" ]]
-then
-	RunBenchCmp $1 $2
-else
-	# install benchcmp if doesnt't exist. 
-	echo "fetching Benchcmp..."
-	go get -u golang.org/x/tools/cmd/benchcmp
-	echo "Done."
-	RunBenchCmp $1 $2
-fi

dist/linux-systemd/minio.service

@@ -1,50 +0,0 @@
-[Unit]
-Description=Minio
-Documentation=http://minio.io
-Wants=network-online.target
-After=network-online.target
-AssertPathExists=/etc/minio/
-AssertFileIsExecutable=/usr/share/minio/bin/minio
-
-[Service]
-WorkingDirectory=/usr/share/minio/
-
-User=minio
-Group=minio
-
-PermissionsStartOnly=true
-    
-EnvironmentFile=-/etc/default/minio
-ExecStartPre=/bin/bash -c "[ -n \"${MINIO_VOLUMES}\" ] || echo \"Variable MINIO_VOLUMES not set in /etc/defaults/minio\""
-ExecStartPre=/bin/bash -c "(for i in $MINIO_VOLUMES; do if [ ! -d $i ]; then echo \"Directory $i of variable MINIO_VOLUMES isn't an existing directory\" && false; exit; fi; done)"
-
-ExecStartPre=-/bin/chown -R root:minio /etc/minio/
-ExecStartPre=-/bin/chmod -R 660 /etc/minio/
-ExecStartPre=-/bin/chmod -R ug+X /etc/minio/
-
-ExecStart=/usr/share/minio/bin/minio \
-                --config-dir "/etc/minio/" \
-                server \
-                $MINIO_OPTS \
-                $MINIO_VOLUMES
-
-StandardOutput=journal
-StandardError=inherit
-
-# Specifies the maximum file descriptor number that can be opened by this process
-LimitNOFILE=65536
-
-# Disable timeout logic and wait until process is stopped
-TimeoutStopSec=0
-
-# SIGTERM signal is used to stop Minio
-KillSignal=SIGTERM
-
-SendSIGKILL=no
-
-SuccessExitStatus=0
-
-[Install]
-WantedBy=multi-user.target
-
-# Built for ${project.name}-${project.version} (${project.name})

dist/linux-systemd/readme.md

@@ -1,35 +0,0 @@
-# Readme
-Service script for minio service for systemd.
-
-# Installation
-```
-mkdir /etc/minio/
-mkdir -p /usr/share/minio/bin/
-wget -o /usr/share/minio/bin/minio http://...
-```
-
-Create minio user.
-```
-useradd minio
-```
-
-Create default configuration. Don't forget to update MINIO_VOLUMES with the correct path(s).
-```
-cat <<EOT >> /etc/default/minio
-MINIO_OPTS="--address :9000"
-MINIO_VOLUMES="/tmp/minio/"
-EOT
-```
-
-# Systemctl
-
-Put minio.service in /etc/systemd/system/
-```
-curl https://raw.githubusercontent.com/minio/minio/master/dist/linux-systemd/minio.service > /etc/systemd/system/
-```
-
-Enable startup on boot
-```
-systemctl enable minio.service
-```
-

docs/TBD.md

@@ -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>
-```

docs/api-bucket-policy.md

@@ -1,33 +0,0 @@
-## Access Policy
-
-This package implements parsing and validating bucket access policies based on Access Policy Language specification - http://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html
-
-### Supports following effects.
-
-    Allow
-    Deny
-
-### Supports following set of operations.
-
-    s3:GetObject
-    s3:ListBucket
-    s3:PutObject
-    s3:GetBucketLocation
-    s3:DeleteObject
-    s3:AbortMultipartUpload
-    s3:ListBucketMultipartUploads
-    s3:ListMultipartUploadParts
-
-### Supports following conditions.
-
-    StringEquals
-    StringNotEquals
-
-Supported applicable condition keys for each conditions.
-
-    s3:prefix
-    s3:max-keys
-
-### Nested policy support.
-
-Nested policies are not allowed.

docs/backend-multipart.md

@@ -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```

docs/backend/fs/format.json

@@ -1,4 +0,0 @@
-{
-  "format": "fs",
-  "version": "1"
-}

docs/backend/fs/fs.json

@@ -1,15 +0,0 @@
-{
-    "version": "1.0.0",
-    "format": "fs",
-    "minio": {
-        "release": "DEVELOPMENT.GOGET"
-    },
-    "parts": [
-        {
-            "number": 1,
-            "name": "part.1",
-            "size": 29,
-            "eTag": "",
-        },
-    ]
-}

docs/backend/fs/uploads.json

@@ -1,10 +0,0 @@
-{
-    "version": "1",
-    "format": "fs",
-    "uploadIds": [
-        {
-            "uploadID": "id",
-            "startTime": "time",
-        }
-    ]
-}

docs/backend/xl/format.json

@@ -1,20 +0,0 @@
-{
-  "xl": {
-    "jbod": [
-      "8aa2b1bc-0e5a-49e0-8221-05228336b040",
-      "3467a69b-0266-478a-9e10-e819447e4545",
-      "d4a4505b-4e4f-4864-befd-4f36adb0bc66",
-      "592b6583-ca26-47af-b991-ba6d097e34e8",
-      "c7ef69f0-dbf5-4c0e-b167-d30a441bad7e",
-      "f0b36ea3-fe96-4f2b-bced-22c7f33e0e0c",
-      "b83abf39-e39d-4e7b-8e16-6f9953455a48",
-      "7d63dfc9-5441-4243-bd36-de8db0691982",
-      "c1bbffc5-81f9-4251-9398-33a959b3ce37",
-      "64408f94-26e0-4277-9593-2d703f4d5a91"
-    ],
-    "disk": "8aa2b1bc-0e5a-49e0-8221-05228336b040",
-    "version": "1"
-  },
-  "format": "xl",
-  "version": "1"
-}

docs/backend/xl/uploads.json

@@ -1,10 +0,0 @@
-{
-    "version": "1.0.0",
-    "format": "xl",
-    "uploadIds": [
-        {
-            "uploadID": "id",
-            "startTime": "time",
-        }
-    ]
-}

docs/backend/xl/xl.json

@@ -1,50 +0,0 @@
-{
-    "parts": [
-        {
-            "number": 1,
-            "size": 5242880,
-            "etag": "3565c6e741e69a007a5ac7db893a62b5",
-            "name": "part.1"
-        },
-        {
-            "number": 2,
-            "size": 5242880,
-            "etag": "d416712335c280ab1e39498552937764",
-            "name": "part.2"
-        }
-    ],
-    "meta": {
-        "md5Sum": "97586a5290d4f5a41328062d6a7da593-3",
-        "content-type": "application\/octet-stream",
-        "content-encoding": ""
-    },
-    "minio": {
-        "release": "DEVELOPMENT.GOGET"
-    },
-    "erasure": {
-        "algorithm": "klauspost/reedsolomon/vandermonde",
-        "index": 2,
-        "distribution": [ 1, 3, 4, 2, 5, 8, 7, 6, 9 ],
-        "blockSize": 4194304,
-        "parity": 5,
-        "data": 5,
-        "checksum": [
-            {
-                "name": "part.1",
-                "algorithm": "blake2b",
-                "hash": "173c2cda7fb9e2798f91ba10135b65475fd2b97684355b328941d1c470a37549502672b2b4630c8268d5e5f79c8eb2fe433a25c6368f31d75b2c0504e3104c0e",
-            },
-            {
-                "name": "part.2",
-                "algorithm": "blake2b",
-                "hash": "14f9ba0006b2db7cd171507e79032ad3a34eab7df02b6564c487614b6d1e6613343a4f56074aa3473ac9c3b26e00cbbeae937d478cca4cfb138e72838ebb0826",
-            },
-        ],
-    },
-    "stat": {
-        "modTime": "2016-05-24T00:09:40.122390255Z",
-        "size": 14824084
-    },
-    "format": "xl",
-    "version": "1.0.0"
-}

docs/caching.md

@@ -1,39 +0,0 @@
-## Object caching
-
-Object caching by turned on by default with following settings
-
-  - Default cache size 8GB, can be changed from environment variable
-    ``MINIO_CACHE_SIZE`` supports both SI and ISO IEC standard forms
-    for input size parameters.
-
-  - Default expiration of entries is 72 hours, can be changed from
-    environment variable ``MINIO_CACHE_EXPIRY`` supportings Go
-    ``time.Duration`` with valid units  "ns", "us" (or "µs"),
-    "ms", "s", "m", "h".
-
-  - Default expiry interval is 1/4th of the expiration hours, so
-    expiration sweep happens across the cache every 1/4th the time
-    duration of the set entry expiration duration.
-
-### Tricks
-
-Setting MINIO_CACHE_SIZE=0 will turn off caching entirely.
-Setting MINIO_CACHE_EXPIRY=0s will turn off cache garbage collections,
-all cached objects will never expire.
-
-### Behavior
-
-Caching happens for both GET and PUT.
-
-- GET caches new objects for entries not found in cache,
-otherwise serves from the cache.
-
-- PUT/POST caches all successfully uploaded objects.
-
-NOTE: Cache is not populated if there are any errors
-      while reading from the disk.
-
-Expiration happens automatically based on the configured
-interval as explained above, frequently accessed objects
-stay alive for significantly longer time due to the fact
-that expiration time is reset for every cache hit.

docs/logging.md

@@ -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"
-		}
-```

docs/web-browser.md

@@ -1,40 +0,0 @@
-## Minio Browser
-
-Minio Browser uses Json Web Tokens to authenticate JSON RPC requests.
-
-Initial request generates a token for 'AccessKey' and 'SecretKey'
-provided by the user.
-
-<blockquote>
-Currently these tokens expire after 10hrs, this is not configurable yet.
-</blockquote>
-
-### Start minio server
-
-```
-minio server <testdir>
-```
-
-### JSON RPC APIs.
-
-JSON RPC namespace is `Web`.
-
-#### Server operations.
-
-* ServerInfo - fetches current server information, includes memory statistics, minio binary
-  version, golang runtime version and more.
-
-#### Auth operations
-
-* Login - waits for 'username, password' and on success replies a new Json Web Token (JWT).
-* SetAuth - change access credentials with new 'username, password'.
-* GetAuth - fetch the current auth from the server.
-
-#### Bucket/Object operations.
-
-* ListBuckets - lists buckets, requires a valid token.
-* ListObjects - lists objects, requires a valid token.
-* MakeBucket - make a new bucket, requires a valid token.
-* RemoveObject - removes an object from a bucket, requires a valid token.
-* Upload - uploads a new object from the browser, requires a valid token.
-* Download - downloads an object from a bucket, requires a valid token.

docs/xl-file-json.md

@@ -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.

erasure-createfile.go

@@ -1,167 +0,0 @@
-/*
- * 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/hex"
-	"hash"
-	"io"
-	"sync"
-
-	"github.com/klauspost/reedsolomon"
-)
-
-// 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)
-
-	// Allocated blockSized buffer for reading.
-	buf := make([]byte, eInfo.BlockSize)
-	hashWriters := newHashWriters(len(disks))
-
-	// Read until io.EOF, erasure codes data and writes to all disks.
-	for {
-		var blocks [][]byte
-		n, rErr := io.ReadFull(data, 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
-		}
-		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 {
-				blocks = make([][]byte, len(disks))
-				rErr = appendFile(disks, volume, path, blocks, eInfo.Distribution, hashWriters, writeQuorum)
-				if rErr != nil {
-					return nil, 0, 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
-		}
-		if n > 0 {
-			// Returns encoded blocks.
-			var enErr error
-			blocks, enErr = encodeData(buf[0:n], eInfo.DataBlocks, eInfo.ParityBlocks)
-			if enErr != nil {
-				return nil, 0, enErr
-			}
-
-			// Write to all disks.
-			if err = appendFile(disks, volume, path, blocks, eInfo.Distribution, hashWriters, writeQuorum); err != nil {
-				return nil, 0, err
-			}
-			size += 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)),
-		}
-	}
-
-	// 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
-}
-
-// encodeData - encodes incoming data buffer into
-// dataBlocks+parityBlocks returns a 2 dimensional byte array.
-func encodeData(dataBuffer []byte, dataBlocks, parityBlocks int) ([][]byte, error) {
-	rs, err := reedsolomon.New(dataBlocks, parityBlocks)
-	if err != nil {
-		return nil, err
-	}
-	// Split the input buffer into data and parity blocks.
-	var blocks [][]byte
-	blocks, err = rs.Split(dataBuffer)
-	if err != nil {
-		return nil, err
-	}
-
-	// Encode parity blocks using data blocks.
-	err = rs.Encode(blocks)
-	if err != nil {
-		return nil, err
-	}
-
-	// Return encoded blocks.
-	return blocks, nil
-}
-
-// appendFile - append data buffer at path.
-func appendFile(disks []StorageAPI, volume, path string, enBlocks [][]byte, distribution []int, 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.
-	for index, disk := range disks {
-		if disk == nil {
-			continue
-		}
-		wg.Add(1)
-		// 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])
-			if wErr != nil {
-				wErrs[index] = wErr
-				return
-			}
-
-			// Calculate hash for each blocks.
-			hashWriters[blockIndex].Write(enBlocks[blockIndex])
-
-			// Successfully wrote.
-			wErrs[index] = nil
-		}(index, disk)
-	}
-
-	// Wait for all the appends to finish.
-	wg.Wait()
-
-	// Do we have write quorum?.
-	if !isDiskQuorum(wErrs, writeQuorum) {
-		return toObjectErr(errXLWriteQuorum, volume, path)
-	}
-	return nil
-}

erasure-readfile.go

@@ -1,378 +0,0 @@
-/*
- * 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/hex"
-	"errors"
-	"io"
-	"sync"
-
-	"github.com/klauspost/reedsolomon"
-)
-
-// isSuccessDecodeBlocks - do we have all the blocks to be
-// successfully decoded?. Input encoded blocks ordered matrix.
-func isSuccessDecodeBlocks(enBlocks [][]byte, dataBlocks int) bool {
-	// Count number of data and parity blocks that were read.
-	var successDataBlocksCount = 0
-	var successParityBlocksCount = 0
-	for index := range enBlocks {
-		if enBlocks[index] == nil {
-			continue
-		}
-		// block index lesser than data blocks, update data block count.
-		if index < dataBlocks {
-			successDataBlocksCount++
-			continue
-		} // else { // update parity block count.
-		successParityBlocksCount++
-	}
-	// Returns true if we have atleast dataBlocks + 1 parity.
-	return successDataBlocksCount == dataBlocks || successDataBlocksCount+successParityBlocksCount >= dataBlocks+1
-}
-
-// isSuccessDataBlocks - do we have all the data blocks?
-// Input encoded blocks ordered matrix.
-func isSuccessDataBlocks(enBlocks [][]byte, dataBlocks int) bool {
-	// Count number of data blocks that were read.
-	var successDataBlocksCount = 0
-	for index := range enBlocks[:dataBlocks] {
-		if enBlocks[index] == nil {
-			continue
-		}
-		// block index lesser than data blocks, update data block count.
-		if index < dataBlocks {
-			successDataBlocksCount++
-		}
-	}
-	// Returns true if we have atleast the dataBlocks.
-	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))
-	dataDisks := 0
-	parityDisks := 0
-	// Count already read data and parity chunks.
-	for i := 0; i < index; i++ {
-		if orderedDisks[i] == nil {
-			continue
-		}
-		if i < dataBlocks {
-			dataDisks++
-		} else {
-			parityDisks++
-		}
-	}
-
-	// Sanity checks - we should never have this situation.
-	if dataDisks == dataBlocks {
-		return nil, 0, errUnexpected
-	}
-	if dataDisks+parityDisks >= dataBlocks+1 {
-		return nil, 0, errUnexpected
-	}
-
-	// Find the disks from which next set of parallel reads should happen.
-	for i := index; i < len(orderedDisks); i++ {
-		if orderedDisks[i] == nil {
-			continue
-		}
-		if i < dataBlocks {
-			dataDisks++
-		} else {
-			parityDisks++
-		}
-		readDisks[i] = orderedDisks[i]
-		if dataDisks == dataBlocks {
-			return readDisks, i + 1, nil
-		}
-		if dataDisks+parityDisks == dataBlocks+1 {
-			return readDisks, i + 1, nil
-		}
-	}
-	return nil, 0, errXLReadQuorum
-}
-
-// 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) {
-	// WaitGroup to synchronise the read go-routines.
-	wg := &sync.WaitGroup{}
-
-	// Read disks in parallel.
-	for index := range readDisks {
-		if readDisks[index] == nil {
-			continue
-		}
-		wg.Add(1)
-		// Reads chunk from readDisk[index] in routine.
-		go func(index int) {
-			defer wg.Done()
-
-			// Verify bit rot for the file on this disk.
-			if !bitRotVerify(index) {
-				// So that we don't read from this disk for the next block.
-				orderedDisks[index] = nil
-				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)
-			if err != nil {
-				// So that we don't read from this disk for the next block.
-				orderedDisks[index] = nil
-				return
-			}
-
-			// Copy the read blocks.
-			enBlocks[index] = chunkWriter.Bytes()
-
-			// Successfully read.
-		}(index)
-	}
-
-	// Waiting for first routines to finish.
-	wg.Wait()
-}
-
-// erasureReadFile - read bytes from erasure coded files and writes to given writer.
-// Erasure coded files are read block by block as per given erasureInfo and data chunks
-// 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) {
-	// Offset and length cannot be negative.
-	if offset < 0 || length < 0 {
-		return 0, errUnexpected
-	}
-
-	// Pick one erasure info.
-	eInfo := pickValidErasureInfo(eInfos)
-
-	// 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)
-
-	// 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))
-		// 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.
-		return func(diskIndex int) bool {
-			if verified[diskIndex] {
-				// Already validated.
-				return true
-			}
-			// Is this a valid block?
-			isValid := isValidBlock(orderedDisks[diskIndex], volume, path, orderedBlockCheckSums[diskIndex])
-			verified[diskIndex] = isValid
-			return isValid
-		}
-	}()
-
-	// 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)
-
-	// Get start and end block, also bytes to be skipped based on the input offset.
-	startBlock, endBlock, bytesToSkip := getBlockInfo(offset, totalLength, eInfo.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++ {
-		// Each element of enBlocks holds curChunkSize'd amount of data read from its corresponding disk.
-		enBlocks := make([][]byte, len(orderedDisks))
-
-		// 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
-		}
-
-		// 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.
-		blockOffset := block * chunkSize
-
-		// nextIndex - index from which next set of parallel reads
-		// should happen.
-		nextIndex := 0
-
-		for {
-			// readDisks - disks from which we need to read in parallel.
-			var readDisks []StorageAPI
-			var err error
-			readDisks, nextIndex, err = getReadDisks(orderedDisks, nextIndex, eInfo.DataBlocks)
-			if err != nil {
-				return bytesWritten, err
-			}
-			parallelRead(volume, path, readDisks, orderedDisks, enBlocks, blockOffset, curChunkSize, bitRotVerify)
-			if isSuccessDecodeBlocks(enBlocks, eInfo.DataBlocks) {
-				// If enough blocks are available to do rs.Reconstruct()
-				break
-			}
-			if nextIndex == len(orderedDisks) {
-				// No more disks to read from.
-				return bytesWritten, errXLReadQuorum
-			}
-		}
-
-		// If we have all the data blocks no need to decode, continue to write.
-		if !isSuccessDataBlocks(enBlocks, eInfo.DataBlocks) {
-			// Reconstruct the missing data blocks.
-			if err := decodeData(enBlocks, eInfo.DataBlocks, eInfo.ParityBlocks); err != nil {
-				return bytesWritten, err
-			}
-		}
-
-		var outSize, outOffset int64
-		// If this is start block, skip unwanted bytes.
-		if block == startBlock {
-			outOffset = bytesToSkip
-		}
-
-		// Total data to be read.
-		outSize = blockSize
-		if length-bytesWritten < blockSize {
-			// We should not send more data than what was requested.
-			outSize = length - bytesWritten
-		}
-
-		// Write data blocks.
-		n, err := writeDataBlocks(writer, enBlocks, eInfo.DataBlocks, outOffset, outSize)
-		if err != nil {
-			return bytesWritten, err
-		}
-
-		// Update total bytes written.
-		bytesWritten += n
-	}
-
-	// 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) {
-	// Disk is not available, not a valid block.
-	if disk == nil {
-		return false
-	}
-	// Read everything for a given block and calculate hash.
-	hashWriter := newHash(blockCheckSum.Algorithm)
-	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
-}
-
-// decodeData - decode encoded blocks.
-func decodeData(enBlocks [][]byte, dataBlocks, parityBlocks int) error {
-	// Initialized reedsolomon.
-	rs, err := reedsolomon.New(dataBlocks, parityBlocks)
-	if err != nil {
-		return err
-	}
-
-	// Reconstruct encoded blocks.
-	err = rs.Reconstruct(enBlocks)
-	if err != nil {
-		return err
-	}
-
-	// Verify reconstructed blocks (parity).
-	ok, err := rs.Verify(enBlocks)
-	if err != nil {
-		return err
-	}
-	if !ok {
-		// Blocks cannot be reconstructed, corrupted data.
-		err = errors.New("Verification failed after reconstruction, data likely corrupted.")
-		return err
-	}
-
-	// Success.
-	return nil
-}

erasure-readfile_test.go

@@ -1,206 +0,0 @@
-/*
- * 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 "testing"
-import "reflect"
-
-// Tests getReadDisks which returns readable disks slice from which we can
-// read parallelly.
-func testGetReadDisks(t *testing.T, xl xlObjects) {
-	d := xl.storageDisks
-	testCases := []struct {
-		index     int          // index argument for getReadDisks
-		argDisks  []StorageAPI // disks argument for getReadDisks
-		retDisks  []StorageAPI // disks return value from getReadDisks
-		nextIndex int          // return value from getReadDisks
-		err       error        // error return value from getReadDisks
-	}{
-		{
-			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,
-		},
-		{
-			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,
-		},
-		{
-			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},
-			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,
-		},
-		{
-			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,
-			nil,
-		},
-		{
-			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,
-			errXLReadQuorum,
-		},
-	}
-
-	for i, test := range testCases {
-		disks, nextIndex, err := getReadDisks(test.argDisks, test.index, xl.dataBlocks)
-		if err != test.err {
-			t.Errorf("test-case %d - expected error : %s, got : %s", i+1, test.err, err)
-			continue
-		}
-		if test.nextIndex != nextIndex {
-			t.Errorf("test-case %d - expected nextIndex: %d, got : %d", i+1, test.nextIndex, nextIndex)
-			continue
-		}
-		if reflect.DeepEqual(test.retDisks, disks) == false {
-			t.Errorf("test-case %d : incorrect disks returned. %v", i+1, disks)
-			continue
-		}
-	}
-}
-
-// Test getOrderedDisks which returns ordered slice of disks from their
-// 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)
-	// 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.
-	if orderedDisks[0] != disks[8] ||
-		orderedDisks[1] != disks[7] ||
-		orderedDisks[2] != disks[9] ||
-		orderedDisks[3] != disks[6] ||
-		orderedDisks[4] != disks[10] ||
-		orderedDisks[5] != disks[5] ||
-		orderedDisks[6] != disks[11] ||
-		orderedDisks[7] != disks[4] ||
-		orderedDisks[8] != disks[12] ||
-		orderedDisks[9] != disks[3] ||
-		orderedDisks[10] != disks[13] ||
-		orderedDisks[11] != disks[2] ||
-		orderedDisks[12] != disks[14] ||
-		orderedDisks[13] != disks[1] ||
-		orderedDisks[14] != disks[15] ||
-		orderedDisks[15] != disks[0] {
-		t.Errorf("getOrderedDisks returned incorrect order.")
-	}
-}
-
-// Test for isSuccessDataBlocks and isSuccessDecodeBlocks.
-func TestIsSuccessBlocks(t *testing.T) {
-	dataBlocks := 8
-	testCases := []struct {
-		enBlocks      [][]byte // data and parity blocks.
-		successData   bool     // expected return value of isSuccessDataBlocks()
-		successDecode bool     // expected return value of isSuccessDecodeBlocks()
-	}{
-		{
-			// When all data and partity blocks are available.
-			[][]byte{
-				{'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'},
-				{'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'},
-			},
-			true,
-			true,
-		},
-		{
-			// When one data block is not available.
-			[][]byte{
-				nil, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'},
-				{'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'},
-			},
-			false,
-			true,
-		},
-		{
-			// When one data and all parity are available, enough for reedsolomon.Reconstruct()
-			[][]byte{
-				nil, nil, nil, nil, nil, nil, nil, {'a'},
-				{'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,
-				{'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'}, {'a'},
-			},
-			false,
-			false,
-		},
-	}
-
-	for i, test := range testCases {
-		got := isSuccessDataBlocks(test.enBlocks, dataBlocks)
-		if test.successData != got {
-			t.Errorf("test-case %d : expected %v got %v", i+1, test.successData, got)
-		}
-		got = isSuccessDecodeBlocks(test.enBlocks, dataBlocks)
-		if test.successDecode != got {
-			t.Errorf("test-case %d : expected %v got %v", i+1, test.successDecode, got)
-		}
-	}
-}
-
-// Wrapper function for testGetReadDisks, testGetOrderedDisks.
-func TestErasureReadFile(t *testing.T) {
-	objLayer, dirs, err := getXLObjectLayer()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer removeRoots(dirs)
-	xl := objLayer.(xlObjects)
-	testGetReadDisks(t, xl)
-	testGetOrderedDisks(t, xl)
-}

erasure-utils.go

@@ -1,245 +0,0 @@
-/*
- * 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"
-	"hash"
-	"io"
-
-	"github.com/klauspost/reedsolomon"
-	"github.com/minio/blake2b-simd"
-)
-
-// newHashWriters - inititialize a slice of hashes for the disk count.
-func newHashWriters(diskCount int) []hash.Hash {
-	hashWriters := make([]hash.Hash, diskCount)
-	for index := range hashWriters {
-		hashWriters[index] = newHash("blake2b")
-	}
-	return hashWriters
-}
-
-// newHash - gives you a newly allocated hash depending on the input algorithm.
-func newHash(algo string) hash.Hash {
-	switch algo {
-	case "blake2b":
-		return blake2b.New512()
-	// Add new hashes here.
-	default:
-		// Default to blake2b.
-		return blake2b.New512()
-	}
-}
-
-// hashSum calculates the hash of the entire path and returns.
-func hashSum(disk StorageAPI, volume, path string, writer hash.Hash) ([]byte, error) {
-	// Allocate staging buffer of 128KiB for copyBuffer.
-	buf := make([]byte, readSizeV1)
-
-	// Copy entire buffer to writer.
-	if err := copyBuffer(writer, disk, volume, path, buf); err != nil {
-		return nil, err
-	}
-
-	// Return the final hash sum.
-	return writer.Sum(nil), nil
-}
-
-// getDataBlockLen - get length of data blocks from encoded blocks.
-func getDataBlockLen(enBlocks [][]byte, dataBlocks int) int {
-	size := 0
-	// Figure out the data block length.
-	for _, block := range enBlocks[:dataBlocks] {
-		size += len(block)
-	}
-	return size
-}
-
-// 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) {
-	// Offset and out size cannot be negative.
-	if outOffset < 0 || outSize < 0 {
-		return 0, errUnexpected
-	}
-
-	// Do we have enough blocks?
-	if len(enBlocks) < dataBlocks {
-		return 0, reedsolomon.ErrTooFewShards
-	}
-
-	// Do we have enough data?
-	if int64(getDataBlockLen(enBlocks, dataBlocks)) < outSize {
-		return 0, reedsolomon.ErrShortData
-	}
-
-	// Counter to decrement total left to write.
-	write := outSize
-
-	// Counter to increment total written.
-	totalWritten := int64(0)
-
-	// Write all data blocks to dst.
-	for _, block := range enBlocks[:dataBlocks] {
-		// Skip blocks until we have reached our offset.
-		if outOffset >= int64(len(block)) {
-			// Decrement offset.
-			outOffset -= int64(len(block))
-			continue
-		} else {
-			// Skip until offset.
-			block = block[outOffset:]
-
-			// Reset the offset for next iteration to read everything
-			// from subsequent blocks.
-			outOffset = 0
-		}
-		// We have written all the blocks, write the last remaining block.
-		if write < int64(len(block)) {
-			n, err := io.Copy(dst, bytes.NewReader(block[:write]))
-			if err != nil {
-				return 0, err
-			}
-			totalWritten += n
-			break
-		}
-		// Copy the block.
-		n, err := io.Copy(dst, bytes.NewReader(block))
-		if err != nil {
-			return 0, err
-		}
-
-		// Decrement output size.
-		write -= n
-
-		// Increment written.
-		totalWritten += n
-	}
-
-	// Success.
-	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
-}
-
-// copyBuffer - copies from disk, volume, path to input writer until either EOF
-// is reached at volume, path or an error occurs. A success copyBuffer returns
-// err == nil, not err == EOF. Because copyBuffer is defined to read from path
-// until EOF. It does not treat an EOF from ReadFile an error to be reported.
-// Additionally copyBuffer stages through the provided buffer; otherwise if it
-// has zero length, returns error.
-func copyBuffer(writer io.Writer, disk StorageAPI, volume string, path string, buf []byte) error {
-	// Error condition of zero length buffer.
-	if buf != nil && len(buf) == 0 {
-		return errors.New("empty buffer in readBuffer")
-	}
-
-	// Starting offset for Reading the file.
-	startOffset := int64(0)
-
-	// Read until io.EOF.
-	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
-			}
-			if int64(m) != n {
-				return io.ErrShortWrite
-			}
-		}
-		if err != nil {
-			if err == io.EOF || err == io.ErrUnexpectedEOF {
-				break
-			}
-			return err
-		}
-		// Progress the offset.
-		startOffset += n
-	}
-
-	// Success.
-	return nil
-}

erasure_test.go

@@ -1,185 +0,0 @@
-/*
- * 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"
-	"testing"
-)
-
-// mustEncodeData - encodes data slice and provides encoded 2 dimensional slice.
-func mustEncodeData(data []byte, dataBlocks, parityBlocks int) [][]byte {
-	encodedData, err := encodeData(data, dataBlocks, parityBlocks)
-	if err != nil {
-		// Upon failure panic this function.
-		panic(err)
-	}
-	return encodedData
-}
-
-// Generates good encoded data with one parity block and data block missing.
-func getGoodEncodedData(data []byte, dataBlocks, parityBlocks int) [][]byte {
-	encodedData := mustEncodeData(data, dataBlocks, parityBlocks)
-	encodedData[3] = nil
-	encodedData[1] = nil
-	return encodedData
-}
-
-// Generates bad encoded data with one parity block and data block with garbage data.
-func getBadEncodedData(data []byte, dataBlocks, parityBlocks int) [][]byte {
-	encodedData := mustEncodeData(data, dataBlocks, parityBlocks)
-	encodedData[3] = []byte("garbage")
-	encodedData[1] = []byte("garbage")
-	return encodedData
-}
-
-// Generates encoded data with all data blocks missing.
-func getMissingData(data []byte, dataBlocks, parityBlocks int) [][]byte {
-	encodedData := mustEncodeData(data, dataBlocks, parityBlocks)
-	for i := 0; i < dataBlocks+1; i++ {
-		encodedData[i] = nil
-	}
-	return encodedData
-}
-
-// Generates encoded data with less number of blocks than expected data blocks.
-func getInsufficientData(data []byte, dataBlocks, parityBlocks int) [][]byte {
-	encodedData := mustEncodeData(data, dataBlocks, parityBlocks)
-	// Return half of the data.
-	return encodedData[:dataBlocks/2]
-}
-
-// Represents erasure encoding matrix dataBlocks and paritBlocks.
-type encodingMatrix struct {
-	dataBlocks   int
-	parityBlocks int
-}
-
-// List of encoding matrices the tests will run on.
-var encodingMatrices = []encodingMatrix{
-	{3, 3}, // 3 data, 3 parity blocks.
-	{4, 4}, // 4 data, 4 parity blocks.
-	{5, 5}, // 5 data, 5 parity blocks.
-	{6, 6}, // 6 data, 6 parity blocks.
-	{7, 7}, // 7 data, 7 parity blocks.
-	{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.")
-
-	// List of decoding cases
-	// - validates bad encoded data.
-	// - validates good encoded data.
-	// - validates insufficient data.
-	testDecodeCases := []struct {
-		enFn       func([]byte, int, int) [][]byte
-		shouldPass bool
-	}{
-		// Generates bad encoded data.
-		{
-			enFn:       getBadEncodedData,
-			shouldPass: false,
-		},
-		// Generates good encoded data.
-		{
-			enFn:       getGoodEncodedData,
-			shouldPass: true,
-		},
-		// Generates missing data.
-		{
-			enFn:       getMissingData,
-			shouldPass: false,
-		},
-		// Generates short data.
-		{
-			enFn:       getInsufficientData,
-			shouldPass: false,
-		},
-	}
-
-	// Validates all decode tests.
-	for i, testCase := range testDecodeCases {
-		for _, encodingMatrix := range encodingMatrices {
-
-			// Encoding matrix.
-			dataBlocks := encodingMatrix.dataBlocks
-			parityBlocks := encodingMatrix.parityBlocks
-
-			// Data block size.
-			blockSize := len(data)
-
-			// Generates encoded data based on type of testCase function.
-			encodedData := testCase.enFn(data, dataBlocks, parityBlocks)
-
-			// Decodes the data.
-			err := decodeData(encodedData, dataBlocks, parityBlocks)
-			if err != nil && testCase.shouldPass {
-				t.Errorf("Test %d: Expected to pass by failed instead with %s", i+1, err)
-			}
-
-			// Proceed to extract the data blocks.
-			decodedDataWriter := new(bytes.Buffer)
-			_, err = writeDataBlocks(decodedDataWriter, encodedData, dataBlocks, 0, int64(blockSize))
-			if err != nil && testCase.shouldPass {
-				t.Errorf("Test %d: Expected to pass by failed instead with %s", i+1, err)
-			}
-
-			// Validate if decoded data is what we expected.
-			if bytes.Equal(decodedDataWriter.Bytes(), data) != testCase.shouldPass {
-				err := errUnexpected
-				t.Errorf("Test %d: Expected to pass by failed instead %s", i+1, err)
-			}
-		}
-	}
-}

format-config-v1.go

@@ -1,660 +0,0 @@
-/*
- * 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"
-	"errors"
-	"fmt"
-	"strings"
-	"sync"
-)
-
-// fsFormat - structure holding 'fs' format.
-type fsFormat struct {
-	Version string `json:"version"`
-}
-
-// xlFormat - structure holding 'xl' format.
-type xlFormat struct {
-	Version string `json:"version"` // Version of 'xl' format.
-	Disk    string `json:"disk"`    // Disk field carries assigned disk uuid.
-	// JBOD field carries the input disk order generated the first
-	// time when fresh disks were supplied.
-	JBOD []string `json:"jbod"`
-}
-
-// formatConfigV1 - structure holds format config version '1'.
-type formatConfigV1 struct {
-	Version string `json:"version"` // Version of the format config.
-	// Format indicates the backend format type, supports two values 'xl' and 'fs'.
-	Format string    `json:"format"`
-	FS     *fsFormat `json:"fs,omitempty"` // FS field holds fs format.
-	XL     *xlFormat `json:"xl,omitempty"` // XL field holds xl format.
-}
-
-/*
-
-All disks online
------------------
-- All Unformatted - format all and return success.
-- Some Unformatted - format all and return success.
-- Any JBOD inconsistent - return failure // Requires deep inspection, phase2.
-- Some are corrupt (missing format.json) - return failure  // Requires deep inspection, phase2.
-- Any unrecognized disks - return failure
-
-Some disks are offline and we have quorum.
------------------
-- Some unformatted - no heal, return success.
-- Any JBOD inconsistent - return failure // Requires deep inspection, phase2.
-- Some are corrupt (missing format.json) - return failure  // Requires deep inspection, phase2.
-- Any unrecognized disks - return failure
-
-No read quorum
------------------
-failure for all cases.
-
-// Pseudo code for managing `format.json`.
-
-// Generic checks.
-if (no quorum) return error
-if (any disk is corrupt) return error // phase2
-if (jbod inconsistent) return error // phase2
-if (disks not recognized) // Always error.
-
-// Specific checks.
-if (all disks online)
-  if (all disks return format.json)
-     if (jbod consistent)
-        if (all disks recognized)
-          return
-  else
-     if (all disks return format.json not found)
-        (initialize format)
-        return
-     else (some disks return format.json not found)
-        (heal format)
-        return
-     fi
-   fi
-else // No healing at this point forward, some disks are offline or dead.
-   if (some disks return format.json not found)
-      if (with force)
-         // Offline disks are marked as dead.
-         (heal format) // Offline disks should be marked as dead.
-         return success
-      else (without force)
-         // --force is necessary to heal few drives, because some drives
-         // are offline. Offline disks will be marked as dead.
-         return error
-      fi
-fi
-*/
-
-// error returned when some disks are found to be unformatted.
-var errSomeDiskUnformatted = errors.New("some disks are found to be unformatted")
-
-// error returned when some disks are offline.
-var errSomeDiskOffline = errors.New("some disks are offline")
-
-// errDiskOrderMismatch - returned when disk UUID is not in consistent JBOD order.
-var errDiskOrderMismatch = errors.New("disk order mismatch")
-
-// Returns error slice into understandable errors.
-func reduceFormatErrs(errs []error, diskCount int) (err error) {
-	var errUnformattedDiskCount = 0
-	var errDiskNotFoundCount = 0
-	for _, dErr := range errs {
-		if dErr == errUnformattedDisk {
-			errUnformattedDiskCount++
-		} else if dErr == errDiskNotFound {
-			errDiskNotFoundCount++
-		}
-	}
-	// Unformatted disks found, we need to figure out if any disks are offline.
-	if errUnformattedDiskCount > 0 {
-		// Returns errUnformattedDisk if all disks report unFormattedDisk.
-		if errUnformattedDiskCount < diskCount {
-			if errDiskNotFoundCount > 0 {
-				// Only some disks are fresh but some disks are offline as well.
-				return errSomeDiskOffline
-			}
-			// Some disks are fresh disks an unformatted, not disks are offline.
-			return errSomeDiskUnformatted
-		}
-		// All disks returned unformatted, all disks must be fresh.
-		return errUnformattedDisk
-	}
-	// No unformatted disks found no need to handle disk not found case, return success here.
-	return nil
-}
-
-// loadAllFormats - load all format config from all input disks in parallel.
-func loadAllFormats(bootstrapDisks []StorageAPI) ([]*formatConfigV1, []error) {
-	// Initialize sync waitgroup.
-	var wg = &sync.WaitGroup{}
-
-	// Initialize list of errors.
-	var sErrs = make([]error, len(bootstrapDisks))
-
-	// Initialize format configs.
-	var formatConfigs = make([]*formatConfigV1, len(bootstrapDisks))
-
-	// Make a volume entry on all underlying storage disks.
-	for index, disk := range bootstrapDisks {
-		if disk == nil {
-			sErrs[index] = errDiskNotFound
-			continue
-		}
-		wg.Add(1)
-		// Make a volume inside a go-routine.
-		go func(index int, disk StorageAPI) {
-			defer wg.Done()
-			formatConfig, lErr := loadFormat(disk)
-			if lErr != nil {
-				sErrs[index] = lErr
-				return
-			}
-			formatConfigs[index] = formatConfig
-		}(index, disk)
-	}
-
-	// Wait for all make vol to finish.
-	wg.Wait()
-
-	for _, err := range sErrs {
-		if err != nil {
-			// Return all formats and errors.
-			return formatConfigs, sErrs
-		}
-	}
-	// Return all formats and nil
-	return formatConfigs, nil
-}
-
-// genericFormatCheck - validates and returns error.
-// if (no quorum) return error
-// if (any disk is corrupt) return error // phase2
-// if (jbod inconsistent) return error // phase2
-// if (disks not recognized) // Always error.
-func genericFormatCheck(formatConfigs []*formatConfigV1, sErrs []error) (err error) {
-	// Calculate the errors.
-	var (
-		errCorruptFormatCount = 0
-		errCount              = 0
-	)
-
-	// Through all errors calculate the actual errors.
-	for _, lErr := range sErrs {
-		if lErr == nil {
-			continue
-		}
-		// These errors are good conditions, means disk is online.
-		if lErr == errUnformattedDisk || lErr == errVolumeNotFound {
-			continue
-		}
-		if lErr == errCorruptedFormat {
-			errCorruptFormatCount++
-		} else {
-			errCount++
-		}
-	}
-
-	// Calculate read quorum.
-	readQuorum := len(formatConfigs)/2 + 1
-
-	// Validate the err count under tolerant limit.
-	if errCount > len(formatConfigs)-readQuorum {
-		return errXLReadQuorum
-	}
-
-	// One of the disk has corrupt format, return error.
-	if errCorruptFormatCount > 0 {
-		return errCorruptedFormat
-	}
-
-	// Validates if format and JBOD are consistent across all disks.
-	if err = checkFormatXL(formatConfigs); err != nil {
-		return err
-	}
-
-	// Success..
-	return nil
-}
-
-// isSavedUUIDInOrder - validates if disk uuid is present and valid in all
-// available format config JBOD. This function also validates if the disk UUID
-// is always available on all JBOD under the same order.
-func isSavedUUIDInOrder(uuid string, formatConfigs []*formatConfigV1) bool {
-	var orderIndexes []int
-	// Validate each for format.json for relevant uuid.
-	for _, formatConfig := range formatConfigs {
-		if formatConfig == nil {
-			continue
-		}
-		// Validate if UUID is present in JBOD.
-		uuidIndex := findDiskIndex(uuid, formatConfig.XL.JBOD)
-		if uuidIndex == -1 {
-			// UUID not found.
-			errorIf(errDiskNotFound, "Disk %s not found in JBOD list", uuid)
-			return false
-		}
-		// Save the position of UUID present in JBOD.
-		orderIndexes = append(orderIndexes, uuidIndex+1)
-	}
-	// Once uuid is found, verify if the uuid
-	// present in same order across all format configs.
-	prevOrderIndex := orderIndexes[0]
-	for _, orderIndex := range orderIndexes {
-		if prevOrderIndex != orderIndex {
-			errorIf(errDiskOrderMismatch, "Disk %s is in wrong order wanted %d, saw %d ", uuid, prevOrderIndex, orderIndex)
-			return false
-		}
-	}
-	// Returns success, when we have verified if uuid
-	// is consistent and valid across all format configs.
-	return true
-}
-
-// checkDisksConsistency - checks if all disks are consistent with all JBOD entries on all disks.
-func checkDisksConsistency(formatConfigs []*formatConfigV1) error {
-	var disks = make([]string, len(formatConfigs))
-	// Collect currently available disk uuids.
-	for index, formatConfig := range formatConfigs {
-		if formatConfig == nil {
-			disks[index] = ""
-			continue
-		}
-		disks[index] = formatConfig.XL.Disk
-	}
-	// Validate collected uuids and verify JBOD.
-	for _, uuid := range disks {
-		if uuid == "" {
-			continue
-		}
-		// Is uuid present on all JBOD ?.
-		if !isSavedUUIDInOrder(uuid, formatConfigs) {
-			return fmt.Errorf("%s disk not found in JBOD", uuid)
-		}
-	}
-	return nil
-}
-
-// checkJBODConsistency - validate xl jbod order if they are consistent.
-func checkJBODConsistency(formatConfigs []*formatConfigV1) error {
-	var jbodStr string
-	// Extract first valid JBOD.
-	for _, format := range formatConfigs {
-		if format == nil {
-			continue
-		}
-		jbodStr = strings.Join(format.XL.JBOD, ".")
-		break
-	}
-	for _, format := range formatConfigs {
-		if format == nil {
-			continue
-		}
-		savedJBODStr := strings.Join(format.XL.JBOD, ".")
-		if jbodStr != savedJBODStr {
-			return errors.New("Inconsistent JBOD found.")
-		}
-	}
-	return nil
-}
-
-// findDiskIndex returns position of disk in JBOD.
-func findDiskIndex(disk string, jbod []string) int {
-	for index, uuid := range jbod {
-		if uuid == disk {
-			return index
-		}
-	}
-	return -1
-}
-
-// reorderDisks - reorder disks in JBOD order.
-func reorderDisks(bootstrapDisks []StorageAPI, formatConfigs []*formatConfigV1) ([]StorageAPI, error) {
-	var savedJBOD []string
-	for _, format := range formatConfigs {
-		if format == nil {
-			continue
-		}
-		savedJBOD = format.XL.JBOD
-		break
-	}
-	// Pick the first JBOD list to verify the order and construct new set of disk slice.
-	var newDisks = make([]StorageAPI, len(bootstrapDisks))
-	for fIndex, format := range formatConfigs {
-		if format == nil {
-			continue
-		}
-		jIndex := findDiskIndex(format.XL.Disk, savedJBOD)
-		if jIndex == -1 {
-			return nil, errors.New("Unrecognized uuid " + format.XL.Disk + " found")
-		}
-		newDisks[jIndex] = bootstrapDisks[fIndex]
-	}
-	return newDisks, nil
-}
-
-// loadFormat - loads format.json from disk.
-func loadFormat(disk StorageAPI) (format *formatConfigV1, err error) {
-	buf, err := disk.ReadAll(minioMetaBucket, formatConfigFile)
-	if err != nil {
-		// 'file not found' and 'volume not found' as
-		// same. 'volume not found' usually means its a fresh disk.
-		if err == errFileNotFound || err == errVolumeNotFound {
-			var vols []VolInfo
-			vols, err = disk.ListVols()
-			if err != nil {
-				return nil, err
-			}
-			if len(vols) > 1 {
-				// 'format.json' not found, but we found user data.
-				return nil, errCorruptedFormat
-			}
-			// No other data found, its a fresh disk.
-			return nil, errUnformattedDisk
-		}
-		return nil, err
-	}
-
-	// Try to decode format json into formatConfigV1 struct.
-	format = &formatConfigV1{}
-	if err = json.Unmarshal(buf, format); err != nil {
-		return nil, err
-	}
-
-	// Success.
-	return format, nil
-}
-
-// isFormatNotFound - returns true if all `format.json` are not
-// found on all disks.
-func isFormatNotFound(formats []*formatConfigV1) bool {
-	for _, format := range formats {
-		// One of the `format.json` is found.
-		if format != nil {
-			return false
-		}
-	}
-	// All format.json missing, success.
-	return true
-}
-
-// isFormatFound - returns true if all input formats are found on
-// all disks.
-func isFormatFound(formats []*formatConfigV1) bool {
-	for _, format := range formats {
-		// One of `format.json` is not found.
-		if format == nil {
-			return false
-		}
-	}
-	// All format.json present, success.
-	return true
-}
-
-// 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 {
-	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
-		}
-		formatXL, err := loadFormat(disk)
-		if err != nil {
-			if err == errUnformattedDisk {
-				// format.json is missing, 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 format configs.
-	var newFormatConfigs = make([]*formatConfigV1, len(storageDisks))
-
-	// 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 {
-			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]
-	}
-	// Save new `format.json` across all disks.
-	return saveFormatXL(storageDisks, newFormatConfigs)
-}
-
-// loadFormatXL - loads XL `format.json` and returns back properly
-// ordered storage slice based on `format.json`.
-func loadFormatXL(bootstrapDisks []StorageAPI) (disks []StorageAPI, err error) {
-	var unformattedDisksFoundCnt = 0
-	var diskNotFoundCount = 0
-	formatConfigs := make([]*formatConfigV1, len(bootstrapDisks))
-
-	// Try to load `format.json` bootstrap disks.
-	for index, disk := range bootstrapDisks {
-		if disk == nil {
-			diskNotFoundCount++
-			continue
-		}
-		var formatXL *formatConfigV1
-		formatXL, err = loadFormat(disk)
-		if err != nil {
-			if err == errUnformattedDisk {
-				unformattedDisksFoundCnt++
-				continue
-			} else if err == errDiskNotFound {
-				diskNotFoundCount++
-				continue
-			}
-			return nil, err
-		}
-		// Save valid formats.
-		formatConfigs[index] = formatXL
-	}
-
-	// If all disks indicate that 'format.json' is not available return 'errUnformattedDisk'.
-	if unformattedDisksFoundCnt > len(bootstrapDisks)-(len(bootstrapDisks)/2+1) {
-		return nil, errUnformattedDisk
-	} else if diskNotFoundCount == len(bootstrapDisks) {
-		return nil, errDiskNotFound
-	} else if diskNotFoundCount > len(bootstrapDisks)-(len(bootstrapDisks)/2+1) {
-		return nil, errXLReadQuorum
-	}
-
-	// Validate the format configs read are correct.
-	if err = checkFormatXL(formatConfigs); err != nil {
-		return nil, err
-	}
-	// Erasure code requires disks to be presented in the same order each time.
-	return reorderDisks(bootstrapDisks, formatConfigs)
-}
-
-// checkFormatXL - verifies if format.json format is intact.
-func checkFormatXL(formatConfigs []*formatConfigV1) error {
-	for _, formatXL := range formatConfigs {
-		if formatXL == nil {
-			continue
-		}
-		// Validate format version and format type.
-		if formatXL.Version != "1" {
-			return fmt.Errorf("Unsupported version of backend format [%s] found.", formatXL.Version)
-		}
-		if formatXL.Format != "xl" {
-			return fmt.Errorf("Unsupported backend format [%s] found.", formatXL.Format)
-		}
-		if formatXL.XL.Version != "1" {
-			return fmt.Errorf("Unsupported XL backend format found [%s]", formatXL.XL.Version)
-		}
-		if len(formatConfigs) != len(formatXL.XL.JBOD) {
-			return fmt.Errorf("Number of disks %d did not match the backend format %d", len(formatConfigs), len(formatXL.XL.JBOD))
-		}
-	}
-	if err := checkJBODConsistency(formatConfigs); err != nil {
-		return err
-	}
-	return checkDisksConsistency(formatConfigs)
-}
-
-// saveFormatXL - populates `format.json` on disks in its order.
-func saveFormatXL(storageDisks []StorageAPI, formats []*formatConfigV1) error {
-	var errs = make([]error, len(storageDisks))
-	var wg = &sync.WaitGroup{}
-	// Write `format.json` to all disks.
-	for index, disk := range storageDisks {
-		if disk == nil {
-			continue
-		}
-		wg.Add(1)
-		go func(index int, disk StorageAPI, format *formatConfigV1) {
-			defer wg.Done()
-
-			// Marshal and write to disk.
-			formatBytes, err := json.Marshal(format)
-			if err != nil {
-				errs[index] = err
-				return
-			}
-
-			// Purge any existing temporary file, okay to ignore errors here.
-			disk.DeleteFile(minioMetaBucket, formatConfigFileTmp)
-
-			// Append file `format.json.tmp`.
-			if err = disk.AppendFile(minioMetaBucket, formatConfigFileTmp, formatBytes); err != nil {
-				errs[index] = err
-				return
-			}
-			// Rename file `format.json.tmp` --> `format.json`.
-			if err = disk.RenameFile(minioMetaBucket, formatConfigFileTmp, minioMetaBucket, formatConfigFile); err != nil {
-				errs[index] = err
-				return
-			}
-		}(index, disk, formats[index])
-	}
-
-	// Wait for the routines to finish.
-	wg.Wait()
-
-	// Validate if we encountered any errors, return quickly.
-	for _, err := range errs {
-		if err != nil {
-			// Failure.
-			return err
-		}
-	}
-
-	// Success.
-	return nil
-}
-
-// initFormatXL - save XL format configuration on all disks.
-func initFormatXL(storageDisks []StorageAPI) (err error) {
-	// Initialize jbods.
-	var jbod = make([]string, len(storageDisks))
-
-	// Initialize formats.
-	var formats = make([]*formatConfigV1, len(storageDisks))
-
-	// Initialize `format.json`.
-	for index, disk := range storageDisks {
-		if disk == nil {
-			continue
-		}
-		// Allocate format config.
-		formats[index] = &formatConfigV1{
-			Version: "1",
-			Format:  "xl",
-			XL: &xlFormat{
-				Version: "1",
-				Disk:    getUUID(),
-			},
-		}
-		jbod[index] = formats[index].XL.Disk
-	}
-
-	// Update the jbod entries.
-	for index, disk := range storageDisks {
-		if disk == nil {
-			continue
-		}
-		// Save jbod.
-		formats[index].XL.JBOD = jbod
-	}
-
-	// Save formats `format.json` across all disks.
-	return saveFormatXL(storageDisks, formats)
-}

format-config-v1_test.go

@@ -1,235 +0,0 @@
-/*
- * 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"
-
-// generates a valid format.json for XL backend.
-func genFormatXLValid() []*formatConfigV1 {
-	jbod := make([]string, 8)
-	formatConfigs := make([]*formatConfigV1, 8)
-	for index := range jbod {
-		jbod[index] = getUUID()
-	}
-	for index := range jbod {
-		formatConfigs[index] = &formatConfigV1{
-			Version: "1",
-			Format:  "xl",
-			XL: &xlFormat{
-				Version: "1",
-				Disk:    jbod[index],
-				JBOD:    jbod,
-			},
-		}
-	}
-	return formatConfigs
-}
-
-// generates a invalid format.json version for XL backend.
-func genFormatXLInvalidVersion() []*formatConfigV1 {
-	jbod := make([]string, 8)
-	formatConfigs := make([]*formatConfigV1, 8)
-	for index := range jbod {
-		jbod[index] = getUUID()
-	}
-	for index := range jbod {
-		formatConfigs[index] = &formatConfigV1{
-			Version: "1",
-			Format:  "xl",
-			XL: &xlFormat{
-				Version: "1",
-				Disk:    jbod[index],
-				JBOD:    jbod,
-			},
-		}
-	}
-	// Corrupt version numbers.
-	formatConfigs[0].Version = "2"
-	formatConfigs[3].Version = "-1"
-	return formatConfigs
-}
-
-// generates a invalid format.json JBOD for XL backend.
-func genFormatXLInvalidJBOD() []*formatConfigV1 {
-	jbod := make([]string, 8)
-	formatConfigs := make([]*formatConfigV1, 8)
-	for index := range jbod {
-		jbod[index] = getUUID()
-	}
-	for index := range jbod {
-		formatConfigs[index] = &formatConfigV1{
-			Version: "1",
-			Format:  "xl",
-			XL: &xlFormat{
-				Version: "1",
-				Disk:    jbod[index],
-				JBOD:    jbod,
-			},
-		}
-	}
-	for index := range jbod {
-		jbod[index] = getUUID()
-	}
-	// Corrupt JBOD entries on disk 6 and disk 8.
-	formatConfigs[5].XL.JBOD = jbod
-	formatConfigs[7].XL.JBOD = jbod
-	return formatConfigs
-}
-
-// generates a invalid format.json Disk UUID for XL backend.
-func genFormatXLInvalidDisks() []*formatConfigV1 {
-	jbod := make([]string, 8)
-	formatConfigs := make([]*formatConfigV1, 8)
-	for index := range jbod {
-		jbod[index] = getUUID()
-	}
-	for index := range jbod {
-		formatConfigs[index] = &formatConfigV1{
-			Version: "1",
-			Format:  "xl",
-			XL: &xlFormat{
-				Version: "1",
-				Disk:    jbod[index],
-				JBOD:    jbod,
-			},
-		}
-	}
-	// Make disk 5 and disk 8 have inconsistent disk uuid's.
-	formatConfigs[4].XL.Disk = getUUID()
-	formatConfigs[7].XL.Disk = getUUID()
-	return formatConfigs
-}
-
-// generates a invalid format.json Disk UUID in wrong order for XL backend.
-func genFormatXLInvalidDisksOrder() []*formatConfigV1 {
-	jbod := make([]string, 8)
-	formatConfigs := make([]*formatConfigV1, 8)
-	for index := range jbod {
-		jbod[index] = getUUID()
-	}
-	for index := range jbod {
-		formatConfigs[index] = &formatConfigV1{
-			Version: "1",
-			Format:  "xl",
-			XL: &xlFormat{
-				Version: "1",
-				Disk:    jbod[index],
-				JBOD:    jbod,
-			},
-		}
-	}
-	// Re order jbod for failure case.
-	var jbod1 = make([]string, 8)
-	for i, j := range jbod {
-		jbod1[i] = j
-	}
-	jbod1[1], jbod1[2] = jbod[2], jbod[1]
-	formatConfigs[2].XL.JBOD = jbod1
-	return formatConfigs
-}
-
-// Wrapper for calling FormatXL tests - currently validates
-//  - valid format
-//  - unrecognized version number
-//  - invalid JBOD
-//  - invalid Disk uuid
-func TestFormatXL(t *testing.T) {
-	formatInputCases := [][]*formatConfigV1{
-		genFormatXLValid(),
-		genFormatXLInvalidVersion(),
-		genFormatXLInvalidJBOD(),
-		genFormatXLInvalidDisks(),
-		genFormatXLInvalidDisksOrder(),
-	}
-	testCases := []struct {
-		formatConfigs []*formatConfigV1
-		shouldPass    bool
-	}{
-		{
-			formatConfigs: formatInputCases[0],
-			shouldPass:    true,
-		},
-		{
-			formatConfigs: formatInputCases[1],
-			shouldPass:    false,
-		},
-		{
-			formatConfigs: formatInputCases[2],
-			shouldPass:    false,
-		},
-		{
-			formatConfigs: formatInputCases[3],
-			shouldPass:    false,
-		},
-		{
-			formatConfigs: formatInputCases[4],
-			shouldPass:    false,
-		},
-	}
-
-	for i, testCase := range testCases {
-		err := checkFormatXL(testCase.formatConfigs)
-		if err != nil && testCase.shouldPass {
-			t.Errorf("Test %d: Expected to pass but failed with %s", i+1, err)
-		}
-		if err == nil && !testCase.shouldPass {
-			t.Errorf("Test %d: Expected to fail but passed instead", i+1)
-		}
-	}
-}
-
-// Tests uuid order verification function.
-func TestSavedUUIDOrder(t *testing.T) {
-	uuidTestCases := make([]struct {
-		uuid       string
-		shouldPass bool
-	}, 8)
-	jbod := make([]string, 8)
-	formatConfigs := make([]*formatConfigV1, 8)
-	for index := range jbod {
-		jbod[index] = getUUID()
-		uuidTestCases[index].uuid = jbod[index]
-		uuidTestCases[index].shouldPass = true
-	}
-	for index := range jbod {
-		formatConfigs[index] = &formatConfigV1{
-			Version: "1",
-			Format:  "xl",
-			XL: &xlFormat{
-				Version: "1",
-				Disk:    jbod[index],
-				JBOD:    jbod,
-			},
-		}
-	}
-	// Re order jbod for failure case.
-	var jbod1 = make([]string, 8)
-	for i, j := range jbod {
-		jbod1[i] = j
-	}
-	jbod1[1], jbod1[2] = jbod[2], jbod[1]
-	formatConfigs[2].XL.JBOD = jbod1
-	uuidTestCases[1].shouldPass = false
-	uuidTestCases[2].shouldPass = false
-
-	for i, testCase := range uuidTestCases {
-		// Is uuid present on all JBOD ?.
-		if testCase.shouldPass != isSavedUUIDInOrder(testCase.uuid, formatConfigs) {
-			t.Errorf("Test %d: Expected to pass but failed", i+1)
-		}
-	}
-}

fs-v1-errors.go

@@ -1,22 +0,0 @@
-/*
- * 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"
-
-// errFSDiskFormat - returned when given disk format is other than FS format.
-var errFSDiskFormat = errors.New("Disk is not in FS format.")

fs-v1-metadata.go

@@ -1,124 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"path"
-	"sort"
-)
-
-const (
-	fsMetaJSONFile   = "fs.json"
-	fsFormatJSONFile = "format.json"
-)
-
-// 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"`
-	Parts []objectPartInfo `json:"parts,omitempty"`
-}
-
-// ObjectPartIndex - returns the index of matching object part number.
-func (m fsMetaV1) ObjectPartIndex(partNumber int) (partIndex int) {
-	for i, part := range m.Parts {
-		if partNumber == part.Number {
-			partIndex = i
-			return partIndex
-		}
-	}
-	return -1
-}
-
-// AddObjectPart - add a new object part in order.
-func (m *fsMetaV1) AddObjectPart(partNumber int, partName string, partETag string, partSize int64) {
-	partInfo := objectPartInfo{
-		Number: partNumber,
-		Name:   partName,
-		ETag:   partETag,
-		Size:   partSize,
-	}
-
-	// Update part info if it already exists.
-	for i, part := range m.Parts {
-		if partNumber == part.Number {
-			m.Parts[i] = partInfo
-			return
-		}
-	}
-
-	// Proceed to include new part info.
-	m.Parts = append(m.Parts, partInfo)
-
-	// Parts in fsMeta should be in sorted order by part number.
-	sort.Sort(byObjectPartNumber(m.Parts))
-}
-
-// readFSMetadata - returns the object metadata `fs.json` content.
-func readFSMetadata(disk StorageAPI, bucket, object string) (fsMeta fsMetaV1, err error) {
-	// Read all `fs.json`.
-	buf, err := disk.ReadAll(bucket, path.Join(object, fsMetaJSONFile))
-	if err != nil {
-		return fsMetaV1{}, err
-	}
-
-	// Decode `fs.json` into fsMeta structure.
-	if err = json.Unmarshal(buf, &fsMeta); err != nil {
-		return fsMetaV1{}, err
-	}
-
-	// Success.
-	return fsMeta, nil
-}
-
-// newFSMetaV1 - initializes new fsMetaV1.
-func newFSMetaV1() (fsMeta fsMetaV1) {
-	fsMeta = fsMetaV1{}
-	fsMeta.Version = "1.0.0"
-	fsMeta.Format = "fs"
-	fsMeta.Minio.Release = minioReleaseTag
-	return fsMeta
-}
-
-// newFSFormatV1 - initializes new formatConfigV1 with FS format info.
-func newFSFormatV1() (format formatConfigV1) {
-	return formatConfigV1{
-		Version: "1",
-		Format:  "fs",
-		FS: &fsFormat{
-			Version: "1",
-		},
-	}
-}
-
-// isFSFormat - returns whether given formatConfigV1 is FS type or not.
-func isFSFormat(format formatConfigV1) bool {
-	return format.Format == "fs"
-}
-
-// writes FS format (format.json) into minioMetaBucket.
-func writeFSFormatData(storage StorageAPI, fsFormat formatConfigV1) error {
-	metadataBytes, err := json.Marshal(fsFormat)
-	if err != nil {
-		return err
-	}
-	// fsFormatJSONFile - format.json file stored in minioMetaBucket(.minio) directory.
-	if err = storage.AppendFile(minioMetaBucket, fsFormatJSONFile, metadataBytes); err != nil {
-		return err
-	}
-	return nil
-}
-
-// writeFSMetadata - writes `fs.json` metadata.
-func (fs fsObjects) writeTempFSMetadata(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 {
-		return err
-	}
-	return nil
-}

fs-v1-multipart-common.go

@@ -1,127 +0,0 @@
-/*
- * 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"
-	"path"
-	"strings"
-	"time"
-)
-
-// Returns if the prefix is a multipart upload.
-func (fs fsObjects) isMultipartUpload(bucket, prefix string) bool {
-	_, err := fs.storage.StatFile(bucket, pathJoin(prefix, uploadsJSONFile))
-	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.
-	_, err := fs.storage.StatVol(bucket)
-	if err != nil {
-		if err == errVolumeNotFound {
-			return false
-		}
-		errorIf(err, "Stat failed on bucket "+bucket+".")
-		return false
-	}
-	return true
-}
-
-// isUploadIDExists - verify if a given uploadID exists and is valid.
-func (fs fsObjects) isUploadIDExists(bucket, object, uploadID string) bool {
-	uploadIDPath := path.Join(mpartMetaPrefix, bucket, object, uploadID)
-	_, err := fs.storage.StatFile(minioMetaBucket, path.Join(uploadIDPath, fsMetaJSONFile))
-	if err != nil {
-		if err == errFileNotFound {
-			return false
-		}
-		errorIf(err, "Unable to access upload id"+uploadIDPath)
-		return false
-	}
-	return true
-}
-
-// writeUploadJSON - create `uploads.json` or update it with new uploadID.
-func (fs fsObjects) writeUploadJSON(bucket, object, uploadID string, initiated time.Time) (err error) {
-	uploadsPath := path.Join(mpartMetaPrefix, bucket, object, uploadsJSONFile)
-	uniqueID := getUUID()
-	tmpUploadsPath := path.Join(tmpMetaPrefix, uniqueID)
-	var uploadsJSON uploadsV1
-	uploadsJSON, err = readUploadsJSON(bucket, object, fs.storage)
-	if err != nil {
-		// For any other errors.
-		if err != errFileNotFound {
-			return err
-		}
-		// Set uploads format to `fs`.
-		uploadsJSON = newUploadsV1("fs")
-	}
-	// Add a new upload id.
-	uploadsJSON.AddUploadID(uploadID, initiated)
-
-	// Update `uploads.json` on all disks.
-	uploadsJSONBytes, wErr := json.Marshal(&uploadsJSON)
-	if wErr != nil {
-		return wErr
-	}
-	// Write `uploads.json` to disk.
-	if wErr = fs.storage.AppendFile(minioMetaBucket, tmpUploadsPath, uploadsJSONBytes); wErr != nil {
-		return wErr
-	}
-	wErr = fs.storage.RenameFile(minioMetaBucket, tmpUploadsPath, minioMetaBucket, uploadsPath)
-	if wErr != nil {
-		if dErr := fs.storage.DeleteFile(minioMetaBucket, tmpUploadsPath); dErr != nil {
-			return dErr
-		}
-		return wErr
-	}
-	return nil
-}
-
-// updateUploadsJSON - update `uploads.json` with new uploadsJSON for all disks.
-func (fs fsObjects) updateUploadsJSON(bucket, object string, uploadsJSON uploadsV1) (err error) {
-	uploadsPath := path.Join(mpartMetaPrefix, bucket, object, uploadsJSONFile)
-	uniqueID := getUUID()
-	tmpUploadsPath := path.Join(tmpMetaPrefix, uniqueID)
-	uploadsBytes, wErr := json.Marshal(uploadsJSON)
-	if wErr != nil {
-		return wErr
-	}
-	if wErr = fs.storage.AppendFile(minioMetaBucket, tmpUploadsPath, uploadsBytes); wErr != nil {
-		return wErr
-	}
-	if wErr = fs.storage.RenameFile(minioMetaBucket, tmpUploadsPath, minioMetaBucket, uploadsPath); wErr != nil {
-		return wErr
-	}
-	return nil
-}

fs-v1-multipart.go

@@ -1,697 +0,0 @@
-/*
- * 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 (
-	"crypto/md5"
-	"encoding/hex"
-	"fmt"
-	"io"
-	"path"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/skyrings/skyring-common/tools/uuid"
-)
-
-// listMultipartUploads - lists all multipart uploads.
-func (fs fsObjects) listMultipartUploads(bucket, prefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, error) {
-	result := ListMultipartsInfo{}
-	recursive := true
-	if delimiter == slashSeparator {
-		recursive = false
-	}
-
-	result.IsTruncated = true
-	result.MaxUploads = maxUploads
-	result.KeyMarker = keyMarker
-	result.Prefix = prefix
-	result.Delimiter = delimiter
-
-	// Not using path.Join() as it strips off the trailing '/'.
-	multipartPrefixPath := pathJoin(mpartMetaPrefix, bucket, prefix)
-	if prefix == "" {
-		// Should have a trailing "/" if prefix is ""
-		// For ex. multipartPrefixPath should be "multipart/bucket/" if prefix is ""
-		multipartPrefixPath += slashSeparator
-	}
-	multipartMarkerPath := ""
-	if keyMarker != "" {
-		multipartMarkerPath = pathJoin(mpartMetaPrefix, bucket, keyMarker)
-	}
-	var uploads []uploadMetadata
-	var err error
-	var eof bool
-	if uploadIDMarker != "" {
-		nsMutex.RLock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, keyMarker))
-		uploads, _, err = listMultipartUploadIDs(bucket, keyMarker, uploadIDMarker, maxUploads, fs.storage)
-		nsMutex.RUnlock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, keyMarker))
-		if err != nil {
-			return ListMultipartsInfo{}, err
-		}
-		maxUploads = maxUploads - len(uploads)
-	}
-	var walkResultCh chan treeWalkResult
-	var endWalkCh chan struct{}
-	if maxUploads > 0 {
-		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)
-		}
-		for maxUploads > 0 {
-			walkResult, ok := <-walkResultCh
-			if !ok {
-				// Closed channel.
-				eof = true
-				break
-			}
-			// For any walk error return right away.
-			if walkResult.err != nil {
-				// File not found or Disk not found is a valid case.
-				if isErrIgnored(walkResult.err, walkResultIgnoredErrs) {
-					eof = true
-					break
-				}
-				return ListMultipartsInfo{}, err
-			}
-			entry := strings.TrimPrefix(walkResult.entry, retainSlash(pathJoin(mpartMetaPrefix, bucket)))
-			if strings.HasSuffix(walkResult.entry, slashSeparator) {
-				uploads = append(uploads, uploadMetadata{
-					Object: entry,
-				})
-				maxUploads--
-				if maxUploads == 0 {
-					if walkResult.end {
-						eof = true
-						break
-					}
-				}
-				continue
-			}
-			var tmpUploads []uploadMetadata
-			var end bool
-			uploadIDMarker = ""
-			nsMutex.RLock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, entry))
-			tmpUploads, end, err = listMultipartUploadIDs(bucket, entry, uploadIDMarker, maxUploads, fs.storage)
-			nsMutex.RUnlock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, entry))
-			if err != nil {
-				return ListMultipartsInfo{}, err
-			}
-			uploads = append(uploads, tmpUploads...)
-			maxUploads -= len(tmpUploads)
-			if walkResult.end && end {
-				eof = true
-				break
-			}
-		}
-	}
-	// Loop through all the received uploads fill in the multiparts result.
-	for _, upload := range uploads {
-		var objectName string
-		var uploadID string
-		if strings.HasSuffix(upload.Object, slashSeparator) {
-			// All directory entries are common prefixes.
-			uploadID = "" // Upload ids are empty for CommonPrefixes.
-			objectName = upload.Object
-			result.CommonPrefixes = append(result.CommonPrefixes, objectName)
-		} else {
-			uploadID = upload.UploadID
-			objectName = upload.Object
-			result.Uploads = append(result.Uploads, upload)
-		}
-		result.NextKeyMarker = objectName
-		result.NextUploadIDMarker = uploadID
-	}
-
-	if !eof {
-		// Save the go-routine state in the pool so that it can continue from where it left off on
-		// the next request.
-		fs.listPool.Set(listParams{bucket, recursive, result.NextKeyMarker, prefix}, walkResultCh, endWalkCh)
-	}
-
-	result.IsTruncated = !eof
-	if !result.IsTruncated {
-		result.NextKeyMarker = ""
-		result.NextUploadIDMarker = ""
-	}
-	return result, nil
-}
-
-// ListMultipartUploads - lists all the pending multipart uploads on a
-// bucket. Additionally takes 'prefix, keyMarker, uploadIDmarker and a
-// delimiter' which allows us to list uploads match a particular
-// prefix or lexically starting from 'keyMarker' or delimiting the
-// output to get a directory like listing.
-//
-// Implements S3 compatible ListMultipartUploads API. The resulting
-// ListMultipartsInfo structure is unmarshalled directly into XML and
-// replied back to the client.
-func (fs fsObjects) ListMultipartUploads(bucket, prefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, error) {
-	// Validate input arguments.
-	if !IsValidBucketName(bucket) {
-		return ListMultipartsInfo{}, BucketNameInvalid{Bucket: bucket}
-	}
-	if !fs.isBucketExist(bucket) {
-		return ListMultipartsInfo{}, BucketNotFound{Bucket: bucket}
-	}
-	if !IsValidObjectPrefix(prefix) {
-		return ListMultipartsInfo{}, ObjectNameInvalid{Bucket: bucket, Object: prefix}
-	}
-	// Verify if delimiter is anything other than '/', which we do not support.
-	if delimiter != "" && delimiter != slashSeparator {
-		return ListMultipartsInfo{}, UnsupportedDelimiter{
-			Delimiter: delimiter,
-		}
-	}
-	// Verify if marker has prefix.
-	if keyMarker != "" && !strings.HasPrefix(keyMarker, prefix) {
-		return ListMultipartsInfo{}, InvalidMarkerPrefixCombination{
-			Marker: keyMarker,
-			Prefix: prefix,
-		}
-	}
-	if uploadIDMarker != "" {
-		if strings.HasSuffix(keyMarker, slashSeparator) {
-			return ListMultipartsInfo{}, InvalidUploadIDKeyCombination{
-				UploadIDMarker: uploadIDMarker,
-				KeyMarker:      keyMarker,
-			}
-		}
-		id, err := uuid.Parse(uploadIDMarker)
-		if err != nil {
-			return ListMultipartsInfo{}, err
-		}
-		if id.IsZero() {
-			return ListMultipartsInfo{}, MalformedUploadID{
-				UploadID: uploadIDMarker,
-			}
-		}
-	}
-	return fs.listMultipartUploads(bucket, prefix, keyMarker, uploadIDMarker, delimiter, maxUploads)
-}
-
-// newMultipartUpload - wrapper for initializing a new multipart
-// request, returns back a unique upload id.
-//
-// Internally this function creates 'uploads.json' associated for the
-// incoming object at '.minio/multipart/bucket/object/uploads.json' on
-// all the disks. `uploads.json` carries metadata regarding on going
-// multipart operation on the object.
-func (fs fsObjects) newMultipartUpload(bucket string, object string, meta map[string]string) (uploadID string, err error) {
-	// Initialize `fs.json` values.
-	fsMeta := newFSMetaV1()
-
-	// This lock needs to be held for any changes to the directory contents of ".minio/multipart/object/"
-	nsMutex.Lock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object))
-	defer nsMutex.Unlock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object))
-
-	uploadID = getUUID()
-	initiated := time.Now().UTC()
-	// Create 'uploads.json'
-	if err = fs.writeUploadJSON(bucket, object, uploadID, initiated); err != nil {
-		return "", err
-	}
-	uploadIDPath := path.Join(mpartMetaPrefix, bucket, object, uploadID)
-	tempFSMetadataPath := path.Join(tmpMetaPrefix, getUUID()+"-"+fsMetaJSONFile)
-	if err = fs.writeTempFSMetadata(minioMetaBucket, tempFSMetadataPath, fsMeta); err != nil {
-		return "", toObjectErr(err, minioMetaBucket, tempFSMetadataPath)
-	}
-	err = fs.storage.RenameFile(minioMetaBucket, tempFSMetadataPath, minioMetaBucket, path.Join(uploadIDPath, fsMetaJSONFile))
-	if err != nil {
-		if dErr := fs.storage.DeleteFile(minioMetaBucket, tempFSMetadataPath); dErr != nil {
-			return "", toObjectErr(dErr, minioMetaBucket, tempFSMetadataPath)
-		}
-		return "", toObjectErr(err, minioMetaBucket, uploadIDPath)
-	}
-	// Return success.
-	return uploadID, nil
-}
-
-// NewMultipartUpload - initialize a new multipart upload, returns a
-// unique id. The unique id returned here is of UUID form, for each
-// subsequent request each UUID is unique.
-//
-// 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}
-	}
-	// Verify whether the bucket exists.
-	if !fs.isBucketExist(bucket) {
-		return "", BucketNotFound{Bucket: bucket}
-	}
-	// Verify if object name is valid.
-	if !IsValidObjectName(object) {
-		return "", ObjectNameInvalid{Bucket: bucket, Object: object}
-	}
-	return fs.newMultipartUpload(bucket, object, meta)
-}
-
-// PutObjectPart - reads incoming data until EOF for the part file on
-// an ongoing multipart transaction. Internally incoming data is
-// written to '.minio/tmp' location and safely renamed to
-// '.minio/multipart' for reach parts.
-func (fs fsObjects) PutObjectPart(bucket, object, uploadID string, partID int, size int64, data io.Reader, md5Hex string) (string, error) {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return "", BucketNameInvalid{Bucket: bucket}
-	}
-	// Verify whether the bucket exists.
-	if !fs.isBucketExist(bucket) {
-		return "", BucketNotFound{Bucket: bucket}
-	}
-	if !IsValidObjectName(object) {
-		return "", ObjectNameInvalid{Bucket: bucket, Object: object}
-	}
-
-	uploadIDPath := path.Join(mpartMetaPrefix, bucket, object, uploadID)
-
-	nsMutex.RLock(minioMetaBucket, uploadIDPath)
-	// Just check if the uploadID exists to avoid copy if it doesn't.
-	uploadIDExists := fs.isUploadIDExists(bucket, object, uploadID)
-	nsMutex.RUnlock(minioMetaBucket, uploadIDPath)
-	if !uploadIDExists {
-		return "", InvalidUploadID{UploadID: uploadID}
-	}
-
-	// Hold write lock on the part so that there is no parallel upload on the part.
-	nsMutex.Lock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object, uploadID, strconv.Itoa(partID)))
-	defer nsMutex.Unlock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object, uploadID, strconv.Itoa(partID)))
-
-	partSuffix := fmt.Sprintf("object%d", partID)
-	tmpPartPath := path.Join(tmpMetaPrefix, uploadID+"-"+partSuffix)
-
-	// Initialize md5 writer.
-	md5Writer := md5.New()
-
-	// Limit the reader to its provided size if specified.
-	var limitDataReader io.Reader
-	if size > 0 {
-		// This is done so that we can avoid erroneous clients sending more data than the set content size.
-		limitDataReader = io.LimitReader(data, size)
-	} else {
-		// else we read till EOF.
-		limitDataReader = data
-	}
-
-	// Allocate buffer for staging buffer.
-	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
-		}
-	}
-
-	// Validate if payload is valid.
-	if isSignVerify(data) {
-		if err := data.(*signVerifyReader).Verify(); err != nil {
-			// Incoming payload wrong, delete the temporary object.
-			fs.storage.DeleteFile(minioMetaBucket, tmpPartPath)
-			// Error return.
-			return "", toObjectErr(err, bucket, object)
-		}
-	}
-
-	newMD5Hex := hex.EncodeToString(md5Writer.Sum(nil))
-	if md5Hex != "" {
-		if newMD5Hex != md5Hex {
-			// MD5 mismatch, delete the temporary object.
-			fs.storage.DeleteFile(minioMetaBucket, tmpPartPath)
-			// Returns md5 mismatch.
-			return "", BadDigest{md5Hex, newMD5Hex}
-		}
-	}
-
-	// Hold write lock as we are updating fs.json
-	nsMutex.Lock(minioMetaBucket, uploadIDPath)
-	defer nsMutex.Unlock(minioMetaBucket, uploadIDPath)
-
-	// Just check if the uploadID exists to avoid copy if it doesn't.
-	if !fs.isUploadIDExists(bucket, object, uploadID) {
-		return "", InvalidUploadID{UploadID: uploadID}
-	}
-
-	fsMeta, err := readFSMetadata(fs.storage, minioMetaBucket, uploadIDPath)
-	if err != nil {
-		return "", toObjectErr(err, minioMetaBucket, uploadIDPath)
-	}
-	fsMeta.AddObjectPart(partID, partSuffix, newMD5Hex, size)
-
-	partPath := path.Join(mpartMetaPrefix, bucket, object, uploadID, partSuffix)
-	err = fs.storage.RenameFile(minioMetaBucket, tmpPartPath, minioMetaBucket, partPath)
-	if err != nil {
-		if dErr := fs.storage.DeleteFile(minioMetaBucket, tmpPartPath); dErr != nil {
-			return "", toObjectErr(dErr, minioMetaBucket, tmpPartPath)
-		}
-		return "", toObjectErr(err, minioMetaBucket, partPath)
-	}
-	uploadIDPath = path.Join(mpartMetaPrefix, bucket, object, uploadID)
-	tempFSMetadataPath := path.Join(tmpMetaPrefix, getUUID()+"-"+fsMetaJSONFile)
-	if err = fs.writeTempFSMetadata(minioMetaBucket, tempFSMetadataPath, fsMeta); err != nil {
-		return "", toObjectErr(err, minioMetaBucket, tempFSMetadataPath)
-	}
-	err = fs.storage.RenameFile(minioMetaBucket, tempFSMetadataPath, minioMetaBucket, path.Join(uploadIDPath, fsMetaJSONFile))
-	if err != nil {
-		if dErr := fs.storage.DeleteFile(minioMetaBucket, tempFSMetadataPath); dErr != nil {
-			return "", toObjectErr(dErr, minioMetaBucket, tempFSMetadataPath)
-		}
-		return "", toObjectErr(err, minioMetaBucket, uploadIDPath)
-	}
-	return newMD5Hex, nil
-}
-
-// listObjectParts - wrapper scanning through
-// '.minio/multipart/bucket/object/UPLOADID'. Lists all the parts
-// saved inside '.minio/multipart/bucket/object/UPLOADID'.
-func (fs fsObjects) listObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, error) {
-	result := ListPartsInfo{}
-
-	uploadIDPath := path.Join(mpartMetaPrefix, bucket, object, uploadID)
-	fsMeta, err := readFSMetadata(fs.storage, minioMetaBucket, uploadIDPath)
-	if err != nil {
-		return ListPartsInfo{}, toObjectErr(err, minioMetaBucket, uploadIDPath)
-	}
-	// Only parts with higher part numbers will be listed.
-	partIdx := fsMeta.ObjectPartIndex(partNumberMarker)
-	parts := fsMeta.Parts
-	if partIdx != -1 {
-		parts = fsMeta.Parts[partIdx+1:]
-	}
-	count := maxParts
-	for _, part := range parts {
-		var fi FileInfo
-		partNamePath := path.Join(mpartMetaPrefix, bucket, object, uploadID, part.Name)
-		fi, err = fs.storage.StatFile(minioMetaBucket, partNamePath)
-		if err != nil {
-			return ListPartsInfo{}, toObjectErr(err, minioMetaBucket, partNamePath)
-		}
-		result.Parts = append(result.Parts, partInfo{
-			PartNumber:   part.Number,
-			ETag:         part.ETag,
-			LastModified: fi.ModTime,
-			Size:         fi.Size,
-		})
-		count--
-		if count == 0 {
-			break
-		}
-	}
-	// If listed entries are more than maxParts, we set IsTruncated as true.
-	if len(parts) > len(result.Parts) {
-		result.IsTruncated = true
-		// Make sure to fill next part number marker if IsTruncated is
-		// true for subsequent listing.
-		nextPartNumberMarker := result.Parts[len(result.Parts)-1].PartNumber
-		result.NextPartNumberMarker = nextPartNumberMarker
-	}
-	result.Bucket = bucket
-	result.Object = object
-	result.UploadID = uploadID
-	result.MaxParts = maxParts
-	return result, nil
-}
-
-// ListObjectParts - lists all previously uploaded parts for a given
-// object and uploadID.  Takes additional input of part-number-marker
-// to indicate where the listing should begin from.
-//
-// Implements S3 compatible ListObjectParts API. The resulting
-// ListPartsInfo structure is unmarshalled directly into XML and
-// replied back to the client.
-func (fs fsObjects) ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, error) {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return ListPartsInfo{}, BucketNameInvalid{Bucket: bucket}
-	}
-	// Verify whether the bucket exists.
-	if !fs.isBucketExist(bucket) {
-		return ListPartsInfo{}, BucketNotFound{Bucket: bucket}
-	}
-	if !IsValidObjectName(object) {
-		return ListPartsInfo{}, ObjectNameInvalid{Bucket: bucket, Object: object}
-	}
-	// Hold lock so that there is no competing abort-multipart-upload or complete-multipart-upload.
-	nsMutex.Lock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object, uploadID))
-	defer nsMutex.Unlock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object, uploadID))
-
-	if !fs.isUploadIDExists(bucket, object, uploadID) {
-		return ListPartsInfo{}, InvalidUploadID{UploadID: uploadID}
-	}
-	return fs.listObjectParts(bucket, object, uploadID, partNumberMarker, maxParts)
-}
-
-// CompleteMultipartUpload - completes an ongoing multipart
-// transaction after receiving all the parts indicated by the client.
-// Returns an md5sum calculated by concatenating all the individual
-// md5sums of all the parts.
-//
-// Implements S3 compatible Complete multipart API.
-func (fs fsObjects) CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (string, error) {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return "", BucketNameInvalid{Bucket: bucket}
-	}
-	// Verify whether the bucket exists.
-	if !fs.isBucketExist(bucket) {
-		return "", BucketNotFound{Bucket: bucket}
-	}
-	if !IsValidObjectName(object) {
-		return "", ObjectNameInvalid{
-			Bucket: bucket,
-			Object: object,
-		}
-	}
-
-	uploadIDPath := path.Join(mpartMetaPrefix, bucket, object, uploadID)
-	// Hold lock so that
-	// 1) no one aborts this multipart upload
-	// 2) no one does a parallel complete-multipart-upload on this
-	// multipart upload
-	nsMutex.Lock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object, uploadID))
-	defer nsMutex.Unlock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object, uploadID))
-
-	if !fs.isUploadIDExists(bucket, object, uploadID) {
-		return "", InvalidUploadID{UploadID: uploadID}
-	}
-
-	// Read saved fs metadata for ongoing multipart.
-	fsMeta, err := readFSMetadata(fs.storage, minioMetaBucket, uploadIDPath)
-	if err != nil {
-		return "", toObjectErr(err, minioMetaBucket, uploadIDPath)
-	}
-
-	// Calculate s3 compatible md5sum for complete multipart.
-	s3MD5, err := completeMultipartMD5(parts...)
-	if err != nil {
-		return "", err
-	}
-
-	tempObj := path.Join(tmpMetaPrefix, uploadID+"-"+"part.1")
-
-	// Allocate staging buffer.
-	var buf = make([]byte, readSizeV1)
-
-	// Loop through all parts, validate them and then commit to disk.
-	for i, part := range parts {
-		partIdx := fsMeta.ObjectPartIndex(part.PartNumber)
-		if partIdx == -1 {
-			return "", InvalidPart{}
-		}
-		if fsMeta.Parts[partIdx].ETag != part.ETag {
-			return "", BadDigest{}
-		}
-		// All parts except the last part has to be atleast 5MB.
-		if (i < len(parts)-1) && !isMinAllowedPartSize(fsMeta.Parts[partIdx].Size) {
-			return "", PartTooSmall{
-				PartNumber: part.PartNumber,
-				PartSize:   fsMeta.Parts[partIdx].Size,
-				PartETag:   part.ETag,
-			}
-		}
-		// Construct part suffix.
-		partSuffix := fmt.Sprintf("object%d", part.PartNumber)
-		multipartPartFile := path.Join(mpartMetaPrefix, bucket, object, uploadID, partSuffix)
-		offset := int64(0)
-		totalLeft := fsMeta.Parts[partIdx].Size
-		for totalLeft > 0 {
-			curLeft := int64(readSizeV1)
-			if totalLeft < readSizeV1 {
-				curLeft = totalLeft
-			}
-			var n int64
-			n, err = fs.storage.ReadFile(minioMetaBucket, multipartPartFile, offset, buf[:curLeft])
-			if n > 0 {
-				if err = fs.storage.AppendFile(minioMetaBucket, tempObj, buf[:n]); err != nil {
-					return "", toObjectErr(err, minioMetaBucket, tempObj)
-				}
-			}
-			if err != nil {
-				if err == io.EOF || err == io.ErrUnexpectedEOF {
-					break
-				}
-				if err == errFileNotFound {
-					return "", InvalidPart{}
-				}
-				return "", toObjectErr(err, minioMetaBucket, multipartPartFile)
-			}
-			offset += n
-			totalLeft -= n
-		}
-	}
-
-	// Rename the file back to original location, if not delete the temporary object.
-	err = fs.storage.RenameFile(minioMetaBucket, tempObj, bucket, object)
-	if err != nil {
-		if dErr := fs.storage.DeleteFile(minioMetaBucket, tempObj); dErr != nil {
-			return "", toObjectErr(dErr, minioMetaBucket, tempObj)
-		}
-		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
-	}
-
-	// Hold the lock so that two parallel complete-multipart-uploads do not
-	// leave a stale uploads.json behind.
-	nsMutex.Lock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object))
-	defer nsMutex.Unlock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object))
-
-	// Validate if there are other incomplete upload-id's present for
-	// the object, if yes do not attempt to delete 'uploads.json'.
-	uploadsJSON, err := readUploadsJSON(bucket, object, fs.storage)
-	if err != nil {
-		return "", toObjectErr(err, minioMetaBucket, object)
-	}
-	// If we have successfully read `uploads.json`, then we proceed to
-	// purge or update `uploads.json`.
-	uploadIDIdx := uploadsJSON.Index(uploadID)
-	if uploadIDIdx != -1 {
-		uploadsJSON.Uploads = append(uploadsJSON.Uploads[:uploadIDIdx], uploadsJSON.Uploads[uploadIDIdx+1:]...)
-	}
-	if len(uploadsJSON.Uploads) > 0 {
-		if err = fs.updateUploadsJSON(bucket, object, uploadsJSON); err != nil {
-			return "", toObjectErr(err, minioMetaBucket, path.Join(mpartMetaPrefix, bucket, object))
-		}
-		// Return success.
-		return s3MD5, nil
-	}
-
-	if err = fs.storage.DeleteFile(minioMetaBucket, path.Join(mpartMetaPrefix, bucket, object, uploadsJSONFile)); err != nil {
-		return "", toObjectErr(err, minioMetaBucket, path.Join(mpartMetaPrefix, bucket, object))
-	}
-
-	// Return md5sum.
-	return s3MD5, nil
-}
-
-// abortMultipartUpload - wrapper for purging an ongoing multipart
-// transaction, deletes uploadID entry from `uploads.json` and purges
-// the directory at '.minio/multipart/bucket/object/uploadID' holding
-// all the upload parts.
-func (fs fsObjects) abortMultipartUpload(bucket, object, uploadID string) error {
-	// Cleanup all uploaded parts.
-	if err := cleanupUploadedParts(bucket, object, uploadID, fs.storage); err != nil {
-		return err
-	}
-
-	// Validate if there are other incomplete upload-id's present for
-	// the object, if yes do not attempt to delete 'uploads.json'.
-	uploadsJSON, err := readUploadsJSON(bucket, object, fs.storage)
-	if err == nil {
-		uploadIDIdx := uploadsJSON.Index(uploadID)
-		if uploadIDIdx != -1 {
-			uploadsJSON.Uploads = append(uploadsJSON.Uploads[:uploadIDIdx], uploadsJSON.Uploads[uploadIDIdx+1:]...)
-		}
-		// There are pending uploads for the same object, preserve
-		// them update 'uploads.json' in-place.
-		if len(uploadsJSON.Uploads) > 0 {
-			err = fs.updateUploadsJSON(bucket, object, uploadsJSON)
-			if err != nil {
-				return toObjectErr(err, bucket, object)
-			}
-			return nil
-		}
-	} // No more pending uploads for the object, we purge the entire
-	// entry at '.minio/multipart/bucket/object'.
-	if err = fs.storage.DeleteFile(minioMetaBucket, path.Join(mpartMetaPrefix, bucket, object, uploadsJSONFile)); err != nil {
-		return toObjectErr(err, minioMetaBucket, path.Join(mpartMetaPrefix, bucket, object))
-	}
-	return nil
-}
-
-// AbortMultipartUpload - aborts an ongoing multipart operation
-// signified by the input uploadID. This is an atomic operation
-// doesn't require clients to initiate multiple such requests.
-//
-// All parts are purged from all disks and reference to the uploadID
-// would be removed from the system, rollback is not possible on this
-// operation.
-//
-// Implements S3 compatible Abort multipart API, slight difference is
-// that this is an atomic idempotent operation. Subsequent calls have
-// no affect and further requests to the same uploadID would not be
-// honored.
-func (fs fsObjects) AbortMultipartUpload(bucket, object, uploadID string) error {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return BucketNameInvalid{Bucket: bucket}
-	}
-	if !fs.isBucketExist(bucket) {
-		return BucketNotFound{Bucket: bucket}
-	}
-	if !IsValidObjectName(object) {
-		return ObjectNameInvalid{Bucket: bucket, Object: object}
-	}
-
-	// Hold lock so that there is no competing complete-multipart-upload or put-object-part.
-	nsMutex.Lock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object, uploadID))
-	defer nsMutex.Unlock(minioMetaBucket, pathJoin(mpartMetaPrefix, bucket, object, uploadID))
-
-	if !fs.isUploadIDExists(bucket, object, uploadID) {
-		return InvalidUploadID{UploadID: uploadID}
-	}
-
-	err := fs.abortMultipartUpload(bucket, object, uploadID)
-	return err
-}

fs-v1.go

@@ -1,598 +0,0 @@
-/*
- * 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 (
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"sort"
-	"strings"
-
-	"github.com/minio/minio/pkg/disk"
-	"github.com/minio/minio/pkg/mimedb"
-)
-
-// fsObjects - Implements fs object layer.
-type fsObjects struct {
-	storage      StorageAPI
-	physicalDisk string
-
-	// List pool management.
-	listPool *treeWalkPool
-}
-
-// creates format.json, the FS format info in minioMetaBucket.
-func initFormatFS(storageDisk StorageAPI) error {
-	return writeFSFormatData(storageDisk, newFSFormatV1())
-}
-
-// loads format.json from minioMetaBucket if it exists.
-func loadFormatFS(storageDisk StorageAPI) (format formatConfigV1, err error) {
-	// Reads entire `format.json`.
-	buf, err := storageDisk.ReadAll(minioMetaBucket, fsFormatJSONFile)
-	if err != nil {
-		return formatConfigV1{}, err
-	}
-
-	// Unmarshal format config.
-	if err = json.Unmarshal(buf, &format); err != nil {
-		return formatConfigV1{}, err
-	}
-
-	// Return structured `format.json`.
-	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)
-	if err != nil && err != errDiskNotFound {
-		return nil, err
-	}
-
-	// Attempt to create `.minio`.
-	err = storage.MakeVol(minioMetaBucket)
-	if err != nil {
-		switch err {
-		// Ignore the errors.
-		case errVolumeExists, errDiskNotFound, errFaultyDisk:
-		default:
-			return nil, toObjectErr(err, minioMetaBucket)
-		}
-	}
-
-	// Runs house keeping code, like creating minioMetaBucket, cleaning up tmp files etc.
-	if err = fsHouseKeeping(storage); err != nil {
-		return nil, err
-	}
-
-	// loading format.json from minioMetaBucket.
-	// Note: The format.json content is ignored, reserved for future use.
-	format, err := loadFormatFS(storage)
-	if err != nil {
-		if err == errFileNotFound {
-			// format.json doesn't exist, create it inside minioMetaBucket.
-			err = initFormatFS(storage)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			return nil, err
-		}
-	} else if !isFSFormat(format) {
-		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{
-		storage:      storage,
-		physicalDisk: disk,
-		listPool:     newTreeWalkPool(globalLookupTimeout),
-	}, nil
-}
-
-// StorageInfo - returns underlying storage statistics.
-func (fs fsObjects) StorageInfo() StorageInfo {
-	info, err := disk.GetInfo(fs.physicalDisk)
-	fatalIf(err, "Unable to get disk info "+fs.physicalDisk)
-	return StorageInfo{
-		Total: info.Total,
-		Free:  info.Free,
-	}
-}
-
-/// Bucket operations
-
-// MakeBucket - make a bucket.
-func (fs fsObjects) MakeBucket(bucket string) error {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return BucketNameInvalid{Bucket: bucket}
-	}
-	if err := fs.storage.MakeVol(bucket); err != nil {
-		return toObjectErr(err, bucket)
-	}
-	return nil
-}
-
-// GetBucketInfo - get bucket info.
-func (fs fsObjects) GetBucketInfo(bucket string) (BucketInfo, error) {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return BucketInfo{}, BucketNameInvalid{Bucket: bucket}
-	}
-	vi, err := fs.storage.StatVol(bucket)
-	if err != nil {
-		return BucketInfo{}, toObjectErr(err, bucket)
-	}
-	return BucketInfo{
-		Name:    bucket,
-		Created: vi.Created,
-	}, nil
-}
-
-// ListBuckets - list buckets.
-func (fs fsObjects) ListBuckets() ([]BucketInfo, error) {
-	var bucketInfos []BucketInfo
-	vols, err := fs.storage.ListVols()
-	if err != nil {
-		return nil, toObjectErr(err)
-	}
-	for _, vol := range vols {
-		// StorageAPI can send volume names which are incompatible
-		// with buckets, handle it and skip them.
-		if !IsValidBucketName(vol.Name) {
-			continue
-		}
-		bucketInfos = append(bucketInfos, BucketInfo{
-			Name:    vol.Name,
-			Created: vol.Created,
-		})
-	}
-	sort.Sort(byBucketName(bucketInfos))
-	return bucketInfos, nil
-}
-
-// DeleteBucket - delete a bucket.
-func (fs fsObjects) DeleteBucket(bucket string) error {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return BucketNameInvalid{Bucket: bucket}
-	}
-	// Attempt to delete regular bucket.
-	if err := fs.storage.DeleteVol(bucket); err != nil {
-		return toObjectErr(err, bucket)
-	}
-	// Cleanup all the previously incomplete multiparts.
-	if err := cleanupDir(fs.storage, path.Join(minioMetaBucket, mpartMetaPrefix), bucket); err != nil && err != errVolumeNotFound {
-		return toObjectErr(err, bucket)
-	}
-	return nil
-}
-
-/// Object Operations
-
-// GetObject - get an object.
-func (fs fsObjects) GetObject(bucket, object string, offset int64, length int64, writer io.Writer) (err error) {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return BucketNameInvalid{Bucket: bucket}
-	}
-	// Verify if object is valid.
-	if !IsValidObjectName(object) {
-		return ObjectNameInvalid{Bucket: bucket, Object: object}
-	}
-	// Offset and length cannot be negative.
-	if offset < 0 || length < 0 {
-		return toObjectErr(errUnexpected, bucket, object)
-	}
-	// Writer cannot be nil.
-	if writer == nil {
-		return toObjectErr(errUnexpected, bucket, object)
-	}
-
-	// Stat the file to get file size.
-	fi, err := fs.storage.StatFile(bucket, object)
-	if err != nil {
-		return toObjectErr(err, bucket, object)
-	}
-
-	// Reply back invalid range if the input offset and length fall out of range.
-	if offset > fi.Size || length > fi.Size {
-		return InvalidRange{offset, length, fi.Size}
-	}
-	// Reply if we have inputs with offset and length falling out of file size range.
-	if offset+length > fi.Size {
-		return InvalidRange{offset, length, fi.Size}
-	}
-
-	var totalLeft = length
-	bufSize := int64(readSizeV1)
-	if length > 0 && bufSize > length {
-		bufSize = length
-	}
-	// Allocate a staging buffer.
-	buf := make([]byte, int(bufSize))
-	for {
-		// Figure out the right size for the buffer.
-		curLeft := bufSize
-		if totalLeft < bufSize {
-			curLeft = totalLeft
-		}
-		// Reads the file at offset.
-		nr, er := fs.storage.ReadFile(bucket, object, offset, buf[:curLeft])
-		if nr > 0 {
-			// Write to response writer.
-			nw, ew := writer.Write(buf[0:nr])
-			if nw > 0 {
-				// Decrement whats left to write.
-				totalLeft -= 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
-		}
-		if totalLeft == 0 {
-			break
-		}
-	}
-	// Returns any error.
-	return toObjectErr(err, bucket, object)
-}
-
-// GetObjectInfo - get object info.
-func (fs fsObjects) GetObjectInfo(bucket, object string) (ObjectInfo, error) {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return ObjectInfo{}, (BucketNameInvalid{Bucket: bucket})
-	}
-	// Verify if object is valid.
-	if !IsValidObjectName(object) {
-		return ObjectInfo{}, (ObjectNameInvalid{Bucket: bucket, Object: object})
-	}
-	fi, err := fs.storage.StatFile(bucket, object)
-	if err != nil {
-		return ObjectInfo{}, toObjectErr(err, bucket, object)
-	}
-
-	// 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
-		}
-	}
-
-	return ObjectInfo{
-		Bucket:      bucket,
-		Name:        object,
-		ModTime:     fi.ModTime,
-		Size:        fi.Size,
-		IsDir:       fi.Mode.IsDir(),
-		ContentType: contentType,
-		MD5Sum:      "", // Read from metadata.
-	}, nil
-}
-
-// PutObject - create an object.
-func (fs fsObjects) PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string) (string, error) {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return "", BucketNameInvalid{Bucket: bucket}
-	}
-	if !IsValidObjectName(object) {
-		return "", ObjectNameInvalid{
-			Bucket: bucket,
-			Object: object,
-		}
-	}
-
-	uniqueID := getUUID()
-
-	// Uploaded object will first be written to the temporary location which will eventually
-	// be renamed to the actual location. It is first written to the temporary location
-	// so that cleaning it up will be easy if the server goes down.
-	tempObj := path.Join(tmpMetaPrefix, uniqueID)
-
-	// Initialize md5 writer.
-	md5Writer := md5.New()
-
-	// Limit the reader to its provided size if specified.
-	var limitDataReader io.Reader
-	if size > 0 {
-		// This is done so that we can avoid erroneous clients sending more data than the set content size.
-		limitDataReader = io.LimitReader(data, size)
-	} else {
-		// else we read till EOF.
-		limitDataReader = data
-	}
-
-	if size == 0 {
-		// For size 0 we write a 0byte file.
-		err := fs.storage.AppendFile(minioMetaBucket, tempObj, []byte(""))
-		if err != nil {
-			return "", toObjectErr(err, bucket, object)
-		}
-	} else {
-		// Allocate a buffer to Read() the object upload stream.
-		bufSize := int64(readSizeV1)
-		if size > 0 && bufSize > size {
-			bufSize = size
-		}
-		buf := make([]byte, int(bufSize))
-
-		// 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
-			}
-		}
-	}
-
-	newMD5Hex := hex.EncodeToString(md5Writer.Sum(nil))
-	// md5Hex representation.
-	var md5Hex string
-	if len(metadata) != 0 {
-		md5Hex = metadata["md5Sum"]
-	}
-
-	// Validate if payload is valid.
-	if isSignVerify(data) {
-		if vErr := data.(*signVerifyReader).Verify(); vErr != nil {
-			// Incoming payload wrong, delete the temporary object.
-			fs.storage.DeleteFile(minioMetaBucket, tempObj)
-			// Error return.
-			return "", toObjectErr(vErr, bucket, object)
-		}
-	}
-
-	if md5Hex != "" {
-		if newMD5Hex != md5Hex {
-			// MD5 mismatch, delete the temporary object.
-			fs.storage.DeleteFile(minioMetaBucket, tempObj)
-			// Returns md5 mismatch.
-			return "", BadDigest{md5Hex, newMD5Hex}
-		}
-	}
-
-	// Entire object was written to the temp location, now it's safe to rename it to the actual location.
-	err := fs.storage.RenameFile(minioMetaBucket, tempObj, bucket, object)
-	if err != nil {
-		return "", toObjectErr(err, bucket, object)
-	}
-
-	// Return md5sum, successfully wrote object.
-	return newMD5Hex, nil
-}
-
-func (fs fsObjects) DeleteObject(bucket, object string) error {
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return BucketNameInvalid{Bucket: bucket}
-	}
-	if !IsValidObjectName(object) {
-		return ObjectNameInvalid{Bucket: bucket, Object: object}
-	}
-	if err := fs.storage.DeleteFile(bucket, object); err != nil {
-		return toObjectErr(err, bucket, object)
-	}
-	return nil
-}
-
-// Checks whether bucket exists.
-func isBucketExist(storage StorageAPI, bucketName string) bool {
-	// Check whether bucket exists.
-	_, err := storage.StatVol(bucketName)
-	if err != nil {
-		if err == errVolumeNotFound {
-			return false
-		}
-		errorIf(err, "Stat failed on bucket "+bucketName+".")
-		return false
-	}
-	return true
-}
-
-func (fs fsObjects) listObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, error) {
-	// Convert entry to FileInfo
-	entryToFileInfo := func(entry string) (fileInfo FileInfo, err error) {
-		if strings.HasSuffix(entry, slashSeparator) {
-			// Object name needs to be full path.
-			fileInfo.Name = entry
-			fileInfo.Mode = os.ModeDir
-			return
-		}
-		if fileInfo, err = fs.storage.StatFile(bucket, entry); err != nil {
-			return
-		}
-		// Object name needs to be full path.
-		fileInfo.Name = entry
-		return
-	}
-
-	// Verify if bucket is valid.
-	if !IsValidBucketName(bucket) {
-		return ListObjectsInfo{}, BucketNameInvalid{Bucket: bucket}
-	}
-	// Verify if bucket exists.
-	if !isBucketExist(fs.storage, bucket) {
-		return ListObjectsInfo{}, BucketNotFound{Bucket: bucket}
-	}
-	if !IsValidObjectPrefix(prefix) {
-		return ListObjectsInfo{}, ObjectNameInvalid{Bucket: bucket, Object: prefix}
-	}
-	// Verify if delimiter is anything other than '/', which we do not support.
-	if delimiter != "" && delimiter != slashSeparator {
-		return ListObjectsInfo{}, UnsupportedDelimiter{
-			Delimiter: delimiter,
-		}
-	}
-	// Verify if marker has prefix.
-	if marker != "" {
-		if !strings.HasPrefix(marker, prefix) {
-			return ListObjectsInfo{}, InvalidMarkerPrefixCombination{
-				Marker: marker,
-				Prefix: prefix,
-			}
-		}
-	}
-
-	// With max keys of zero we have reached eof, return right here.
-	if maxKeys == 0 {
-		return ListObjectsInfo{}, nil
-	}
-
-	// For delimiter and prefix as '/' we do not list anything at all
-	// since according to s3 spec we stop at the 'delimiter'
-	// along // with the prefix. On a flat namespace with 'prefix'
-	// as '/' we don't have any entries, since all the keys are
-	// of form 'keyName/...'
-	if delimiter == slashSeparator && prefix == slashSeparator {
-		return ListObjectsInfo{}, nil
-	}
-
-	// Over flowing count - reset to maxObjectList.
-	if maxKeys < 0 || maxKeys > maxObjectList {
-		maxKeys = maxObjectList
-	}
-
-	// Default is recursive, if delimiter is set then list non recursive.
-	recursive := true
-	if delimiter == slashSeparator {
-		recursive = false
-	}
-
-	walkResultCh, endWalkCh := fs.listPool.Release(listParams{bucket, recursive, marker, prefix})
-	if walkResultCh == nil {
-		endWalkCh = make(chan struct{})
-		listDir := listDirFactory(func(bucket, object string) bool {
-			return !strings.HasSuffix(object, slashSeparator)
-		}, fs.storage)
-		walkResultCh = startTreeWalk(bucket, prefix, marker, recursive, listDir, endWalkCh)
-	}
-	var fileInfos []FileInfo
-	var eof bool
-	var nextMarker string
-	for i := 0; i < maxKeys; {
-		walkResult, ok := <-walkResultCh
-		if !ok {
-			// Closed channel.
-			eof = true
-			break
-		}
-		// For any walk error return right away.
-		if walkResult.err != nil {
-			// File not found is a valid case.
-			if walkResult.err == errFileNotFound {
-				return ListObjectsInfo{}, nil
-			}
-			return ListObjectsInfo{}, toObjectErr(walkResult.err, bucket, prefix)
-		}
-		fileInfo, err := entryToFileInfo(walkResult.entry)
-		if err != nil {
-			return ListObjectsInfo{}, nil
-		}
-		nextMarker = fileInfo.Name
-		fileInfos = append(fileInfos, fileInfo)
-		if walkResult.end {
-			eof = true
-			break
-		}
-		i++
-	}
-	params := listParams{bucket, recursive, nextMarker, prefix}
-	if !eof {
-		fs.listPool.Set(params, walkResultCh, endWalkCh)
-	}
-
-	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.Objects = append(result.Objects, ObjectInfo{
-			Name:    fileInfo.Name,
-			ModTime: fileInfo.ModTime,
-			Size:    fileInfo.Size,
-			IsDir:   false,
-		})
-	}
-	return result, nil
-}
-
-// ListObjects - list all objects.
-func (fs fsObjects) ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, error) {
-	return fs.listObjects(bucket, prefix, marker, delimiter, maxKeys)
-}

fs-v1_test.go

@@ -1,61 +0,0 @@
-/*
- * 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"
-	"path/filepath"
-	"testing"
-)
-
-// TestNewFS - tests initialization of all input disks
-// and constructs a valid `FS` object layer.
-func TestNewFS(t *testing.T) {
-	// Do not attempt to create this path, the test validates
-	// so that newFSObjects initializes non existing paths
-	// and successfully returns initialized object layer.
-	disk := filepath.Join(os.TempDir(), "minio-"+nextSuffix())
-	defer removeAll(disk)
-
-	// Setup to test errFSDiskFormat.
-	disks := []string{}
-	for i := 0; i < 6; i++ {
-		xlDisk := filepath.Join(os.TempDir(), "minio-"+nextSuffix())
-		defer removeAll(xlDisk)
-		disks = append(disks, xlDisk)
-	}
-
-	// Initializes all disks with XL
-	_, err := newXLObjects(disks, nil)
-	if err != nil {
-		t.Fatalf("Unable to initialize XL object, %s", err)
-	}
-
-	testCases := []struct {
-		disk        string
-		expectedErr error
-	}{
-		{disk, nil},
-		{disks[0], errFSDiskFormat},
-	}
-
-	for _, testCase := range testCases {
-		if _, err := newFSObjects(testCase.disk); err != testCase.expectedErr {
-			t.Fatalf("expected: %s, got: %s", testCase.expectedErr, err)
-		}
-	}
-}

generic-handlers.go

@@ -1,292 +0,0 @@
-/*
- * Minio Cloud 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 (
-	"net/http"
-	"path"
-	"regexp"
-	"strings"
-	"time"
-
-	router "github.com/gorilla/mux"
-	"github.com/rs/cors"
-)
-
-// HandlerFunc - useful to chain different middleware http.Handler
-type HandlerFunc func(http.Handler) http.Handler
-
-func registerHandlers(mux *router.Router, handlerFns ...HandlerFunc) http.Handler {
-	var f http.Handler
-	f = mux
-	for _, hFn := range handlerFns {
-		f = hFn(f)
-	}
-	return f
-}
-
-// Adds redirect rules for incoming requests.
-type redirectHandler struct {
-	handler        http.Handler
-	locationPrefix string
-}
-
-// Reserved bucket.
-const (
-	reservedBucket = "/minio"
-)
-
-func setBrowserRedirectHandler(h http.Handler) http.Handler {
-	return redirectHandler{handler: h, locationPrefix: reservedBucket}
-}
-
-func (h redirectHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Re-direction handled specifically for browsers.
-	if strings.Contains(r.Header.Get("User-Agent"), "Mozilla") {
-		// '/' is redirected to 'locationPrefix/'
-		// '/webrpc' is redirected to 'locationPrefix/webrpc'
-		// '/login' is redirected to 'locationPrefix/login'
-		switch r.URL.Path {
-		case "/", "/webrpc", "/login", "/favicon.ico":
-			location := h.locationPrefix + r.URL.Path
-			// Redirect to new location.
-			http.Redirect(w, r, location, http.StatusTemporaryRedirect)
-			return
-		}
-	}
-	h.handler.ServeHTTP(w, r)
-}
-
-// Adds Cache-Control header
-type cacheControlHandler struct {
-	handler http.Handler
-}
-
-func setBrowserCacheControlHandler(h http.Handler) http.Handler {
-	return cacheControlHandler{h}
-}
-
-func (h cacheControlHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	if r.Method == "GET" && strings.Contains(r.Header.Get("User-Agent"), "Mozilla") {
-		// For all browser requests set appropriate Cache-Control policies
-		match, e := regexp.MatchString(reservedBucket+`/([^/]+\.js|favicon.ico)`, r.URL.Path)
-		if e != nil {
-			writeErrorResponse(w, r, ErrInternalError, r.URL.Path)
-			return
-		}
-		if match {
-			// For assets set cache expiry of one year. For each release, the name
-			// of the asset name will change and hence it can not be served from cache.
-			w.Header().Set("Cache-Control", "max-age=31536000")
-		} else if strings.HasPrefix(r.URL.Path, reservedBucket+"/") {
-			// For non asset requests we serve index.html which will never be cached.
-			w.Header().Set("Cache-Control", "no-store")
-		}
-	}
-	h.handler.ServeHTTP(w, r)
-}
-
-// Adds verification for incoming paths.
-type minioPrivateBucketHandler struct {
-	handler        http.Handler
-	reservedBucket string
-}
-
-func setPrivateBucketHandler(h http.Handler) http.Handler {
-	return minioPrivateBucketHandler{handler: h, reservedBucket: reservedBucket}
-}
-
-func (h minioPrivateBucketHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// For all non browser requests, reject access to 'reservedBucket'.
-	if !strings.Contains(r.Header.Get("User-Agent"), "Mozilla") && path.Clean(r.URL.Path) == reservedBucket {
-		writeErrorResponse(w, r, ErrAllAccessDisabled, r.URL.Path)
-		return
-	}
-	h.handler.ServeHTTP(w, r)
-}
-
-// Supported Amz date formats.
-var amzDateFormats = []string{
-	time.RFC1123,
-	time.RFC1123Z,
-	iso8601Format,
-	// Add new AMZ date formats here.
-}
-
-// parseAmzDate - parses date string into supported amz date formats.
-func parseAmzDate(amzDateStr string) (amzDate time.Time, apiErr APIErrorCode) {
-	for _, dateFormat := range amzDateFormats {
-		amzDate, e := time.Parse(dateFormat, amzDateStr)
-		if e == nil {
-			return amzDate, ErrNone
-		}
-	}
-	return time.Time{}, ErrMalformedDate
-}
-
-// Supported Amz date headers.
-var amzDateHeaders = []string{
-	"x-amz-date",
-	"date",
-}
-
-// parseAmzDateHeader - parses supported amz date headers, in
-// supported amz date formats.
-func parseAmzDateHeader(req *http.Request) (time.Time, APIErrorCode) {
-	for _, amzDateHeader := range amzDateHeaders {
-		amzDateStr := req.Header.Get(http.CanonicalHeaderKey(amzDateHeader))
-		if amzDateStr != "" {
-			return parseAmzDate(amzDateStr)
-		}
-	}
-	// Date header missing.
-	return time.Time{}, ErrMissingDateHeader
-}
-
-type timeHandler struct {
-	handler http.Handler
-}
-
-// setTimeValidityHandler to validate parsable time over http header
-func setTimeValidityHandler(h http.Handler) http.Handler {
-	return timeHandler{h}
-}
-
-func (h timeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Verify if date headers are set, if not reject the request
-	if _, ok := r.Header["Authorization"]; ok {
-		amzDate, apiErr := parseAmzDateHeader(r)
-		if apiErr != ErrNone {
-			// All our internal APIs are sensitive towards Date
-			// header, for all requests where Date header is not
-			// present we will reject such clients.
-			writeErrorResponse(w, r, apiErr, r.URL.Path)
-			return
-		}
-		// Verify if the request date header is more than 5minutes
-		// late, reject such clients.
-		if time.Now().UTC().Sub(amzDate)/time.Minute > time.Duration(5)*time.Minute {
-			writeErrorResponse(w, r, ErrRequestTimeTooSkewed, r.URL.Path)
-			return
-		}
-	}
-	h.handler.ServeHTTP(w, r)
-}
-
-type resourceHandler struct {
-	handler http.Handler
-}
-
-// setCorsHandler handler for CORS (Cross Origin Resource Sharing)
-func setCorsHandler(h http.Handler) http.Handler {
-	c := cors.New(cors.Options{
-		AllowedOrigins: []string{"*"},
-		AllowedMethods: []string{"GET", "HEAD", "POST", "PUT"},
-		AllowedHeaders: []string{"*"},
-		ExposedHeaders: []string{"ETag"},
-	})
-	return c.Handler(h)
-}
-
-// setIgnoreResourcesHandler -
-// Ignore resources handler is wrapper handler used for API request resource validation
-// Since we do not support all the S3 queries, it is necessary for us to throw back a
-// valid error message indicating that requested feature is not implemented.
-func setIgnoreResourcesHandler(h http.Handler) http.Handler {
-	return resourceHandler{h}
-}
-
-// Resource handler ServeHTTP() wrapper
-func (h resourceHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Skip the first element which is usually '/' and split the rest.
-	splits := strings.SplitN(r.URL.Path[1:], "/", 2)
-
-	// Save bucketName and objectName extracted from url Path.
-	var bucketName, objectName string
-	if len(splits) == 1 {
-		bucketName = splits[0]
-	}
-	if len(splits) == 2 {
-		bucketName = splits[0]
-		objectName = splits[1]
-	}
-	// 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)
-			return
-		}
-	}
-	// If bucketName and objectName are present check for its resource queries.
-	if bucketName != "" && objectName != "" {
-		if ignoreNotImplementedObjectResources(r) {
-			writeErrorResponse(w, r, ErrNotImplemented, r.URL.Path)
-			return
-		}
-	}
-	// A put method on path "/" doesn't make sense, ignore it.
-	if r.Method == "PUT" && r.URL.Path == "/" {
-		writeErrorResponse(w, r, ErrNotImplemented, r.URL.Path)
-		return
-	}
-	h.handler.ServeHTTP(w, r)
-}
-
-//// helpers
-
-// Checks requests for not implemented Bucket resources
-func ignoreNotImplementedBucketResources(req *http.Request) bool {
-	for name := range req.URL.Query() {
-		if notimplementedBucketResourceNames[name] {
-			return true
-		}
-	}
-	return false
-}
-
-// Checks requests for not implemented Object resources
-func ignoreNotImplementedObjectResources(req *http.Request) bool {
-	for name := range req.URL.Query() {
-		if notimplementedObjectResourceNames[name] {
-			return true
-		}
-	}
-	return false
-}
-
-// List of not implemented bucket queries
-var notimplementedBucketResourceNames = map[string]bool{
-	"acl":            true,
-	"cors":           true,
-	"lifecycle":      true,
-	"logging":        true,
-	"notification":   true,
-	"replication":    true,
-	"tagging":        true,
-	"versions":       true,
-	"requestPayment": true,
-	"versioning":     true,
-	"website":        true,
-}
-
-// List of not implemented object queries
-var notimplementedObjectResourceNames = map[string]bool{
-	"torrent": true,
-	"acl":     true,
-	"policy":  true,
-}

globals.go

@@ -1,62 +0,0 @@
-/*
- * 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 (
-	"github.com/fatih/color"
-	"github.com/minio/minio/pkg/objcache"
-)
-
-// Global constants for Minio.
-const (
-	minGoVersion = ">= 1.6" // Minio requires at least Go v1.6
-)
-
-// minio configuration related constants.
-const (
-	globalMinioConfigVersion = "4"
-	globalMinioConfigDir     = ".minio"
-	globalMinioCertsDir      = "certs"
-	globalMinioCertFile      = "public.crt"
-	globalMinioKeyFile       = "private.key"
-	globalMinioConfigFile    = "config.json"
-	globalMinioProfilePath   = "profile"
-	// Add new global values here.
-)
-
-var (
-	globalQuiet = false // Quiet flag set via command line
-	globalTrace = false // Trace flag set via environment setting.
-	// Add new global flags here.
-
-	// Maximum connections handled per
-	// server, defaults to 0 (unlimited).
-	globalMaxConn = 0
-	// Maximum cache size.
-	globalMaxCacheSize = uint64(maxCacheSize)
-	// Cache expiry.
-	globalCacheExpiry = objcache.DefaultExpiry
-	// Add new variable global values here.
-)
-
-// 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()
-)

handler-utils.go

@@ -1,54 +0,0 @@
-/*
- * 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 (
-	"io"
-)
-
-// 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)
-		}
-	} 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
-		}
-	}
-	return errCode
-}

handler-utils_test.go

@@ -1,66 +0,0 @@
-/*
- * 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 (
-	"bytes"
-	"encoding/xml"
-	"io/ioutil"
-	"net/http"
-	"testing"
-)
-
-// Tests validate bucket LocationConstraint.
-func TestIsValidLocationContraint(t *testing.T) {
-	// 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{}
-		createBucketConfig.Location = location
-		var createBucketConfigBytes []byte
-		createBucketConfigBytes, e := xml.Marshal(createBucketConfig)
-		if e != nil {
-			return nil, e
-		}
-		createBucketConfigBuffer := bytes.NewBuffer(createBucketConfigBytes)
-		req.Body = ioutil.NopCloser(createBucketConfigBuffer)
-		return req, nil
-	}
-
-	testCases := []struct {
-		locationForInputRequest string
-		serverConfigRegion      string
-		expectedCode            APIErrorCode
-	}{
-		// Test case - 1.
-		{"us-east-1", "us-east-1", ErrNone},
-		// Test case - 2.
-		// In case of empty request body ErrNone is returned.
-		{"", "us-east-1", ErrNone},
-		// Test case - 3.
-		{"eu-central-1", "us-east-1", ErrInvalidRegion},
-	}
-	for i, testCase := range testCases {
-		inputRequest, e := createExpectedRequest(&http.Request{}, testCase.locationForInputRequest)
-		if e != nil {
-			t.Fatalf("Test %d: Failed to Marshal bucket configuration", i+1)
-		}
-		actualCode := isValidLocationContraint(inputRequest.Body, testCase.serverConfigRegion)
-		if testCase.expectedCode != actualCode {
-			t.Errorf("Test %d: Expected the APIErrCode to be %d, but instead found %d", i+1, testCase.expectedCode, actualCode)
-		}
-	}
-}

host-to-ip.go

@@ -1,47 +0,0 @@
-/*
- * 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"
-	"sort"
-)
-
-// byLastOctet implements sort.Interface used in sorting a list
-// of ip address by their last octet value.
-type byLastOctet []net.IP
-
-func (n byLastOctet) Len() int      { return len(n) }
-func (n byLastOctet) Swap(i, j int) { n[i], n[j] = n[j], n[i] }
-func (n byLastOctet) Less(i, j int) bool {
-	return []byte(n[i].To4())[3] < []byte(n[j].To4())[3]
-}
-
-// getIPsFromHosts - returns a reverse sorted list of ips based on the last octet value.
-func getIPsFromHosts(hosts []string) (ips []net.IP) {
-	for _, host := range hosts {
-		ips = append(ips, net.ParseIP(host))
-	}
-	// Reverse sort ips by their last octet.
-	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)
-}

host-to-ip_test.go

@@ -1,61 +0,0 @@
-/*
- * 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 sorted list generated from hosts to ip.
-func TestHostToIP(t *testing.T) {
-	// Collection of test cases to validate last octet sorting.
-	testCases := []struct {
-		hosts       []string
-		sortedHosts []string
-	}{
-		{
-			// List of ip addresses that need to be sorted.
-			[]string{
-				"129.95.30.40",
-				"5.24.69.2",
-				"19.20.203.5",
-				"1.2.3.4",
-				"127.0.0.1",
-				"19.20.21.22",
-				"5.220.100.50",
-			},
-			// Numerical sorting result based on the last octet.
-			[]string{
-				"5.220.100.50",
-				"129.95.30.40",
-				"19.20.21.22",
-				"19.20.203.5",
-				"1.2.3.4",
-				"5.24.69.2",
-				"127.0.0.1",
-			},
-		},
-	}
-
-	// Tests the correct sorting behavior of getIPsFromHosts.
-	for j, testCase := range testCases {
-		ips := getIPsFromHosts(testCase.hosts)
-		for i, ip := range ips {
-			if ip.String() != testCase.sortedHosts[i] {
-				t.Fatalf("Test %d expected to pass but failed. Wanted ip %s, but got %s", j+1, testCase.sortedHosts[i], ip.String())
-			}
-		}
-	}
-}

httprange.go

@@ -1,134 +0,0 @@
-/*
- * 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 (
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-const (
-	byteRangePrefix = "bytes="
-)
-
-// Valid byte position regexp
-var validBytePos = regexp.MustCompile(`^[0-9]+$`)
-
-// HttpRange specifies the byte range to be sent to the client.
-type httpRange struct {
-	offsetBegin  int64
-	offsetEnd    int64
-	resourceSize int64
-}
-
-// String populate range stringer interface
-func (hrange httpRange) String() string {
-	return fmt.Sprintf("bytes %d-%d/%d", hrange.offsetBegin, hrange.offsetEnd, hrange.resourceSize)
-}
-
-// getlength - get length from the range.
-func (hrange httpRange) getLength() int64 {
-	return 1 + hrange.offsetEnd - hrange.offsetBegin
-}
-
-func parseRequestRange(rangeString string, resourceSize int64) (hrange *httpRange, err error) {
-	// Return error if given range string doesn't start with byte range prefix.
-	if !strings.HasPrefix(rangeString, byteRangePrefix) {
-		return nil, fmt.Errorf("'%s' does not start with '%s'", rangeString, byteRangePrefix)
-	}
-
-	// Trim byte range prefix.
-	byteRangeString := strings.TrimPrefix(rangeString, byteRangePrefix)
-
-	// Check if range string contains delimiter '-', else return error. eg. "bytes=8"
-	sepIndex := strings.Index(byteRangeString, "-")
-	if sepIndex == -1 {
-		return nil, fmt.Errorf("'%s' does not have a valid range value", rangeString)
-	}
-
-	offsetBeginString := byteRangeString[:sepIndex]
-	offsetBegin := int64(-1)
-	// Convert offsetBeginString only if its not empty.
-	if len(offsetBeginString) > 0 {
-		if !validBytePos.MatchString(offsetBeginString) {
-			return nil, fmt.Errorf("'%s' does not have a valid first byte position value", rangeString)
-		}
-
-		if offsetBegin, err = strconv.ParseInt(offsetBeginString, 10, 64); err != nil {
-			return nil, fmt.Errorf("'%s' does not have a valid first byte position value", rangeString)
-		}
-	}
-
-	offsetEndString := byteRangeString[sepIndex+1:]
-	offsetEnd := int64(-1)
-	// Convert offsetEndString only if its not empty.
-	if len(offsetEndString) > 0 {
-		if !validBytePos.MatchString(offsetEndString) {
-			return nil, fmt.Errorf("'%s' does not have a valid last byte position value", rangeString)
-		}
-
-		if offsetEnd, err = strconv.ParseInt(offsetEndString, 10, 64); err != nil {
-			return nil, fmt.Errorf("'%s' does not have a valid last byte position value", rangeString)
-		}
-	}
-
-	// rangeString contains first and last byte positions. eg. "bytes=2-5"
-	if offsetBegin > -1 && offsetEnd > -1 {
-		if offsetBegin > offsetEnd {
-			// Last byte position is not greater than first byte position. eg. "bytes=5-2"
-			return nil, fmt.Errorf("'%s' does not have valid range value", rangeString)
-		}
-
-		// First and last byte positions should not be >= resourceSize.
-		if offsetBegin >= resourceSize {
-			return nil, errInvalidRange
-		}
-
-		if offsetEnd >= resourceSize {
-			offsetEnd = resourceSize - 1
-		}
-	} else if offsetBegin > -1 {
-		// rangeString contains only first byte position. eg. "bytes=8-"
-		if offsetBegin >= resourceSize {
-			// First byte position should not be >= resourceSize.
-			return nil, errInvalidRange
-		}
-
-		offsetEnd = resourceSize - 1
-	} else if offsetEnd > -1 {
-		// rangeString contains only last byte position. eg. "bytes=-3"
-		if offsetEnd == 0 {
-			// Last byte position should not be zero eg. "bytes=-0"
-			return nil, errInvalidRange
-		}
-
-		if offsetEnd >= resourceSize {
-			offsetBegin = 0
-		} else {
-			offsetBegin = resourceSize - offsetEnd
-		}
-
-		offsetEnd = resourceSize - 1
-	} else {
-		// rangeString contains first and last byte positions missing. eg. "bytes=-"
-		return nil, fmt.Errorf("'%s' does not have valid range value", rangeString)
-	}
-
-	return &httpRange{offsetBegin, offsetEnd, resourceSize}, nil
-}

httprange_test.go

@@ -1,90 +0,0 @@
-/*
- * 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"
-
-// Test parseRequestRange()
-func TestParseRequestRange(t *testing.T) {
-	// Test success cases.
-	successCases := []struct {
-		rangeString string
-		offsetBegin int64
-		offsetEnd   int64
-		length      int64
-	}{
-		{"bytes=2-5", 2, 5, 4},
-		{"bytes=2-20", 2, 9, 8},
-		{"bytes=2-2", 2, 2, 1},
-		{"bytes=0000-0006", 0, 6, 7},
-		{"bytes=2-", 2, 9, 8},
-		{"bytes=-4", 6, 9, 4},
-		{"bytes=-20", 0, 9, 10},
-	}
-
-	for _, successCase := range successCases {
-		hrange, err := parseRequestRange(successCase.rangeString, 10)
-		if err != nil {
-			t.Fatalf("expected: <nil>, got: %s", err)
-		}
-
-		if hrange.offsetBegin != successCase.offsetBegin {
-			t.Fatalf("expected: %d, got: %d", successCase.offsetBegin, hrange.offsetBegin)
-		}
-
-		if hrange.offsetEnd != successCase.offsetEnd {
-			t.Fatalf("expected: %d, got: %d", successCase.offsetEnd, hrange.offsetEnd)
-		}
-		if hrange.getLength() != successCase.length {
-			t.Fatalf("expected: %d, got: %d", successCase.length, hrange.getLength())
-		}
-	}
-
-	// Test invalid range strings.
-	invalidRangeStrings := []string{
-		"bytes=8",
-		"bytes=5-2",
-		"bytes=+2-5",
-		"bytes=2-+5",
-		"bytes=2--5",
-		"bytes=-",
-		"",
-		"2-5",
-		"bytes = 2-5",
-		"bytes=2 - 5",
-		"bytes=0-0,-1",
-		"bytes=2-5 ",
-	}
-	for _, rangeString := range invalidRangeStrings {
-		if _, err := parseRequestRange(rangeString, 10); err == nil {
-			t.Fatalf("expected: an error, got: <nil>")
-		}
-	}
-
-	// Test error range strings.
-	errorRangeString := []string{
-		"bytes=10-10",
-		"bytes=20-30",
-		"bytes=20-",
-		"bytes=-0",
-	}
-	for _, rangeString := range errorRangeString {
-		if _, err := parseRequestRange(rangeString, 10); err != errInvalidRange {
-			t.Fatalf("expected: %s, got: %s", errInvalidRange, err)
-		}
-	}
-}

logger-console-hook.go

@@ -1,46 +0,0 @@
-/*
- * 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 (
-	"io/ioutil"
-
-	"github.com/Sirupsen/logrus"
-)
-
-// consoleLogger - default logger if not other logging is enabled.
-type consoleLogger struct {
-	Enable bool   `json:"enable"`
-	Level  string `json:"level"`
-}
-
-// enable console logger.
-func enableConsoleLogger() {
-	clogger := serverConfig.GetConsoleLogger()
-	if !clogger.Enable {
-		// Disable console logger if asked for.
-		log.Out = ioutil.Discard
-		return
-	}
-
-	// log.Out and log.Formatter use the default versions.
-	// Only set specific log level.
-	lvl, err := logrus.ParseLevel(clogger.Level)
-	fatalIf(err, "Unknown log level found in the config file.")
-
-	log.Level = lvl
-}

logger-file-hook.go

@@ -1,75 +0,0 @@
-/*
- * 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 (
-	"fmt"
-	"os"
-
-	"github.com/Sirupsen/logrus"
-)
-
-type fileLogger struct {
-	Enable   bool   `json:"enable"`
-	Filename string `json:"fileName"`
-	Level    string `json:"level"`
-}
-
-type localFile struct {
-	*os.File
-}
-
-func enableFileLogger() {
-	flogger := serverConfig.GetFileLogger()
-	if !flogger.Enable || flogger.Filename == "" {
-		return
-	}
-
-	// Creates the named file with mode 0666, honors system umask.
-	file, err := os.OpenFile(flogger.Filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
-	fatalIf(err, "Unable to open log file.")
-
-	// Add a local file hook.
-	log.Hooks.Add(&localFile{file})
-
-	lvl, err := logrus.ParseLevel(flogger.Level)
-	fatalIf(err, "Unknown log level found in the config file.")
-
-	// Set default JSON formatter.
-	log.Formatter = new(logrus.JSONFormatter)
-	log.Level = lvl // Minimum log level.
-}
-
-// Fire fires the file logger hook and logs to the file.
-func (l *localFile) Fire(entry *logrus.Entry) error {
-	line, err := entry.String()
-	if err != nil {
-		return fmt.Errorf("Unable to read entry, %v", err)
-	}
-	l.File.Write([]byte(line + "\n"))
-	l.File.Sync()
-	return nil
-}
-
-// Levels - indicate log levels supported.
-func (l *localFile) Levels() []logrus.Level {
-	return []logrus.Level{
-		logrus.PanicLevel,
-		logrus.FatalLevel,
-		logrus.ErrorLevel,
-	}
-}

logger-syslog-hook_nix.go

@@ -1,82 +0,0 @@
-// +build !windows
-
-/*
- * 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 (
-	"fmt"
-	"log/syslog"
-
-	"github.com/Sirupsen/logrus"
-)
-
-type syslogLogger struct {
-	Enable bool   `json:"enable"`
-	Addr   string `json:"address"`
-	Level  string `json:"level"`
-}
-
-// syslogHook to send logs via syslog.
-type syslogHook struct {
-	writer        *syslog.Writer
-	syslogNetwork string
-	syslogRaddr   string
-}
-
-// enableSyslogLogger - enable logger at raddr.
-func enableSyslogLogger(raddr string) {
-	syslogHook, err := newSyslog("udp", raddr, syslog.LOG_ERR, "MINIO")
-	fatalIf(err, "Unable to initialize syslog logger.")
-
-	log.Hooks.Add(syslogHook)               // Add syslog hook.
-	log.Formatter = &logrus.JSONFormatter{} // JSON formatted log.
-	log.Level = logrus.ErrorLevel           // Minimum log level.
-}
-
-// newSyslog - Creates a hook to be added to an instance of logger.
-func newSyslog(network, raddr string, priority syslog.Priority, tag string) (*syslogHook, error) {
-	w, err := syslog.Dial(network, raddr, priority, tag)
-	return &syslogHook{w, network, raddr}, err
-}
-
-// Fire - fire the log event
-func (hook *syslogHook) Fire(entry *logrus.Entry) error {
-	line, err := entry.String()
-	if err != nil {
-		return fmt.Errorf("Unable to read entry, %v", err)
-	}
-	switch entry.Level {
-	case logrus.PanicLevel:
-		return hook.writer.Crit(line)
-	case logrus.FatalLevel:
-		return hook.writer.Crit(line)
-	case logrus.ErrorLevel:
-		return hook.writer.Err(line)
-	default:
-		return nil
-	}
-}
-
-// Levels -
-func (hook *syslogHook) Levels() []logrus.Level {
-	return []logrus.Level{
-		logrus.PanicLevel,
-		logrus.FatalLevel,
-		logrus.ErrorLevel,
-	}
-}

logger-syslog-hook_windows.go

@@ -1,30 +0,0 @@
-// +build windows
-
-/*
- * 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
-
-type syslogLogger struct {
-	Enable bool   `json:"enable"`
-	Addr   string `json:"address"`
-	Level  string `json:"level"`
-}
-
-// enableSyslogLogger - unsupported on windows.
-func enableSyslogLogger(raddr string) {
-	fatalIf(errSyslogNotSupported, "Unable to enable syslog.")
-}

logger.go

@@ -1,121 +0,0 @@
-/*
- * 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 (
-	"bufio"
-	"bytes"
-	"os"
-	"reflect"
-	"runtime"
-	"runtime/debug"
-	"strconv"
-	"strings"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/dustin/go-humanize"
-)
-
-type fields map[string]interface{}
-
-var log = logrus.New() // Default console logger.
-
-// logger carries logging configuration for various supported loggers.
-// Currently supported loggers are
-//
-//   - console [default]
-//   - file
-//   - syslog
-//
-type logger struct {
-	Console consoleLogger `json:"console"`
-	File    fileLogger    `json:"file"`
-	Syslog  syslogLogger  `json:"syslog"`
-	// 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.
-	rawStack := bufio.NewReader(bytes.NewBuffer(debug.Stack()))
-	// Skip stack trace lines until our real caller.
-	for i := 0; i <= 4; i++ {
-		rawStack.ReadLine()
-	}
-
-	// Read the rest of useful stack trace.
-	stackBuf := new(bytes.Buffer)
-	stackBuf.ReadFrom(rawStack)
-
-	// Strip GOPATH of the build system and return.
-	return strings.Replace(stackBuf.String(), minioGOPATH+"/src/", "", -1)
-}
-
-// errorIf synonymous with fatalIf but doesn't exit on error != nil
-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,
-	}
-	if globalTrace {
-		fields["stack"] = "\n" + stackInfo()
-	}
-	log.WithFields(fields).Errorf(msg, data...)
-}
-
-// fatalIf wrapper function which takes error and prints jsonic error messages.
-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,
-	}
-	if globalTrace {
-		fields["stack"] = "\n" + stackInfo()
-	}
-	log.WithFields(fields).Fatalf(msg, data...)
-}

logger_test.go

@@ -1,47 +0,0 @@
-/*
- * Minio Cloud 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 (
-	"bytes"
-	"encoding/json"
-	"errors"
-
-	"github.com/Sirupsen/logrus"
-
-	. "gopkg.in/check.v1"
-)
-
-type LoggerSuite struct{}
-
-var _ = Suite(&LoggerSuite{})
-
-func (s *LoggerSuite) TestLogger(c *C) {
-	var buffer bytes.Buffer
-	var fields logrus.Fields
-	log.Out = &buffer
-	log.Formatter = new(logrus.JSONFormatter)
-
-	errorIf(errors.New("Fake error"), "Failed with error.")
-	err := json.Unmarshal(buffer.Bytes(), &fields)
-	c.Assert(err, IsNil)
-	c.Assert(fields["level"], Equals, "error")
-
-	msg, ok := fields["cause"]
-	c.Assert(ok, Equals, true)
-	c.Assert(msg, Equals, "Fake error")
-}

main.go

@@ -1,195 +0,0 @@
-/*
- * 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 (
-	"fmt"
-	"os"
-	"sort"
-
-	"github.com/minio/cli"
-	"github.com/minio/mc/pkg/console"
-	"github.com/pkg/profile"
-)
-
-var (
-	// global flags for minio.
-	minioFlags = []cli.Flag{
-		cli.BoolFlag{
-			Name:  "help, h",
-			Usage: "Show help.",
-		},
-	}
-)
-
-// Help template for minio.
-var minioHelpTemplate = `NAME:
-  {{.Name}} - {{.Usage}}
-
-DESCRIPTION:
-  {{.Description}}
-
-USAGE:
-  minio {{if .Flags}}[flags] {{end}}command{{if .Flags}}{{end}} [arguments...]
-
-COMMANDS:
-  {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-  {{end}}{{if .Flags}}
-FLAGS:
-  {{range .Flags}}{{.}}
-  {{end}}{{end}}
-VERSION:
-  ` + minioVersion +
-	`{{ "\n"}}`
-
-// init - check the environment before main starts
-func init() {
-	// Check if minio was compiled using a supported version of Golang.
-	checkGoVersion()
-
-	// Set global trace flag.
-	globalTrace = os.Getenv("MINIO_TRACE") == "1"
-}
-
-func migrate() {
-	// Migrate config file
-	migrateConfig()
-
-	// Migrate other configs here.
-}
-
-func enableLoggers() {
-	// Enable all loggers here.
-	enableConsoleLogger()
-	enableFileLogger()
-
-	// Add your logger here.
-}
-
-func findClosestCommands(command string) []string {
-	var closestCommands []string
-	for _, value := range commandsTree.PrefixMatch(command) {
-		closestCommands = append(closestCommands, value.(string))
-	}
-	sort.Strings(closestCommands)
-	// Suggest other close commands - allow missed, wrongly added and
-	// even transposed characters
-	for _, value := range commandsTree.walk(commandsTree.root) {
-		if sort.SearchStrings(closestCommands, value.(string)) < len(closestCommands) {
-			continue
-		}
-		// 2 is arbitrary and represents the max
-		// allowed number of typed errors
-		if DamerauLevenshteinDistance(command, value.(string)) < 2 {
-			closestCommands = append(closestCommands, value.(string))
-		}
-	}
-	return closestCommands
-}
-
-func registerApp() *cli.App {
-	// Register all commands.
-	registerCommand(serverCmd)
-	registerCommand(versionCmd)
-	registerCommand(updateCmd)
-
-	// Set up app.
-	app := cli.NewApp()
-	app.Name = "Minio"
-	app.Author = "Minio.io"
-	app.Usage = "Cloud Storage Server."
-	app.Description = `Minio is an Amazon S3 compatible object storage server. Use it to store photos, videos, VMs, containers, log files, or any blob of data as objects.`
-	app.Flags = append(minioFlags, globalFlags...)
-	app.Commands = commands
-	app.CustomAppHelpTemplate = minioHelpTemplate
-	app.CommandNotFound = func(ctx *cli.Context, command string) {
-		msg := fmt.Sprintf("‘%s’ is not a minio sub-command. See ‘minio --help’.", command)
-		closestCommands := findClosestCommands(command)
-		if len(closestCommands) > 0 {
-			msg += fmt.Sprintf("\n\nDid you mean one of these?\n")
-			for _, cmd := range closestCommands {
-				msg += fmt.Sprintf("        ‘%s’\n", cmd)
-			}
-		}
-		console.Fatalln(msg)
-	}
-	return app
-}
-
-func checkMainSyntax(c *cli.Context) {
-	configPath, err := getConfigPath()
-	if err != nil {
-		console.Fatalf("Unable to obtain user's home directory. \nError: %s\n", err)
-	}
-	if configPath == "" {
-		console.Fatalln("Config folder cannot be empty, please specify --config-dir <foldername>.")
-	}
-}
-
-func main() {
-	app := registerApp()
-	app.Before = func(c *cli.Context) error {
-		// Sets new config folder.
-		setGlobalConfigPath(c.GlobalString("config-dir"))
-
-		// Valid input arguments to main.
-		checkMainSyntax(c)
-
-		// Migrate any old version of config / state files to newer format.
-		migrate()
-
-		// Initialize config.
-		err := initConfig()
-		fatalIf(err, "Unable to initialize minio config.")
-
-		// Enable all loggers by now.
-		enableLoggers()
-
-		// Initialize name space lock.
-		initNSLock()
-
-		// Set global quiet flag.
-		globalQuiet = c.Bool("quiet") || c.GlobalBool("quiet")
-
-		// Do not print update messages, if quiet flag is set.
-		if !globalQuiet {
-			// Do not print any errors in release update function.
-			noError := true
-			updateMsg := getReleaseUpdate(minioUpdateStableURL, noError)
-			if updateMsg.Update {
-				console.Println(updateMsg)
-			}
-		}
-
-		return nil
-	}
-
-	// Set ``MINIO_PROFILE_DIR`` to the directory where profiling information should be persisted
-	profileDir := os.Getenv("MINIO_PROFILE_DIR")
-	// Enable profiler if ``MINIO_PROFILER`` is set. Supported options are [cpu, mem, block].
-	switch os.Getenv("MINIO_PROFILER") {
-	case "cpu":
-		defer profile.Start(profile.CPUProfile, profile.ProfilePath(profileDir)).Stop()
-	case "mem":
-		defer profile.Start(profile.MemProfile, profile.ProfilePath(profileDir)).Stop()
-	case "block":
-		defer profile.Start(profile.BlockProfile, profile.ProfilePath(profileDir)).Stop()
-	}
-
-	// Run the app - exit on error.
-	app.RunAndExitOnError()
-}

main_test.go

@@ -1,26 +0,0 @@
-/*
- * Minio Cloud 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 (
-	"testing"
-
-	. "gopkg.in/check.v1"
-)
-
-// Hook up gocheck into the "go test" runner.
-func Test(t *testing.T) { TestingT(t) }