@@ -46,8 +46,9 @@ github.com/armon/go-metrics                         eb0af217e5e9747e41dd53037553

 github.com/hashicorp/go-msgpack                     71c2886f5a673a35f909803f38ece5810165097b

 github.com/hashicorp/memberlist                     3d8438da9589e7b608a83ffac1ef8211486bcb7c

 github.com/sean-/seed                               e2103e2c35297fb7e17febb81e49b312087a2372

+github.com/hashicorp/errwrap                        8a6fb523712970c966eefc6b39ed2c5e74880354 # v1.0.0

 github.com/hashicorp/go-sockaddr                    6d291a969b86c4b633730bfc6b8b9d64c3aafed9

-github.com/hashicorp/go-multierror                  fcdddc395df1ddf4247c69bd436e84cfa0733f7e

+github.com/hashicorp/go-multierror                  886a7fbe3eb1c874d46f623bfa70af45f425b3d1 # v1.0.0

 github.com/hashicorp/serf                           598c54895cc5a7b1a24a398d635e8c0ea0959870

 github.com/docker/libkv                             458977154600b9f23984d9f4b82e79570b5ae12b

 github.com/vishvananda/netns                        7109fa855b0ff1ebef7fbd2f6aa613e8db7cfbc0

new file mode 100644

@@ -0,0 +1,354 @@

+Mozilla Public License, version 2.0

+

+1. Definitions

+

+1.1. “Contributor”

+

+     means each individual or legal entity that creates, contributes to the

+     creation of, or owns Covered Software.

+

+1.2. “Contributor Version”

+

+     means the combination of the Contributions of others (if any) used by a

+     Contributor and that particular Contributor’s Contribution.

+

+1.3. “Contribution”

+

+     means Covered Software of a particular Contributor.

+

+1.4. “Covered Software”

+

+     means Source Code Form to which the initial Contributor has attached the

+     notice in Exhibit A, the Executable Form of such Source Code Form, and

+     Modifications of such Source Code Form, in each case including portions

+     thereof.

+

+1.5. “Incompatible With Secondary Licenses”

+     means

+

+     a. that the initial Contributor has attached the notice described in

+        Exhibit B to the Covered Software; or

+

+     b. that the Covered Software was made available under the terms of version

+        1.1 or earlier of the License, but not also under the terms of a

+        Secondary License.

+

+1.6. “Executable Form”

+

+     means any form of the work other than Source Code Form.

+

+1.7. “Larger Work”

+

+     means a work that combines Covered Software with other material, in a separate

+     file or files, that is not Covered Software.

+

+1.8. “License”

+

+     means this document.

+

+1.9. “Licensable”

+

+     means having the right to grant, to the maximum extent possible, whether at the

+     time of the initial grant or subsequently, any and all of the rights conveyed by

+     this License.

+

+1.10. “Modifications”

+

+     means any of the following:

+

+     a. any file in Source Code Form that results from an addition to, deletion

+        from, or modification of the contents of Covered Software; or

+

+     b. any new file in Source Code Form that contains any Covered Software.

+

+1.11. “Patent Claims” of a Contributor

+

+      means any patent claim(s), including without limitation, method, process,

+      and apparatus claims, in any patent Licensable by such Contributor that

+      would be infringed, but for the grant of the License, by the making,

+      using, selling, offering for sale, having made, import, or transfer of

+      either its Contributions or its Contributor Version.

+

+1.12. “Secondary License”

+

+      means either the GNU General Public License, Version 2.0, the GNU Lesser

+      General Public License, Version 2.1, the GNU Affero General Public

+      License, Version 3.0, or any later versions of those licenses.

+

+1.13. “Source Code Form”

+

+      means the form of the work preferred for making modifications.

+

+1.14. “You” (or “Your”)

+

+      means an individual or a legal entity exercising rights under this

+      License. For legal entities, “You” includes any entity that controls, is

+      controlled by, or is under common control with You. For purposes of this

