Update Kubernetes TLS doc with info for distributed setups (#5971)

Also, add details on how to create wildcard self-signed certificates
using openssl

CONTRIBUTING.md

@@ -6,7 +6,7 @@
 
 Start by forking the Minio GitHub repository, make changes in a branch and then send a pull request. We encourage pull requests to discuss code changes. Here are the steps in details:
 
-### Setup your Minio Github Repository
+### Setup your Minio GitHub Repository
 Fork [Minio upstream](https://github.com/minio/minio/fork) source repository to your own personal repository. Copy the URL of your Minio fork (you will need it for the `git clone` command below).
 
 ```sh

MAINTAINERS.md

@@ -1,6 +1,6 @@
 # For maintainers only
 
-### Setup your minio Github Repository
+### Setup your minio GitHub Repository
 
 Fork [minio upstream](https://github.com/minio/minio/fork) source repository to your own personal repository.
 ```bash

browser/app/js/browser/BrowserDropdown.js

@@ -89,7 +89,7 @@ export class BrowserDropdown extends React.Component {
           <Dropdown.Menu className="dropdown-menu-right">
             <li>
               <a target="_blank" href="https://github.com/minio/minio">
-                Github <i className="fa fa-github" />
+                GitHub <i className="fa fa-github" />
               </a>
             </li>
             <li>

browser/app/js/browser/StorageInfo.js

@@ -25,23 +25,16 @@ export class StorageInfo extends React.Component {
     fetchStorageInfo()
   }
   render() {
-    const { total, free } = this.props.storageInfo
-    const used = total - free
-    const usedPercent = used / total * 100 + "%"
-    const freePercent = free * 100 / total
+    const { used } = this.props.storageInfo
     return (
-      <div className="feh-usage">
+      <div className="feh-used">
         <div className="fehu-chart">
-          <div style={{ width: usedPercent }} />
+          <div style={{ width: 0 }} />
         </div>
         <ul>
           <li>
             <span>Used: </span>
-            {humanize.filesize(total - free)}
-          </li>
-          <li className="pull-right">
-            <span>Free: </span>
-            {humanize.filesize(total - used)}
+            {humanize.filesize(used)}
           </li>
         </ul>
       </div>

browser/app/js/browser/__tests__/StorageInfo.test.js

@@ -22,7 +22,7 @@ describe("StorageInfo", () => {
   it("should render without crashing", () => {
     shallow(
       <StorageInfo
-        storageInfo={{ total: 100, free: 60 }}
+        storageInfo={{ used: 60 }}
         fetchStorageInfo={jest.fn()}
       />
     )
@@ -32,7 +32,7 @@ describe("StorageInfo", () => {
     const fetchStorageInfo = jest.fn()
     shallow(
       <StorageInfo
-        storageInfo={{ total: 100, free: 60 }}
+        storageInfo={{ used: 60 }}
         fetchStorageInfo={fetchStorageInfo}
       />
     )

browser/app/js/browser/__tests__/actions.test.js

@@ -20,7 +20,7 @@ import * as actionsCommon from "../actions"
 
 jest.mock("../../web", () => ({
   StorageInfo: jest.fn(() => {
-    return Promise.resolve({ storageInfo: { Total: 100, Free: 60 } })
+    return Promise.resolve({ storageInfo: { Used: 60 } })
   }),
   ServerInfo: jest.fn(() => {
     return Promise.resolve({
@@ -40,7 +40,7 @@ describe("Common actions", () => {
   it("creates common/SET_STORAGE_INFO after fetching the storage details ", () => {
     const store = mockStore()
     const expectedActions = [
-      { type: "common/SET_STORAGE_INFO", storageInfo: { total: 100, free: 60 } }
+      { type: "common/SET_STORAGE_INFO", storageInfo: { used: 60 } }
     ]
     return store.dispatch(actionsCommon.fetchStorageInfo()).then(() => {
       const actions = store.getActions()

browser/app/js/browser/actions.js

@@ -34,7 +34,7 @@ export const fetchStorageInfo = () => {
     return web.StorageInfo().then(res => {
       const storageInfo = {
         total: res.storageInfo.Total,
-        free: res.storageInfo.Free
+        used:  res.storageInfo.Used
       }
       dispatch(setStorageInfo(storageInfo))
     })

browser/app/less/inc/header.less

@@ -44,9 +44,9 @@
 
 
 /*--------------------------
-    Disk usage
+    Disk used
 ----------------------------*/
-.feh-usage {
+.feh-used {
     margin-top: 12px;
     max-width: 285px;
 

cmd/acl-handlers.go

@@ -0,0 +1,141 @@
+/*
+ * Minio Cloud Storage, (C) 2018 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 cmd
+
+import (
+	"encoding/xml"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/minio/minio/pkg/policy"
+)
+
+// Data types used for returning dummy access control
+// policy XML, these variables shouldn't be used elsewhere
+// they are only defined to be used in this file alone.
+type grantee struct {
+	XMLNS       string `xml:"xmlns:xsi,attr"`
+	XMLXSI      string `xml:"xsi:type,attr"`
+	Type        string `xml:"Type"`
+	ID          string `xml:"ID,omitempty"`
+	DisplayName string `xml:"DisplayName,omitempty"`
+	URI         string `xml:"URI,omitempty"`
+}
+
+type grant struct {
+	Grantee    grantee `xml:"Grantee"`
+	Permission string  `xml:"Permission"`
+}
+
+type accessControlPolicy struct {
+	XMLName           xml.Name `xml:"AccessControlPolicy"`
+	Owner             Owner    `xml:"Owner"`
+	AccessControlList struct {
+		Grants []grant `xml:"Grant"`
+	} `xml:"AccessControlList"`
+}
+
+// GetBucketACLHandler - GET Bucket ACL
+// -----------------
+// This operation uses the ACL
+// subresource to return the ACL of a specified bucket.
+func (api objectAPIHandlers) GetBucketACLHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := newContext(r, "GetBucketACL")
+
+	vars := mux.Vars(r)
+	bucket := vars["bucket"]
+
+	objAPI := api.ObjectAPI()
+	if objAPI == nil {
+		writeErrorResponse(w, ErrServerNotInitialized, r.URL)
+		return
+	}
+
+	// Allow getBucketACL if policy action is set, since this is a dummy call
+	// we are simply re-purposing the bucketPolicyAction.
+	if s3Error := checkRequestAuthType(ctx, r, policy.GetBucketPolicyAction, bucket, ""); s3Error != ErrNone {
+		writeErrorResponse(w, s3Error, r.URL)
+		return
+	}
+
+	// Before proceeding validate if bucket exists.
+	_, err := objAPI.GetBucketInfo(ctx, bucket)
+	if err != nil {
+		writeErrorResponse(w, toAPIErrorCode(err), r.URL)
+		return
+	}
+
+	acl := &accessControlPolicy{}
+	acl.AccessControlList.Grants = append(acl.AccessControlList.Grants, grant{
+		Grantee: grantee{
+			Type: "CanonicalUser",
+		},
+		Permission: "FULL_CONTROL",
+	})
+	if err := xml.NewEncoder(w).Encode(acl); err != nil {
+		writeErrorResponse(w, toAPIErrorCode(err), r.URL)
+		return
+	}
+
+	w.(http.Flusher).Flush()
+}
+
+// GetObjectACLHandler - GET Object ACL
+// -----------------
+// This operation uses the ACL
+// subresource to return the ACL of a specified object.
+func (api objectAPIHandlers) GetObjectACLHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := newContext(r, "GetObjectACL")
+
+	vars := mux.Vars(r)
+	bucket := vars["bucket"]
+	object := vars["object"]
+
+	objAPI := api.ObjectAPI()
+	if objAPI == nil {
+		writeErrorResponse(w, ErrServerNotInitialized, r.URL)
+		return
+	}
+
+	// Allow getObjectACL if policy action is set, since this is a dummy call
+	// we are simply re-purposing the bucketPolicyAction.
+	if s3Error := checkRequestAuthType(ctx, r, policy.GetBucketPolicyAction, bucket, ""); s3Error != ErrNone {
+		writeErrorResponse(w, s3Error, r.URL)
+		return
+	}
+
+	// Before proceeding validate if object exists.
+	_, err := objAPI.GetObjectInfo(ctx, bucket, object)
+	if err != nil {
+		writeErrorResponse(w, toAPIErrorCode(err), r.URL)
+		return
+	}
+
+	acl := &accessControlPolicy{}
+	acl.AccessControlList.Grants = append(acl.AccessControlList.Grants, grant{
+		Grantee: grantee{
+			Type: "CanonicalUser",
+		},
+		Permission: "FULL_CONTROL",
+	})
+	if err := xml.NewEncoder(w).Encode(acl); err != nil {
+		writeErrorResponse(w, toAPIErrorCode(err), r.URL)
+		return
+	}
+
+	w.(http.Flusher).Flush()
+}

cmd/admin-handlers_test.go

@@ -929,9 +929,6 @@ func TestAdminServerInfo(t *testing.T) {
 		if serverInfo.Error != "" {
 			t.Errorf("Unexpected error = %v\n", serverInfo.Error)
 		}
-		if serverInfo.Data.StorageInfo.Free == 0 {
-			t.Error("Expected StorageInfo.Free to be non empty")
-		}
 		if serverInfo.Data.Properties.Region != globalMinioDefaultRegion {
 			t.Errorf("Expected %s, got %s", globalMinioDefaultRegion, serverInfo.Data.Properties.Region)
 		}

cmd/api-router.go

@@ -83,6 +83,10 @@ func registerAPIRouter(router *mux.Router) {
 		bucket.Methods("GET").HandlerFunc(httpTraceAll(api.GetBucketLocationHandler)).Queries("location", "")
 		// GetBucketPolicy
 		bucket.Methods("GET").HandlerFunc(httpTraceAll(api.GetBucketPolicyHandler)).Queries("policy", "")
+
+		// GetBucketACL -- this is a dummy call.
+		bucket.Methods("GET").HandlerFunc(httpTraceAll(api.GetBucketACLHandler)).Queries("acl", "")
+
 		// GetBucketNotification
 		bucket.Methods("GET").HandlerFunc(httpTraceAll(api.GetBucketNotificationHandler)).Queries("notification", "")
 		// ListenBucketNotification

cmd/auth-handler.go

@@ -28,6 +28,7 @@ import (
 	"strings"
 
 	"github.com/minio/minio/cmd/logger"
+	"github.com/minio/minio/pkg/hash"
 	"github.com/minio/minio/pkg/policy"
 )
 
@@ -209,59 +210,45 @@ func reqSignatureV4Verify(r *http.Request, region string) (s3Error APIErrorCode)
 
 // Verify if request has valid AWS Signature Version '4'.
 func isReqAuthenticated(r *http.Request, region string) (s3Error APIErrorCode) {
-	if r == nil {
-		return ErrInternalError
-	}
-
 	if errCode := reqSignatureV4Verify(r, region); errCode != ErrNone {
 		return errCode
 	}
 
-	payload, err := ioutil.ReadAll(r.Body)
+	var (
+		err                       error
+		contentMD5, contentSHA256 []byte
+	)
+	// Extract 'Content-Md5' if present.
+	if _, ok := r.Header["Content-Md5"]; ok {
+		contentMD5, err = base64.StdEncoding.Strict().DecodeString(r.Header.Get("Content-Md5"))
+		if err != nil || len(contentMD5) == 0 {
+			return ErrInvalidDigest
+		}
+	}
+
+	// Extract either 'X-Amz-Content-Sha256' header or 'X-Amz-Content-Sha256' query parameter (if V4 presigned)
+	// Do not verify 'X-Amz-Content-Sha256' if skipSHA256.
+	if skipSHA256 := skipContentSha256Cksum(r); !skipSHA256 && isRequestPresignedSignatureV4(r) {
+		if sha256Sum, ok := r.URL.Query()["X-Amz-Content-Sha256"]; ok && len(sha256Sum) > 0 {
+			contentSHA256, err = hex.DecodeString(sha256Sum[0])
+			if err != nil {
+				return ErrContentSHA256Mismatch
+			}
+		}
+	} else if _, ok := r.Header["X-Amz-Content-Sha256"]; !skipSHA256 && ok {
+		contentSHA256, err = hex.DecodeString(r.Header.Get("X-Amz-Content-Sha256"))
+		if err != nil || len(contentSHA256) == 0 {
+			return ErrContentSHA256Mismatch
+		}
+	}
+
+	// Verify 'Content-Md5' and/or 'X-Amz-Content-Sha256' if present.
+	// The verification happens implicit during reading.
+	reader, err := hash.NewReader(r.Body, -1, hex.EncodeToString(contentMD5), hex.EncodeToString(contentSHA256))
 	if err != nil {
-		logger.LogIf(context.Background(), err)
-		return ErrInternalError
-	}
-
-	// Populate back the payload.
-	r.Body = ioutil.NopCloser(bytes.NewReader(payload))
-
-	// Verify Content-Md5, if payload is set.
-	if clntMD5B64, ok := r.Header["Content-Md5"]; ok {
-		if clntMD5B64[0] == "" {
-			return ErrInvalidDigest
-		}
-		md5Sum, err := base64.StdEncoding.Strict().DecodeString(clntMD5B64[0])
-		if err != nil {
-			return ErrInvalidDigest
-		}
-		if !bytes.Equal(md5Sum, getMD5Sum(payload)) {
-			return ErrBadDigest
-		}
-	}
-
-	if skipContentSha256Cksum(r) {
-		return ErrNone
-	}
-
-	// Verify that X-Amz-Content-Sha256 Header == sha256(payload)
-	// If X-Amz-Content-Sha256 header is not sent then we don't calculate/verify sha256(payload)
-	sumHex, ok := r.Header["X-Amz-Content-Sha256"]
-	if isRequestPresignedSignatureV4(r) {
-		sumHex, ok = r.URL.Query()["X-Amz-Content-Sha256"]
-	}
-	if ok {
-		if sumHex[0] == "" {
-			return ErrContentSHA256Mismatch
-		}
-		sum, err := hex.DecodeString(sumHex[0])
-		if err != nil {
-			return ErrContentSHA256Mismatch
-		}
-		if !bytes.Equal(sum, getSHA256Sum(payload)) {
-			return ErrContentSHA256Mismatch
-		}
+		return toAPIErrorCode(err)
 	}
+	r.Body = ioutil.NopCloser(reader)
 	return ErrNone
 }
 

cmd/auth-handler_test.go

@@ -19,6 +19,7 @@ package cmd
 import (
 	"bytes"
 	"io"
+	"io/ioutil"
 	"net/http"
 	"net/url"
 	"os"
@@ -361,8 +362,6 @@ func TestIsReqAuthenticated(t *testing.T) {
 		req     *http.Request
 		s3Error APIErrorCode
 	}{
-		// When request is nil, internal error is returned.
-		{nil, ErrInternalError},
 		// When request is unsigned, access denied is returned.
 		{mustNewRequest("GET", "http://127.0.0.1:9000", 0, nil, t), ErrAccessDenied},
 		// Empty Content-Md5 header.
@@ -376,9 +375,11 @@ func TestIsReqAuthenticated(t *testing.T) {
 	}
 
 	// Validates all testcases.
-	for _, testCase := range testCases {
+	for i, testCase := range testCases {
 		if s3Error := isReqAuthenticated(testCase.req, globalServerConfig.GetRegion()); s3Error != testCase.s3Error {
-			t.Fatalf("Unexpected s3error returned wanted %d, got %d", testCase.s3Error, s3Error)
+			if _, err := ioutil.ReadAll(testCase.req.Body); toAPIErrorCode(err) != testCase.s3Error {
+				t.Fatalf("Test %d: Unexpected S3 error: want %d - got %d (got after reading request %d)", i, testCase.s3Error, s3Error, toAPIErrorCode(err))
+			}
 		}
 	}
 }

cmd/bucket-handlers.go

@@ -655,9 +655,9 @@ func (api objectAPIHandlers) DeleteBucketHandler(w http.ResponseWriter, r *http.
 
 	globalNotificationSys.RemoveNotification(bucket)
 	globalPolicySys.Remove(bucket)
-	for addr, err := range globalNotificationSys.DeleteBucket(bucket) {
-		logger.GetReqInfo(ctx).AppendTags("remotePeer", addr.Name)
-		logger.LogIf(ctx, err)
+	for nerr := range globalNotificationSys.DeleteBucket(bucket) {
+		logger.GetReqInfo(ctx).AppendTags("remotePeer", nerr.Host.Name)
+		logger.LogIf(ctx, nerr.Err)
 	}
 
 	// Write success response.

cmd/bucket-notification-handlers.go

@@ -146,9 +146,9 @@ func (api objectAPIHandlers) PutBucketNotificationHandler(w http.ResponseWriter,
 
 	rulesMap := config.ToRulesMap()
 	globalNotificationSys.AddRulesMap(bucketName, rulesMap)
-	for addr, err := range globalNotificationSys.PutBucketNotification(bucketName, rulesMap) {
-		logger.GetReqInfo(ctx).AppendTags("remotePeer", addr.Name)
-		logger.LogIf(ctx, err)
+	for nerr := range globalNotificationSys.PutBucketNotification(bucketName, rulesMap) {
+		logger.GetReqInfo(ctx).AppendTags("remotePeer", nerr.Host.Name)
+		logger.LogIf(ctx, nerr.Err)
 	}
 
 	writeSuccessResponseHeadersOnly(w)
@@ -251,10 +251,10 @@ func (api objectAPIHandlers) ListenBucketNotificationHandler(w http.ResponseWrit
 		return
 	}
 
-	errors := globalNotificationSys.ListenBucketNotification(bucketName, eventNames, pattern, target.ID(), *thisAddr)
-	for addr, err := range errors {
-		logger.GetReqInfo(ctx).AppendTags("remotePeer", addr.Name)
-		logger.LogIf(ctx, err)
+	errCh := globalNotificationSys.ListenBucketNotification(bucketName, eventNames, pattern, target.ID(), *thisAddr)
+	for nerr := range errCh {
+		logger.GetReqInfo(ctx).AppendTags("remotePeer", nerr.Host.Name)
+		logger.LogIf(ctx, nerr.Err)
 	}
 
 	<-target.DoneCh

cmd/bucket-policy-handlers.go

@@ -91,9 +91,9 @@ func (api objectAPIHandlers) PutBucketPolicyHandler(w http.ResponseWriter, r *ht
 	}
 
 	globalPolicySys.Set(bucket, *bucketPolicy)
-	for addr, err := range globalNotificationSys.SetBucketPolicy(bucket, bucketPolicy) {
-		logger.GetReqInfo(ctx).AppendTags("remotePeer", addr.Name)
-		logger.LogIf(ctx, err)
+	for nerr := range globalNotificationSys.SetBucketPolicy(bucket, bucketPolicy) {
+		logger.GetReqInfo(ctx).AppendTags("remotePeer", nerr.Host.Name)
+		logger.LogIf(ctx, nerr.Err)
 	}
 
 	// Success.
@@ -130,9 +130,9 @@ func (api objectAPIHandlers) DeleteBucketPolicyHandler(w http.ResponseWriter, r
 	}
 
 	globalPolicySys.Remove(bucket)
-	for addr, err := range globalNotificationSys.RemoveBucketPolicy(bucket) {
-		logger.GetReqInfo(ctx).AppendTags("remotePeer", addr.Name)
-		logger.LogIf(ctx, err)
+	for nerr := range globalNotificationSys.RemoveBucketPolicy(bucket) {
+		logger.GetReqInfo(ctx).AppendTags("remotePeer", nerr.Host.Name)
+		logger.LogIf(ctx, nerr.Err)
 	}
 
 	// Success.

cmd/certs.go

@@ -17,12 +17,12 @@
 package cmd
 
 import (
+	"bytes"
 	"crypto"
 	"crypto/ecdsa"
 	"crypto/tls"
 	"crypto/x509"
 	"encoding/pem"
-	"fmt"
 	"io/ioutil"
 	"os"
 )
@@ -39,24 +39,27 @@ func parsePublicCertFile(certFile string) (x509Certs []*x509.Certificate, err er
 		return nil, err
 	}
 
+	// Trimming leading and tailing white spaces.
+	data = bytes.TrimSpace(data)
+
 	// Parse all certs in the chain.
 	current := data
 	for len(current) > 0 {
 		var pemBlock *pem.Block
 		if pemBlock, current = pem.Decode(current); pemBlock == nil {
-			return nil, fmt.Errorf("Could not read PEM block from file %s", certFile)
+			return nil, uiErrSSLUnexpectedData(nil).Msg("Could not read PEM block from file %s", certFile)
 		}
 
 		var x509Cert *x509.Certificate
 		if x509Cert, err = x509.ParseCertificate(pemBlock.Bytes); err != nil {
-			return nil, err
+			return nil, uiErrSSLUnexpectedData(err)
 		}
 
 		x509Certs = append(x509Certs, x509Cert)
 	}
 
 	if len(x509Certs) == 0 {
-		return nil, fmt.Errorf("Empty public certificate file %s", certFile)
+		return nil, uiErrSSLUnexpectedData(nil).Msg("Empty public certificate file %s", certFile)
 	}
 
 	return x509Certs, nil
@@ -107,28 +110,32 @@ func getRootCAs(certsCAsDir string) (*x509.CertPool, error) {
 func loadX509KeyPair(certFile, keyFile string) (tls.Certificate, error) {
 	certPEMBlock, err := ioutil.ReadFile(certFile)
 	if err != nil {
-		return tls.Certificate{}, fmt.Errorf("TLS: failed to read cert file: %v", err)
+		return tls.Certificate{}, uiErrSSLUnexpectedError(err)
 	}
 	keyPEMBlock, err := ioutil.ReadFile(keyFile)
 	if err != nil {
-		return tls.Certificate{}, fmt.Errorf("TLS: failed to read private key: %v", err)
+		return tls.Certificate{}, uiErrSSLUnexpectedError(err)
 	}
 	key, rest := pem.Decode(keyPEMBlock)
 	if len(rest) > 0 {
-		return tls.Certificate{}, fmt.Errorf("TLS: private key contains additional data")
+		return tls.Certificate{}, uiErrSSLUnexpectedData(nil).Msg("The private key contains additional data")
 	}
 	if x509.IsEncryptedPEMBlock(key) {
 		password, ok := os.LookupEnv(TLSPrivateKeyPassword)
 		if !ok {
-			return tls.Certificate{}, fmt.Errorf("TLS: private key is encrypted but no password is present - set env var: %s", TLSPrivateKeyPassword)
+			return tls.Certificate{}, uiErrSSLNoPassword(nil)
 		}
 		decryptedKey, decErr := x509.DecryptPEMBlock(key, []byte(password))
 		if decErr != nil {
-			return tls.Certificate{}, fmt.Errorf("TLS: failed to decrypt private key: %v", decErr)
+			return tls.Certificate{}, uiErrSSLWrongPassword(decErr)
 		}
 		keyPEMBlock = pem.EncodeToMemory(&pem.Block{Type: key.Type, Bytes: decryptedKey})
 	}
-	return tls.X509KeyPair(certPEMBlock, keyPEMBlock)
+	cert, err := tls.X509KeyPair(certPEMBlock, keyPEMBlock)
+	if err != nil {
+		return tls.Certificate{}, uiErrSSLUnexpectedData(nil).Msg(err.Error())
+	}
+	return cert, nil
 }
 
 func getSSLConfig() (x509Certs []*x509.Certificate, rootCAs *x509.CertPool, tlsCert *tls.Certificate, secureConn bool, err error) {
@@ -149,7 +156,7 @@ func getSSLConfig() (x509Certs []*x509.Certificate, rootCAs *x509.CertPool, tlsC
 	if priv, ok := cert.PrivateKey.(crypto.Signer); ok {
 		if pub, ok := priv.Public().(*ecdsa.PublicKey); ok {
 			if name := pub.Params().Name; name == "P-384" || name == "P-521" { // unfortunately there is no cleaner way to check
-				return nil, nil, nil, false, fmt.Errorf("TLS: the ECDSA curve '%s' is not supported", name)
+				return nil, nil, nil, false, uiErrSSLUnexpectedData(nil).Msg("tls: the ECDSA curve '%s' is not supported", name)
 			}
 		}
 

cmd/common-main.go

@@ -44,10 +44,10 @@ func checkUpdate(mode string) {
 func initConfig() {
 	// Config file does not exist, we create it fresh and return upon success.
 	if isFile(getConfigFile()) {
-		logger.FatalIf(migrateConfig(), "Config migration failed.")
-		logger.FatalIf(loadConfig(), "Unable to load config version: '%s'.", serverConfigVersion)
+		logger.FatalIf(migrateConfig(), "Config migration failed")
+		logger.FatalIf(loadConfig(), "Unable to load the configuration file")
 	} else {
-		logger.FatalIf(newConfig(), "Unable to initialize minio config for the first time.")
+		logger.FatalIf(newConfig(), "Unable to initialize minio config for the first time")
 		logger.Info("Created minio configuration file successfully at " + getConfigDir())
 	}
 }
@@ -71,12 +71,12 @@ func handleCommonCmdArgs(ctx *cli.Context) {
 		// default config directory.
 		configDir = getConfigDir()
 		if configDir == "" {
-			logger.FatalIf(errors.New("missing option"), "config-dir option must be provided.")
+			logger.FatalIf(errors.New("missing option"), "config-dir option must be provided")
 		}
 	}
 
 	if configDir == "" {
-		logger.FatalIf(errors.New("empty directory"), "Configuration directory cannot be empty.")
+		logger.FatalIf(errors.New("empty directory"), "Configuration directory cannot be empty")
 	}
 
 	// Disallow relative paths, figure out absolute paths.
@@ -95,7 +95,9 @@ func handleCommonEnvVars() {
 	secretKey := os.Getenv("MINIO_SECRET_KEY")
 	if accessKey != "" && secretKey != "" {
 		cred, err := auth.CreateCredentials(accessKey, secretKey)
-		logger.FatalIf(err, "Invalid access/secret Key set in environment.")
+		if err != nil {
+			logger.Fatal(uiErrInvalidCredentials(err), "Unable to validate credentials inherited from the shell environment")
+		}
 
 		// credential Envs are set globally.
 		globalIsEnvCreds = true
@@ -105,7 +107,7 @@ func handleCommonEnvVars() {
 	if browser := os.Getenv("MINIO_BROWSER"); browser != "" {
 		browserFlag, err := ParseBrowserFlag(browser)
 		if err != nil {
-			logger.FatalIf(errors.New("invalid value"), "Unknown value ‘%s’ in MINIO_BROWSER environment variable.", browser)
+			logger.Fatal(uiErrInvalidBrowserValue(nil).Msg("Unknown value `%s`", browser), "Unable to validate MINIO_BROWSER environment variable")
 		}
 
 		// browser Envs are set globally, this does not represent
@@ -128,18 +130,26 @@ func handleCommonEnvVars() {
 
 	if drives := os.Getenv("MINIO_CACHE_DRIVES"); drives != "" {
 		driveList, err := parseCacheDrives(strings.Split(drives, cacheEnvDelimiter))
-		logger.FatalIf(err, "Invalid value set in environment variable MINIO_CACHE_DRIVES %s.", drives)
+		if err != nil {
+			logger.Fatal(err, "Unable to parse MINIO_CACHE_DRIVES value (%s)", drives)
+		}
 		globalCacheDrives = driveList
 		globalIsDiskCacheEnabled = true
 	}
+
 	if excludes := os.Getenv("MINIO_CACHE_EXCLUDE"); excludes != "" {
 		excludeList, err := parseCacheExcludes(strings.Split(excludes, cacheEnvDelimiter))
-		logger.FatalIf(err, "Invalid value set in environment variable MINIO_CACHE_EXCLUDE %s.", excludes)
+		if err != nil {
+			logger.Fatal(err, "Unable to parse MINIO_CACHE_EXCLUDE value (`%s`)", excludes)
+		}
 		globalCacheExcludes = excludeList
 	}
+
 	if expiryStr := os.Getenv("MINIO_CACHE_EXPIRY"); expiryStr != "" {
 		expiry, err := strconv.Atoi(expiryStr)
-		logger.FatalIf(err, "Invalid value set in environment variable MINIO_CACHE_EXPIRY %s.", expiryStr)
+		if err != nil {
+			logger.Fatal(uiErrInvalidCacheExpiryValue(err), "Unable to parse MINIO_CACHE_EXPIRY value (`%s`)", expiryStr)
+		}
 		globalCacheExpiry = expiry
 	}
 
@@ -155,25 +165,25 @@ func handleCommonEnvVars() {
 		// Check for environment variables and parse into storageClass struct
 		if ssc := os.Getenv(standardStorageClassEnv); ssc != "" {
 			globalStandardStorageClass, err = parseStorageClass(ssc)
-			logger.FatalIf(err, "Invalid value set in environment variable %s.", standardStorageClassEnv)
+			logger.FatalIf(err, "Invalid value set in environment variable %s", standardStorageClassEnv)
 		}
 
 		if rrsc := os.Getenv(reducedRedundancyStorageClassEnv); rrsc != "" {
 			globalRRStorageClass, err = parseStorageClass(rrsc)
-			logger.FatalIf(err, "Invalid value set in environment variable %s.", reducedRedundancyStorageClassEnv)
+			logger.FatalIf(err, "Invalid value set in environment variable %s", reducedRedundancyStorageClassEnv)
 		}
 
 		// Validation is done after parsing both the storage classes. This is needed because we need one
 		// storage class value to deduce the correct value of the other storage class.
 		if globalRRStorageClass.Scheme != "" {
 			err = validateParity(globalStandardStorageClass.Parity, globalRRStorageClass.Parity)
-			logger.FatalIf(err, "Invalid value set in environment variable %s.", reducedRedundancyStorageClassEnv)
+			logger.FatalIf(err, "Invalid value set in environment variable %s", reducedRedundancyStorageClassEnv)
 			globalIsStorageClass = true
 		}
 
 		if globalStandardStorageClass.Scheme != "" {
 			err = validateParity(globalStandardStorageClass.Parity, globalRRStorageClass.Parity)
-			logger.FatalIf(err, "Invalid value set in environment variable %s.", standardStorageClassEnv)
+			logger.FatalIf(err, "Invalid value set in environment variable %s", standardStorageClassEnv)
 			globalIsStorageClass = true
 		}
 	}

cmd/config-current.go

@@ -287,7 +287,7 @@ func getValidConfig() (*serverConfig, error) {
 func loadConfig() error {
 	srvCfg, err := getValidConfig()
 	if err != nil {
-		return err
+		return uiErrInvalidConfig(nil).Msg(err.Error())
 	}
 
 	// If env is set override the credentials from config file.

cmd/disk-cache-config.go

@@ -18,7 +18,6 @@ package cmd
 
 import (
 	"encoding/json"
-	"fmt"
 	"path/filepath"
 )
 
@@ -54,7 +53,7 @@ func (cfg *CacheConfig) UnmarshalJSON(data []byte) (err error) {
 func parseCacheDrives(drives []string) ([]string, error) {
 	for _, d := range drives {
 		if !filepath.IsAbs(d) {
-			return nil, fmt.Errorf("cache dir should be absolute path: %s", d)
+			return nil, uiErrInvalidCacheDrivesValue(nil).Msg("cache dir should be absolute path: %s", d)
 		}
 	}
 	return drives, nil
@@ -64,10 +63,10 @@ func parseCacheDrives(drives []string) ([]string, error) {
 func parseCacheExcludes(excludes []string) ([]string, error) {
 	for _, e := range excludes {
 		if len(e) == 0 {
-			return nil, fmt.Errorf("cache exclude path (%s) cannot be empty", e)
+			return nil, uiErrInvalidCacheExcludesValue(nil).Msg("cache exclude path (%s) cannot be empty", e)
 		}
 		if hasPrefix(e, slashSeparator) {
-			return nil, fmt.Errorf("cache exclude pattern (%s) cannot start with / as prefix", e)
+			return nil, uiErrInvalidCacheExcludesValue(nil).Msg("cache exclude pattern (%s) cannot start with / as prefix", e)
 		}
 	}
 	return excludes, nil

cmd/disk-cache.go

@@ -357,8 +357,16 @@ func (c cacheObjects) listCacheObjects(ctx context.Context, bucket, prefix, mark
 			return err == nil
 		}
 
+		isLeafDir := func(bucket, object string) bool {
+			fs, err := c.cache.getCacheFS(ctx, bucket, object)
+			if err != nil {
+				return false
+			}
+			return fs.isObjectDir(bucket, object)
+		}
+
 		listDir := listDirCacheFactory(isLeaf, cacheTreeWalkIgnoredErrs, c.cache.cfs)
-		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, isLeaf, endWalkCh)
+		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, isLeaf, isLeafDir, endWalkCh)
 	}
 
 	for i := 0; i < maxKeys; {
@@ -417,7 +425,7 @@ func (c cacheObjects) listCacheObjects(ctx context.Context, bucket, prefix, mark
 	result = ListObjectsInfo{IsTruncated: !eof}
 	for _, objInfo := range objInfos {
 		result.NextMarker = objInfo.Name
-		if objInfo.IsDir {
+		if objInfo.IsDir && delimiter == slashSeparator {
 			result.Prefixes = append(result.Prefixes, objInfo.Name)
 			continue
 		}
@@ -769,7 +777,7 @@ func (c cacheObjects) StorageInfo(ctx context.Context) (storageInfo StorageInfo)
 		if cfs == nil {
 			continue
 		}
-		info, err := getDiskInfo((cfs.fsPath))
+		info, err := getDiskInfo(cfs.fsPath)
 		logger.GetReqInfo(ctx).AppendTags("cachePath", cfs.fsPath)
 		logger.LogIf(ctx, err)
 		total += info.Total

cmd/disk-usage.go

@@ -0,0 +1,59 @@
+/*
+ * Minio Cloud Storage, (C) 2018 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 cmd
+
+import (
+	"context"
+	"time"
+)
+
+const (
+	usageCheckInterval = 12 * time.Hour // 12 hours
+)
+
+// getDiskUsage walks the file tree rooted at root, calling usageFn
+// for each file or directory in the tree, including root.
+func getDiskUsage(ctx context.Context, root string, usageFn usageFunc) error {
+	return walk(ctx, root+slashSeparator, usageFn)
+}
+
+type usageFunc func(ctx context.Context, entry string) error
+
+// walk recursively descends path, calling walkFn.
+func walk(ctx context.Context, path string, usageFn usageFunc) error {
+	if err := usageFn(ctx, path); err != nil {
+		return err
+	}
+
+	if !hasSuffix(path, slashSeparator) {
+		return nil
+	}
+
+	entries, err := readDir(path)
+	if err != nil {
+		return usageFn(ctx, path)
+	}
+
+	for _, entry := range entries {
+		fname := pathJoin(path, entry)
+		if err = walk(ctx, fname, usageFn); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

cmd/endpoint-ellipses.go

@@ -70,11 +70,10 @@ func getSetIndexes(args []string, totalSizes []uint64) (setIndexes [][]uint64, e
 	}
 
 	setIndexes = make([][]uint64, len(totalSizes))
-	for i, totalSize := range totalSizes {
+	for _, totalSize := range totalSizes {
 		// Check if totalSize has minimum range upto setSize
 		if totalSize < setSizes[0] {
-			return nil, fmt.Errorf("Invalid inputs (%s). Ellipses range or number of args %d should be atleast divisible by least possible set size %d",
-				args[i], totalSize, setSizes[0])
+			return nil, uiErrInvalidNumberOfErasureEndpoints(nil)
 		}
 	}
 
@@ -103,8 +102,7 @@ func getSetIndexes(args []string, totalSizes []uint64) (setIndexes [][]uint64, e
 
 	// Check whether setSize is with the supported range.
 	if !isValidSetSize(setSize) {
-		return nil, fmt.Errorf("Invalid inputs (%s). Ellipses range or number of args %d should be atleast divisible by least possible set size %d",
-			args, setSize, setSizes[0])
+		return nil, uiErrInvalidNumberOfErasureEndpoints(nil)
 	}
 
 	for i := range totalSizes {
@@ -167,14 +165,14 @@ func parseEndpointSet(args ...string) (ep endpointSet, err error) {
 	for i, arg := range args {
 		patterns, perr := ellipses.FindEllipsesPatterns(arg)
 		if perr != nil {
-			return endpointSet{}, perr
+			return endpointSet{}, uiErrInvalidErasureEndpoints(nil).Msg(perr.Error())
 		}
 		argPatterns[i] = patterns
 	}
 
 	ep.setIndexes, err = getSetIndexes(args, getTotalSizes(argPatterns))
 	if err != nil {
-		return endpointSet{}, err
+		return endpointSet{}, uiErrInvalidErasureEndpoints(nil).Msg(err.Error())
 	}
 
 	ep.argPatterns = argPatterns
@@ -223,7 +221,7 @@ func getAllSets(args ...string) ([][]string, error) {
 	for _, sargs := range setArgs {
 		for _, arg := range sargs {
 			if uniqueArgs.Contains(arg) {
-				return nil, fmt.Errorf("Input args (%s) has duplicate ellipses", args)
+				return nil, uiErrInvalidErasureEndpoints(nil).Msg(fmt.Sprintf("Input args (%s) has duplicate ellipses", args))
 			}
 			uniqueArgs.Add(arg)
 		}

cmd/endpoint.go

@@ -252,14 +252,14 @@ func CreateEndpoints(serverAddr string, args ...[]string) (string, EndpointList,
 			return serverAddr, endpoints, setupType, err
 		}
 		if endpoint.Type() != PathEndpointType {
-			return serverAddr, endpoints, setupType, fmt.Errorf("use path style endpoint for FS setup")
+			return serverAddr, endpoints, setupType, uiErrInvalidFSEndpoint(nil).Msg("use path style endpoint for FS setup")
 		}
 		endpoints = append(endpoints, endpoint)
 		setupType = FSSetupType
 
 		// Check for cross device mounts if any.
 		if err = checkCrossDeviceMounts(endpoints); err != nil {
-			return serverAddr, endpoints, setupType, err
+			return serverAddr, endpoints, setupType, uiErrInvalidFSEndpoint(nil).Msg(err.Error())
 		}
 		return serverAddr, endpoints, setupType, nil
 	}
@@ -270,12 +270,12 @@ func CreateEndpoints(serverAddr string, args ...[]string) (string, EndpointList,
 		var eps EndpointList
 		eps, err = NewEndpointList(iargs...)
 		if err != nil {
-			return serverAddr, endpoints, setupType, err
+			return serverAddr, endpoints, setupType, uiErrInvalidErasureEndpoints(nil).Msg(err.Error())
 		}
 
 		// Check for cross device mounts if any.
 		if err = checkCrossDeviceMounts(eps); err != nil {
-			return serverAddr, endpoints, setupType, err
+			return serverAddr, endpoints, setupType, uiErrInvalidErasureEndpoints(nil).Msg(err.Error())
 		}
 
 		for _, ep := range eps {
@@ -316,7 +316,7 @@ func CreateEndpoints(serverAddr string, args ...[]string) (string, EndpointList,
 
 	// No local endpoint found.
 	if localEndpointCount == 0 {
-		return serverAddr, endpoints, setupType, fmt.Errorf("no endpoint found for this host")
+		return serverAddr, endpoints, setupType, uiErrInvalidErasureEndpoints(nil).Msg("no endpoint pointing to the local machine is found")
 	}
 
 	// Check whether same path is not used in endpoints of a host on different port.
@@ -331,8 +331,8 @@ func CreateEndpoints(serverAddr string, args ...[]string) (string, EndpointList,
 			hostIPSet, _ := getHostIP4(host)
 			if IPSet, ok := pathIPMap[endpoint.Path]; ok {
 				if !IPSet.Intersection(hostIPSet).IsEmpty() {
-					err = fmt.Errorf("path '%s' can not be served by different port on same address", endpoint.Path)
-					return serverAddr, endpoints, setupType, err
+					return serverAddr, endpoints, setupType,
+						uiErrInvalidErasureEndpoints(nil).Msg(fmt.Sprintf("path '%s' can not be served by different port on same address", endpoint.Path))
 				}
 				pathIPMap[endpoint.Path] = IPSet.Union(hostIPSet)
 			} else {
@@ -349,8 +349,8 @@ func CreateEndpoints(serverAddr string, args ...[]string) (string, EndpointList,
 				continue
 			}
 			if localPathSet.Contains(endpoint.Path) {
-				err = fmt.Errorf("path '%s' cannot be served by different address on same server", endpoint.Path)
-				return serverAddr, endpoints, setupType, err
+				return serverAddr, endpoints, setupType,
+					uiErrInvalidErasureEndpoints(nil).Msg(fmt.Sprintf("path '%s' cannot be served by different address on same server", endpoint.Path))
 			}
 			localPathSet.Add(endpoint.Path)
 		}
@@ -360,12 +360,11 @@ func CreateEndpoints(serverAddr string, args ...[]string) (string, EndpointList,
 	{
 		if !localPortSet.Contains(serverAddrPort) {
 			if len(localPortSet) > 1 {
-				err = fmt.Errorf("port number in server address must match with one of the port in local endpoints")
-			} else {
-				err = fmt.Errorf("server address and local endpoint have different ports")
+				return serverAddr, endpoints, setupType,
+					uiErrInvalidErasureEndpoints(nil).Msg("port number in server address must match with one of the port in local endpoints")
 			}
-
-			return serverAddr, endpoints, setupType, err
+			return serverAddr, endpoints, setupType,
+				uiErrInvalidErasureEndpoints(nil).Msg("server address and local endpoint have different ports")
 		}
 	}
 
@@ -374,7 +373,7 @@ func CreateEndpoints(serverAddr string, args ...[]string) (string, EndpointList,
 		// If all endpoints have same port number, then this is XL setup using URL style endpoints.
 		if len(localPortSet) == 1 {
 			if len(localServerAddrSet) > 1 {
-				// TODO: Eventhough all endpoints are local, the local host is referred by different IP/name.
+				// TODO: Even though all endpoints are local, the local host is referred by different IP/name.
 				// eg '172.0.0.1', 'localhost' and 'mylocalhostname' point to same local host.
 				//
 				// In this case, we bind to 0.0.0.0 ie to all interfaces.
@@ -388,7 +387,7 @@ func CreateEndpoints(serverAddr string, args ...[]string) (string, EndpointList,
 			return serverAddr, endpoints, setupType, nil
 		}
 
-		// Eventhough all endpoints are local, but those endpoints use different ports.
+		// Even though all endpoints are local, but those endpoints use different ports.
 		// This means it is DistXL setup.
 	} else {
 		// This is DistXL setup.

cmd/endpoint_test.go

@@ -225,8 +225,8 @@ func TestCreateEndpoints(t *testing.T) {
 		{"localhost:10000", [][]string{{"./d1"}}, "localhost:10000", EndpointList{Endpoint{URL: &url.URL{Path: "d1"}, IsLocal: true}}, FSSetupType, nil},
 		{"localhost:10000", [][]string{{`\d1`}}, "localhost:10000", EndpointList{Endpoint{URL: &url.URL{Path: `\d1`}, IsLocal: true}}, FSSetupType, nil},
 		{"localhost:10000", [][]string{{`.\d1`}}, "localhost:10000", EndpointList{Endpoint{URL: &url.URL{Path: `.\d1`}, IsLocal: true}}, FSSetupType, nil},
-		{":8080", [][]string{{"https://example.org/d1", "https://example.org/d2", "https://example.org/d3", "https://example.org/d4"}}, "", EndpointList{}, -1, fmt.Errorf("no endpoint found for this host")},
-		{":8080", [][]string{{"https://example.org/d1", "https://example.com/d2", "https://example.net:8000/d3", "https://example.edu/d1"}}, "", EndpointList{}, -1, fmt.Errorf("no endpoint found for this host")},
+		{":8080", [][]string{{"https://example.org/d1", "https://example.org/d2", "https://example.org/d3", "https://example.org/d4"}}, "", EndpointList{}, -1, fmt.Errorf("no endpoint pointing to the local machine is found")},
+		{":8080", [][]string{{"https://example.org/d1", "https://example.com/d2", "https://example.net:8000/d3", "https://example.edu/d1"}}, "", EndpointList{}, -1, fmt.Errorf("no endpoint pointing to the local machine is found")},
 		{"localhost:9000", [][]string{{"https://127.0.0.1:9000/d1", "https://localhost:9001/d1", "https://example.com/d1", "https://example.com/d2"}}, "", EndpointList{}, -1, fmt.Errorf("path '/d1' can not be served by different port on same address")},
 		{"localhost:9000", [][]string{{"https://127.0.0.1:8000/d1", "https://localhost:9001/d2", "https://example.com/d1", "https://example.com/d2"}}, "", EndpointList{}, -1, fmt.Errorf("port number in server address must match with one of the port in local endpoints")},
 		{"localhost:10000", [][]string{{"https://127.0.0.1:8000/d1", "https://localhost:8000/d2", "https://example.com/d1", "https://example.com/d2"}}, "", EndpointList{}, -1, fmt.Errorf("server address and local endpoint have different ports")},

cmd/format-fs.go

@@ -24,7 +24,6 @@ import (
 	"path"
 	"time"
 
-	"github.com/minio/minio/cmd/logger"
 	"github.com/minio/minio/pkg/lock"
 )
 
@@ -113,7 +112,6 @@ func formatFSMigrateV1ToV2(ctx context.Context, wlk *lock.LockedFile, fsPath str
 	}
 
 	if err = os.MkdirAll(path.Join(fsPath, minioMetaMultipartBucket), 0755); err != nil {
-		logger.LogIf(ctx, err)
 		return err
 	}
 
@@ -147,7 +145,7 @@ func formatFSMigrate(ctx context.Context, wlk *lock.LockedFile, fsPath string) e
 		return err
 	}
 	if version != formatFSVersionV2 {
-		return fmt.Errorf(`%s file: expected FS version: %s, found FS version: %s`, formatConfigFile, formatFSVersionV2, version)
+		return uiErrUnexpectedBackendVersion(fmt.Errorf(`%s file: expected FS version: %s, found FS version: %s`, formatConfigFile, formatFSVersionV2, version))
 	}
 	return nil
 }
@@ -158,7 +156,6 @@ func createFormatFS(ctx context.Context, fsFormatPath string) error {
 	// file stored in minioMetaBucket(.minio.sys) directory.
 	lk, err := lock.TryLockedOpenFile(fsFormatPath, os.O_RDWR|os.O_CREATE, 0600)
 	if err != nil {
-		logger.LogIf(ctx, err)
 		return err
 	}
 	// Close the locked file upon return.
@@ -166,7 +163,6 @@ func createFormatFS(ctx context.Context, fsFormatPath string) error {
 
 	fi, err := lk.Stat()
 	if err != nil {
-		logger.LogIf(ctx, err)
 		return err
 	}
 	if fi.Size() != 0 {
@@ -195,7 +191,6 @@ func initFormatFS(ctx context.Context, fsPath string) (rlk *lock.RLockedFile, er
 			var fi os.FileInfo
 			fi, err = rlk.Stat()
 			if err != nil {
-				logger.LogIf(ctx, err)
 				return nil, err
 			}
 			isEmpty = fi.Size() == 0
@@ -214,7 +209,6 @@ func initFormatFS(ctx context.Context, fsPath string) (rlk *lock.RLockedFile, er
 				continue
 			}
 			if err != nil {
-				logger.LogIf(ctx, err)
 				return nil, err
 			}
 			// After successfully creating format.json try to hold a read-lock on
@@ -222,13 +216,11 @@ func initFormatFS(ctx context.Context, fsPath string) (rlk *lock.RLockedFile, er
 			continue
 		}
 		if err != nil {
-			logger.LogIf(ctx, err)
 			return nil, err
 		}
 
 		formatBackend, err := formatMetaGetFormatBackendFS(rlk)
 		if err != nil {
-			logger.LogIf(ctx, err)
 			return nil, err
 		}
 		if formatBackend != formatBackendFS {

cmd/fs-v1-helpers.go

@@ -225,6 +225,15 @@ func fsStatDir(ctx context.Context, statDir string) (os.FileInfo, error) {
 	return fi, nil
 }
 
+// Returns if the dirPath is a directory.
+func fsIsDir(ctx context.Context, dirPath string) bool {
+	fi, err := fsStat(ctx, dirPath)
+	if err != nil {
+		return false
+	}
+	return fi.IsDir()
+}
+
 // Lookup if file exists, returns file attributes upon success.
 func fsStatFile(ctx context.Context, statFile string) (os.FileInfo, error) {
 	fi, err := fsStat(ctx, statFile)
@@ -242,6 +251,15 @@ func fsStatFile(ctx context.Context, statFile string) (os.FileInfo, error) {
 	return fi, nil
 }
 
+// Returns if the filePath is a regular file.
+func fsIsFile(ctx context.Context, filePath string) bool {
+	fi, err := fsStat(ctx, filePath)
+	if err != nil {
+		return false
+	}
+	return fi.Mode().IsRegular()
+}
+
 // Opens the file at given path, optionally from an offset. Upon success returns
 // a readable stream and the size of the readable stream.
 func fsOpenFile(ctx context.Context, readPath string, offset int64) (io.ReadCloser, int64, error) {
@@ -402,7 +420,9 @@ func fsDeleteFile(ctx context.Context, basePath, deletePath string) error {
 	}
 
 	if err := deleteFile(basePath, deletePath); err != nil {
-		logger.LogIf(ctx, err)
+		if err != errFileNotFound {
+			logger.LogIf(ctx, err)
+		}
 		return err
 	}
 	return nil

cmd/fs-v1-helpers_test.go

@@ -547,3 +547,33 @@ func TestFSRemoveMeta(t *testing.T) {
 		t.Fatalf("`%s` parent directory found though it should have been deleted.", filePath)
 	}
 }
+
+func TestFSIsDir(t *testing.T) {
+	dirPath, err := ioutil.TempDir(globalTestTmpDir, "minio-")
+	if err != nil {
+		t.Fatalf("Unable to create tmp directory %s", err)
+	}
+	defer os.RemoveAll(dirPath)
+
+	if !fsIsDir(context.Background(), dirPath) {
+		t.Fatalf("Expected %s to be a directory", dirPath)
+	}
+}
+
+func TestFSIsFile(t *testing.T) {
+	dirPath, err := ioutil.TempDir(globalTestTmpDir, "minio-")
+	if err != nil {
+		t.Fatalf("Unable to create tmp directory %s", err)
+	}
+	defer os.RemoveAll(dirPath)
+
+	filePath := pathJoin(dirPath, "tmpfile")
+
+	if err = ioutil.WriteFile(filePath, nil, 0777); err != nil {
+		t.Fatalf("Unable to create file %s", filePath)
+	}
+
+	if !fsIsFile(context.Background(), filePath) {
+		t.Fatalf("Expected %s to be a file", filePath)
+	}
+}

cmd/fs-v1-multipart_test.go

@@ -80,7 +80,7 @@ func TestNewMultipartUploadFaultyDisk(t *testing.T) {
 	}
 
 	// Test with disk removed.
-	fs.fsPath = filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
+	os.RemoveAll(disk)
 	if _, err := fs.NewMultipartUpload(context.Background(), bucketName, objectName, map[string]string{"X-Amz-Meta-xid": "3f"}); err != nil {
 		if !isSameType(err, BucketNotFound{}) {
 			t.Fatal("Unexpected error ", err)

cmd/fs-v1.go

@@ -19,7 +19,6 @@ package cmd
 import (
 	"context"
 	"encoding/hex"
-	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -27,6 +26,7 @@ import (
 	"sort"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/minio/minio/cmd/logger"
@@ -64,6 +64,10 @@ type FSObjects struct {
 
 	// To manage the appendRoutine go-routines
 	nsMutex *nsLockMap
+
+	// Disk usage metrics
+	totalUsed          uint64
+	usageCheckInterval time.Duration
 }
 
 // Represents the background append file.
@@ -80,6 +84,7 @@ func initMetaVolumeFS(fsPath, fsUUID string) error {
 	// optimizing all other calls. Create minio meta volume,
 	// if it doesn't exist yet.
 	metaBucketPath := pathJoin(fsPath, minioMetaBucket)
+
 	if err := os.MkdirAll(metaBucketPath, 0777); err != nil {
 		return err
 	}
@@ -102,8 +107,8 @@ func NewFSObjectLayer(fsPath string) (ObjectLayer, error) {
 	}
 
 	var err error
-	if fsPath, err = checkPathValid(fsPath); err != nil {
-		return nil, err
+	if fsPath, err = getValidPath(fsPath); err != nil {
+		return nil, uiErrUnableToWriteInBackend(err)
 	}
 
 	// Assign a new UUID for FS minio mode. Each server instance
@@ -112,7 +117,7 @@ func NewFSObjectLayer(fsPath string) (ObjectLayer, error) {
 
 	// Initialize meta volume, if volume already exists ignores it.
 	if err = initMetaVolumeFS(fsPath, fsUUID); err != nil {
-		return nil, fmt.Errorf("Unable to initialize '.minio.sys' meta volume, %s", err)
+		return nil, err
 	}
 
 	// Initialize `format.json`, this function also returns.
@@ -129,9 +134,10 @@ func NewFSObjectLayer(fsPath string) (ObjectLayer, error) {
 		rwPool: &fsIOPool{
 			readersMap: make(map[string]*lock.RLockedFile),
 		},
-		nsMutex:       newNSLock(false),
-		listPool:      newTreeWalkPool(globalLookupTimeout),
-		appendFileMap: make(map[string]*fsAppendFile),
+		nsMutex:            newNSLock(false),
+		listPool:           newTreeWalkPool(globalLookupTimeout),
+		appendFileMap:      make(map[string]*fsAppendFile),
+		usageCheckInterval: usageCheckInterval,
 	}
 
 	// Once the filesystem has initialized hold the read lock for
@@ -142,14 +148,15 @@ func NewFSObjectLayer(fsPath string) (ObjectLayer, error) {
 
 	// Initialize notification system.
 	if err = globalNotificationSys.Init(fs); err != nil {
-		return nil, fmt.Errorf("Unable to initialize notification system. %v", err)
+		return nil, uiErrUnableToReadFromBackend(err).Msg("Unable to initialize notification system")
 	}
 
 	// Initialize policy system.
 	if err = globalPolicySys.Init(fs); err != nil {
-		return nil, fmt.Errorf("Unable to initialize policy system. %v", err)
+		return nil, uiErrUnableToReadFromBackend(err).Msg("Unable to initialize policy system")
 	}
 
+	go fs.diskUsage(globalServiceDoneCh)
 	go fs.cleanupStaleMultipartUploads(ctx, globalMultipartCleanupInterval, globalMultipartExpiry, globalServiceDoneCh)
 
 	// Return successfully initialized object layer.
@@ -164,14 +171,62 @@ func (fs *FSObjects) Shutdown(ctx context.Context) error {
 	return fsRemoveAll(ctx, pathJoin(fs.fsPath, minioMetaTmpBucket, fs.fsUUID))
 }
 
+// diskUsage returns du information for the posix path, in a continuous routine.
+func (fs *FSObjects) diskUsage(doneCh chan struct{}) {
+	ticker := time.NewTicker(fs.usageCheckInterval)
+	defer ticker.Stop()
+
+	usageFn := func(ctx context.Context, entry string) error {
+		var fi os.FileInfo
+		var err error
+		if hasSuffix(entry, slashSeparator) {
+			fi, err = fsStatDir(ctx, entry)
+		} else {
+			fi, err = fsStatFile(ctx, entry)
+		}
+		if err != nil {
+			return err
+		}
+		atomic.AddUint64(&fs.totalUsed, uint64(fi.Size()))
+		return nil
+	}
+
+	if err := getDiskUsage(context.Background(), fs.fsPath, usageFn); err != nil {
+		return
+	}
+
+	for {
+		select {
+		case <-doneCh:
+			return
+		case <-ticker.C:
+			var usage uint64
+			usageFn = func(ctx context.Context, entry string) error {
+				var fi os.FileInfo
+				var err error
+				if hasSuffix(entry, slashSeparator) {
+					fi, err = fsStatDir(ctx, entry)
+				} else {
+					fi, err = fsStatFile(ctx, entry)
+				}
+				if err != nil {
+					return err
+				}
+				usage = usage + uint64(fi.Size())
+				return nil
+			}
+			if err := getDiskUsage(context.Background(), fs.fsPath, usageFn); err != nil {
+				continue
+			}
+			atomic.StoreUint64(&fs.totalUsed, usage)
+		}
+	}
+}
+
 // StorageInfo - returns underlying storage statistics.
 func (fs *FSObjects) StorageInfo(ctx context.Context) StorageInfo {
-	info, err := getDiskInfo((fs.fsPath))
-	logger.GetReqInfo(ctx).AppendTags("path", fs.fsPath)
-	logger.LogIf(ctx, err)
 	storageInfo := StorageInfo{
-		Total: info.Total,
-		Free:  info.Free,
+		Used: atomic.LoadUint64(&fs.totalUsed),
 	}
 	storageInfo.Backend.Type = FS
 	return storageInfo
@@ -480,7 +535,7 @@ func (fs *FSObjects) getObject(ctx context.Context, bucket, object string, offse
 		}
 	}
 
-	if etag != "" {
+	if etag != "" && etag != defaultEtag {
 		objEtag, perr := fs.getObjectETag(ctx, bucket, object, lock)
 		if perr != nil {
 			return toObjectErr(perr, bucket, object)
@@ -563,17 +618,16 @@ func (fs *FSObjects) defaultFsJSON(object string) fsMetaV1 {
 // getObjectInfo - wrapper for reading object metadata and constructs ObjectInfo.
 func (fs *FSObjects) getObjectInfo(ctx context.Context, bucket, object string) (oi ObjectInfo, e error) {
 	fsMeta := fsMetaV1{}
-	fi, err := fsStatDir(ctx, pathJoin(fs.fsPath, bucket, object))
-	if err != nil && err != errFileAccessDenied {
-		return oi, err
-	}
-	if fi != nil {
-		// If file found and request was with object ending with "/", consider it
-		// as directory and return object info
-		if hasSuffix(object, slashSeparator) {
-			return fsMeta.ToObjectInfo(bucket, object, fi), nil
+	if hasSuffix(object, slashSeparator) {
+		// Since we support PUT of a "directory" object, we allow HEAD.
+		if !fsIsDir(ctx, pathJoin(fs.fsPath, bucket, object)) {
+			return oi, errFileNotFound
 		}
-		return oi, errFileNotFound
+		fi, err := fsStatDir(ctx, pathJoin(fs.fsPath, bucket, object))
+		if err != nil {
+			return oi, err
+		}
+		return fsMeta.ToObjectInfo(bucket, object, fi), nil
 	}
 
 	fsMetaPath := pathJoin(fs.fsPath, minioMetaBucket, bucketMetaPrefix, bucket, object, fs.metaJSONFile)
@@ -602,7 +656,7 @@ func (fs *FSObjects) getObjectInfo(ctx context.Context, bucket, object string) (
 	}
 
 	// Stat the file to get file size.
-	fi, err = fsStatFile(ctx, pathJoin(fs.fsPath, bucket, object))
+	fi, err := fsStatFile(ctx, pathJoin(fs.fsPath, bucket, object))
 	if err != nil {
 		return oi, err
 	}
@@ -627,6 +681,10 @@ func (fs *FSObjects) getObjectInfoWithLock(ctx context.Context, bucket, object s
 		return oi, toObjectErr(err, bucket)
 	}
 
+	if strings.HasSuffix(object, slashSeparator) && !fs.isObjectDir(bucket, object) {
+		return oi, errFileNotFound
+	}
+
 	return fs.getObjectInfo(ctx, bucket, object)
 }
 
@@ -660,7 +718,7 @@ func (fs *FSObjects) parentDirIsObject(ctx context.Context, bucket, parent strin
 		if p == "." || p == "/" {
 			return false
 		}
-		if _, err := fsStatFile(ctx, pathJoin(fs.fsPath, bucket, p)); err == nil {
+		if fsIsFile(ctx, pathJoin(fs.fsPath, bucket, p)) {
 			// If there is already a file at prefix "p", return true.
 			return true
 		}
@@ -890,6 +948,17 @@ func (fs *FSObjects) listDirFactory(isLeaf isLeafFunc) listDirFunc {
 	return listDir
 }
 
+// isObjectDir returns true if the specified bucket & prefix exists
+// and the prefix represents an empty directory. An S3 empty directory
+// is also an empty directory in the FS backend.
+func (fs *FSObjects) isObjectDir(bucket, prefix string) bool {
+	entries, err := readDirN(pathJoin(fs.fsPath, bucket, prefix), 1)
+	if err != nil {
+		return false
+	}
+	return len(entries) == 0
+}
+
 // getObjectETag is a helper function, which returns only the md5sum
 // of the file on the disk.
 func (fs *FSObjects) getObjectETag(ctx context.Context, bucket, entry string, lock bool) (string, error) {
@@ -1019,8 +1088,15 @@ func (fs *FSObjects) ListObjects(ctx context.Context, bucket, prefix, marker, de
 			// object string does not end with "/".
 			return !hasSuffix(object, slashSeparator)
 		}
+		// Return true if the specified object is an empty directory
+		isLeafDir := func(bucket, object string) bool {
+			if !hasSuffix(object, slashSeparator) {
+				return false
+			}
+			return fs.isObjectDir(bucket, object)
+		}
 		listDir := fs.listDirFactory(isLeaf)
-		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, isLeaf, endWalkCh)
+		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, isLeaf, isLeafDir, endWalkCh)
 	}
 
 	var objInfos []ObjectInfo
@@ -1065,7 +1141,7 @@ func (fs *FSObjects) ListObjects(ctx context.Context, bucket, prefix, marker, de
 	result := ListObjectsInfo{IsTruncated: !eof}
 	for _, objInfo := range objInfos {
 		result.NextMarker = objInfo.Name
-		if objInfo.IsDir {
+		if objInfo.IsDir && delimiter == slashSeparator {
 			result.Prefixes = append(result.Prefixes, objInfo.Name)
 			continue
 		}

cmd/gateway-main.go

@@ -33,6 +33,11 @@ import (
 	"github.com/minio/minio/cmd/logger"
 )
 
+func init() {
+	logger.Init(GOPATH)
+	logger.RegisterUIError(fmtError)
+}
+
 var (
 	gatewayCmd = cli.Command{
 		Name:            "gateway",
@@ -102,16 +107,16 @@ func ValidateGatewayArguments(serverAddr, endpointAddr string) error {
 	return nil
 }
 
-func init() {
-	logger.Init(GOPATH)
-}
-
 // StartGateway - handler for 'minio gateway <name>'.
 func StartGateway(ctx *cli.Context, gw Gateway) {
 	if gw == nil {
-		logger.FatalIf(errUnexpected, "Gateway implementation not initialized, exiting.")
+		logger.FatalIf(errUnexpected, "Gateway implementation not initialized")
 	}
 
+	// Disable logging until gateway initialization is complete, any
+	// error during initialization will be shown as a fatal message
+	logger.Disable = true
+
 	// Validate if we have access, secret set through environment.
 	gatewayName := gw.Name()
 	if ctx.Args().First() == "help" {
@@ -152,7 +157,7 @@ func StartGateway(ctx *cli.Context, gw Gateway) {
 	}
 
 	// Create certs path.
-	logger.FatalIf(createConfigDir(), "Unable to create configuration directories.")
+	logger.FatalIf(createConfigDir(), "Unable to create configuration directories")
 
 	// Initialize gateway config.
 	initConfig()
@@ -169,7 +174,7 @@ func StartGateway(ctx *cli.Context, gw Gateway) {
 
 	// Create new notification system.
 	globalNotificationSys, err = NewNotificationSys(globalServerConfig, EndpointList{})
-	logger.FatalIf(err, "Unable to create new notification system.")
+	logger.FatalIf(err, "Unable to create new notification system")
 
 	// Create new policy system.
 	globalPolicySys = NewPolicySys()
@@ -219,5 +224,8 @@ func StartGateway(ctx *cli.Context, gw Gateway) {
 		printGatewayStartupMessage(getAPIEndpoints(gatewayAddr), gatewayName)
 	}
 
+	// Reenable logging
+	logger.Disable = false
+
 	handleSignals()
 }

cmd/gateway/azure/gateway-azure.go

@@ -75,36 +75,32 @@ ENVIRONMENT VARIABLES:
   BROWSER:
      MINIO_BROWSER: To disable web browser access, set this value to "off".
 
+  DOMAIN:
+     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
+
   CACHE:
      MINIO_CACHE_DRIVES: List of mounted drives or directories delimited by ";".
      MINIO_CACHE_EXCLUDE: List of cache exclusion patterns delimited by ";".
      MINIO_CACHE_EXPIRY: Cache expiry duration in days.
 
-  UPDATE:
-     MINIO_UPDATE: To turn off in-place upgrades, set this value to "off".
-
-  DOMAIN:
-     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
-
 EXAMPLES:
   1. Start minio gateway server for Azure Blob Storage backend.
-      $ export MINIO_ACCESS_KEY=azureaccountname
-      $ export MINIO_SECRET_KEY=azureaccountkey
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=azureaccountname
+     $ export MINIO_SECRET_KEY=azureaccountkey
+     $ {{.HelpName}}
 
   2. Start minio gateway server for Azure Blob Storage backend on custom endpoint.
-      $ export MINIO_ACCESS_KEY=azureaccountname
-      $ export MINIO_SECRET_KEY=azureaccountkey
-      $ {{.HelpName}} https://azure.example.com
+     $ export MINIO_ACCESS_KEY=azureaccountname
+     $ export MINIO_SECRET_KEY=azureaccountkey
+     $ {{.HelpName}} https://azure.example.com
 
   3. Start minio gateway server for Azure Blob Storage backend with edge caching enabled.
-      $ export MINIO_ACCESS_KEY=azureaccountname
-      $ export MINIO_SECRET_KEY=azureaccountkey
-      $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
-      $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
-      $ export MINIO_CACHE_EXPIRY=40
-      $ {{.HelpName}}
-
+     $ export MINIO_ACCESS_KEY=azureaccountname
+     $ export MINIO_SECRET_KEY=azureaccountkey
+     $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
+     $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
+     $ export MINIO_CACHE_EXPIRY=40
+     $ {{.HelpName}}
 `
 
 	minio.RegisterGatewayCommand(cli.Command{
@@ -551,7 +547,7 @@ func (a *azureObjects) ListObjects(ctx context.Context, bucket, prefix, marker,
 		}
 
 		for _, blob := range resp.Blobs {
-			if strings.HasPrefix(blob.Name, minio.GatewayMinioSysTmp) {
+			if delimiter == "" && strings.HasPrefix(blob.Name, minio.GatewayMinioSysTmp) {
 				// We filter out minio.GatewayMinioSysTmp entries in the recursive listing.
 				continue
 			}
@@ -572,7 +568,7 @@ func (a *azureObjects) ListObjects(ctx context.Context, bucket, prefix, marker,
 		}
 
 		for _, blobPrefix := range resp.BlobPrefixes {
-			if prefix == minio.GatewayMinioSysTmp {
+			if blobPrefix == minio.GatewayMinioSysTmp {
 				// We don't do strings.HasPrefix(blob.Name, minio.GatewayMinioSysTmp) here so that
 				// we can use tools like mc to inspect the contents of minio.sys.tmp/
 				// It is OK to allow listing of minio.sys.tmp/ in non-recursive mode as it aids in debugging.

cmd/gateway/b2/gateway-b2.go

@@ -65,30 +65,27 @@ ENVIRONMENT VARIABLES:
   BROWSER:
      MINIO_BROWSER: To disable web browser access, set this value to "off".
 
+  DOMAIN:
+     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
+
   CACHE:
      MINIO_CACHE_DRIVES: List of mounted drives or directories delimited by ";".
      MINIO_CACHE_EXCLUDE: List of cache exclusion patterns delimited by ";".
      MINIO_CACHE_EXPIRY: Cache expiry duration in days.
 
-  UPDATE:
-     MINIO_UPDATE: To turn off in-place upgrades, set this value to "off".
-
-  DOMAIN:
-     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
-
 EXAMPLES:
   1. Start minio gateway server for B2 backend.
-      $ export MINIO_ACCESS_KEY=accountID
-      $ export MINIO_SECRET_KEY=applicationKey
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=accountID
+     $ export MINIO_SECRET_KEY=applicationKey
+     $ {{.HelpName}}
 
   2. Start minio gateway server for B2 backend with edge caching enabled.
-      $ export MINIO_ACCESS_KEY=accountID
-      $ export MINIO_SECRET_KEY=applicationKey
-      $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
-      $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
-      $ export MINIO_CACHE_EXPIRY=40
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=accountID
+     $ export MINIO_SECRET_KEY=applicationKey
+     $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
+     $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
+     $ export MINIO_CACHE_EXPIRY=40
+     $ {{.HelpName}}
 `
 	minio.RegisterGatewayCommand(cli.Command{
 		Name:               b2Backend,

cmd/gateway/gcs/gateway-gcs.go

@@ -111,36 +111,33 @@ ENVIRONMENT VARIABLES:
   BROWSER:
      MINIO_BROWSER: To disable web browser access, set this value to "off".
 
+  DOMAIN:
+     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
+
   CACHE:
      MINIO_CACHE_DRIVES: List of mounted drives or directories delimited by ";".
      MINIO_CACHE_EXCLUDE: List of cache exclusion patterns delimited by ";".
      MINIO_CACHE_EXPIRY: Cache expiry duration in days.
 
-  UPDATE:
-     MINIO_UPDATE: To turn off in-place upgrades, set this value to "off".
-
-  DOMAIN:
-     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
-
   GCS credentials file:
      GOOGLE_APPLICATION_CREDENTIALS: Path to credentials.json
 
 EXAMPLES:
   1. Start minio gateway server for GCS backend.
-      $ export GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.json
-      (Instructions to generate credentials : https://developers.google.com/identity/protocols/application-default-credentials)
-      $ export MINIO_ACCESS_KEY=accesskey
-      $ export MINIO_SECRET_KEY=secretkey
-      $ {{.HelpName}} mygcsprojectid
+     $ export GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.json
+     (Instructions to generate credentials : https://developers.google.com/identity/protocols/application-default-credentials)
+     $ export MINIO_ACCESS_KEY=accesskey
+     $ export MINIO_SECRET_KEY=secretkey
+     $ {{.HelpName}} mygcsprojectid
 
   2. Start minio gateway server for GCS backend with edge caching enabled.
-      $ export GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.json
-      $ export MINIO_ACCESS_KEY=accesskey
-      $ export MINIO_SECRET_KEY=secretkey
-      $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
-      $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
-      $ export MINIO_CACHE_EXPIRY=40
-      $ {{.HelpName}} mygcsprojectid
+     $ export GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.json
+     $ export MINIO_ACCESS_KEY=accesskey
+     $ export MINIO_SECRET_KEY=secretkey
+     $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
+     $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
+     $ export MINIO_CACHE_EXPIRY=40
+     $ {{.HelpName}} mygcsprojectid
 `
 
 	minio.RegisterGatewayCommand(cli.Command{

cmd/gateway/manta/gateway-manta.go

@@ -81,28 +81,28 @@ ENVIRONMENT VARIABLES:
 
 EXAMPLES:
   1. Start minio gateway server for Manta Object Storage backend.
-      $ export MINIO_ACCESS_KEY=manta_account_name
-      $ export MINIO_SECRET_KEY=manta_key_id
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=manta_account_name
+     $ export MINIO_SECRET_KEY=manta_key_id
+     $ {{.HelpName}}
 
   2. Start minio gateway server for Manta Object Storage backend on custom endpoint.
-      $ export MINIO_ACCESS_KEY=manta_account_name
-      $ export MINIO_SECRET_KEY=manta_key_id
-      $ {{.HelpName}} https://us-west.manta.joyent.com
+     $ export MINIO_ACCESS_KEY=manta_account_name
+     $ export MINIO_SECRET_KEY=manta_key_id
+     $ {{.HelpName}} https://us-west.manta.joyent.com
 
   3. Start minio gateway server for Manta Object Storage backend without using SSH Agent.
-      $ export MINIO_ACCESS_KEY=manta_account_name
-      $ export MINIO_SECRET_KEY=manta_key_id
-      $ export MANTA_KEY_MATERIAL=~/.ssh/custom_rsa
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=manta_account_name
+     $ export MINIO_SECRET_KEY=manta_key_id
+     $ export MANTA_KEY_MATERIAL=~/.ssh/custom_rsa
+     $ {{.HelpName}}
 
   4. Start minio gateway server for Manta Object Storage backend with edge caching enabled.
-      $ export MINIO_ACCESS_KEY=manta_account_name
-      $ export MINIO_SECRET_KEY=manta_key_id
-      $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
-      $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
-      $ export MINIO_CACHE_EXPIRY=40
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=manta_account_name
+     $ export MINIO_SECRET_KEY=manta_key_id
+     $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
+     $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
+     $ export MINIO_CACHE_EXPIRY=40
+     $ {{.HelpName}}
 `
 
 	minio.RegisterGatewayCommand(cli.Command{

cmd/gateway/nas/gateway-nas.go

@@ -40,7 +40,7 @@ FLAGS:
   {{range .VisibleFlags}}{{.}}
   {{end}}{{end}}
 PATH:
-  path to NAS mount point.
+  Path to NAS mount point.
 
 ENVIRONMENT VARIABLES:
   ACCESS:
@@ -50,30 +50,27 @@ ENVIRONMENT VARIABLES:
   BROWSER:
      MINIO_BROWSER: To disable web browser access, set this value to "off".
 
+  DOMAIN:
+     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
+
   CACHE:
      MINIO_CACHE_DRIVES: List of mounted drives or directories delimited by ";".
      MINIO_CACHE_EXCLUDE: List of cache exclusion patterns delimited by ";".
      MINIO_CACHE_EXPIRY: Cache expiry duration in days.
 
-  UPDATE:
-     MINIO_UPDATE: To turn off in-place upgrades, set this value to "off".
-
-  DOMAIN:
-     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
-
 EXAMPLES:
   1. Start minio gateway server for NAS backend.
-      $ export MINIO_ACCESS_KEY=accesskey
-      $ export MINIO_SECRET_KEY=secretkey
-      $ {{.HelpName}} /shared/nasvol
+     $ export MINIO_ACCESS_KEY=accesskey
+     $ export MINIO_SECRET_KEY=secretkey
+     $ {{.HelpName}} /shared/nasvol
  
   2. Start minio gateway server for NAS with edge caching enabled.
-      $ export MINIO_ACCESS_KEY=accesskey			
-      $ export MINIO_SECRET_KEY=secretkey
-      $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
-      $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
-      $ export MINIO_CACHE_EXPIRY=40
-      $ {{.HelpName}} /shared/nasvol
+     $ export MINIO_ACCESS_KEY=accesskey
+     $ export MINIO_SECRET_KEY=secretkey
+     $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
+     $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
+     $ export MINIO_CACHE_EXPIRY=40
+     $ {{.HelpName}} /shared/nasvol
 `
 
 	minio.RegisterGatewayCommand(cli.Command{

cmd/gateway/oss/gateway-oss.go

@@ -67,9 +67,6 @@ ENVIRONMENT VARIABLES:
   BROWSER:
      MINIO_BROWSER: To disable web browser access, set this value to "off".
 
-  UPDATE:
-     MINIO_UPDATE: To turn off in-place upgrades, set this value to "off".
-
   DOMAIN:
      MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
 	
@@ -80,22 +77,22 @@ ENVIRONMENT VARIABLES:
 
 EXAMPLES:
   1. Start minio gateway server for Aliyun OSS backend.
-      $ export MINIO_ACCESS_KEY=accesskey
-      $ export MINIO_SECRET_KEY=secretkey
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=accesskey
+     $ export MINIO_SECRET_KEY=secretkey
+     $ {{.HelpName}}
 
   2. Start minio gateway server for Aliyun OSS backend on custom endpoint.
-      $ export MINIO_ACCESS_KEY=Q3AM3UQ867SPQQA43P2F
-      $ export MINIO_SECRET_KEY=zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG
-      $ {{.HelpName}} https://oss.example.com
+     $ export MINIO_ACCESS_KEY=Q3AM3UQ867SPQQA43P2F
+     $ export MINIO_SECRET_KEY=zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG
+     $ {{.HelpName}} https://oss.example.com
 
   3. Start minio gateway server for Aliyun OSS backend with edge caching enabled.
-      $ export MINIO_ACCESS_KEY=accesskey
-      $ export MINIO_SECRET_KEY=secretkey
-      $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
-      $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
-      $ export MINIO_CACHE_EXPIRY=40
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=accesskey
+     $ export MINIO_SECRET_KEY=secretkey
+     $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
+     $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
+     $ export MINIO_CACHE_EXPIRY=40
+     $ {{.HelpName}}
 `
 
 	minio.RegisterGatewayCommand(cli.Command{

cmd/gateway/s3/gateway-s3.go

@@ -58,35 +58,32 @@ ENVIRONMENT VARIABLES:
   BROWSER:
      MINIO_BROWSER: To disable web browser access, set this value to "off".
 
+  DOMAIN:
+     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
+
   CACHE:
      MINIO_CACHE_DRIVES: List of mounted drives or directories delimited by ";".
      MINIO_CACHE_EXCLUDE: List of cache exclusion patterns delimited by ";".
      MINIO_CACHE_EXPIRY: Cache expiry duration in days.
 
-  UPDATE:
-     MINIO_UPDATE: To turn off in-place upgrades, set this value to "off".
-
-  DOMAIN:
-     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
-
 EXAMPLES:
   1. Start minio gateway server for AWS S3 backend.
-      $ export MINIO_ACCESS_KEY=accesskey
-      $ export MINIO_SECRET_KEY=secretkey
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=accesskey
+     $ export MINIO_SECRET_KEY=secretkey
+     $ {{.HelpName}}
 
   2. Start minio gateway server for S3 backend on custom endpoint.
-      $ export MINIO_ACCESS_KEY=Q3AM3UQ867SPQQA43P2F
-      $ export MINIO_SECRET_KEY=zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG
-      $ {{.HelpName}} https://play.minio.io:9000
+     $ export MINIO_ACCESS_KEY=Q3AM3UQ867SPQQA43P2F
+     $ export MINIO_SECRET_KEY=zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG
+     $ {{.HelpName}} https://play.minio.io:9000
 
   3. Start minio gateway server for AWS S3 backend with edge caching enabled.
-      $ export MINIO_ACCESS_KEY=accesskey
-      $ export MINIO_SECRET_KEY=secretkey
-      $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
-      $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
-      $ export MINIO_CACHE_EXPIRY=40
-      $ {{.HelpName}}
+     $ export MINIO_ACCESS_KEY=accesskey
+     $ export MINIO_SECRET_KEY=secretkey
+     $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
+     $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
+     $ export MINIO_CACHE_EXPIRY=40
+     $ {{.HelpName}}
 `
 
 	minio.RegisterGatewayCommand(cli.Command{

cmd/gateway/sia/gateway-sia.go

@@ -72,29 +72,26 @@ ENVIRONMENT VARIABLES: (Default values in parenthesis)
   BROWSER:
      MINIO_BROWSER: To disable web browser access, set this value to "off".
 
+  DOMAIN:
+     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
+
   CACHE:
      MINIO_CACHE_DRIVES: List of mounted drives or directories delimited by ";".
      MINIO_CACHE_EXCLUDE: List of cache exclusion patterns delimited by ";".
      MINIO_CACHE_EXPIRY: Cache expiry duration in days.
 
-  UPDATE:
-     MINIO_UPDATE: To turn off in-place upgrades, set this value to "off".
-
-  DOMAIN:
-     MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
-
   SIA_TEMP_DIR:        The name of the local Sia temporary storage directory. (.sia_temp)
   SIA_API_PASSWORD:    API password for Sia daemon. (default is empty)
 
 EXAMPLES:
   1. Start minio gateway server for Sia backend.
-      $ {{.HelpName}}
+     $ {{.HelpName}}
 
   2. Start minio gateway server for Sia backend with edge caching enabled.
-      $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
-      $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
-      $ export MINIO_CACHE_EXPIRY=40
-      $ {{.HelpName}}
+     $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
+     $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
+     $ export MINIO_CACHE_EXPIRY=40
+     $ {{.HelpName}}
 `
 
 	minio.RegisterGatewayCommand(cli.Command{

cmd/generic-handlers.go

@@ -420,6 +420,11 @@ func setIgnoreResourcesHandler(h http.Handler) http.Handler {
 // Checks requests for not implemented Bucket resources
 func ignoreNotImplementedBucketResources(req *http.Request) bool {
 	for name := range req.URL.Query() {
+		// Enable GetBucketACL dummy call specifically.
+		if name == "acl" && req.Method == http.MethodGet {
+			return false
+		}
+
 		if notimplementedBucketResourceNames[name] {
 			return true
 		}
@@ -430,6 +435,10 @@ func ignoreNotImplementedBucketResources(req *http.Request) bool {
 // Checks requests for not implemented Object resources
 func ignoreNotImplementedObjectResources(req *http.Request) bool {
 	for name := range req.URL.Query() {
+		// Enable GetObjectACL dummy call specifically.
+		if name == "acl" && req.Method == http.MethodGet {
+			return false
+		}
 		if notimplementedObjectResourceNames[name] {
 			return true
 		}
@@ -449,6 +458,9 @@ var notimplementedBucketResourceNames = map[string]bool{
 	"requestPayment": true,
 	"versioning":     true,
 	"website":        true,
+	"inventory":      true,
+	"metrics":        true,
+	"accelerate":     true,
 }
 
 // List of not implemented object queries
@@ -456,6 +468,9 @@ var notimplementedObjectResourceNames = map[string]bool{
 	"torrent": true,
 	"acl":     true,
 	"policy":  true,
+	"tagging": true,
+	"restore": true,
+	"select":  true,
 }
 
 // Resource handler ServeHTTP() wrapper

cmd/globals.go

@@ -192,9 +192,12 @@ var (
 
 // global colors.
 var (
-	colorBold   = color.New(color.Bold).SprintFunc()
-	colorBlue   = color.New(color.FgBlue).SprintfFunc()
-	colorYellow = color.New(color.FgYellow).SprintfFunc()
+	colorBold     = color.New(color.Bold).SprintFunc()
+	colorRed      = color.New(color.FgRed).SprintfFunc()
+	colorBlue     = color.New(color.FgBlue).SprintfFunc()
+	colorYellow   = color.New(color.FgYellow).SprintfFunc()
+	colorBgYellow = color.New(color.BgYellow).SprintfFunc()
+	colorBlack    = color.New(color.FgBlack).SprintfFunc()
 )
 
 // Returns minio global information, as a key value map.

cmd/http-stats.go

@@ -190,8 +190,6 @@ func (st *HTTPStats) updateStats(r *http.Request, w *httpResponseRecorder, durat
 			st.successDELETEs.Duration.Add(durationSecs)
 		}
 	}
-	// Increment the prometheus http request count with appropriate label
-	httpRequests.With(prometheus.Labels{"request_type": r.Method}).Inc()
 	// Increment the prometheus http request response histogram with appropriate label
 	httpRequestsDuration.With(prometheus.Labels{"request_type": r.Method}).Observe(durationSecs)
 }

cmd/logger/logger.go

@@ -27,14 +27,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/fatih/color"
 	c "github.com/minio/mc/pkg/console"
-)
-
-// global colors.
-var (
-	colorBold = color.New(color.Bold).SprintFunc()
-	colorRed  = color.New(color.FgRed).SprintfFunc()
+	"golang.org/x/crypto/ssh/terminal"
 )
 
 // Disable disables all logging, false by default. (used for "go test")
@@ -47,9 +41,9 @@ type Level int8
 
 // Enumerated level types
 const (
-	Information Level = iota + 1
-	Error
-	Fatal
+	InformationLvl Level = iota + 1
+	ErrorLvl
+	FatalLvl
 )
 
 const loggerTimeFormat string = "15:04:05 MST 01/02/2006"
@@ -64,11 +58,11 @@ var matchingFuncNames = [...]string{
 func (level Level) String() string {
 	var lvlStr string
 	switch level {
-	case Information:
+	case InformationLvl:
 		lvlStr = "INFO"
-	case Error:
+	case ErrorLvl:
 		lvlStr = "ERROR"
-	case Fatal:
+	case FatalLvl:
 		lvlStr = "FATAL"
 	}
 	return lvlStr
@@ -82,10 +76,9 @@ type Console interface {
 }
 
 func consoleLog(console Console, msg string, args ...interface{}) {
-	if Disable {
-		return
-	}
 	if jsonFlag {
+		// Strip escape control characters from json message
+		msg = ansiRE.ReplaceAllLiteralString(msg, "")
 		console.json(msg, args...)
 	} else if quiet {
 		console.quiet(msg, args...)
@@ -124,6 +117,8 @@ type logEntry struct {
 // jsonFlag: Display in JSON format, if enabled
 var (
 	quiet, jsonFlag bool
+	// Custom function to format error
+	errorFmtFunc func(string, error, bool) string
 )
 
 // EnableQuiet - turns quiet option on.
@@ -137,11 +132,18 @@ func EnableJSON() {
 	quiet = true
 }
 
+// RegisterUIError registers the specified rendering function. This latter
+// will be called for a pretty rendering of fatal errors.
+func RegisterUIError(f func(string, error, bool) string) {
+	errorFmtFunc = f
+}
+
 // Init sets the trimStrings to possible GOPATHs
 // and GOROOT directories. Also append github.com/minio/minio
 // This is done to clean up the filename, when stack trace is
 // displayed when an error happens.
 func Init(goPath string) {
+
 	var goPathList []string
 	var defaultgoPathList []string
 	// Add all possible GOPATH paths into trimStrings
@@ -182,8 +184,8 @@ func trimTrace(f string) string {
 	return filepath.FromSlash(f)
 }
 
-func getSource() string {
-	pc, file, lineNumber, ok := runtime.Caller(5)
+func getSource(level int) string {
+	pc, file, lineNumber, ok := runtime.Caller(level)
 	if ok {
 		// Clean up the common prefixes
 		file = trimTrace(file)
@@ -225,7 +227,8 @@ func getTrace(traceLevel int) []string {
 	return trace
 }
 
-// LogIf :
+// LogIf prints a detailed error message during
+// the execution of the server.
 func LogIf(ctx context.Context, err error) {
 	if Disable {
 		return
@@ -251,15 +254,17 @@ func LogIf(ctx context.Context, err error) {
 		tags[entry.Key] = entry.Val
 	}
 
-	// Get the cause for the Error
-	message := err.Error()
 	// Get full stack trace
 	trace := getTrace(2)
+
+	// Get the cause for the Error
+	message := err.Error()
+
 	// Output the formatted log message at console
 	var output string
 	if jsonFlag {
 		logJSON, err := json.Marshal(&logEntry{
-			Level:      Error.String(),
+			Level:      ErrorLvl.String(),
 			RemoteHost: req.RemoteHost,
 			RequestID:  req.RequestID,
 			UserAgent:  req.UserAgent,
@@ -317,9 +322,10 @@ func LogIf(ctx context.Context, err error) {
 			tagString = "\n       " + tagString
 		}
 
+		var msg = colorFgRed(colorBold(message))
 		output = fmt.Sprintf("\n%s\n%s%s%s%s\nError: %s%s\n%s",
 			apiString, timeString, requestID, remoteHost, userAgent,
-			colorRed(colorBold(message)), tagString, strings.Join(trace, "\n"))
+			msg, tagString, strings.Join(trace, "\n"))
 	}
 	fmt.Println(output)
 }
@@ -334,17 +340,28 @@ func CriticalIf(ctx context.Context, err error) {
 	}
 }
 
-// FatalIf :
-// Just fatal error message, no stack trace
-// It'll be called for input validation failures
+// FatalIf is similar to Fatal() but it ignores passed nil error
 func FatalIf(err error, msg string, data ...interface{}) {
-	if err != nil {
-		if msg != "" {
-			consoleLog(fatalMessage, msg, data...)
-		} else {
-			consoleLog(fatalMessage, err.Error())
-		}
+	if err == nil {
+		return
 	}
+	fatal(err, msg, data...)
+}
+
+// Fatal prints only fatal error message without no stack trace
+// it will be called for input validation failures
+func Fatal(err error, msg string, data ...interface{}) {
+	fatal(err, msg, data...)
+}
+
+func fatal(err error, msg string, data ...interface{}) {
+	var errMsg string
+	if msg != "" {
+		errMsg = errorFmtFunc(fmt.Sprintf(msg, data...), err, jsonFlag)
+	} else {
+		errMsg = err.Error()
+	}
+	consoleLog(fatalMessage, errMsg)
 }
 
 var fatalMessage fatalMsg
@@ -354,14 +371,15 @@ type fatalMsg struct {
 
 func (f fatalMsg) json(msg string, args ...interface{}) {
 	logJSON, err := json.Marshal(&logEntry{
-		Level: Fatal.String(),
+		Level: FatalLvl.String(),
 		Time:  time.Now().UTC().Format(time.RFC3339Nano),
-		Trace: &traceEntry{Message: fmt.Sprintf(msg, args...), Source: []string{getSource()}},
+		Trace: &traceEntry{Message: fmt.Sprintf(msg, args...), Source: []string{getSource(6)}},
 	})
 	if err != nil {
 		panic(err)
 	}
 	fmt.Println(string(logJSON))
+
 	os.Exit(1)
 
 }
@@ -370,9 +388,65 @@ func (f fatalMsg) quiet(msg string, args ...interface{}) {
 	f.pretty(msg, args...)
 }
 
+var (
+	logTag       = "ERROR"
+	logBanner    = colorBgRed(colorFgWhite(colorBold(logTag))) + " "
+	emptyBanner  = colorBgRed(strings.Repeat(" ", len(logTag))) + " "
+	minimumWidth = 80
+	bannerWidth  = len(logTag) + 1
+)
+
 func (f fatalMsg) pretty(msg string, args ...interface{}) {
+	// Build the passed error message
 	errMsg := fmt.Sprintf(msg, args...)
-	fmt.Println(colorRed(colorBold("Error: " + errMsg)))
+	// Check terminal width
+	termWidth, _, err := terminal.GetSize(0)
+	if err != nil || termWidth < minimumWidth {
+		termWidth = minimumWidth
+	}
+	// Calculate available widht without the banner
+	width := termWidth - bannerWidth
+
+	tagPrinted := false
+
+	// Print the error message: the following code takes care
+	// of splitting error text and always pretty printing the
+	// red banner along with the error message. Since the error
+	// message itself contains some colored text, we needed
+	// to use some ANSI control escapes to cursor color state
+	// and freely move in the screen.
+	for _, line := range strings.Split(errMsg, "\n") {
+		if len(line) == 0 {
+			// No more text to print, just quit.
+			break
+		}
+
+		for {
+			// Save the attributes of the current cursor helps
+			// us save the text color of the passed error message
+			ansiSaveAttributes()
+			// Print banner with or without the log tag
+			if !tagPrinted {
+				fmt.Print(logBanner)
+				tagPrinted = true
+			} else {
+				fmt.Print(emptyBanner)
+			}
+			// Restore the text color of the error message
+			ansiRestoreAttributes()
+			ansiMoveRight(bannerWidth)
+			// Continue  error message printing
+			if len(line) > width {
+				fmt.Println(line[:width])
+				line = line[width:]
+			} else {
+				fmt.Println(line)
+				break
+			}
+		}
+	}
+
+	// Exit because this is a fatal error message
 	os.Exit(1)
 }
 
@@ -383,7 +457,7 @@ type infoMsg struct {
 
 func (i infoMsg) json(msg string, args ...interface{}) {
 	logJSON, err := json.Marshal(&logEntry{
-		Level:   Information.String(),
+		Level:   InformationLvl.String(),
 		Message: fmt.Sprintf(msg, args...),
 		Time:    time.Now().UTC().Format(time.RFC3339Nano),
 	})

cmd/logger/logonce.go

@@ -0,0 +1,82 @@
+/*
+ * Minio Cloud Storage, (C) 2018 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 logger
+
+import (
+	"context"
+	"sync"
+
+	"time"
+)
+
+// Holds a map of recently logged errors.
+type logOnceType struct {
+	IDMap map[interface{}]error
+	sync.Mutex
+}
+
+// One log message per error.
+func (l *logOnceType) logOnceIf(ctx context.Context, err error, id interface{}) {
+	if err == nil {
+		return
+	}
+	l.Lock()
+	shouldLog := false
+	prevErr := l.IDMap[id]
+	if prevErr == nil {
+		l.IDMap[id] = err
+		shouldLog = true
+	} else {
+		if prevErr.Error() != err.Error() {
+			l.IDMap[id] = err
+			shouldLog = true
+		}
+	}
+	l.Unlock()
+
+	if shouldLog {
+		LogIf(ctx, err)
+	}
+}
+
+// Cleanup the map every 30 minutes so that the log message is printed again for the user to notice.
+func (l *logOnceType) cleanupRoutine() {
+	for {
+		select {
+		case <-time.After(time.Minute * 30):
+			l.Lock()
+			l.IDMap = make(map[interface{}]error)
+			l.Unlock()
+		}
+	}
+}
+
+// Returns logOnceType
+func newLogOnceType() *logOnceType {
+	l := &logOnceType{IDMap: make(map[interface{}]error)}
+	go l.cleanupRoutine()
+	return l
+}
+
+var logOnce = newLogOnceType()
+
+// LogOnceIf - Logs notification errors - once per error.
+// id is a unique identifier for related log messages, refer to cmd/notification.go
+// on how it is used.
+func LogOnceIf(ctx context.Context, err error, id interface{}) {
+	logOnce.logOnceIf(ctx, err, id)
+}

cmd/logger/utils.go

@@ -0,0 +1,52 @@
+/*
+ * Minio Cloud Storage, (C) 2018 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 logger
+
+import (
+	"fmt"
+	"regexp"
+
+	"github.com/fatih/color"
+)
+
+// Global colors.
+var (
+	colorBold    = color.New(color.Bold).SprintFunc()
+	colorFgRed   = color.New(color.FgRed).SprintfFunc()
+	colorBgRed   = color.New(color.BgRed).SprintfFunc()
+	colorFgWhite = color.New(color.FgWhite).SprintfFunc()
+)
+
+var ansiRE = regexp.MustCompile("(\x1b[^m]*m)")
+
+// Print ANSI Control escape
+func ansiEscape(format string, args ...interface{}) {
+	var Esc = "\x1b"
+	fmt.Printf("%s%s", Esc, fmt.Sprintf(format, args...))
+}
+
+func ansiMoveRight(n int) {
+	ansiEscape("[%dC", n)
+}
+
+func ansiSaveAttributes() {
+	ansiEscape("7")
+}
+
+func ansiRestoreAttributes() {
+	ansiEscape("8")
+}

cmd/metrics-router.go

@@ -17,8 +17,7 @@
 package cmd
 
 import (
-	router "github.com/gorilla/mux"
-	"github.com/prometheus/client_golang/prometheus"
+	"github.com/gorilla/mux"
 )
 
 const (
@@ -26,8 +25,8 @@ const (
 )
 
 // registerMetricsRouter - add handler functions for metrics.
-func registerMetricsRouter(mux *router.Router) {
+func registerMetricsRouter(router *mux.Router) {
 	// metrics router
-	metricsRouter := mux.NewRoute().PathPrefix(minioReservedBucketPath).Subrouter()
-	metricsRouter.Handle(prometheusMetricsPath, metricsHandler(prometheus.Handler()))
+	metricsRouter := router.NewRoute().PathPrefix(minioReservedBucketPath).Subrouter()
+	metricsRouter.Handle(prometheusMetricsPath, metricsHandler())
 }

cmd/metrics.go

@@ -20,17 +20,12 @@ import (
 	"context"
 	"net/http"
 
+	"github.com/minio/minio/cmd/logger"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
 var (
-	httpRequests = prometheus.NewCounterVec(
-		prometheus.CounterOpts{
-			Name: "minio_http_requests_total",
-			Help: "Total number of requests served by current Minio server instance",
-		},
-		[]string{"request_type"},
-	)
 	httpRequestsDuration = prometheus.NewHistogramVec(
 		prometheus.HistogramOpts{
 			Name:    "minio_http_requests_duration_seconds",
@@ -39,65 +34,35 @@ var (
 		},
 		[]string{"request_type"},
 	)
-	networkSentBytes = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "minio_network_sent_bytes",
-			Help: "Total number of bytes sent by current Minio server instance",
-		},
-	)
-	networkReceivedBytes = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "minio_network_received_bytes",
-			Help: "Total number of bytes received by current Minio server instance",
-		},
-	)
-	onlineMinioDisks = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "minio_online_disks_total",
-			Help: "Total number of online disks for current Minio server instance",
-		},
-	)
-	offlineMinioDisks = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "minio_offline_disks_total",
-			Help: "Total number of offline disks for current Minio server instance",
-		},
-	)
-	serverUptime = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "minio_server_uptime_seconds",
-			Help: "Time elapsed since current Minio server instance started",
-		},
-	)
-	minioStorageTotal = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "minio_disk_storage_bytes",
-			Help: "Total disk storage available to current Minio server instance",
-		},
-	)
-	minioStorageFree = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "minio_disk_storage_free_bytes",
-			Help: "Total free disk storage available to current Minio server instance",
-		},
-	)
 )
 
 func init() {
-	prometheus.MustRegister(httpRequests)
 	prometheus.MustRegister(httpRequestsDuration)
-	prometheus.MustRegister(networkSentBytes)
-	prometheus.MustRegister(networkReceivedBytes)
-	prometheus.MustRegister(onlineMinioDisks)
-	prometheus.MustRegister(offlineMinioDisks)
-	prometheus.MustRegister(serverUptime)
-	prometheus.MustRegister(minioStorageTotal)
-	prometheus.MustRegister(minioStorageFree)
+	prometheus.MustRegister(newMinioCollector())
 }
 
-func updateGeneralMetrics() {
-	// Increment server uptime
-	serverUptime.Set(UTCNow().Sub(globalBootTime).Seconds())
+// newMinioCollector describes the collector
+// and returns reference of minioCollector
+// It creates the Prometheus Description which is used
+// to define metric and  help string
+func newMinioCollector() *minioCollector {
+	return &minioCollector{
+		desc: prometheus.NewDesc("minio_stats", "Statistics exposed by Minio server", nil, nil),
+	}
+}
+
+// minioCollector is the Custom Collector
+type minioCollector struct {
+	desc *prometheus.Desc
+}
+
+// Describe sends the super-set of all possible descriptors of metrics
+func (c *minioCollector) Describe(ch chan<- *prometheus.Desc) {
+	ch <- c.desc
+}
+
+// Collect is called by the Prometheus registry when collecting metrics.
+func (c *minioCollector) Collect(ch chan<- prometheus.Metric) {
 
 	// Fetch disk space info
 	objLayer := newObjectLayerFn()
@@ -105,25 +70,92 @@ func updateGeneralMetrics() {
 	if objLayer == nil {
 		return
 	}
-
-	// Update total/free disk space
 	s := objLayer.StorageInfo(context.Background())
-	minioStorageTotal.Set(float64(s.Total))
-	minioStorageFree.Set(float64(s.Free))
 
-	// Update online/offline disks
-	onlineMinioDisks.Set(float64(s.Backend.OnlineDisks))
-	offlineMinioDisks.Set(float64(s.Backend.OfflineDisks))
+	var totalDisks, offlineDisks int
+	// Setting totalDisks to 1 and offlineDisks to 0 in FS mode
+	if s.Backend.Type == FS {
+		totalDisks = 1
+		offlineDisks = 0
+	} else {
+		offlineDisks = s.Backend.OfflineDisks
+		totalDisks = s.Backend.OfflineDisks + s.Backend.OnlineDisks
+	}
 
-	// Update prometheus metric
-	networkSentBytes.Set(float64(globalConnStats.getTotalOutputBytes()))
-	networkReceivedBytes.Set(float64(globalConnStats.getTotalInputBytes()))
+	// Network Sent/Received Bytes
+	ch <- prometheus.MustNewConstMetric(
+		prometheus.NewDesc(
+			prometheus.BuildFQName("minio", "network", "sent_bytes_total"),
+			"Total number of bytes sent by current Minio server instance",
+			nil, nil),
+		prometheus.CounterValue,
+		float64(globalConnStats.getTotalOutputBytes()),
+	)
+	ch <- prometheus.MustNewConstMetric(
+		prometheus.NewDesc(
+			prometheus.BuildFQName("minio", "network", "received_bytes_total"),
+			"Total number of bytes received by current Minio server instance",
+			nil, nil),
+		prometheus.CounterValue,
+		float64(globalConnStats.getTotalInputBytes()),
+	)
+
+	// Total/Free Storage Bytes
+	ch <- prometheus.MustNewConstMetric(
+		prometheus.NewDesc(
+			prometheus.BuildFQName("minio", "disk", "storage_bytes"),
+			"Total disk storage available to current Minio server instance",
+			nil, nil),
+		prometheus.GaugeValue,
+		float64(s.Total),
+	)
+	ch <- prometheus.MustNewConstMetric(
+		prometheus.NewDesc(
+			prometheus.BuildFQName("minio", "disk", "storage_free_bytes"),
+			"Total free disk storage available to current Minio server instance",
+			nil, nil),
+		prometheus.GaugeValue,
+		float64(s.Free),
+	)
+
+	// Minio Total Disk/Offline Disk
+	ch <- prometheus.MustNewConstMetric(
+		prometheus.NewDesc(
+			prometheus.BuildFQName("minio", "total", "disks"),
+			"Total number of disks for current Minio server instance",
+			nil, nil),
+		prometheus.GaugeValue,
+		float64(totalDisks),
+	)
+	ch <- prometheus.MustNewConstMetric(
+		prometheus.NewDesc(
+			prometheus.BuildFQName("minio", "offline", "disks"),
+			"Total number of offline disks for current Minio server instance",
+			nil, nil),
+		prometheus.GaugeValue,
+		float64(offlineDisks),
+	)
 }
 
-func metricsHandler(h http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Update generic metrics before handling the prometheus scrape request
-		updateGeneralMetrics()
-		prometheus.Handler().ServeHTTP(w, r)
-	})
+func metricsHandler() http.Handler {
+	registry := prometheus.NewRegistry()
+
+	err := registry.Register(httpRequestsDuration)
+	logger.LogIf(context.Background(), err)
+
+	err = registry.Register(newMinioCollector())
+	logger.LogIf(context.Background(), err)
+
+	gatherers := prometheus.Gatherers{
+		prometheus.DefaultGatherer,
+		registry,
+	}
+	// Delegate http serving to Prometheus client library, which will call collector.Collect.
+	return promhttp.InstrumentMetricHandler(
+		registry,
+		promhttp.HandlerFor(gatherers,
+			promhttp.HandlerOpts{
+				ErrorHandling: promhttp.ContinueOnError,
+			}),
+	)
 }

cmd/naughty-disk_test.go

@@ -18,8 +18,6 @@ package cmd
 
 import (
 	"sync"
-
-	"github.com/minio/minio/pkg/disk"
 )
 
 // naughtyDisk wraps a POSIX disk and returns programmed errors
@@ -74,7 +72,7 @@ func (d *naughtyDisk) calcError() (err error) {
 	return nil
 }
 
-func (d *naughtyDisk) DiskInfo() (info disk.Info, err error) {
+func (d *naughtyDisk) DiskInfo() (info DiskInfo, err error) {
 	if err := d.calcError(); err != nil {
 		return info, err
 	}
@@ -108,11 +106,11 @@ func (d *naughtyDisk) DeleteVol(volume string) (err error) {
 	return d.disk.DeleteVol(volume)
 }
 
-func (d *naughtyDisk) ListDir(volume, path string) (entries []string, err error) {
+func (d *naughtyDisk) ListDir(volume, path string, count int) (entries []string, err error) {
 	if err := d.calcError(); err != nil {
 		return []string{}, err
 	}
-	return d.disk.ListDir(volume, path)
+	return d.disk.ListDir(volume, path, count)
 }
 
 func (d *naughtyDisk) ReadFile(volume string, path string, offset int64, buf []byte, verifier *BitrotVerifier) (n int64, err error) {

cmd/net.go

@@ -48,7 +48,7 @@ func mustSplitHostPort(hostPort string) (host, port string) {
 func mustGetLocalIP4() (ipList set.StringSet) {
 	ipList = set.NewStringSet()
 	addrs, err := net.InterfaceAddrs()
-	logger.FatalIf(err, "Unable to get IP addresses of this host.")
+	logger.FatalIf(err, "Unable to get IP addresses of this host")
 
 	for _, addr := range addrs {
 		var ip net.IP
@@ -352,15 +352,15 @@ func sameLocalAddrs(addr1, addr2 string) (bool, error) {
 func CheckLocalServerAddr(serverAddr string) error {
 	host, port, err := net.SplitHostPort(serverAddr)
 	if err != nil {
-		return err
+		return uiErrInvalidAddressFlag(err)
 	}
 
 	// Check whether port is a valid port number.
 	p, err := strconv.Atoi(port)
 	if err != nil {
-		return fmt.Errorf("invalid port number")
+		return uiErrInvalidAddressFlag(err).Msg("invalid port number")
 	} else if p < 1 || p > 65535 {
-		return fmt.Errorf("port number must be between 1 to 65535")
+		return uiErrInvalidAddressFlag(nil).Msg("port number must be between 1 to 65535")
 	}
 
 	// 0.0.0.0 is a wildcard address and refers to local network
@@ -372,7 +372,7 @@ func CheckLocalServerAddr(serverAddr string) error {
 			return err
 		}
 		if !isLocalHost {
-			return fmt.Errorf("host in server address should be this server")
+			return uiErrInvalidAddressFlag(nil).Msg("host in server address should be this server")
 		}
 	}
 

cmd/notification.go

@@ -59,94 +59,136 @@ func (sys *NotificationSys) GetPeerRPCClient(addr xnet.Host) *PeerRPCClient {
 	return sys.peerRPCClientMap[addr]
 }
 
-// DeleteBucket - calls DeleteBucket RPC call on all peers.
-func (sys *NotificationSys) DeleteBucket(bucketName string) map[xnet.Host]error {
-	errors := make(map[xnet.Host]error)
-	var wg sync.WaitGroup
-	for addr, client := range sys.peerRPCClientMap {
-		wg.Add(1)
-		go func(addr xnet.Host, client *PeerRPCClient) {
-			defer wg.Done()
-			if err := client.DeleteBucket(bucketName); err != nil {
-				errors[addr] = err
-			}
-		}(addr, client)
-	}
-	wg.Wait()
+// NotificationPeerErr returns error associated for a remote peer.
+type NotificationPeerErr struct {
+	Host xnet.Host // Remote host on which the rpc call was initiated
+	Err  error     // Error returned by the remote peer for an rpc call
+}
 
-	return errors
+// DeleteBucket - calls DeleteBucket RPC call on all peers.
+func (sys *NotificationSys) DeleteBucket(bucketName string) <-chan NotificationPeerErr {
+	errCh := make(chan NotificationPeerErr)
+	go func() {
+		defer close(errCh)
+
+		var wg sync.WaitGroup
+		for addr, client := range sys.peerRPCClientMap {
+			wg.Add(1)
+			go func(addr xnet.Host, client *PeerRPCClient) {
+				defer wg.Done()
+				if err := client.DeleteBucket(bucketName); err != nil {
+					errCh <- NotificationPeerErr{
+						Host: addr,
+						Err:  err,
+					}
+				}
+			}(addr, client)
+		}
+		wg.Wait()
+	}()
+
+	return errCh
 }
 
 // SetBucketPolicy - calls SetBucketPolicy RPC call on all peers.
-func (sys *NotificationSys) SetBucketPolicy(bucketName string, bucketPolicy *policy.Policy) map[xnet.Host]error {
-	errors := make(map[xnet.Host]error)
-	var wg sync.WaitGroup
-	for addr, client := range sys.peerRPCClientMap {
-		wg.Add(1)
-		go func(addr xnet.Host, client *PeerRPCClient) {
-			defer wg.Done()
-			if err := client.SetBucketPolicy(bucketName, bucketPolicy); err != nil {
-				errors[addr] = err
-			}
-		}(addr, client)
-	}
-	wg.Wait()
+func (sys *NotificationSys) SetBucketPolicy(bucketName string, bucketPolicy *policy.Policy) <-chan NotificationPeerErr {
+	errCh := make(chan NotificationPeerErr)
+	go func() {
+		defer close(errCh)
 
-	return errors
+		var wg sync.WaitGroup
+		for addr, client := range sys.peerRPCClientMap {
+			wg.Add(1)
+			go func(addr xnet.Host, client *PeerRPCClient) {
+				defer wg.Done()
+				if err := client.SetBucketPolicy(bucketName, bucketPolicy); err != nil {
+					errCh <- NotificationPeerErr{
+						Host: addr,
+						Err:  err,
+					}
+				}
+			}(addr, client)
+		}
+		wg.Wait()
+	}()
+
+	return errCh
 }
 
 // RemoveBucketPolicy - calls RemoveBucketPolicy RPC call on all peers.
-func (sys *NotificationSys) RemoveBucketPolicy(bucketName string) map[xnet.Host]error {
-	errors := make(map[xnet.Host]error)
-	var wg sync.WaitGroup
-	for addr, client := range sys.peerRPCClientMap {
-		wg.Add(1)
-		go func(addr xnet.Host, client *PeerRPCClient) {
-			defer wg.Done()
-			if err := client.RemoveBucketPolicy(bucketName); err != nil {
-				errors[addr] = err
-			}
-		}(addr, client)
-	}
-	wg.Wait()
+func (sys *NotificationSys) RemoveBucketPolicy(bucketName string) <-chan NotificationPeerErr {
+	errCh := make(chan NotificationPeerErr)
+	go func() {
+		defer close(errCh)
 
-	return errors
+		var wg sync.WaitGroup
+		for addr, client := range sys.peerRPCClientMap {
+			wg.Add(1)
+			go func(addr xnet.Host, client *PeerRPCClient) {
+				defer wg.Done()
+				if err := client.RemoveBucketPolicy(bucketName); err != nil {
+					errCh <- NotificationPeerErr{
+						Host: addr,
+						Err:  err,
+					}
+				}
+			}(addr, client)
+		}
+		wg.Wait()
+	}()
+
+	return errCh
 }
 
 // PutBucketNotification - calls PutBucketNotification RPC call on all peers.
-func (sys *NotificationSys) PutBucketNotification(bucketName string, rulesMap event.RulesMap) map[xnet.Host]error {
-	errors := make(map[xnet.Host]error)
-	var wg sync.WaitGroup
-	for addr, client := range sys.peerRPCClientMap {
-		wg.Add(1)
-		go func(addr xnet.Host, client *PeerRPCClient, rulesMap event.RulesMap) {
-			defer wg.Done()
-			if err := client.PutBucketNotification(bucketName, rulesMap); err != nil {
-				errors[addr] = err
-			}
-		}(addr, client, rulesMap.Clone())
-	}
-	wg.Wait()
+func (sys *NotificationSys) PutBucketNotification(bucketName string, rulesMap event.RulesMap) <-chan NotificationPeerErr {
+	errCh := make(chan NotificationPeerErr)
+	go func() {
+		defer close(errCh)
 
-	return errors
+		var wg sync.WaitGroup
+		for addr, client := range sys.peerRPCClientMap {
+			wg.Add(1)
+			go func(addr xnet.Host, client *PeerRPCClient, rulesMap event.RulesMap) {
+				defer wg.Done()
+				if err := client.PutBucketNotification(bucketName, rulesMap); err != nil {
+					errCh <- NotificationPeerErr{
+						Host: addr,
+						Err:  err,
+					}
+				}
+			}(addr, client, rulesMap.Clone())
+		}
+		wg.Wait()
+	}()
+
+	return errCh
 }
 
 // ListenBucketNotification - calls ListenBucketNotification RPC call on all peers.
-func (sys *NotificationSys) ListenBucketNotification(bucketName string, eventNames []event.Name, pattern string, targetID event.TargetID, localPeer xnet.Host) map[xnet.Host]error {
-	errors := make(map[xnet.Host]error)
-	var wg sync.WaitGroup
-	for addr, client := range sys.peerRPCClientMap {
-		wg.Add(1)
-		go func(addr xnet.Host, client *PeerRPCClient) {
-			defer wg.Done()
-			if err := client.ListenBucketNotification(bucketName, eventNames, pattern, targetID, localPeer); err != nil {
-				errors[addr] = err
-			}
-		}(addr, client)
-	}
-	wg.Wait()
+func (sys *NotificationSys) ListenBucketNotification(bucketName string, eventNames []event.Name, pattern string,
+	targetID event.TargetID, localPeer xnet.Host) <-chan NotificationPeerErr {
+	errCh := make(chan NotificationPeerErr)
+	go func() {
+		defer close(errCh)
 
-	return errors
+		var wg sync.WaitGroup
+		for addr, client := range sys.peerRPCClientMap {
+			wg.Add(1)
+			go func(addr xnet.Host, client *PeerRPCClient) {
+				defer wg.Done()
+				if err := client.ListenBucketNotification(bucketName, eventNames, pattern, targetID, localPeer); err != nil {
+					errCh <- NotificationPeerErr{
+						Host: addr,
+						Err:  err,
+					}
+				}
+			}(addr, client)
+		}
+		wg.Wait()
+	}()
+
+	return errCh
 }
 
 // AddRemoteTarget - adds event rules map, HTTP/PeerRPC client target to bucket name.
@@ -350,10 +392,10 @@ func (sys *NotificationSys) RemoveAllRemoteTargets() {
 
 // RemoveRemoteTarget - closes and removes target by target ID.
 func (sys *NotificationSys) RemoveRemoteTarget(bucketName string, targetID event.TargetID) {
-	for id, err := range sys.targetList.Remove(targetID) {
-		reqInfo := (&logger.ReqInfo{}).AppendTags("targetID", id.Name)
+	for terr := range sys.targetList.Remove(targetID) {
+		reqInfo := (&logger.ReqInfo{}).AppendTags("targetID", terr.ID.Name)
 		ctx := logger.SetReqInfo(context.Background(), reqInfo)
-		logger.LogIf(ctx, err)
+		logger.LogIf(ctx, terr.Err)
 	}
 
 	sys.Lock()
@@ -367,19 +409,20 @@ func (sys *NotificationSys) RemoveRemoteTarget(bucketName string, targetID event
 	}
 }
 
-func (sys *NotificationSys) send(bucketName string, eventData event.Event, targetIDs ...event.TargetID) map[event.TargetID]error {
-	errMap := sys.targetList.Send(eventData, targetIDs...)
-	for targetID := range errMap {
-		if sys.RemoteTargetExist(bucketName, targetID) {
-			sys.RemoveRemoteTarget(bucketName, targetID)
+func (sys *NotificationSys) send(bucketName string, eventData event.Event, targetIDs ...event.TargetID) (errs []event.TargetIDErr) {
+	errCh := sys.targetList.Send(eventData, targetIDs...)
+	for terr := range errCh {
+		errs = append(errs, terr)
+		if sys.RemoteTargetExist(bucketName, terr.ID) {
+			sys.RemoveRemoteTarget(bucketName, terr.ID)
 		}
 	}
 
-	return errMap
+	return errs
 }
 
 // Send - sends event data to all matching targets.
-func (sys *NotificationSys) Send(args eventArgs) map[event.TargetID]error {
+func (sys *NotificationSys) Send(args eventArgs) []event.TargetIDErr {
 	sys.RLock()
 	targetIDSet := sys.bucketRulesMap[args.BucketName].Match(args.EventName, args.Object.Name)
 	sys.RUnlock()
@@ -484,12 +527,12 @@ func sendEvent(args eventArgs) {
 		return
 	}
 
-	for targetID, err := range globalNotificationSys.Send(args) {
+	for _, err := range globalNotificationSys.Send(args) {
 		reqInfo := &logger.ReqInfo{BucketName: args.BucketName, ObjectName: args.Object.Name}
 		reqInfo.AppendTags("EventName", args.EventName.String())
-		reqInfo.AppendTags("targetID", targetID.Name)
+		reqInfo.AppendTags("targetID", err.ID.Name)
 		ctx := logger.SetReqInfo(context.Background(), reqInfo)
-		logger.LogIf(ctx, err)
+		logger.LogOnceIf(ctx, err.Err, err.ID)
 	}
 }
 

cmd/object-api-common.go

@@ -116,7 +116,7 @@ func cleanupDir(ctx context.Context, storage StorageAPI, volume, dirPath string)
 		}
 
 		// If it's a directory, list and call delFunc() for each entry.
-		entries, err := storage.ListDir(volume, entryPath)
+		entries, err := storage.ListDir(volume, entryPath, -1)
 		// If entryPath prefix never existed, safe to ignore.
 		if err == errFileNotFound {
 			return nil

cmd/object-api-datatypes.go

@@ -39,10 +39,10 @@ const (
 
 // StorageInfo - represents total capacity of underlying storage.
 type StorageInfo struct {
-	// Total disk space.
-	Total uint64
-	// Free available disk space.
-	Free uint64
+	Total uint64 // Total disk space.
+	Free  uint64 // Free available space.
+	Used  uint64 // Used total used per tenant.
+
 	// Backend type.
 	Backend struct {
 		// Represents various backend types, currently on FS and Erasure.

cmd/peer-rpc.go

@@ -163,18 +163,12 @@ func (receiver *PeerRPCReceiver) SendEvent(args *SendEventArgs, reply *SendEvent
 	}
 
 	var err error
-	if errMap := globalNotificationSys.send(args.BucketName, args.Event, args.TargetID); len(errMap) != 0 {
-		var found bool
-		if err, found = errMap[args.TargetID]; !found {
-			return fmt.Errorf("error for target %v not found in error map %+v", args.TargetID, errMap)
-		}
-	}
-
-	if err != nil {
+	for _, terr := range globalNotificationSys.send(args.BucketName, args.Event, args.TargetID) {
 		reqInfo := (&logger.ReqInfo{}).AppendTags("Event", args.Event.EventName.String())
 		reqInfo.AppendTags("targetName", args.TargetID.Name)
 		ctx := logger.SetReqInfo(context.Background(), reqInfo)
-		logger.LogIf(ctx, err)
+		logger.LogIf(ctx, terr.Err)
+		err = terr.Err
 	}
 
 	reply.Error = err

cmd/posix-list-dir-nix.go

@@ -112,6 +112,12 @@ var readDirBufPool = sync.Pool{
 
 // Return all the entries at the directory dirPath.
 func readDir(dirPath string) (entries []string, err error) {
+	return readDirN(dirPath, -1)
+}
+
+// Return count entries at the directory dirPath and all entries
+// if count is set to -1
+func readDirN(dirPath string, count int) (entries []string, err error) {
 	bufp := readDirBufPool.Get().(*[]byte)
 	buf := *bufp
 	defer readDirBufPool.Put(bufp)
@@ -135,7 +141,11 @@ func readDir(dirPath string) (entries []string, err error) {
 	defer d.Close()
 
 	fd := int(d.Fd())
-	for {
+
+	remaining := count
+	done := false
+
+	for !done {
 		nbuf, err := syscall.ReadDirent(fd, buf)
 		if err != nil {
 			return nil, err
@@ -147,6 +157,13 @@ func readDir(dirPath string) (entries []string, err error) {
 		if tmpEntries, err = parseDirents(dirPath, buf[:nbuf]); err != nil {
 			return nil, err
 		}
+		if count > 0 {
+			if remaining <= len(tmpEntries) {
+				tmpEntries = tmpEntries[:remaining]
+				done = true
+			}
+			remaining -= len(tmpEntries)
+		}
 		entries = append(entries, tmpEntries...)
 	}
 	return

cmd/posix-list-dir-others.go

@@ -30,7 +30,12 @@ import (
 
 // Return all the entries at the directory dirPath.
 func readDir(dirPath string) (entries []string, err error) {
-	d, err := os.Open((dirPath))
+	return readDirN(dirPath, -1)
+}
+
+// Return N entries at the directory dirPath. If count is -1, return all entries
+func readDirN(dirPath string, count int) (entries []string, err error) {
+	d, err := os.Open(dirPath)
 	if err != nil {
 		// File is really not found.
 		if os.IsNotExist(err) {
@@ -45,20 +50,34 @@ func readDir(dirPath string) (entries []string, err error) {
 	}
 	defer d.Close()
 
-	for {
-		// Read 1000 entries.
-		fis, err := d.Readdir(1000)
+	maxEntries := 1000
+	if count > 0 && count < maxEntries {
+		maxEntries = count
+	}
+
+	done := false
+	remaining := count
+
+	for !done {
+		// Read up to max number of entries.
+		fis, err := d.Readdir(maxEntries)
 		if err != nil {
 			if err == io.EOF {
 				break
 			}
 			return nil, err
 		}
+		if count > 0 {
+			if remaining <= len(fis) {
+				fis = fis[:remaining]
+				done = true
+			}
+		}
 		for _, fi := range fis {
 			// Stat symbolic link and follow to get the final value.
 			if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
 				var st os.FileInfo
-				st, err = os.Stat((path.Join(dirPath, fi.Name())))
+				st, err = os.Stat(path.Join(dirPath, fi.Name()))
 				if err != nil {
 					reqInfo := (&logger.ReqInfo{}).AppendTags("path", path.Join(dirPath, fi.Name()))
 					ctx := logger.SetReqInfo(context.Background(), reqInfo)
@@ -71,6 +90,9 @@ func readDir(dirPath string) (entries []string, err error) {
 				} else if st.Mode().IsRegular() {
 					entries = append(entries, fi.Name())
 				}
+				if count > 0 {
+					remaining--
+				}
 				continue
 			}
 			if fi.Mode().IsDir() {
@@ -79,6 +101,9 @@ func readDir(dirPath string) (entries []string, err error) {
 			} else if fi.Mode().IsRegular() {
 				entries = append(entries, fi.Name())
 			}
+			if count > 0 {
+				remaining--
+			}
 		}
 	}
 	return entries, nil

cmd/posix-list-dir_test.go

@@ -201,3 +201,41 @@ func TestReadDir(t *testing.T) {
 		}
 	}
 }
+
+func TestReadDirN(t *testing.T) {
+	testCases := []struct {
+		numFiles    int
+		n           int
+		expectedNum int
+	}{
+		{0, 0, 0},
+		{0, 1, 0},
+		{1, 0, 1},
+		{0, -1, 0},
+		{1, -1, 1},
+		{10, -1, 10},
+		{1, 1, 1},
+		{2, 1, 1},
+		{10, 9, 9},
+		{10, 10, 10},
+		{10, 11, 10},
+	}
+
+	for i, testCase := range testCases {
+		dir := mustSetupDir(t)
+		defer os.RemoveAll(dir)
+
+		for c := 1; c <= testCase.numFiles; c++ {
+			if err := ioutil.WriteFile(filepath.Join(dir, fmt.Sprintf("%d", c)), []byte{}, os.ModePerm); err != nil {
+				t.Fatalf("Unable to create a file, %s", err)
+			}
+		}
+		entries, err := readDirN(dir, testCase.n)
+		if err != nil {
+			t.Fatalf("Unable to read entries, %s", err)
+		}
+		if len(entries) != testCase.expectedNum {
+			t.Fatalf("Test %d: unexpected number of entries, waiting for %d, but found %d", i+1, testCase.expectedNum, len(entries))
+		}
+	}
+}

cmd/posix.go

@@ -29,6 +29,7 @@ import (
 	"sync"
 	"sync/atomic"
 	"syscall"
+	"time"
 
 	humanize "github.com/dustin/go-humanize"
 	"github.com/minio/minio/cmd/logger"
@@ -47,6 +48,11 @@ type posix struct {
 	diskPath   string
 	pool       sync.Pool
 	connected  bool
+
+	// Disk usage metrics
+	stopUsageCh        chan struct{}
+	totalUsage         uint64
+	usageCheckInterval time.Duration
 }
 
 // checkPathLength - returns error if given path name length more than 255
@@ -72,7 +78,7 @@ func checkPathLength(pathName string) error {
 	return nil
 }
 
-func checkPathValid(path string) (string, error) {
+func getValidPath(path string) (string, error) {
 	if path == "" {
 		return path, errInvalidArgument
 	}
@@ -128,6 +134,7 @@ func isDirEmpty(dirname string) bool {
 		return false
 	}
 	defer f.Close()
+
 	// List one entry.
 	_, err = f.Readdirnames(1)
 	if err != io.EOF {
@@ -144,7 +151,7 @@ func isDirEmpty(dirname string) bool {
 // Initialize a new storage disk.
 func newPosix(path string) (StorageAPI, error) {
 	var err error
-	if path, err = checkPathValid(path); err != nil {
+	if path, err = getValidPath(path); err != nil {
 		return nil, err
 	}
 
@@ -157,9 +164,14 @@ func newPosix(path string) (StorageAPI, error) {
 				return &b
 			},
 		},
+		stopUsageCh:        make(chan struct{}),
+		usageCheckInterval: usageCheckInterval,
 	}
+
 	st.connected = true
 
+	go st.diskUsage()
+
 	// Success.
 	return st, nil
 }
@@ -242,6 +254,7 @@ func (s *posix) String() string {
 }
 
 func (s *posix) Close() error {
+	close(s.stopUsageCh)
 	s.connected = false
 	return nil
 }
@@ -250,10 +263,26 @@ func (s *posix) IsOnline() bool {
 	return s.connected
 }
 
+// DiskInfo is an extended type which returns current
+// disk usage per path.
+type DiskInfo struct {
+	Total uint64
+	Free  uint64
+	Used  uint64
+}
+
 // DiskInfo provides current information about disk space usage,
 // total free inodes and underlying filesystem.
-func (s *posix) DiskInfo() (info disk.Info, err error) {
-	return getDiskInfo((s.diskPath))
+func (s *posix) DiskInfo() (info DiskInfo, err error) {
+	di, err := getDiskInfo(s.diskPath)
+	if err != nil {
+		return info, err
+	}
+	return DiskInfo{
+		Total: di.Total,
+		Free:  di.Free,
+		Used:  atomic.LoadUint64(&s.totalUsage),
+	}, nil
 }
 
 // getVolDir - will convert incoming volume names to
@@ -285,6 +314,58 @@ func (s *posix) checkDiskFound() (err error) {
 	return err
 }
 
+// diskUsage returns du information for the posix path, in a continuous routine.
+func (s *posix) diskUsage() {
+	ticker := time.NewTicker(s.usageCheckInterval)
+	defer ticker.Stop()
+
+	usageFn := func(ctx context.Context, entry string) error {
+		select {
+		case <-s.stopUsageCh:
+			return errWalkAbort
+		default:
+			fi, err := os.Stat(entry)
+			if err != nil {
+				return err
+			}
+			atomic.AddUint64(&s.totalUsage, uint64(fi.Size()))
+			return nil
+		}
+	}
+
+	if err := getDiskUsage(context.Background(), s.diskPath, usageFn); err != nil {
+		return
+	}
+
+	for {
+		select {
+		case <-s.stopUsageCh:
+			return
+		case <-globalServiceDoneCh:
+			return
+		case <-ticker.C:
+			var usage uint64
+			usageFn = func(ctx context.Context, entry string) error {
+				select {
+				case <-s.stopUsageCh:
+					return errWalkAbort
+				default:
+					fi, err := os.Stat(entry)
+					if err != nil {
+						return err
+					}
+					usage = usage + uint64(fi.Size())
+					return nil
+				}
+			}
+			if err := getDiskUsage(context.Background(), s.diskPath, usageFn); err != nil {
+				continue
+			}
+			atomic.StoreUint64(&s.totalUsage, usage)
+		}
+	}
+}
+
 // Make a volume entry.
 func (s *posix) MakeVol(volume string) (err error) {
 	defer func() {
@@ -467,7 +548,7 @@ func (s *posix) DeleteVol(volume string) (err error) {
 
 // ListDir - return all the entries at the given directory path.
 // If an entry is a directory it will be returned with a trailing "/".
-func (s *posix) ListDir(volume, dirPath string) (entries []string, err error) {
+func (s *posix) ListDir(volume, dirPath string, count int) (entries []string, err error) {
 	defer func() {
 		if err == syscall.EIO {
 			atomic.AddInt32(&s.ioErrCount, 1)
@@ -495,7 +576,12 @@ func (s *posix) ListDir(volume, dirPath string) (entries []string, err error) {
 		}
 		return nil, err
 	}
-	return readDir(pathJoin(volumeDir, dirPath))
+
+	dirPath = pathJoin(volumeDir, dirPath)
+	if count > 0 {
+		return readDirN(dirPath, count)
+	}
+	return readDir(dirPath)
 }
 
 // ReadAll reads from r until an error or EOF and returns the data it read.

cmd/posix_test.go

@@ -785,7 +785,7 @@ func TestPosixPosixListDir(t *testing.T) {
 		} else {
 			t.Errorf("Expected the StorageAPI to be of type *posix")
 		}
-		dirList, err = posixStorage.ListDir(testCase.srcVol, testCase.srcPath)
+		dirList, err = posixStorage.ListDir(testCase.srcVol, testCase.srcPath, -1)
 		if err != testCase.expectedErr {
 			t.Fatalf("TestPosix case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
 		}

cmd/server-main.go

@@ -18,10 +18,11 @@ package cmd
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 	"os"
 	"os/signal"
-	"runtime"
+	"strings"
 	"syscall"
 
 	"github.com/minio/cli"
@@ -30,6 +31,11 @@ import (
 	"github.com/minio/minio/cmd/logger"
 )
 
+func init() {
+	logger.Init(GOPATH)
+	logger.RegisterUIError(fmtError)
+}
+
 var serverFlags = []cli.Flag{
 	cli.StringFlag{
 		Name:  "address",
@@ -65,6 +71,9 @@ ENVIRONMENT VARIABLES:
      MINIO_ACCESS_KEY: Custom username or access key of minimum 3 characters in length.
      MINIO_SECRET_KEY: Custom password or secret key of minimum 8 characters in length.
 
+  ENDPOINTS:
+     MINIO_ENDPOINTS: List of all endpoints delimited by ' '.
+
   BROWSER:
      MINIO_BROWSER: To disable web browser access, set this value to "off".
 
@@ -73,12 +82,6 @@ ENVIRONMENT VARIABLES:
      MINIO_CACHE_EXCLUDE: List of cache exclusion patterns delimited by ";".
      MINIO_CACHE_EXPIRY: Cache expiry duration in days.
 	
-  REGION:
-     MINIO_REGION: To set custom region. By default all regions are accepted.
-
-  UPDATE:
-     MINIO_UPDATE: To turn off in-place upgrades, set this value to "off".
-
   DOMAIN:
      MINIO_DOMAIN: To enable virtual-host-style requests, set this value to Minio host domain name.
 
@@ -87,23 +90,24 @@ ENVIRONMENT VARIABLES:
 
 EXAMPLES:
   1. Start minio server on "/home/shared" directory.
-      $ {{.HelpName}} /home/shared
+     $ {{.HelpName}} /home/shared
 
   2. Start minio server bound to a specific ADDRESS:PORT.
-      $ {{.HelpName}} --address 192.168.1.101:9000 /home/shared
+     $ {{.HelpName}} --address 192.168.1.101:9000 /home/shared
 
   3. Start minio server and enable virtual-host-style requests.
-      $ export MINIO_DOMAIN=mydomain.com
-      $ {{.HelpName}} --address mydomain.com:9000 /mnt/export
+     $ export MINIO_DOMAIN=mydomain.com
+     $ {{.HelpName}} --address mydomain.com:9000 /mnt/export
 
-  4. Start minio server on 64 disks server.
-      $ {{.HelpName}} /mnt/export{1...64}
+  4. Start minio server on 64 disks server with endpoints through environment variable.
+     $ export MINIO_ENDPOINTS=/mnt/export{1...64}
+     $ {{.HelpName}}
 
   5. Start distributed minio server on an 8 node setup with 8 drives each. Run following command on all the 8 nodes.
-      $ export MINIO_ACCESS_KEY=minio
-      $ export MINIO_SECRET_KEY=miniostorage
-      $ {{.HelpName}} http://node{1...8}.example.com/mnt/export/{1...8}
-	
+     $ export MINIO_ACCESS_KEY=minio
+     $ export MINIO_SECRET_KEY=miniostorage
+     $ {{.HelpName}} http://node{1...8}.example.com/mnt/export/{1...8}
+
   6. Start minio server with edge caching enabled.
      $ export MINIO_CACHE_DRIVES="/mnt/drive1;/mnt/drive2;/mnt/drive3;/mnt/drive4"
      $ export MINIO_CACHE_EXCLUDE="bucket1/*;*.png"
@@ -112,32 +116,48 @@ EXAMPLES:
 `,
 }
 
+// Checks if endpoints are either available through environment
+// or command line, returns false if both fails.
+func endpointsPresent(ctx *cli.Context) bool {
+	_, ok := os.LookupEnv("MINIO_ENDPOINTS")
+	if !ok {
+		ok = ctx.Args().Present()
+	}
+	return ok
+}
+
 func serverHandleCmdArgs(ctx *cli.Context) {
 	// Handle common command args.
 	handleCommonCmdArgs(ctx)
 
 	// Server address.
 	serverAddr := ctx.String("address")
-	logger.FatalIf(CheckLocalServerAddr(serverAddr), "Invalid address ‘%s’ in command line argument.", serverAddr)
+	logger.FatalIf(CheckLocalServerAddr(serverAddr), "Unable to validate passed arguments")
 
 	var setupType SetupType
 	var err error
 
 	if len(ctx.Args()) > serverCommandLineArgsMax {
-		logger.FatalIf(errInvalidArgument, "Invalid total number of arguments (%d) passed, supported upto 32 unique arguments", len(ctx.Args()))
+		uErr := uiErrInvalidErasureEndpoints(nil).Msg(fmt.Sprintf("Invalid total number of endpoints (%d) passed, supported upto 32 unique arguments",
+			len(ctx.Args())))
+		logger.FatalIf(uErr, "Unable to validate passed endpoints")
 	}
 
-	globalMinioAddr, globalEndpoints, setupType, globalXLSetCount, globalXLSetDriveCount, err = createServerEndpoints(serverAddr, ctx.Args()...)
-	logger.FatalIf(err, "Invalid command line arguments server=‘%s’, args=%s", serverAddr, ctx.Args())
+	endpoints := strings.Fields(os.Getenv("MINIO_ENDPOINTS"))
+	if len(endpoints) > 0 {
+		globalMinioAddr, globalEndpoints, setupType, globalXLSetCount, globalXLSetDriveCount, err = createServerEndpoints(serverAddr, endpoints...)
+	} else {
+		globalMinioAddr, globalEndpoints, setupType, globalXLSetCount, globalXLSetDriveCount, err = createServerEndpoints(serverAddr, ctx.Args()...)
+	}
+	logger.FatalIf(err, "Invalid command line arguments")
 
 	globalMinioHost, globalMinioPort = mustSplitHostPort(globalMinioAddr)
-	if runtime.GOOS == "darwin" {
-		// On macOS, if a process already listens on LOCALIPADDR:PORT, net.Listen() falls back
-		// to IPv6 address ie minio will start listening on IPv6 address whereas another
-		// (non-)minio process is listening on IPv4 of given port.
-		// To avoid this error sutiation we check for port availability only for macOS.
-		logger.FatalIf(checkPortAvailability(globalMinioPort), "Port %d already in use", globalMinioPort)
-	}
+
+	// On macOS, if a process already listens on LOCALIPADDR:PORT, net.Listen() falls back
+	// to IPv6 address ie minio will start listening on IPv6 address whereas another
+	// (non-)minio process is listening on IPv4 of given port.
+	// To avoid this error sutiation we check for port availability.
+	logger.FatalIf(checkPortAvailability(globalMinioPort), "Unable to start the server")
 
 	globalIsXL = (setupType == XLSetupType)
 	globalIsDistXL = (setupType == DistXLSetupType)
@@ -158,16 +178,16 @@ func serverHandleEnvVars() {
 
 }
 
-func init() {
-	logger.Init(GOPATH)
-}
-
 // serverMain handler called for 'minio server' command.
 func serverMain(ctx *cli.Context) {
-	if (!ctx.IsSet("sets") && !ctx.Args().Present()) || ctx.Args().First() == "help" {
+	if ctx.Args().First() == "help" || !endpointsPresent(ctx) {
 		cli.ShowCommandHelpAndExit(ctx, "server", 1)
 	}
 
+	// Disable logging until server initialization is complete, any
+	// error during initialization will be shown as a fatal message
+	logger.Disable = true
+
 	// Get "json" flag from command line argument and
 	// enable json and quite modes if jason flag is turned on.
 	jsonFlag := ctx.IsSet("json") || ctx.GlobalIsSet("json")
@@ -188,7 +208,7 @@ func serverMain(ctx *cli.Context) {
 	serverHandleEnvVars()
 
 	// Create certs path.
-	logger.FatalIf(createConfigDir(), "Unable to create configuration directories.")
+	logger.FatalIf(createConfigDir(), "Unable to initialize configuration files")
 
 	// Initialize server config.
 	initConfig()
@@ -196,15 +216,15 @@ func serverMain(ctx *cli.Context) {
 	// Check and load SSL certificates.
 	var err error
 	globalPublicCerts, globalRootCAs, globalTLSCertificate, globalIsSSL, err = getSSLConfig()
-	logger.FatalIf(err, "Invalid SSL certificate file")
+	logger.FatalIf(err, "Unable to load the TLS configuration")
 
 	// Is distributed setup, error out if no certificates are found for HTTPS endpoints.
 	if globalIsDistXL {
 		if globalEndpoints.IsHTTPS() && !globalIsSSL {
-			logger.FatalIf(errInvalidArgument, "No certificates found, use HTTP endpoints (%s)", globalEndpoints)
+			logger.Fatal(uiErrNoCertsAndHTTPSEndpoints(nil), "Unable to start the server")
 		}
 		if !globalEndpoints.IsHTTPS() && globalIsSSL {
-			logger.FatalIf(errInvalidArgument, "TLS Certificates found, use HTTPS endpoints (%s)", globalEndpoints)
+			logger.Fatal(uiErrCertsAndHTTPEndpoints(nil), "Unable to start the server")
 		}
 	}
 
@@ -225,7 +245,9 @@ func serverMain(ctx *cli.Context) {
 	// Set nodes for dsync for distributed setup.
 	if globalIsDistXL {
 		globalDsync, err = dsync.New(newDsyncNodes(globalEndpoints))
-		logger.FatalIf(err, "Unable to initialize distributed locking on %s", globalEndpoints)
+		if err != nil {
+			logger.Fatal(err, "Unable to initialize distributed locking on %s", globalEndpoints)
+		}
 	}
 
 	// Initialize name space lock.
@@ -237,11 +259,15 @@ func serverMain(ctx *cli.Context) {
 	// Configure server.
 	var handler http.Handler
 	handler, err = configureServerHandler(globalEndpoints)
-	logger.FatalIf(err, "Unable to configure one of server's RPC services.")
+	if err != nil {
+		logger.Fatal(uiErrUnexpectedError(err), "Unable to configure one of server's RPC services")
+	}
 
 	// Create new notification system.
 	globalNotificationSys, err = NewNotificationSys(globalServerConfig, globalEndpoints)
-	logger.FatalIf(err, "Unable to create new notification system.")
+	if err != nil {
+		logger.Fatal(err, "Unable to initialize the notification system")
+	}
 
 	// Create new policy system.
 	globalPolicySys = NewPolicySys()
@@ -262,10 +288,8 @@ func serverMain(ctx *cli.Context) {
 
 	newObject, err := newObjectLayer(globalEndpoints)
 	if err != nil {
-		logger.LogIf(context.Background(), err)
-		err = globalHTTPServer.Shutdown()
-		logger.LogIf(context.Background(), err)
-		os.Exit(1)
+		globalHTTPServer.Shutdown()
+		logger.FatalIf(err, "Unable to initialize backend")
 	}
 
 	globalObjLayerMutex.Lock()
@@ -279,6 +303,9 @@ func serverMain(ctx *cli.Context) {
 	// Set uptime time after object layer has initialized.
 	globalBootTime = UTCNow()
 
+	// Re-enable logging
+	logger.Disable = false
+
 	handleSignals()
 }
 

cmd/server-startup-msg.go

@@ -173,19 +173,19 @@ func printObjectAPIMsg() {
 
 // Get formatted disk/storage info message.
 func getStorageInfoMsg(storageInfo StorageInfo) string {
-	msg := fmt.Sprintf("%s %s Free, %s Total", colorBlue("Drive Capacity:"),
-		humanize.IBytes(uint64(storageInfo.Free)),
-		humanize.IBytes(uint64(storageInfo.Total)))
+	var msg string
 	if storageInfo.Backend.Type == Erasure {
 		diskInfo := fmt.Sprintf(" %d Online, %d Offline. ", storageInfo.Backend.OnlineDisks, storageInfo.Backend.OfflineDisks)
-		msg += colorBlue("\nStatus:") + fmt.Sprintf(getFormatStr(len(diskInfo), 8), diskInfo)
+		msg += colorBlue("Status:") + fmt.Sprintf(getFormatStr(len(diskInfo), 8), diskInfo)
 	}
 	return msg
 }
 
 // Prints startup message of storage capacity and erasure information.
 func printStorageInfo(storageInfo StorageInfo) {
-	logger.StartupMessage(getStorageInfoMsg(storageInfo) + "\n")
+	if msg := getStorageInfoMsg(storageInfo); msg != "" {
+		logger.StartupMessage(msg)
+	}
 }
 
 func printCacheStorageInfo(storageInfo StorageInfo) {

cmd/server-startup-msg_test.go

@@ -25,20 +25,16 @@ import (
 	"strings"
 	"testing"
 	"time"
-
-	humanize "github.com/dustin/go-humanize"
 )
 
 // Tests if we generate storage info.
 func TestStorageInfoMsg(t *testing.T) {
 	infoStorage := StorageInfo{}
-	infoStorage.Total = 10 * humanize.GiByte
-	infoStorage.Free = 2 * humanize.GiByte
 	infoStorage.Backend.Type = Erasure
 	infoStorage.Backend.OnlineDisks = 7
 	infoStorage.Backend.OfflineDisks = 1
 
-	if msg := getStorageInfoMsg(infoStorage); !strings.Contains(msg, "2.0 GiB Free, 10 GiB Total") || !strings.Contains(msg, "7 Online, 1 Offline") {
+	if msg := getStorageInfoMsg(infoStorage); !strings.Contains(msg, "7 Online, 1 Offline") {
 		t.Fatal("Unexpected storage info message, found:", msg)
 	}
 }

cmd/storage-class.go

@@ -18,7 +18,6 @@ package cmd
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"strconv"
 	"strings"
@@ -104,20 +103,20 @@ func parseStorageClass(storageClassEnv string) (sc storageClass, err error) {
 
 	// only two elements allowed in the string - "scheme" and "number of parity disks"
 	if len(s) > 2 {
-		return storageClass{}, errors.New("Too many sections in " + storageClassEnv)
+		return storageClass{}, uiErrStorageClassValue(nil).Msg("Too many sections in " + storageClassEnv)
 	} else if len(s) < 2 {
-		return storageClass{}, errors.New("Too few sections in " + storageClassEnv)
+		return storageClass{}, uiErrStorageClassValue(nil).Msg("Too few sections in " + storageClassEnv)
 	}
 
 	// only allowed scheme is "EC"
 	if s[0] != supportedStorageClassScheme {
-		return storageClass{}, errors.New("Unsupported scheme " + s[0] + ". Supported scheme is EC")
+		return storageClass{}, uiErrStorageClassValue(nil).Msg("Unsupported scheme " + s[0] + ". Supported scheme is EC")
 	}
 
 	// Number of parity disks should be integer
 	parityDisks, err := strconv.Atoi(s[1])
 	if err != nil {
-		return storageClass{}, err
+		return storageClass{}, uiErrStorageClassValue(err)
 	}
 
 	sc = storageClass{

cmd/storage-class_test.go

@@ -69,8 +69,8 @@ func testParseStorageClass(obj ObjectLayer, instanceType string, t TestErrHandle
 			t.Errorf("Test %d, Expected %v, got %v", i+1, tt.wantSc, gotSc)
 			return
 		}
-		if tt.expectedError != nil && !reflect.DeepEqual(err, tt.expectedError) {
-			t.Errorf("Test %d, Expected %v, got %v", i+1, tt.expectedError, err)
+		if tt.expectedError != nil && err.Error() != tt.expectedError.Error() {
+			t.Errorf("Test %d, Expected `%v`, got `%v`", i+1, tt.expectedError, err)
 		}
 	}
 }

cmd/storage-interface.go

@@ -18,8 +18,6 @@ package cmd
 
 import (
 	"io"
-
-	"github.com/minio/minio/pkg/disk"
 )
 
 // StorageAPI interface.
@@ -30,7 +28,7 @@ type StorageAPI interface {
 	// Storage operations.
 	IsOnline() bool // Returns true if disk is online.
 	Close() error
-	DiskInfo() (info disk.Info, err error)
+	DiskInfo() (info DiskInfo, err error)
 
 	// Volume operations.
 	MakeVol(volume string) (err error)
@@ -39,7 +37,7 @@ type StorageAPI interface {
 	DeleteVol(volume string) (err error)
 
 	// File operations.
-	ListDir(volume, dirPath string) ([]string, error)
+	ListDir(volume, dirPath string, count int) ([]string, error)
 	ReadFile(volume string, path string, offset int64, buf []byte, verifier *BitrotVerifier) (n int64, err error)
 	PrepareFile(volume string, path string, len int64) (err error)
 	AppendFile(volume string, path string, buf []byte) (err error)

cmd/storage-rpc-client.go

@@ -23,8 +23,6 @@ import (
 	"net/rpc"
 	"path"
 	"strings"
-
-	"github.com/minio/minio/pkg/disk"
 )
 
 type networkStorage struct {
@@ -164,10 +162,10 @@ func (n *networkStorage) call(handler string, args interface {
 }
 
 // DiskInfo - fetch disk information for a remote disk.
-func (n *networkStorage) DiskInfo() (info disk.Info, err error) {
+func (n *networkStorage) DiskInfo() (info DiskInfo, err error) {
 	args := AuthRPCArgs{}
 	if err = n.call("Storage.DiskInfoHandler", &args, &info); err != nil {
-		return disk.Info{}, err
+		return DiskInfo{}, err
 	}
 	return info, nil
 }
@@ -283,10 +281,11 @@ func (n *networkStorage) ReadFile(volume string, path string, offset int64, buff
 }
 
 // ListDir - list all entries at prefix.
-func (n *networkStorage) ListDir(volume, path string) (entries []string, err error) {
+func (n *networkStorage) ListDir(volume, path string, count int) (entries []string, err error) {
 	if err = n.call("Storage.ListDirHandler", &ListDirArgs{
-		Vol:  volume,
-		Path: path,
+		Vol:   volume,
+		Path:  path,
+		Count: count,
 	}, &entries); err != nil {
 		return nil, err
 	}

cmd/storage-rpc-client_test.go

@@ -435,7 +435,7 @@ func (s *TestRPCStorageSuite) testRPCStorageListDir(t *testing.T) {
 				t.Error("Unable to initiate MakeVol", err)
 			}
 		}
-		dirs, err := storageDisk.ListDir("myvol", "")
+		dirs, err := storageDisk.ListDir("myvol", "", -1)
 		if err != nil {
 			t.Error(err)
 		}
@@ -448,7 +448,7 @@ func (s *TestRPCStorageSuite) testRPCStorageListDir(t *testing.T) {
 				t.Error("Unable to initiate DeleteVol", err)
 			}
 		}
-		dirs, err = storageDisk.ListDir("myvol", "")
+		dirs, err = storageDisk.ListDir("myvol", "", -1)
 		if err != nil {
 			t.Error(err)
 		}

cmd/storage-rpc-server-datatypes.go

@@ -134,6 +134,9 @@ type ListDirArgs struct {
 
 	// Name of the path.
 	Path string
+
+	// Number of wanted results
+	Count int
 }
 
 // RenameFileArgs represents rename file RPC arguments.

cmd/storage-rpc-server.go

@@ -24,7 +24,6 @@ import (
 
 	"github.com/gorilla/mux"
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/disk"
 )
 
 // Storage server implements rpc primitives to facilitate exporting a
@@ -39,7 +38,7 @@ type storageServer struct {
 /// Storage operations handlers.
 
 // DiskInfoHandler - disk info handler is rpc wrapper for DiskInfo operation.
-func (s *storageServer) DiskInfoHandler(args *AuthRPCArgs, reply *disk.Info) error {
+func (s *storageServer) DiskInfoHandler(args *AuthRPCArgs, reply *DiskInfo) error {
 	if err := args.IsAuthenticated(); err != nil {
 		return err
 	}
@@ -120,7 +119,7 @@ func (s *storageServer) ListDirHandler(args *ListDirArgs, reply *[]string) error
 		return err
 	}
 
-	entries, err := s.storage.ListDir(args.Vol, args.Path)
+	entries, err := s.storage.ListDir(args.Vol, args.Path, args.Count)
 	if err != nil {
 		return err
 	}

cmd/storage-rpc-server_test.go

@@ -19,8 +19,6 @@ package cmd
 import (
 	"os"
 	"testing"
-
-	"github.com/minio/minio/pkg/disk"
 )
 
 type testStorageRPCServer struct {
@@ -91,7 +89,7 @@ func TestStorageRPCInvalidToken(t *testing.T) {
 		Vol:         "myvol",
 	}
 	// 1. DiskInfoHandler
-	diskInfoReply := &disk.Info{}
+	diskInfoReply := &DiskInfo{}
 	err = storageRPC.DiskInfoHandler(&badAuthRPCArgs, diskInfoReply)
 	errorIfInvalidToken(t, err)
 

cmd/tree-walk.go

@@ -20,8 +20,6 @@ import (
 	"context"
 	"sort"
 	"strings"
-
-	"github.com/minio/minio/cmd/logger"
 )
 
 // Tree walk result carries results of tree walking.
@@ -98,6 +96,9 @@ type listDirFunc func(bucket, prefixDir, prefixEntry string) (entries []string,
 // 4. XL backend multipart listing - isLeaf is true if the entry is a directory and contains uploads.json
 type isLeafFunc func(string, string) bool
 
+// A function isLeafDir of type isLeafDirFunc is used to detect if an entry represents an empty directory.
+type isLeafDirFunc func(string, string) bool
+
 func filterListEntries(bucket, prefixDir string, entries []string, prefixEntry string, isLeaf isLeafFunc) ([]string, bool) {
 	// Listing needs to be sorted.
 	sort.Strings(entries)
@@ -125,7 +126,7 @@ func filterListEntries(bucket, prefixDir string, entries []string, prefixEntry s
 }
 
 // treeWalk walks directory tree recursively pushing treeWalkResult into the channel as and when it encounters files.
-func doTreeWalk(ctx context.Context, bucket, prefixDir, entryPrefixMatch, marker string, recursive bool, listDir listDirFunc, isLeaf isLeafFunc, resultCh chan treeWalkResult, endWalkCh chan struct{}, isEnd bool) error {
+func doTreeWalk(ctx context.Context, bucket, prefixDir, entryPrefixMatch, marker string, recursive bool, listDir listDirFunc, isLeaf isLeafFunc, isLeafDir isLeafDirFunc, resultCh chan treeWalkResult, endWalkCh chan struct{}, isEnd bool) error {
 	// Example:
 	// if prefixDir="one/two/three/" and marker="four/five.txt" treeWalk is recursively
 	// called with prefixDir="one/two/three/four/" and marker="five.txt"
@@ -144,12 +145,17 @@ func doTreeWalk(ctx context.Context, bucket, prefixDir, entryPrefixMatch, marker
 	if err != nil {
 		select {
 		case <-endWalkCh:
-			logger.LogIf(ctx, errWalkAbort)
 			return errWalkAbort
 		case resultCh <- treeWalkResult{err: err}:
 			return err
 		}
 	}
+
+	// When isleaf check is delayed, make sure that it is set correctly here.
+	if delayIsLeaf && isLeaf == nil {
+		return errInvalidArgument
+	}
+
 	// For an empty list return right here.
 	if len(entries) == 0 {
 		return nil
@@ -166,18 +172,31 @@ func doTreeWalk(ctx context.Context, bucket, prefixDir, entryPrefixMatch, marker
 	if len(entries) == 0 {
 		return nil
 	}
+
 	for i, entry := range entries {
+		var leaf, leafDir bool
+
 		// Decision to do isLeaf check was pushed from listDir() to here.
-		if delayIsLeaf && isLeaf(bucket, pathJoin(prefixDir, entry)) {
-			entry = strings.TrimSuffix(entry, slashSeparator)
+		if delayIsLeaf {
+			leaf = isLeaf(bucket, pathJoin(prefixDir, entry))
+			if leaf {
+				entry = strings.TrimSuffix(entry, slashSeparator)
+			}
+		} else {
+			leaf = !strings.HasSuffix(entry, slashSeparator)
 		}
 
+		if strings.HasSuffix(entry, slashSeparator) {
+			leafDir = isLeafDir(bucket, pathJoin(prefixDir, entry))
+		}
+
+		isDir := !leafDir && !leaf
 		if i == 0 && markerDir == entry {
 			if !recursive {
 				// Skip as the marker would already be listed in the previous listing.
 				continue
 			}
-			if recursive && !hasSuffix(entry, slashSeparator) {
+			if recursive && !isDir {
 				// We should not skip for recursive listing and if markerDir is a directory
 				// for ex. if marker is "four/five.txt" markerDir will be "four/" which
 				// should not be skipped, instead it will need to be treeWalk()'ed into.
@@ -186,7 +205,7 @@ func doTreeWalk(ctx context.Context, bucket, prefixDir, entryPrefixMatch, marker
 				continue
 			}
 		}
-		if recursive && hasSuffix(entry, slashSeparator) {
+		if recursive && isDir {
 			// If the entry is a directory, we will need recurse into it.
 			markerArg := ""
 			if entry == markerDir {
@@ -198,7 +217,7 @@ func doTreeWalk(ctx context.Context, bucket, prefixDir, entryPrefixMatch, marker
 			// markIsEnd is passed to this entry's treeWalk() so that treeWalker.end can be marked
 			// true at the end of the treeWalk stream.
 			markIsEnd := i == len(entries)-1 && isEnd
-			if tErr := doTreeWalk(ctx, bucket, pathJoin(prefixDir, entry), prefixMatch, markerArg, recursive, listDir, isLeaf, resultCh, endWalkCh, markIsEnd); tErr != nil {
+			if tErr := doTreeWalk(ctx, bucket, pathJoin(prefixDir, entry), prefixMatch, markerArg, recursive, listDir, isLeaf, isLeafDir, resultCh, endWalkCh, markIsEnd); tErr != nil {
 				return tErr
 			}
 			continue
@@ -207,7 +226,6 @@ func doTreeWalk(ctx context.Context, bucket, prefixDir, entryPrefixMatch, marker
 		isEOF := ((i == len(entries)-1) && isEnd)
 		select {
 		case <-endWalkCh:
-			logger.LogIf(ctx, errWalkAbort)
 			return errWalkAbort
 		case resultCh <- treeWalkResult{entry: pathJoin(prefixDir, entry), end: isEOF}:
 		}
@@ -218,7 +236,7 @@ func doTreeWalk(ctx context.Context, bucket, prefixDir, entryPrefixMatch, marker
 }
 
 // Initiate a new treeWalk in a goroutine.
-func startTreeWalk(ctx context.Context, bucket, prefix, marker string, recursive bool, listDir listDirFunc, isLeaf isLeafFunc, endWalkCh chan struct{}) chan treeWalkResult {
+func startTreeWalk(ctx context.Context, bucket, prefix, marker string, recursive bool, listDir listDirFunc, isLeaf isLeafFunc, isLeafDir isLeafDirFunc, endWalkCh chan struct{}) chan treeWalkResult {
 	// Example 1
 	// If prefix is "one/two/three/" and marker is "one/two/three/four/five.txt"
 	// treeWalk is called with prefixDir="one/two/three/" and marker="four/five.txt"
@@ -240,7 +258,7 @@ func startTreeWalk(ctx context.Context, bucket, prefix, marker string, recursive
 	marker = strings.TrimPrefix(marker, prefixDir)
 	go func() {
 		isEnd := true // Indication to start walking the tree with end as true.
-		doTreeWalk(ctx, bucket, prefixDir, entryPrefixMatch, marker, recursive, listDir, isLeaf, resultCh, endWalkCh, isEnd)
+		doTreeWalk(ctx, bucket, prefixDir, entryPrefixMatch, marker, recursive, listDir, isLeaf, isLeafDir, resultCh, endWalkCh, isEnd)
 		close(resultCh)
 	}()
 	return resultCh

cmd/tree-walk_test.go

@@ -128,11 +128,11 @@ func createNamespace(disk StorageAPI, volume string, files []string) error {
 
 // Test if tree walker returns entries matching prefix alone are received
 // when a non empty prefix is supplied.
-func testTreeWalkPrefix(t *testing.T, listDir listDirFunc, isLeaf isLeafFunc) {
+func testTreeWalkPrefix(t *testing.T, listDir listDirFunc, isLeaf isLeafFunc, isLeafDir isLeafDirFunc) {
 	// Start the tree walk go-routine.
 	prefix := "d/"
 	endWalkCh := make(chan struct{})
-	twResultCh := startTreeWalk(context.Background(), volume, prefix, "", true, listDir, isLeaf, endWalkCh)
+	twResultCh := startTreeWalk(context.Background(), volume, prefix, "", true, listDir, isLeaf, isLeafDir, endWalkCh)
 
 	// Check if all entries received on the channel match the prefix.
 	for res := range twResultCh {
@@ -143,11 +143,11 @@ func testTreeWalkPrefix(t *testing.T, listDir listDirFunc, isLeaf isLeafFunc) {
 }
 
 // Test if entries received on tree walk's channel appear after the supplied marker.
-func testTreeWalkMarker(t *testing.T, listDir listDirFunc, isLeaf isLeafFunc) {
+func testTreeWalkMarker(t *testing.T, listDir listDirFunc, isLeaf isLeafFunc, isLeafDir isLeafDirFunc) {
 	// Start the tree walk go-routine.
 	prefix := ""
 	endWalkCh := make(chan struct{})
-	twResultCh := startTreeWalk(context.Background(), volume, prefix, "d/g", true, listDir, isLeaf, endWalkCh)
+	twResultCh := startTreeWalk(context.Background(), volume, prefix, "d/g", true, listDir, isLeaf, isLeafDir, endWalkCh)
 
 	// Check if only 3 entries, namely d/g/h, i/j/k, lmn are received on the channel.
 	expectedCount := 3
@@ -187,11 +187,20 @@ func TestTreeWalk(t *testing.T) {
 	isLeaf := func(volume, prefix string) bool {
 		return !hasSuffix(prefix, slashSeparator)
 	}
+
+	isLeafDir := func(volume, prefix string) bool {
+		entries, listErr := disk.ListDir(volume, prefix, 1)
+		if listErr != nil {
+			return false
+		}
+		return len(entries) == 0
+	}
+
 	listDir := listDirFactory(context.Background(), isLeaf, xlTreeWalkIgnoredErrs, disk)
 	// Simple test for prefix based walk.
-	testTreeWalkPrefix(t, listDir, isLeaf)
+	testTreeWalkPrefix(t, listDir, isLeaf, isLeafDir)
 	// Simple test when marker is set.
-	testTreeWalkMarker(t, listDir, isLeaf)
+	testTreeWalkMarker(t, listDir, isLeaf, isLeafDir)
 	err = os.RemoveAll(fsDir)
 	if err != nil {
 		t.Fatal(err)
@@ -222,6 +231,15 @@ func TestTreeWalkTimeout(t *testing.T) {
 	isLeaf := func(volume, prefix string) bool {
 		return !hasSuffix(prefix, slashSeparator)
 	}
+
+	isLeafDir := func(volume, prefix string) bool {
+		entries, listErr := disk.ListDir(volume, prefix, 1)
+		if listErr != nil {
+			return false
+		}
+		return len(entries) == 0
+	}
+
 	listDir := listDirFactory(context.Background(), isLeaf, xlTreeWalkIgnoredErrs, disk)
 
 	// TreeWalk pool with 2 seconds timeout for tree-walk go routines.
@@ -231,7 +249,7 @@ func TestTreeWalkTimeout(t *testing.T) {
 	prefix := ""
 	marker := ""
 	recursive := true
-	resultCh := startTreeWalk(context.Background(), volume, prefix, marker, recursive, listDir, isLeaf, endWalkCh)
+	resultCh := startTreeWalk(context.Background(), volume, prefix, marker, recursive, listDir, isLeaf, isLeafDir, endWalkCh)
 
 	params := listParams{
 		bucket:    volume,
@@ -373,6 +391,14 @@ func TestRecursiveTreeWalk(t *testing.T) {
 		return !hasSuffix(prefix, slashSeparator)
 	}
 
+	isLeafDir := func(volume, prefix string) bool {
+		entries, listErr := disk1.ListDir(volume, prefix, 1)
+		if listErr != nil {
+			return false
+		}
+		return len(entries) == 0
+	}
+
 	// Create listDir function.
 	listDir := listDirFactory(context.Background(), isLeaf, xlTreeWalkIgnoredErrs, disk1)
 
@@ -450,7 +476,7 @@ func TestRecursiveTreeWalk(t *testing.T) {
 	for i, testCase := range testCases {
 		for entry := range startTreeWalk(context.Background(), volume,
 			testCase.prefix, testCase.marker, testCase.recursive,
-			listDir, isLeaf, endWalkCh) {
+			listDir, isLeaf, isLeafDir, endWalkCh) {
 			if _, found := testCase.expected[entry.entry]; !found {
 				t.Errorf("Test %d: Expected %s, but couldn't find", i+1, entry.entry)
 			}
@@ -479,6 +505,15 @@ func TestSortedness(t *testing.T) {
 	isLeaf := func(volume, prefix string) bool {
 		return !hasSuffix(prefix, slashSeparator)
 	}
+
+	isLeafDir := func(volume, prefix string) bool {
+		entries, listErr := disk1.ListDir(volume, prefix, 1)
+		if listErr != nil {
+			return false
+		}
+		return len(entries) == 0
+	}
+
 	// Create listDir function.
 	listDir := listDirFactory(context.Background(), isLeaf, xlTreeWalkIgnoredErrs, disk1)
 
@@ -522,7 +557,7 @@ func TestSortedness(t *testing.T) {
 		var actualEntries []string
 		for entry := range startTreeWalk(context.Background(), volume,
 			test.prefix, test.marker, test.recursive,
-			listDir, isLeaf, endWalkCh) {
+			listDir, isLeaf, isLeafDir, endWalkCh) {
 			actualEntries = append(actualEntries, entry.entry)
 		}
 		if !sort.IsSorted(sort.StringSlice(actualEntries)) {
@@ -553,6 +588,15 @@ func TestTreeWalkIsEnd(t *testing.T) {
 	isLeaf := func(volume, prefix string) bool {
 		return !hasSuffix(prefix, slashSeparator)
 	}
+
+	isLeafDir := func(volume, prefix string) bool {
+		entries, listErr := disk1.ListDir(volume, prefix, 1)
+		if listErr != nil {
+			return false
+		}
+		return len(entries) == 0
+	}
+
 	// Create listDir function.
 	listDir := listDirFactory(context.Background(), isLeaf, xlTreeWalkIgnoredErrs, disk1)
 
@@ -595,7 +639,7 @@ func TestTreeWalkIsEnd(t *testing.T) {
 	}
 	for i, test := range testCases {
 		var entry treeWalkResult
-		for entry = range startTreeWalk(context.Background(), volume, test.prefix, test.marker, test.recursive, listDir, isLeaf, endWalkCh) {
+		for entry = range startTreeWalk(context.Background(), volume, test.prefix, test.marker, test.recursive, listDir, isLeaf, isLeafDir, endWalkCh) {
 		}
 		if entry.entry != test.expectedEntry {
 			t.Errorf("Test %d: Expected entry %s, but received %s with the EOF marker", i, test.expectedEntry, entry.entry)

cmd/typed-errors.go

@@ -16,7 +16,9 @@
 
 package cmd
 
-import "errors"
+import (
+	"errors"
+)
 
 // errInvalidArgument means that input argument is invalid.
 var errInvalidArgument = errors.New("Invalid arguments specified")

cmd/ui-errors-utils.go

@@ -0,0 +1,135 @@
+/*
+ * Minio Cloud Storage, (C) 2018 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 cmd
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"os"
+)
+
+// uiErr is a structure which contains all information
+// to print a fatal error message in json or pretty mode
+// uiErr implements error so we can use it anywhere
+type uiErr struct {
+	msg    string
+	detail string
+	action string
+	help   string
+}
+
+// Return the error message
+func (u uiErr) Error() string {
+	if u.detail == "" {
+		return u.msg
+	}
+	return u.detail
+}
+
+// Replace the current error's message
+func (u uiErr) Msg(m string, args ...interface{}) uiErr {
+	return uiErr{
+		msg:    fmt.Sprintf(m, args...),
+		detail: u.detail,
+		action: u.action,
+		help:   u.help,
+	}
+}
+
+type uiErrFn func(err error) uiErr
+
+// Create a UI error generator, this is needed to simplify
+// the update of the detailed error message in several places
+// in Minio code
+func newUIErrFn(msg, action, help string) uiErrFn {
+	return func(err error) uiErr {
+		u := uiErr{
+			msg:    msg,
+			action: action,
+			help:   help,
+		}
+		if err != nil {
+			u.detail = err.Error()
+		}
+		return u
+	}
+}
+
+// errorToUIError inspects the passed error and transforms it
+// to the appropriate UI error.
+func errorToUIErr(err error) uiErr {
+	// If this is already a uiErr, do nothing
+	if e, ok := err.(uiErr); ok {
+		return e
+	}
+
+	// Show a generic message for known golang errors
+	switch e := err.(type) {
+	case *net.OpError:
+		if e.Op == "listen" {
+			return uiErrPortAlreadyInUse(e).Msg("Port " + e.Addr.String() + " is already in use")
+
+		}
+	case *os.PathError:
+		if os.IsPermission(e) {
+			return uiErrNoPermissionsToAccessDirFiles(e).Msg("Insufficient permissions to access path, `" + e.Path + "`")
+		}
+	}
+
+	switch err {
+	case io.ErrUnexpectedEOF:
+		return uiErrUnexpectedDataContent(err)
+	default:
+		// Failed to identify what type of error this, return a simple UI error
+		return uiErr{msg: err.Error()}
+	}
+
+}
+
+// fmtError() converts a fatal error message to a more clear error
+// using some colors
+func fmtError(introMsg string, err error, jsonFlag bool) string {
+	renderedTxt := ""
+	uiErr := errorToUIErr(err)
+	// JSON print
+	if jsonFlag {
+		// Message text in json should be simple
+		if uiErr.detail != "" {
+			return uiErr.msg + ": " + uiErr.detail
+		}
+		return uiErr.msg
+	}
+	// Pretty print error message
+	introMsg += ": "
+	if uiErr.msg != "" {
+		introMsg += colorBold(uiErr.msg + ".")
+	} else {
+		introMsg += colorBold(err.Error() + ".")
+	}
+	renderedTxt += colorRed(introMsg) + "\n"
+	// Add action message
+	if uiErr.action != "" {
+		renderedTxt += "> " + colorBgYellow(colorBlack(uiErr.action+".")) + "\n"
+	}
+	// Add help
+	if uiErr.help != "" {
+		renderedTxt += colorBold("HELP:") + "\n"
+		renderedTxt += "  " + uiErr.help
+	}
+	return renderedTxt
+}

cmd/ui-errors.go

@@ -0,0 +1,170 @@
+/*
+ * Minio Cloud Storage, (C) 2018 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 cmd
+
+var (
+	uiErrInvalidConfig = newUIErrFn(
+		"Invalid value found in the configuration file",
+		"Please ensure a valid value in the configuration file, for more details refer https://docs.minio.io/docs/minio-server-configuration-guide",
+		"",
+	)
+
+	uiErrInvalidBrowserValue = newUIErrFn(
+		"Invalid browser value",
+		"Please check the passed value",
+		"Browser can only accept `on` and `off` values. To disable web browser access, set this value to `off`",
+	)
+
+	uiErrInvalidCacheDrivesValue = newUIErrFn(
+		"Invalid cache drive value",
+		"Please check the value in this ENV variable",
+		"MINIO_CACHE_DRIVES: Mounted drives or directories are delimited by `;`",
+	)
+
+	uiErrInvalidCacheExcludesValue = newUIErrFn(
+		"Invalid cache excludes value",
+		"Please check the passed value",
+		"MINIO_CACHE_EXCLUDE: Cache exclusion patterns are delimited by `;`",
+	)
+
+	uiErrInvalidCacheExpiryValue = newUIErrFn(
+		"Invalid cache expiry value",
+		"Please check the passed value",
+		"MINIO_CACHE_EXPIRY: Valid cache expiry duration is in days.",
+	)
+
+	uiErrInvalidCredentials = newUIErrFn(
+		"Invalid credentials",
+		"Please provide correct credentials",
+		`Access key length should be between minimum 3 characters in length.
+Secret key should be in between 8 and 40 characters.`,
+	)
+
+	uiErrInvalidErasureEndpoints = newUIErrFn(
+		"Invalid endpoint(s) in erasure mode",
+		"Please provide correct combination of local/remote paths",
+		"For more information, please refer to https://docs.minio.io/docs/minio-erasure-code-quickstart-guide",
+	)
+
+	uiErrInvalidNumberOfErasureEndpoints = newUIErrFn(
+		"Invalid total number of endpoints for erasure mode",
+		"Please provide an even number of endpoints greater or equal to 4",
+		"For more information, please refer to https://docs.minio.io/docs/minio-erasure-code-quickstart-guide",
+	)
+
+	uiErrStorageClassValue = newUIErrFn(
+		"Invalid storage class value",
+		"Please check the value",
+		`MINIO_STORAGE_CLASS_STANDARD: Format "EC:<Default_Parity_Standard_Class>" (e.g. "EC:3"). This sets the number of parity disks for Minio server in Standard mode. Objects are stored in Standard mode, if storage class is not defined in Put request.
+MINIO_STORAGE_CLASS_RRS: Format "EC:<Default_Parity_Reduced_Redundancy_Class>" (e.g. "EC:3"). This sets the number of parity disks for Minio server in Reduced Redundancy mode. Objects are stored in Reduced Redundancy mode, if Put request specifies RRS storage class.
+Refer to the link https://github.com/minio/minio/tree/master/docs/erasure/storage-class for more information.`,
+	)
+
+	uiErrUnexpectedBackendVersion = newUIErrFn(
+		"Backend version seems to be too recent",
+		"Please update to the latest Minio version",
+		"",
+	)
+
+	uiErrInvalidAddressFlag = newUIErrFn(
+		"--address input is invalid",
+		"Please check --address parameter",
+		`--address binds to a specific ADDRESS:PORT, ADDRESS can be an  IP or hostname (default port is ':9000')
+    Examples: --address ':443'
+              --address '172.16.34.31:9000'`,
+	)
+
+	uiErrInvalidFSEndpoint = newUIErrFn(
+		"Invalid endpoint for standalone FS mode",
+		"Please check the FS endpoint",
+		`FS mode requires only one writable disk path.
+Example 1:
+   $ minio server /data/minio/`,
+	)
+
+	uiErrUnableToWriteInBackend = newUIErrFn(
+		"Unable to write to the backend",
+		"Please ensure Minio binary has write permissions for the backend",
+		"",
+	)
+
+	uiErrUnableToReadFromBackend = newUIErrFn(
+		"Unable to read from the backend",
+		"Please ensure Minio binary has read permissions for the backend",
+		"",
+	)
+
+	uiErrPortAlreadyInUse = newUIErrFn(
+		"Port is already in use",
+		"Please ensure no other program uses the same address/port",
+		"",
+	)
+
+	uiErrNoPermissionsToAccessDirFiles = newUIErrFn(
+		"Missing permissions to access the specified path",
+		"Please ensure the specified path can be accessed",
+		"",
+	)
+
+	uiErrSSLUnexpectedError = newUIErrFn(
+		"Invalid TLS certificate",
+		"Please check the content of your certificate data",
+		`Only PEM (x.509) format is accepted as valid public & private certificates.`,
+	)
+
+	uiErrSSLUnexpectedData = newUIErrFn(
+		"Invalid TLS certificate",
+		"Please check your certificate",
+		"",
+	)
+
+	uiErrSSLNoPassword = newUIErrFn(
+		"Missing TLS password",
+		"Please set the password to environment variable `"+TLSPrivateKeyPassword+"` so that the private key can be decrypted",
+		"",
+	)
+
+	uiErrNoCertsAndHTTPSEndpoints = newUIErrFn(
+		"HTTPS specified in endpoints, but no TLS certificate is found on the local machine",
+		"Please add a certificate or switch to HTTP.",
+		"Refer to https://docs.minio.io/docs/how-to-secure-access-to-minio-server-with-tls for information about how to load a TLS certificate in your server.",
+	)
+
+	uiErrCertsAndHTTPEndpoints = newUIErrFn(
+		"HTTP specified in endpoints, but the server in the local machine is configured with a TLS certificate",
+		"Please remove the certificate in the configuration directory or switch to HTTPS",
+		"",
+	)
+
+	uiErrSSLWrongPassword = newUIErrFn(
+		"Unable to decrypt the private key using the provided password",
+		"Please set the correct password in environment variable "+TLSPrivateKeyPassword,
+		"",
+	)
+
+	uiErrUnexpectedDataContent = newUIErrFn(
+		"Unexpected data content",
+		"Please contact Minio at https://slack.minio.io",
+		"",
+	)
+
+	uiErrUnexpectedError = newUIErrFn(
+		"Unexpected error",
+		"Please contact Minio at https://slack.minio.io",
+		"",
+	)
+)

cmd/update-main.go

@@ -65,7 +65,7 @@ EXIT STATUS:
 
 EXAMPLES:
    1. Check and update minio:
-       $ {{.HelpName}}
+      $ {{.HelpName}}
 `,
 }
 

cmd/version-main.go

@@ -36,7 +36,7 @@ FLAGS:
   {{end}}{{end}}
 EXAMPLES:
    1. Prints server version:
-       $ {{.HelpName}}
+      $ {{.HelpName}}
 `,
 }
 

cmd/web-handlers.go

@@ -169,9 +169,9 @@ func (web *webAPIHandlers) DeleteBucket(r *http.Request, args *RemoveBucketArgs,
 
 	globalNotificationSys.RemoveNotification(args.BucketName)
 	globalPolicySys.Remove(args.BucketName)
-	for addr, err := range globalNotificationSys.DeleteBucket(args.BucketName) {
-		logger.GetReqInfo(ctx).AppendTags("remotePeer", addr.Name)
-		logger.LogIf(ctx, err)
+	for nerr := range globalNotificationSys.DeleteBucket(args.BucketName) {
+		logger.GetReqInfo(ctx).AppendTags("remotePeer", nerr.Host.Name)
+		logger.LogIf(ctx, nerr.Err)
 	}
 
 	reply.UIVersion = browser.UIVersion
@@ -943,9 +943,9 @@ func (web *webAPIHandlers) SetBucketPolicy(r *http.Request, args *SetBucketPolic
 	}
 
 	globalPolicySys.Set(args.BucketName, *bucketPolicy)
-	for addr, err := range globalNotificationSys.SetBucketPolicy(args.BucketName, bucketPolicy) {
-		logger.GetReqInfo(ctx).AppendTags("remotePeer", addr.Name)
-		logger.LogIf(ctx, err)
+	for nerr := range globalNotificationSys.SetBucketPolicy(args.BucketName, bucketPolicy) {
+		logger.GetReqInfo(ctx).AppendTags("remotePeer", nerr.Host.Name)
+		logger.LogIf(ctx, nerr.Err)
 	}
 
 	return nil

cmd/web-handlers_test.go

@@ -221,13 +221,9 @@ func testStorageInfoWebHandler(obj ObjectLayer, instanceType string, t TestErrHa
 	if rec.Code != http.StatusOK {
 		t.Fatalf("Expected the response status to be 200, but instead found `%d`", rec.Code)
 	}
-	err = getTestWebRPCResponse(rec, &storageInfoReply)
-	if err != nil {
+	if err = getTestWebRPCResponse(rec, &storageInfoReply); err != nil {
 		t.Fatalf("Failed %v", err)
 	}
-	if storageInfoReply.StorageInfo.Total <= 0 {
-		t.Fatalf("Got a zero or negative total free space disk")
-	}
 }
 
 // Wrapper for calling ServerInfo Web Handler

cmd/xl-sets.go

@@ -280,8 +280,7 @@ func (s *xlSets) StorageInfo(ctx context.Context) StorageInfo {
 	storageInfo.Backend.Type = Erasure
 	for _, set := range s.sets {
 		lstorageInfo := set.StorageInfo(ctx)
-		storageInfo.Total = storageInfo.Total + lstorageInfo.Total
-		storageInfo.Free = storageInfo.Free + lstorageInfo.Free
+		storageInfo.Used = storageInfo.Used + lstorageInfo.Used
 		storageInfo.Backend.OnlineDisks = storageInfo.Backend.OnlineDisks + lstorageInfo.Backend.OnlineDisks
 		storageInfo.Backend.OfflineDisks = storageInfo.Backend.OfflineDisks + lstorageInfo.Backend.OfflineDisks
 	}
@@ -623,7 +622,7 @@ func (s *xlSets) CopyObject(ctx context.Context, srcBucket, srcObject, destBucke
 // Returns function "listDir" of the type listDirFunc.
 // isLeaf - is used by listDir function to check if an entry is a leaf or non-leaf entry.
 // disks - used for doing disk.ListDir(). Sets passes set of disks.
-func listDirSetsFactory(ctx context.Context, isLeaf isLeafFunc, treeWalkIgnoredErrs []error, sets ...[]StorageAPI) listDirFunc {
+func listDirSetsFactory(ctx context.Context, isLeaf isLeafFunc, isLeafDir isLeafDirFunc, treeWalkIgnoredErrs []error, sets ...[]StorageAPI) listDirFunc {
 	listDirInternal := func(bucket, prefixDir, prefixEntry string, disks []StorageAPI) (mergedEntries []string, err error) {
 		for _, disk := range disks {
 			if disk == nil {
@@ -632,7 +631,7 @@ func listDirSetsFactory(ctx context.Context, isLeaf isLeafFunc, treeWalkIgnoredE
 
 			var entries []string
 			var newEntries []string
-			entries, err = disk.ListDir(bucket, prefixDir)
+			entries, err = disk.ListDir(bucket, prefixDir, -1)
 			if err != nil {
 				// For any reason disk was deleted or goes offline, continue
 				// and list from other disks if possible.
@@ -723,13 +722,17 @@ func (s *xlSets) ListObjects(ctx context.Context, bucket, prefix, marker, delimi
 			return s.getHashedSet(entry).isObject(bucket, entry)
 		}
 
+		isLeafDir := func(bucket, entry string) bool {
+			return s.getHashedSet(entry).isObjectDir(bucket, entry)
+		}
+
 		var setDisks = make([][]StorageAPI, len(s.sets))
 		for _, set := range s.sets {
 			setDisks = append(setDisks, set.getLoadBalancedDisks())
 		}
 
-		listDir := listDirSetsFactory(ctx, isLeaf, xlTreeWalkIgnoredErrs, setDisks...)
-		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, isLeaf, endWalkCh)
+		listDir := listDirSetsFactory(ctx, isLeaf, isLeafDir, xlTreeWalkIgnoredErrs, setDisks...)
+		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, isLeaf, isLeafDir, endWalkCh)
 	}
 
 	for i := 0; i < maxKeys; {
@@ -781,7 +784,7 @@ func (s *xlSets) ListObjects(ctx context.Context, bucket, prefix, marker, delimi
 	result = ListObjectsInfo{IsTruncated: !eof}
 	for _, objInfo := range objInfos {
 		result.NextMarker = objInfo.Name
-		if objInfo.IsDir {
+		if objInfo.IsDir && delimiter == slashSeparator {
 			result.Prefixes = append(result.Prefixes, objInfo.Name)
 			continue
 		}
@@ -1270,7 +1273,7 @@ func listDirSetsHealFactory(isLeaf isLeafFunc, sets ...[]StorageAPI) listDirFunc
 			}
 			var entries []string
 			var newEntries []string
-			entries, err = disk.ListDir(bucket, prefixDir)
+			entries, err = disk.ListDir(bucket, prefixDir, -1)
 			if err != nil {
 				continue
 			}
@@ -1356,13 +1359,17 @@ func (s *xlSets) listObjectsHeal(ctx context.Context, bucket, prefix, marker, de
 			return s.getHashedSet(entry).isObject(bucket, entry)
 		}
 
+		isLeafDir := func(bucket, entry string) bool {
+			return s.getHashedSet(entry).isObjectDir(bucket, entry)
+		}
+
 		var setDisks = make([][]StorageAPI, len(s.sets))
 		for _, set := range s.sets {
 			setDisks = append(setDisks, set.getLoadBalancedDisks())
 		}
 
 		listDir := listDirSetsHealFactory(isLeaf, setDisks...)
-		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, nil, endWalkCh)
+		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, nil, isLeafDir, endWalkCh)
 	}
 
 	var objInfos []ObjectInfo
@@ -1399,20 +1406,7 @@ func (s *xlSets) listObjectsHeal(ctx context.Context, bucket, prefix, marker, de
 	result := ListObjectsInfo{IsTruncated: !eof}
 	for _, objInfo := range objInfos {
 		result.NextMarker = objInfo.Name
-		if objInfo.IsDir {
-			result.Prefixes = append(result.Prefixes, objInfo.Name)
-			continue
-		}
-
-		// Add each object seen to the result - objects are
-		// checked for healing later.
-		result.Objects = append(result.Objects, ObjectInfo{
-			Bucket:  bucket,
-			Name:    objInfo.Name,
-			ModTime: objInfo.ModTime,
-			Size:    objInfo.Size,
-			IsDir:   false,
-		})
+		result.Objects = append(result.Objects, objInfo)
 	}
 	return result, nil
 }

cmd/xl-sets_test.go

@@ -98,46 +98,6 @@ func TestNewXLSets(t *testing.T) {
 	}
 }
 
-// TestStorageInfoSets - tests storage info for erasure coded sets of disks.
-func TestStorageInfoSets(t *testing.T) {
-	var nDisks = 16 // Maximum disks.
-	var erasureDisks []string
-	for i := 0; i < nDisks; i++ {
-		// Do not attempt to create this path, the test validates
-		// so that newXLSets initializes non existing paths
-		// and successfully returns initialized object layer.
-		disk := filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
-		erasureDisks = append(erasureDisks, disk)
-		defer os.RemoveAll(disk)
-	}
-
-	endpoints := mustGetNewEndpointList(erasureDisks...)
-	// Initializes all erasure disks
-	format, err := waitForFormatXL(context.Background(), true, endpoints, 1, 16)
-	if err != nil {
-		t.Fatalf("Unable to format disks for erasure, %s", err)
-	}
-
-	objLayer, err := newXLSets(endpoints, format, 1, 16)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Get storage info first attempt.
-	disks16Info := objLayer.StorageInfo(context.Background())
-
-	// This test assumes homogeneity between all disks,
-	// i.e if we loose one disk the effective storage
-	// usage values is assumed to decrease. If we have
-	// heterogenous environment this is not true all the time.
-	if disks16Info.Free <= 0 {
-		t.Fatalf("Diskinfo total free values should be greater 0")
-	}
-	if disks16Info.Total <= 0 {
-		t.Fatalf("Diskinfo total values should be greater 0")
-	}
-}
-
 // TestHashedLayer - tests the hashed layer which will be returned
 // consistently for a given object name.
 func TestHashedLayer(t *testing.T) {

cmd/xl-v1-bucket.go

@@ -137,7 +137,6 @@ func (xl xlObjects) getBucketInfo(ctx context.Context, bucketName string) (bucke
 			}
 			return bucketInfo, nil
 		}
-		logger.LogIf(ctx, serr)
 		err = serr
 		// For any reason disk went offline continue and pick the next one.
 		if IsErrIgnored(err, bucketMetadataOpIgnoredErrs...) {

cmd/xl-v1-common.go

@@ -76,6 +76,32 @@ func (xl xlObjects) isObject(bucket, prefix string) (ok bool) {
 	return false
 }
 
+// isObjectDir returns if the specified path represents an empty directory.
+func (xl xlObjects) isObjectDir(bucket, prefix string) (ok bool) {
+	for _, disk := range xl.getLoadBalancedDisks() {
+		if disk == nil {
+			continue
+		}
+		// Check if 'prefix' is an object on this 'disk', else continue the check the next disk
+		ctnts, err := disk.ListDir(bucket, prefix, 1)
+		if err == nil {
+			if len(ctnts) == 0 {
+				return true
+			}
+			return false
+		}
+		// Ignore for file not found,  disk not found or faulty disk.
+		if IsErrIgnored(err, xlTreeWalkIgnoredErrs...) {
+			continue
+		}
+		reqInfo := &logger.ReqInfo{BucketName: bucket}
+		reqInfo.AppendTags("prefix", prefix)
+		ctx := logger.SetReqInfo(context.Background(), reqInfo)
+		logger.LogIf(ctx, err)
+	} // Exhausted all disks - return false.
+	return false
+}
+
 // Calculate the space occupied by an object in a single disk
 func (xl xlObjects) sizeOnDisk(fileSize int64, blockSize int64, dataBlocks int) int64 {
 	numBlocks := fileSize / blockSize

cmd/xl-v1-healing.go

@@ -422,7 +422,7 @@ func healObject(ctx context.Context, storageDisks []StorageAPI, bucket string, o
 		}
 
 		// List and delete the object directory,
-		files, derr := disk.ListDir(bucket, object)
+		files, derr := disk.ListDir(bucket, object, -1)
 		if derr == nil {
 			for _, entry := range files {
 				_ = disk.DeleteFile(bucket,
@@ -539,12 +539,74 @@ func healObject(ctx context.Context, storageDisks []StorageAPI, bucket string, o
 	return result, nil
 }
 
+// healObjectDir - heals object directory specifically, this special call
+// is needed since we do not have a special backend format for directories.
+func (xl xlObjects) healObjectDir(ctx context.Context, bucket, object string, dryRun bool) (hr madmin.HealResultItem, err error) {
+	storageDisks := xl.getDisks()
+
+	// Initialize heal result object
+	hr = madmin.HealResultItem{
+		Type:         madmin.HealItemObject,
+		Bucket:       bucket,
+		Object:       object,
+		DiskCount:    len(storageDisks),
+		ParityBlocks: len(storageDisks) / 2,
+		DataBlocks:   len(storageDisks) / 2,
+		ObjectSize:   0,
+	}
+
+	// Prepare object creation in all disks
+	for _, disk := range storageDisks {
+		if disk == nil {
+			hr.Before.Drives = append(hr.Before.Drives, madmin.HealDriveInfo{
+				UUID:  "",
+				State: madmin.DriveStateOffline,
+			})
+			hr.After.Drives = append(hr.After.Drives, madmin.HealDriveInfo{
+				UUID:  "",
+				State: madmin.DriveStateMissing,
+			})
+			continue
+		}
+
+		drive := disk.String()
+		hr.Before.Drives = append(hr.Before.Drives, madmin.HealDriveInfo{
+			UUID:     "",
+			Endpoint: drive,
+			State:    madmin.DriveStateMissing,
+		})
+		hr.After.Drives = append(hr.After.Drives, madmin.HealDriveInfo{
+			UUID:     "",
+			Endpoint: drive,
+			State:    madmin.DriveStateMissing,
+		})
+
+		if !dryRun {
+			if err := disk.MakeVol(pathJoin(bucket, object)); err != nil && err != errVolumeExists {
+				return hr, toObjectErr(err, bucket, object)
+			}
+
+			for i, v := range hr.Before.Drives {
+				if v.Endpoint == drive {
+					hr.After.Drives[i].State = madmin.DriveStateOk
+				}
+			}
+		}
+	}
+	return hr, nil
+}
+
 // HealObject - heal the given object.
 //
 // FIXME: If an object object was deleted and one disk was down,
 // and later the disk comes back up again, heal on the object
 // should delete it.
 func (xl xlObjects) HealObject(ctx context.Context, bucket, object string, dryRun bool) (hr madmin.HealResultItem, err error) {
+	// Healing directories handle it separately.
+	if hasSuffix(object, slashSeparator) {
+		return xl.healObjectDir(ctx, bucket, object, dryRun)
+	}
+
 	// FIXME: Metadata is read again in the healObject() call below.
 	// Read metadata files from all the disks
 	partsMetadata, errs := readAllXLMetadata(ctx, xl.getDisks(), bucket, object)

cmd/xl-v1-list-objects.go

@@ -33,7 +33,7 @@ func listDirFactory(ctx context.Context, isLeaf isLeafFunc, treeWalkIgnoredErrs
 			}
 			var entries []string
 			var newEntries []string
-			entries, err = disk.ListDir(bucket, prefixDir)
+			entries, err = disk.ListDir(bucket, prefixDir, -1)
 			if err != nil {
 				// For any reason disk was deleted or goes offline, continue
 				// and list from other disks if possible.
@@ -78,8 +78,9 @@ func (xl xlObjects) listObjects(ctx context.Context, bucket, prefix, marker, del
 	if walkResultCh == nil {
 		endWalkCh = make(chan struct{})
 		isLeaf := xl.isObject
+		isLeafDir := xl.isObjectDir
 		listDir := listDirFactory(ctx, isLeaf, xlTreeWalkIgnoredErrs, xl.getLoadBalancedDisks()...)
-		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, isLeaf, endWalkCh)
+		walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, isLeaf, isLeafDir, endWalkCh)
 	}
 
 	var objInfos []ObjectInfo
@@ -136,7 +137,7 @@ func (xl xlObjects) listObjects(ctx context.Context, bucket, prefix, marker, del
 	result := ListObjectsInfo{IsTruncated: !eof}
 	for _, objInfo := range objInfos {
 		result.NextMarker = objInfo.Name
-		if objInfo.IsDir {
+		if objInfo.IsDir && delimiter == slashSeparator {
 			result.Prefixes = append(result.Prefixes, objInfo.Name)
 			continue
 		}

cmd/xl-v1-multipart.go

@@ -156,7 +156,7 @@ func (xl xlObjects) ListMultipartUploads(ctx context.Context, bucket, object, ke
 		if disk == nil {
 			continue
 		}
-		uploadIDs, err := disk.ListDir(minioMetaMultipartBucket, xl.getMultipartSHADir(bucket, object))
+		uploadIDs, err := disk.ListDir(minioMetaMultipartBucket, xl.getMultipartSHADir(bucket, object), -1)
 		if err != nil {
 			if err == errFileNotFound {
 				return result, nil
@@ -862,12 +862,12 @@ func (xl xlObjects) cleanupStaleMultipartUploads(ctx context.Context, cleanupInt
 // Remove the old multipart uploads on the given disk.
 func (xl xlObjects) cleanupStaleMultipartUploadsOnDisk(ctx context.Context, disk StorageAPI, expiry time.Duration) {
 	now := time.Now()
-	shaDirs, err := disk.ListDir(minioMetaMultipartBucket, "")
+	shaDirs, err := disk.ListDir(minioMetaMultipartBucket, "", -1)
 	if err != nil {
 		return
 	}
 	for _, shaDir := range shaDirs {
-		uploadIDDirs, err := disk.ListDir(minioMetaMultipartBucket, shaDir)
+		uploadIDDirs, err := disk.ListDir(minioMetaMultipartBucket, shaDir, -1)
 		if err != nil {
 			continue
 		}

cmd/xl-v1-object.go

@@ -359,6 +359,9 @@ func (xl xlObjects) GetObjectInfo(ctx context.Context, bucket, object string) (o
 	}
 
 	if hasSuffix(object, slashSeparator) {
+		if !xl.isObjectDir(bucket, object) {
+			return oi, toObjectErr(errFileNotFound, bucket, object)
+		}
 		if oi, e = xl.getObjectInfoDir(ctx, bucket, object); e != nil {
 			return oi, toObjectErr(e, bucket, object)
 		}
@@ -829,7 +832,6 @@ func (xl xlObjects) DeleteObject(ctx context.Context, bucket, object string) (er
 
 	// Validate object exists.
 	if !xl.isObject(bucket, object) {
-		logger.LogIf(ctx, ObjectNotFound{bucket, object})
 		return ObjectNotFound{bucket, object}
 	} // else proceed to delete the object.
 

cmd/xl-v1-utils.go

@@ -66,7 +66,7 @@ func reduceErrs(errs []error, ignoredErrs []error) (maxCount int, maxErr error)
 func reduceQuorumErrs(ctx context.Context, errs []error, ignoredErrs []error, quorum int, quorumErr error) error {
 	maxCount, maxErr := reduceErrs(errs, ignoredErrs)
 	if maxCount >= quorum {
-		if maxErr != errFileNotFound {
+		if maxErr != errFileNotFound && maxErr != errVolumeNotFound {
 			logger.LogIf(ctx, maxErr)
 		}
 		return maxErr

cmd/xl-v1.go

@@ -23,7 +23,6 @@ import (
 
 	"github.com/minio/minio/cmd/logger"
 	"github.com/minio/minio/pkg/bpool"
-	"github.com/minio/minio/pkg/disk"
 )
 
 // XL constants.
@@ -118,7 +117,7 @@ func (xl xlObjects) ClearLocks(ctx context.Context, volLocks []VolumeLockInfo) e
 }
 
 // byDiskTotal is a collection satisfying sort.Interface.
-type byDiskTotal []disk.Info
+type byDiskTotal []DiskInfo
 
 func (d byDiskTotal) Len() int      { return len(d) }
 func (d byDiskTotal) Swap(i, j int) { d[i], d[j] = d[j], d[i] }
@@ -127,8 +126,8 @@ func (d byDiskTotal) Less(i, j int) bool {
 }
 
 // getDisksInfo - fetch disks info across all other storage API.
-func getDisksInfo(disks []StorageAPI) (disksInfo []disk.Info, onlineDisks int, offlineDisks int) {
-	disksInfo = make([]disk.Info, len(disks))
+func getDisksInfo(disks []StorageAPI) (disksInfo []DiskInfo, onlineDisks int, offlineDisks int) {
+	disksInfo = make([]DiskInfo, len(disks))
 	for i, storageDisk := range disks {
 		if storageDisk == nil {
 			// Storage disk is empty, perhaps ignored disk or not available.
@@ -154,8 +153,8 @@ func getDisksInfo(disks []StorageAPI) (disksInfo []disk.Info, onlineDisks int, o
 // returns sorted disksInfo slice which has only valid entries.
 // i.e the entries where the total size of the disk is not stated
 // as 0Bytes, this means that the disk is not online or ignored.
-func sortValidDisksInfo(disksInfo []disk.Info) []disk.Info {
-	var validDisksInfo []disk.Info
+func sortValidDisksInfo(disksInfo []DiskInfo) []DiskInfo {
+	var validDisksInfo []DiskInfo
 	for _, diskInfo := range disksInfo {
 		if diskInfo.Total == 0 {
 			continue
@@ -174,10 +173,7 @@ func getStorageInfo(disks []StorageAPI) StorageInfo {
 	validDisksInfo := sortValidDisksInfo(disksInfo)
 	// If there are no valid disks, set total and free disks to 0
 	if len(validDisksInfo) == 0 {
-		return StorageInfo{
-			Total: 0,
-			Free:  0,
-		}
+		return StorageInfo{}
 	}
 
 	_, sscParity := getRedundancyCount(standardStorageClass, len(disks))
@@ -193,13 +189,14 @@ func getStorageInfo(disks []StorageAPI) StorageInfo {
 		availableDataDisks = uint64(onlineDisks)
 	}
 
-	// Return calculated storage info, choose the lowest Total and
-	// Free as the total aggregated values. Total capacity is always
-	// the multiple of smallest disk among the disk list.
-	storageInfo := StorageInfo{
-		Total: validDisksInfo[0].Total * availableDataDisks,
-		Free:  validDisksInfo[0].Free * availableDataDisks,
+	storageInfo := StorageInfo{}
+
+	// Combine all disks to get total usage.
+	var used uint64
+	for _, di := range validDisksInfo {
+		used = used + di.Used
 	}
+	storageInfo.Used = used
 
 	storageInfo.Backend.Type = Erasure
 	storageInfo.Backend.OnlineDisks = onlineDisks

cmd/xl-v1_test.go

@@ -17,56 +17,25 @@
 package cmd
 
 import (
-	"context"
-	"os"
 	"reflect"
 	"testing"
-
-	"github.com/minio/minio/pkg/disk"
 )
 
-// TestStorageInfo - tests storage info.
-func TestStorageInfo(t *testing.T) {
-	objLayer, fsDirs, err := prepareXL16()
-	if err != nil {
-		t.Fatalf("Unable to initialize 'XL' object layer.")
-	}
-
-	// Remove all dirs.
-	for _, dir := range fsDirs {
-		defer os.RemoveAll(dir)
-	}
-
-	// Get storage info first attempt.
-	disks16Info := objLayer.StorageInfo(context.Background())
-
-	// This test assumes homogenity between all disks,
-	// i.e if we loose one disk the effective storage
-	// usage values is assumed to decrease. If we have
-	// heterogenous environment this is not true all the time.
-	if disks16Info.Free <= 0 {
-		t.Fatalf("Diskinfo total free values should be greater 0")
-	}
-	if disks16Info.Total <= 0 {
-		t.Fatalf("Diskinfo total values should be greater 0")
-	}
-}
-
 // Sort valid disks info.
 func TestSortingValidDisks(t *testing.T) {
 	testCases := []struct {
-		disksInfo      []disk.Info
-		validDisksInfo []disk.Info
+		disksInfo      []DiskInfo
+		validDisksInfo []DiskInfo
 	}{
 		// One of the disks is offline.
 		{
-			disksInfo: []disk.Info{
+			disksInfo: []DiskInfo{
 				{Total: 150, Free: 10},
 				{Total: 0, Free: 0},
 				{Total: 200, Free: 10},
 				{Total: 100, Free: 10},
 			},
-			validDisksInfo: []disk.Info{
+			validDisksInfo: []DiskInfo{
 				{Total: 100, Free: 10},
 				{Total: 150, Free: 10},
 				{Total: 200, Free: 10},
@@ -74,13 +43,13 @@ func TestSortingValidDisks(t *testing.T) {
 		},
 		// All disks are online.
 		{
-			disksInfo: []disk.Info{
+			disksInfo: []DiskInfo{
 				{Total: 150, Free: 10},
 				{Total: 200, Free: 10},
 				{Total: 100, Free: 10},
 				{Total: 115, Free: 10},
 			},
-			validDisksInfo: []disk.Info{
+			validDisksInfo: []DiskInfo{
 				{Total: 100, Free: 10},
 				{Total: 115, Free: 10},
 				{Total: 150, Free: 10},

docs/metric/README.md

@@ -1,38 +0,0 @@
-## Minio Prometheus Metric
-
-Minio server exposes an endpoint for Promethueus to scrape server data at `/minio/metric`.
-
-### Prometheus probe
-Prometheus is used to monitor Minio server information like http request, disk storage, network stats etc.. It uses a config file named `prometheus.yaml` to scrape data from server. The value for `metrics_path` and `targets` need to be configured in the config yaml to specify the endpoint and url as shown:
-```
-scrape_configs:
-  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
-  - job_name: minio
-    metrics_path: /minio/prometheus/metrics
-
-    # metrics_path defaults to '/metrics'
-    # scheme defaults to 'http'.
-
-    static_configs:
-      - targets: ['localhost:9000']
-```
- Prometheus can be run by executing :
-```
-./prometheus --config.file=prometheus.yml
-```
-
-### List of Minio metric exposed
-Minio exposes the following list of metric to Prometheus
-```
-minio_disk_storage_bytes
-minio_disk_storage_free_bytes
-minio_http_requests_duration_seconds_bucket
-minio_http_requests_duration_seconds_count
-minio_http_requests_duration_seconds_sum
-minio_http_requests_total
-minio_network_received_bytes
-minio_network_sent_bytes
-minio_offline_disks_total
-minio_online_disks_total
-minio_server_uptime_seconds
-```

docs/metrics/README.md

@@ -0,0 +1,20 @@
+## Minio Monitoring Guide
+
+Minio server exposes monitoring data over un-authenticated endpoints so monitoring tools can pick the data without you having to share Minio server credentials. This document lists the monitoring endpoints and relevant documentation.
+
+### Healthcheck Probe
+
+Minio server has two healthcheck related endpoints, a liveness probe to indicate if server is working fine and a readiness probe to indicate if server is not accepting connections due to heavy load.
+
+- Liveness probe available at `/minio/health/live`
+- Readiness probe available at `/minio/health/ready`
+
+Read more on how to use these endpoints in [Minio healthcheck guide](https://github.com/minio/minio/blob/master/docs/metrics/healthcheck/README.md).
+
+### Prometheus Probe
+
+Minio server exposes Prometheus compatible data on a single endpoint.
+
+- Prometheus data available at `/minio/prometheus/metrics`
+
+To use this endpoint, setup Prometheus to scrape data from this endpoint. Read more on how to use Prometheues to monitor Minio server in [How to monitor Minio server with Prometheus](https://github.com/minio/cookbook/blob/master/docs/how-to-monitor-minio-with-prometheus.md).

docs/metrics/healthcheck/README.md

@@ -4,11 +4,11 @@ Minio server exposes two un-authenticated, healthcheck endpoints - liveness prob
 
 ### Liveness probe
 
-This probe is used to identify situations where the server is running but may not behave optimally, i.e. sluggish response or corrupt backend. Such problems can be *only* fixed by a restart.
+This probe is used to identify situations where the server is running but may not behave optimally, i.e. sluggish response or corrupt back-end. Such problems can be *only* fixed by a restart.
 
 Internally, Minio liveness probe handler does a ListBuckets call. If successful, the server returns 200 OK, otherwise 503 Service Unavailable.
 
-When liveness probe fails, Kubernetes like platforms restart the container. 
+When liveness probe fails, Kubernetes like platforms restart the container.
 
 ### Readiness probe
 

docs/orchestration/docker-compose/docker-compose.yaml

@@ -5,7 +5,7 @@ version: '2'
 # 9001 through 9004.
 services:
  minio1:
-  image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+  image: minio/minio:RELEASE.2018-05-16T23-35-33Z
   volumes:
    - data1:/data
   ports:
@@ -15,7 +15,7 @@ services:
    MINIO_SECRET_KEY: minio123
   command: server http://minio1/data http://minio2/data http://minio3/data http://minio4/data 
  minio2:
-  image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+  image: minio/minio:RELEASE.2018-05-16T23-35-33Z
   volumes:
    - data2:/data
   ports:
@@ -25,7 +25,7 @@ services:
    MINIO_SECRET_KEY: minio123
   command: server http://minio1/data http://minio2/data http://minio3/data http://minio4/data 
  minio3:
-  image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+  image: minio/minio:RELEASE.2018-05-16T23-35-33Z
   volumes:
    - data3:/data
   ports:
@@ -35,7 +35,7 @@ services:
    MINIO_SECRET_KEY: minio123
   command: server http://minio1/data http://minio2/data http://minio3/data http://minio4/data 
  minio4:
-  image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+  image: minio/minio:RELEASE.2018-05-16T23-35-33Z
   volumes:
    - data4:/data
   ports:

docs/orchestration/docker-swarm/docker-compose-secrets.yaml

@@ -2,7 +2,7 @@ version: '3.1'
 
 services:
   minio1:
-    image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+    image: minio/minio:RELEASE.2018-05-16T23-35-33Z
     volumes:
       - minio1-data:/export
     ports:
@@ -20,7 +20,7 @@ services:
       - access_key
 
   minio2:
-    image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+    image: minio/minio:RELEASE.2018-05-16T23-35-33Z
     volumes:
       - minio2-data:/export
     ports:
@@ -38,7 +38,7 @@ services:
       - access_key
 
   minio3:
-    image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+    image: minio/minio:RELEASE.2018-05-16T23-35-33Z
     volumes:
       - minio3-data:/export
     ports:
@@ -56,7 +56,7 @@ services:
       - access_key
 
   minio4:
-    image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+    image: minio/minio:RELEASE.2018-05-16T23-35-33Z
     volumes:
       - minio4-data:/export
     ports:

docs/orchestration/docker-swarm/docker-compose.yaml

@@ -2,7 +2,7 @@ version: '3'
 
 services:
   minio1:
-    image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+    image: minio/minio:RELEASE.2018-05-16T23-35-33Z
     volumes:
       - minio1-data:/export
     ports:
@@ -20,7 +20,7 @@ services:
     command: server http://minio1/export http://minio2/export http://minio3/export http://minio4/export
 
   minio2:
-    image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+    image: minio/minio:RELEASE.2018-05-16T23-35-33Z
     volumes:
       - minio2-data:/export
     ports:
@@ -38,7 +38,7 @@ services:
     command: server http://minio1/export http://minio2/export http://minio3/export http://minio4/export
 
   minio3:
-    image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+    image: minio/minio:RELEASE.2018-05-16T23-35-33Z
     volumes:
       - minio3-data:/export
     ports:
@@ -56,7 +56,7 @@ services:
     command: server http://minio1/export http://minio2/export http://minio3/export http://minio4/export
 
   minio4:
-    image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+    image: minio/minio:RELEASE.2018-05-16T23-35-33Z
     volumes:
       - minio4-data:/export
     ports:

docs/orchestration/kubernetes-yaml/README.md

@@ -124,7 +124,7 @@ spec:
         - name: data 
           mountPath: "/data"
         # Pulls the lastest Minio image from Docker Hub
-        image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+        image: minio/minio:RELEASE.2018-05-16T23-35-33Z
         args:
         - server
         - /data
@@ -303,7 +303,7 @@ spec:
           value: "minio"
         - name: MINIO_SECRET_KEY
           value: "minio123"
-        image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+        image: minio/minio:RELEASE.2018-05-16T23-35-33Z
         args:
         - server
         - http://minio-0.minio.default.svc.cluster.local/data
@@ -514,7 +514,7 @@ spec:
       containers:
       - name: minio
         # Pulls the default Minio image from Docker Hub
-        image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+        image: minio/minio:RELEASE.2018-05-16T23-35-33Z
         args:
         - gateway
         - gcs

docs/orchestration/kubernetes-yaml/minio-distributed-statefulset.yaml

@@ -21,7 +21,7 @@ spec:
           value: "minio"
         - name: MINIO_SECRET_KEY
           value: "minio123"
-        image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+        image: minio/minio:RELEASE.2018-05-16T23-35-33Z
         args:
         - server
         - http://minio-0.minio.default.svc.cluster.local/data

docs/orchestration/kubernetes-yaml/minio-gcs-gateway-deployment.yaml

@@ -21,7 +21,7 @@ spec:
       containers:
       - name: minio
         # Pulls the default Minio image from Docker Hub
-        image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+        image: minio/minio:RELEASE.2018-05-16T23-35-33Z
         args:
         - gateway
         - gcs

docs/orchestration/kubernetes-yaml/minio-standalone-deployment.yaml

@@ -29,7 +29,7 @@ spec:
         - name: data 
           mountPath: "/data"
         # Pulls the lastest Minio image from Docker Hub
-        image: minio/minio:RELEASE.2018-04-27T23-33-52Z
+        image: minio/minio:RELEASE.2018-05-16T23-35-33Z
         args:
         - server
         - /data