minio/cmd/errors.go

/*
 * Minio Cloud Storage, (C) 2016 Minio, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package cmd

import (
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"strings"
)

// Holds the current directory path. Used for trimming path in traceError()
var rootPath string

// Figure out the rootPath
func initError() {
	// Root path is automatically determined from the calling function's source file location.
	// Catch the calling function's source file path.
	_, file, _, _ := runtime.Caller(1)
	// Save the directory alone.
	rootPath = filepath.Dir(file)
}

// Represents a stack frame in the stack trace.
type traceInfo struct {
	file string // File where error occurred
	line int    // Line where error occurred
	name string // Name of the function where error occurred
}

// Error - error type containing cause and the stack trace.
type Error struct {
	e     error       // Holds the cause error
	trace []traceInfo // stack trace
	errs  []error     // Useful for XL to hold errors from all disks
}

// Implement error interface.
func (e Error) Error() string {
	return e.e.Error()
}

// Trace - returns stack trace.
func (e Error) Trace() []string {
	var traceArr []string
	for _, info := range e.trace {
		traceArr = append(traceArr, fmt.Sprintf("%s:%d:%s",
			info.file, info.line, info.name))
	}
	return traceArr
}

// NewStorageError - return new Error type.
func traceError(e error, errs ...error) error {
	if e == nil {
		return nil
	}
	err := &Error{}
	err.e = e
	err.errs = errs

	stack := make([]uintptr, 40)
	length := runtime.Callers(2, stack)
	if length > len(stack) {
		length = len(stack)
	}
	stack = stack[:length]

	for _, pc := range stack {
		pc = pc - 1
		fn := runtime.FuncForPC(pc)
		file, line := fn.FileLine(pc)
		name := fn.Name()
		if hasSuffix(name, "ServeHTTP") {
			break
		}
		if hasSuffix(name, "runtime.") {
			break
		}

		file = strings.TrimPrefix(file, rootPath+string(os.PathSeparator))
		name = strings.TrimPrefix(name, "github.com/minio/minio/cmd.")
		err.trace = append(err.trace, traceInfo{file, line, name})
	}

	return err
}

// Returns the underlying cause error.
func errorCause(err error) error {
	if e, ok := err.(*Error); ok {
		err = e.e
	}
	return err
}

// Returns slice of underlying cause error.
func errorsCause(errs []error) []error {
	cerrs := make([]error, len(errs))
	for i, err := range errs {
		if err == nil {
			continue
		}
		cerrs[i] = errorCause(err)
	}
	return cerrs
}

// Collection of basic errors.
var baseErrs = []error{
	errDiskNotFound,
	errFaultyDisk,
	errFaultyRemoteDisk,
}

var baseIgnoredErrs = baseErrs

// isErrIgnored returns whether given error is ignored or not.
func isErrIgnored(err error, ignoredErrs ...error) bool {
	err = errorCause(err)
	for _, ignoredErr := range ignoredErrs {
		if ignoredErr == err {
			return true
		}
	}
	return false
}

// isErr returns whether given error is exact error.
func isErr(err error, errs ...error) bool {
	err = errorCause(err)
	for _, exactErr := range errs {
		if err == exactErr {
			return true
		}
	}
	return false
}

// traceErrorf behaves like fmt.traceErrorf but also traces the returned error.
func traceErrorf(format string, args ...interface{}) error {
	return traceError(fmt.Errorf(format, args...))
}