+      definition, “control” means (a) the power, direct or indirect, to cause

+      the direction or management of such entity, whether by contract or

+      otherwise, or (b) ownership of more than fifty percent (50%) of the

+      outstanding shares or beneficial ownership of such entity.

+

+

+2. License Grants and Conditions

+

+2.1. Grants

+

+     Each Contributor hereby grants You a world-wide, royalty-free,

+     non-exclusive license:

+

+     a. under intellectual property rights (other than patent or trademark)

+        Licensable by such Contributor to use, reproduce, make available,

+        modify, display, perform, distribute, and otherwise exploit its

+        Contributions, either on an unmodified basis, with Modifications, or as

+        part of a Larger Work; and

+

+     b. under Patent Claims of such Contributor to make, use, sell, offer for

+        sale, have made, import, and otherwise transfer either its Contributions

+        or its Contributor Version.

+

+2.2. Effective Date

+

+     The licenses granted in Section 2.1 with respect to any Contribution become

+     effective for each Contribution on the date the Contributor first distributes

+     such Contribution.

+

+2.3. Limitations on Grant Scope

+

+     The licenses granted in this Section 2 are the only rights granted under this

+     License. No additional rights or licenses will be implied from the distribution

+     or licensing of Covered Software under this License. Notwithstanding Section

+     2.1(b) above, no patent license is granted by a Contributor:

+

+     a. for any code that a Contributor has removed from Covered Software; or

+

+     b. for infringements caused by: (i) Your and any other third party’s

+        modifications of Covered Software, or (ii) the combination of its

+        Contributions with other software (except as part of its Contributor

+        Version); or

+

+     c. under Patent Claims infringed by Covered Software in the absence of its

+        Contributions.

+

+     This License does not grant any rights in the trademarks, service marks, or

+     logos of any Contributor (except as may be necessary to comply with the

+     notice requirements in Section 3.4).

+

+2.4. Subsequent Licenses

+

+     No Contributor makes additional grants as a result of Your choice to

+     distribute the Covered Software under a subsequent version of this License

+     (see Section 10.2) or under the terms of a Secondary License (if permitted

+     under the terms of Section 3.3).

+

+2.5. Representation

+

+     Each Contributor represents that the Contributor believes its Contributions

+     are its original creation(s) or it has sufficient rights to grant the

+     rights to its Contributions conveyed by this License.

+

+2.6. Fair Use

+

+     This License is not intended to limit any rights You have under applicable

+     copyright doctrines of fair use, fair dealing, or other equivalents.

+

+2.7. Conditions

+

+     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in

+     Section 2.1.

+

+

+3. Responsibilities

+

+3.1. Distribution of Source Form

+

+     All distribution of Covered Software in Source Code Form, including any

+     Modifications that You create or to which You contribute, must be under the

+     terms of this License. You must inform recipients that the Source Code Form

+     of the Covered Software is governed by the terms of this License, and how

+     they can obtain a copy of this License. You may not attempt to alter or

+     restrict the recipients’ rights in the Source Code Form.

+

+3.2. Distribution of Executable Form

+

+     If You distribute Covered Software in Executable Form then:

+

+     a. such Covered Software must also be made available in Source Code Form,

+        as described in Section 3.1, and You must inform recipients of the

+        Executable Form how they can obtain a copy of such Source Code Form by

+        reasonable means in a timely manner, at a charge no more than the cost

+        of distribution to the recipient; and

+

+     b. You may distribute such Executable Form under the terms of this License,

+        or sublicense it under different terms, provided that the license for

+        the Executable Form does not attempt to limit or alter the recipients’

+        rights in the Source Code Form under this License.

+

+3.3. Distribution of a Larger Work

+

+     You may create and distribute a Larger Work under terms of Your choice,

+     provided that You also comply with the requirements of this License for the

+     Covered Software. If the Larger Work is a combination of Covered Software

+     with a work governed by one or more Secondary Licenses, and the Covered

+     Software is not Incompatible With Secondary Licenses, this License permits

+     You to additionally distribute such Covered Software under the terms of

+     such Secondary License(s), so that the recipient of the Larger Work may, at

+     their option, further distribute the Covered Software under the terms of

+     either this License or such Secondary License(s).

+

+3.4. Notices

+

+     You may not remove or alter the substance of any license notices (including

+     copyright notices, patent notices, disclaimers of warranty, or limitations

+     of liability) contained within the Source Code Form of the Covered

+     Software, except that You may alter any license notices to the extent

+     required to remedy known factual inaccuracies.

+

+3.5. Application of Additional Terms

+

+     You may choose to offer, and to charge a fee for, warranty, support,

+     indemnity or liability obligations to one or more recipients of Covered

+     Software. However, You may do so only on Your own behalf, and not on behalf

+     of any Contributor. You must make it absolutely clear that any such

+     warranty, support, indemnity, or liability obligation is offered by You

+     alone, and You hereby agree to indemnify every Contributor for any

+     liability incurred by such Contributor as a result of warranty, support,

+     indemnity or liability terms You offer. You may include additional

+     disclaimers of warranty and limitations of liability specific to any

+     jurisdiction.

+

+4. Inability to Comply Due to Statute or Regulation

+

+   If it is impossible for You to comply with any of the terms of this License

+   with respect to some or all of the Covered Software due to statute, judicial

+   order, or regulation then You must: (a) comply with the terms of this License

+   to the maximum extent possible; and (b) describe the limitations and the code

+   they affect. Such description must be placed in a text file included with all

+   distributions of the Covered Software under this License. Except to the

+   extent prohibited by statute or regulation, such description must be

+   sufficiently detailed for a recipient of ordinary skill to be able to

+   understand it.

+

+5. Termination

+

+5.1. The rights granted under this License will terminate automatically if You

+     fail to comply with any of its terms. However, if You become compliant,

+     then the rights granted under this License from a particular Contributor

+     are reinstated (a) provisionally, unless and until such Contributor

+     explicitly and finally terminates Your grants, and (b) on an ongoing basis,

+     if such Contributor fails to notify You of the non-compliance by some

+     reasonable means prior to 60 days after You have come back into compliance.

+     Moreover, Your grants from a particular Contributor are reinstated on an

+     ongoing basis if such Contributor notifies You of the non-compliance by

+     some reasonable means, this is the first time You have received notice of

+     non-compliance with this License from such Contributor, and You become

+     compliant prior to 30 days after Your receipt of the notice.

+

+5.2. If You initiate litigation against any entity by asserting a patent

+     infringement claim (excluding declaratory judgment actions, counter-claims,

+     and cross-claims) alleging that a Contributor Version directly or

+     indirectly infringes any patent, then the rights granted to You by any and

+     all Contributors for the Covered Software under Section 2.1 of this License

+     shall terminate.

+

+5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user

+     license agreements (excluding distributors and resellers) which have been

+     validly granted by You or Your distributors under this License prior to

+     termination shall survive termination.

+

+6. Disclaimer of Warranty

+

+   Covered Software is provided under this License on an “as is” basis, without

+   warranty of any kind, either expressed, implied, or statutory, including,

+   without limitation, warranties that the Covered Software is free of defects,

+   merchantable, fit for a particular purpose or non-infringing. The entire

+   risk as to the quality and performance of the Covered Software is with You.

+   Should any Covered Software prove defective in any respect, You (not any

+   Contributor) assume the cost of any necessary servicing, repair, or

+   correction. This disclaimer of warranty constitutes an essential part of this

+   License. No use of  any Covered Software is authorized under this License

+   except under this disclaimer.

+

+7. Limitation of Liability

+

+   Under no circumstances and under no legal theory, whether tort (including

+   negligence), contract, or otherwise, shall any Contributor, or anyone who

+   distributes Covered Software as permitted above, be liable to You for any

+   direct, indirect, special, incidental, or consequential damages of any

+   character including, without limitation, damages for lost profits, loss of

+   goodwill, work stoppage, computer failure or malfunction, or any and all

+   other commercial damages or losses, even if such party shall have been

+   informed of the possibility of such damages. This limitation of liability

+   shall not apply to liability for death or personal injury resulting from such

+   party’s negligence to the extent applicable law prohibits such limitation.

+   Some jurisdictions do not allow the exclusion or limitation of incidental or

+   consequential damages, so this exclusion and limitation may not apply to You.

+

+8. Litigation

+

+   Any litigation relating to this License may be brought only in the courts of

+   a jurisdiction where the defendant maintains its principal place of business

+   and such litigation shall be governed by laws of that jurisdiction, without

+   reference to its conflict-of-law provisions. Nothing in this Section shall

+   prevent a party’s ability to bring cross-claims or counter-claims.

+

+9. Miscellaneous

+

+   This License represents the complete agreement concerning the subject matter

+   hereof. If any provision of this License is held to be unenforceable, such

+   provision shall be reformed only to the extent necessary to make it

+   enforceable. Any law or regulation which provides that the language of a

+   contract shall be construed against the drafter shall not be used to construe

+   this License against a Contributor.

+

+

+10. Versions of the License

+

+10.1. New Versions

+

+      Mozilla Foundation is the license steward. Except as provided in Section

+      10.3, no one other than the license steward has the right to modify or

+      publish new versions of this License. Each version will be given a

+      distinguishing version number.

+

+10.2. Effect of New Versions

+

+      You may distribute the Covered Software under the terms of the version of

+      the License under which You originally received the Covered Software, or

+      under the terms of any subsequent version published by the license

+      steward.

+

+10.3. Modified Versions

+

+      If you create software not governed by this License, and you want to

+      create a new license for such software, you may create and use a modified

+      version of this License if you rename the license and remove any

+      references to the name of the license steward (except to note that such

+      modified license differs from this License).

+

+10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses

+      If You choose to distribute Source Code Form that is Incompatible With

+      Secondary Licenses under the terms of this version of the License, the

+      notice described in Exhibit B of this License must be attached.

+

+Exhibit A - Source Code Form License Notice

+

+      This Source Code Form is subject to the

+      terms of the Mozilla Public License, v.

+      2.0. If a copy of the MPL was not

+      distributed with this file, You can

+      obtain one at

+      http://mozilla.org/MPL/2.0/.

+

+If it is not possible or desirable to put the notice in a particular file, then

+You may include the notice in a location (such as a LICENSE file in a relevant

+directory) where a recipient would be likely to look for such a notice.

+

+You may add additional accurate notices of copyright ownership.

+

+Exhibit B - “Incompatible With Secondary Licenses” Notice

+

+      This Source Code Form is “Incompatible

+      With Secondary Licenses”, as defined by

+      the Mozilla Public License, v. 2.0.

+

new file mode 100644

@@ -0,0 +1,89 @@

+# errwrap

+

+`errwrap` is a package for Go that formalizes the pattern of wrapping errors

+and checking if an error contains another error.

+

+There is a common pattern in Go of taking a returned `error` value and

+then wrapping it (such as with `fmt.Errorf`) before returning it. The problem

+with this pattern is that you completely lose the original `error` structure.

+

+Arguably the _correct_ approach is that you should make a custom structure

+implementing the `error` interface, and have the original error as a field

+on that structure, such [as this example](http://golang.org/pkg/os/#PathError).

+This is a good approach, but you have to know the entire chain of possible

+rewrapping that happens, when you might just care about one.

+

+`errwrap` formalizes this pattern (it doesn't matter what approach you use

+above) by giving a single interface for wrapping errors, checking if a specific

+error is wrapped, and extracting that error.

+

+## Installation and Docs

+

+Install using `go get github.com/hashicorp/errwrap`.

+

+Full documentation is available at

+http://godoc.org/github.com/hashicorp/errwrap

+

+## Usage

+

+#### Basic Usage

+

+Below is a very basic example of its usage:

+

+```go

+// A function that always returns an error, but wraps it, like a real

+// function might.

+func tryOpen() error {

+	_, err := os.Open("/i/dont/exist")

+	if err != nil {

+		return errwrap.Wrapf("Doesn't exist: {{err}}", err)

+	}

+

+	return nil

+}

+

+func main() {

+	err := tryOpen()

+

+	// We can use the Contains helpers to check if an error contains

+	// another error. It is safe to do this with a nil error, or with

+	// an error that doesn't even use the errwrap package.

+	if errwrap.Contains(err, "does not exist") {

+		// Do something

+	}

+	if errwrap.ContainsType(err, new(os.PathError)) {

+		// Do something

+	}

+

+	// Or we can use the associated `Get` functions to just extract

+	// a specific error. This would return nil if that specific error doesn't

+	// exist.

+	perr := errwrap.GetType(err, new(os.PathError))

+}

+```

+

+#### Custom Types

+

+If you're already making custom types that properly wrap errors, then

+you can get all the functionality of `errwraps.Contains` and such by

+implementing the `Wrapper` interface with just one function. Example:

+

+```go

+type AppError {

+  Code ErrorCode

+  Err  error

+}

+

+func (e *AppError) WrappedErrors() []error {

+  return []error{e.Err}

+}

+```

+

+Now this works:

+

+```go

+err := &AppError{Err: fmt.Errorf("an error")}

+if errwrap.ContainsType(err, fmt.Errorf("")) {

+	// This will work!

+}

+```

new file mode 100644

@@ -0,0 +1,169 @@

+// Package errwrap implements methods to formalize error wrapping in Go.

+//

+// All of the top-level functions that take an `error` are built to be able

+// to take any error, not just wrapped errors. This allows you to use errwrap

+// without having to type-check and type-cast everywhere.

+package errwrap

+

+import (

+	"errors"

+	"reflect"

+	"strings"

+)

+

+// WalkFunc is the callback called for Walk.

+type WalkFunc func(error)

+

+// Wrapper is an interface that can be implemented by custom types to

+// have all the Contains, Get, etc. functions in errwrap work.

+//

+// When Walk reaches a Wrapper, it will call the callback for every

+// wrapped error in addition to the wrapper itself. Since all the top-level

+// functions in errwrap use Walk, this means that all those functions work

+// with your custom type.

+type Wrapper interface {

+	WrappedErrors() []error

+}

+

+// Wrap defines that outer wraps inner, returning an error type that

+// can be cleanly used with the other methods in this package, such as

+// Contains, GetAll, etc.

+//

+// This function won't modify the error message at all (the outer message

+// will be used).

+func Wrap(outer, inner error) error {

+	return &wrappedError{

+		Outer: outer,

+		Inner: inner,

+	}

+}

+

+// Wrapf wraps an error with a formatting message. This is similar to using

+// `fmt.Errorf` to wrap an error. If you're using `fmt.Errorf` to wrap

+// errors, you should replace it with this.

+//

+// format is the format of the error message. The string '{{err}}' will

+// be replaced with the original error message.

+func Wrapf(format string, err error) error {

+	outerMsg := "<nil>"

+	if err != nil {

+		outerMsg = err.Error()

+	}

+

+	outer := errors.New(strings.Replace(

+		format, "{{err}}", outerMsg, -1))

+

+	return Wrap(outer, err)

+}

+

+// Contains checks if the given error contains an error with the

+// message msg. If err is not a wrapped error, this will always return

+// false unless the error itself happens to match this msg.

+func Contains(err error, msg string) bool {

+	return len(GetAll(err, msg)) > 0

+}

+

+// ContainsType checks if the given error contains an error with

+// the same concrete type as v. If err is not a wrapped error, this will

+// check the err itself.

+func ContainsType(err error, v interface{}) bool {

+	return len(GetAllType(err, v)) > 0

+}

+

+// Get is the same as GetAll but returns the deepest matching error.

+func Get(err error, msg string) error {

+	es := GetAll(err, msg)

+	if len(es) > 0 {

+		return es[len(es)-1]

+	}

+

+	return nil

+}

+

+// GetType is the same as GetAllType but returns the deepest matching error.

+func GetType(err error, v interface{}) error {

+	es := GetAllType(err, v)

+	if len(es) > 0 {

+		return es[len(es)-1]

+	}

+

+	return nil

+}

+

+// GetAll gets all the errors that might be wrapped in err with the

+// given message. The order of the errors is such that the outermost

+// matching error (the most recent wrap) is index zero, and so on.

+func GetAll(err error, msg string) []error {

+	var result []error

+

+	Walk(err, func(err error) {

+		if err.Error() == msg {

+			result = append(result, err)

+		}

+	})

+

+	return result

+}

+

+// GetAllType gets all the errors that are the same type as v.

+//

+// The order of the return value is the same as described in GetAll.

+func GetAllType(err error, v interface{}) []error {

+	var result []error

+

+	var search string

+	if v != nil {

+		search = reflect.TypeOf(v).String()

+	}

+	Walk(err, func(err error) {

+		var needle string

+		if err != nil {

+			needle = reflect.TypeOf(err).String()

+		}

+

+		if needle == search {

+			result = append(result, err)

+		}

+	})

+

+	return result

+}

+

+// Walk walks all the wrapped errors in err and calls the callback. If

+// err isn't a wrapped error, this will be called once for err. If err

+// is a wrapped error, the callback will be called for both the wrapper

+// that implements error as well as the wrapped error itself.

+func Walk(err error, cb WalkFunc) {

+	if err == nil {

+		return

+	}

+

+	switch e := err.(type) {

+	case *wrappedError:

+		cb(e.Outer)

+		Walk(e.Inner, cb)

+	case Wrapper:

+		cb(err)

+

+		for _, err := range e.WrappedErrors() {

+			Walk(err, cb)

+		}

+	default:

+		cb(err)

+	}

+}

+

+// wrappedError is an implementation of error that has both the

+// outer and inner errors.

+type wrappedError struct {

+	Outer error

+	Inner error

+}

+

+func (w *wrappedError) Error() string {

+	return w.Outer.Error()

+}

+

+func (w *wrappedError) WrappedErrors() []error {

+	return []error{w.Outer, w.Inner}

+}

new file mode 100644

@@ -0,0 +1 @@

+module github.com/hashicorp/errwrap

@@ -1,5 +1,11 @@

 # go-multierror

+[![Build Status](http://img.shields.io/travis/hashicorp/go-multierror.svg?style=flat-square)][travis]

+[![Go Documentation](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)][godocs]

+

+[travis]: https://travis-ci.org/hashicorp/go-multierror

+[godocs]: https://godoc.org/github.com/hashicorp/go-multierror

+

 `go-multierror` is a package for Go that provides a mechanism for

 representing a list of `error` values as a single `error`.

@@ -14,7 +14,20 @@ func Append(err error, errs ...error) *Error {

 			err = new(Error)

 		}

-		err.Errors = append(err.Errors, errs...)

+		// Go through each error and flatten

+		for _, e := range errs {

+			switch e := e.(type) {

+			case *Error:

+				if e != nil {

+					err.Errors = append(err.Errors, e.Errors...)

+				}

+			default:

+				if e != nil {

+					err.Errors = append(err.Errors, e)

+				}

+			}

+		}

+

 		return err

 	default:

 		newErrs := make([]error, 0, len(errs)+1)

@@ -23,8 +36,6 @@ func Append(err error, errs ...error) *Error {

 		}

 		newErrs = append(newErrs, errs...)

-		return &Error{

-			Errors: newErrs,

-		}

+		return Append(&Error{}, newErrs...)

 	}

 }

new file mode 100644

@@ -0,0 +1,26 @@

+package multierror

+

+// Flatten flattens the given error, merging any *Errors together into

+// a single *Error.

+func Flatten(err error) error {

+	// If it isn't an *Error, just return the error as-is

+	if _, ok := err.(*Error); !ok {

+		return err

+	}

+

+	// Otherwise, make the result and flatten away!

+	flatErr := new(Error)

+	flatten(err, flatErr)

+	return flatErr

+}

+

+func flatten(err error, flatErr *Error) {

+	switch err := err.(type) {

+	case *Error:

+		for _, e := range err.Errors {

+			flatten(e, flatErr)

+		}

+	default:

+		flatErr.Errors = append(flatErr.Errors, err)

+	}

+}

@@ -12,12 +12,16 @@ type ErrorFormatFunc func([]error) string

 // ListFormatFunc is a basic formatter that outputs the number of errors

 // that occurred along with a bullet point list of the errors.

 func ListFormatFunc(es []error) string {

+	if len(es) == 1 {

+		return fmt.Sprintf("1 error occurred:\n\t* %s\n\n", es[0])

+	}

+

 	points := make([]string, len(es))

 	for i, err := range es {

 		points[i] = fmt.Sprintf("* %s", err)

 	}

 	return fmt.Sprintf(

-		"%d error(s) occurred:\n\n%s",

-		len(es), strings.Join(points, "\n"))

+		"%d errors occurred:\n\t%s\n\n",

+		len(es), strings.Join(points, "\n\t"))

 }

new file mode 100644

@@ -0,0 +1,3 @@

+module github.com/hashicorp/go-multierror

+

+require github.com/hashicorp/errwrap v1.0.0

@@ -40,11 +40,11 @@ func (e *Error) GoString() string {

 }

 // WrappedErrors returns the list of errors that this Error is wrapping.

-// It is an implementatin of the errwrap.Wrapper interface so that

+// It is an implementation of the errwrap.Wrapper interface so that

 // multierror.Error can be used with that library.

 //

 // This method is not safe to be called concurrently and is no different

-// than accessing the Errors field directly. It is implementd only to

+// than accessing the Errors field directly. It is implemented only to

 // satisfy the errwrap.Wrapper interface.

 func (e *Error) WrappedErrors() []error {

 	return e.Errors

new file mode 100644

@@ -0,0 +1,37 @@

+package multierror

+

+import (

+	"fmt"

+

+	"github.com/hashicorp/errwrap"

+)

+

+// Prefix is a helper function that will prefix some text

+// to the given error. If the error is a multierror.Error, then

+// it will be prefixed to each wrapped error.

+//

+// This is useful to use when appending multiple multierrors

+// together in order to give better scoping.

+func Prefix(err error, prefix string) error {

+	if err == nil {

+		return nil

+	}

+

+	format := fmt.Sprintf("%s {{err}}", prefix)

+	switch err := err.(type) {

+	case *Error:

+		// Typed nils can reach here, so initialize if we are nil

+		if err == nil {

+			err = new(Error)

+		}

+

+		// Wrap each of the errors

+		for i, e := range err.Errors {

+			err.Errors[i] = errwrap.Wrapf(format, e)

+		}

+

+		return err

+	default:

+		return errwrap.Wrapf(format, err)

+	}

+}

new file mode 100644

@@ -0,0 +1,16 @@

+package multierror

+

+// Len implements sort.Interface function for length

+func (err Error) Len() int {

+	return len(err.Errors)

+}

+

+// Swap implements sort.Interface function for swapping elements

+func (err Error) Swap(i, j int) {

+	err.Errors[i], err.Errors[j] = err.Errors[j], err.Errors[i]

+}

+

+// Less implements sort.Interface function for determining order

+func (err Error) Less(i, j int) bool {

+	return err.Errors[i].Error() < err.Errors[j].Error()

+}