@@ -395,7 +395,7 @@ func (s *snapshotter) View(ctx context.Context, key, parent string, opts ...snap

 }

 func (s *snapshotter) Walk(context.Context, snapshots.WalkFunc, ...string) error {

-	return errors.Errorf("not-implemented")

+	return nil

 }

 func (s *snapshotter) Update(ctx context.Context, info snapshots.Info, fieldpaths ...string) (snapshots.Info, error) {

@@ -86,7 +86,11 @@ func newController(rt http.RoundTripper, opt Opt) (*control.Controller, error) {

 		return nil, err

 	}

-	md, err := metadata.NewStore(filepath.Join(root, "metadata.db"))

+	if err := cache.MigrateV2(context.Background(), filepath.Join(root, "metadata.db"), filepath.Join(root, "metadata_v2.db"), store, snapshotter, lm); err != nil {

+		return nil, err

+	}

+

+	md, err := metadata.NewStore(filepath.Join(root, "metadata_v2.db"))

 	if err != nil {

 		return nil, err

 	}

@@ -194,7 +194,8 @@ func (b *Builder) build(source builder.Source, dockerfile *parser.Result) (*buil

 	stages, metaArgs, err := instructions.Parse(dockerfile.AST)

 	if err != nil {

-		if instructions.IsUnknownInstruction(err) {

+		var uiErr *instructions.UnknownInstruction

+		if errors.As(err, &uiErr) {

 			buildsFailed.WithValues(metricsUnknownInstructionError).Inc()

 		}

 		return nil, errdefs.InvalidParameter(err)

@@ -205,7 +205,8 @@ func dispatchTriggeredOnBuild(d dispatchRequest, triggers []string) error {

 		}

 		cmd, err := instructions.ParseCommand(ast.AST.Children[0])

 		if err != nil {

-			if instructions.IsUnknownInstruction(err) {

+			var uiErr *instructions.UnknownInstruction

+			if errors.As(err, &uiErr) {

 				buildsFailed.WithValues(metricsUnknownInstructionError).Inc()

 			}

 			return err

@@ -6103,7 +6103,7 @@ func (s *DockerSuite) TestBuildLineErrorOnBuild(c *testing.T) {

   ONBUILD

   `)).Assert(c, icmd.Expected{

 		ExitCode: 1,

-		Err:      "Dockerfile parse error line 2: ONBUILD requires at least one argument",

+		Err:      "parse error line 2: ONBUILD requires at least one argument",

 	})

 }

@@ -6117,7 +6117,7 @@ func (s *DockerSuite) TestBuildLineErrorUnknownInstruction(c *testing.T) {

   ERROR

   `)).Assert(c, icmd.Expected{

 		ExitCode: 1,

-		Err:      "Dockerfile parse error line 3: unknown instruction: NOINSTRUCTION",

+		Err:      "parse error line 3: unknown instruction: NOINSTRUCTION",

 	})

 }

@@ -6134,7 +6134,7 @@ func (s *DockerSuite) TestBuildLineErrorWithEmptyLines(c *testing.T) {

   CMD ["/bin/init"]

   `)).Assert(c, icmd.Expected{

 		ExitCode: 1,

-		Err:      "Dockerfile parse error line 6: unknown instruction: NOINSTRUCTION",

+		Err:      "parse error line 6: unknown instruction: NOINSTRUCTION",

 	})

 }

@@ -6148,7 +6148,7 @@ func (s *DockerSuite) TestBuildLineErrorWithComments(c *testing.T) {

   NOINSTRUCTION echo ba

   `)).Assert(c, icmd.Expected{

 		ExitCode: 1,

-		Err:      "Dockerfile parse error line 5: unknown instruction: NOINSTRUCTION",

+		Err:      "parse error line 5: unknown instruction: NOINSTRUCTION",

 	})

 }

@@ -28,7 +28,7 @@ github.com/imdario/mergo                            1afb36080aec31e0d1528973ebe6

 golang.org/x/sync                                   cd5d95a43a6e21273425c7ae415d3df9ea832eeb

 # buildkit

-github.com/moby/buildkit                            ae7ff7174f73bcb4df89b97e1623b3fb0bfb0a0c

+github.com/moby/buildkit                            df35e9818d1f9066e616e03f4b8d727c97562e5b

 github.com/tonistiigi/fsutil                        c2c7d7b0e1441705cd802e5699c0a10b1dfe39fd

 github.com/grpc-ecosystem/grpc-opentracing          8e809c8a86450a29b90dcc9efbf062d0fe6d9746

 github.com/opentracing/opentracing-go               1361b9cd60be79c4c3a7fa9841b3c132e40066a7

@@ -36,6 +36,7 @@ github.com/google/shlex                             e7afc7fbc51079733e9468cdfd1e

 github.com/opentracing-contrib/go-stdlib            b1a47cfbdd7543e70e9ef3e73d0802ad306cc1cc

 github.com/mitchellh/hashstructure                  2bca23e0e452137f789efbc8610126fd8b94f73b

 github.com/gofrs/flock                              392e7fae8f1b0bdbd67dad7237d23f618feb6dbb # v0.7.1

+github.com/grpc-ecosystem/go-grpc-middleware        3c51f7f332123e8be5a157c0802a228ac85bf9db # v1.2.0

 # libnetwork

new file mode 100644

@@ -0,0 +1,201 @@

+                 Apache License

+                           Version 2.0, January 2004

+                        http://www.apache.org/licenses/

+

+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

+

+   1. Definitions.

+

+      "License" shall mean the terms and conditions for use, reproduction,

+      and distribution as defined by Sections 1 through 9 of this document.

+

+      "Licensor" shall mean the copyright owner or entity authorized by

+      the copyright owner that is granting the License.

+

+      "Legal Entity" shall mean the union of the acting entity and all

+      other entities that control, are controlled by, or are under common

+      control with that entity. For the purposes of this definition,

+      "control" means (i) the power, direct or indirect, to cause the

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

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

+      outstanding shares, or (iii) beneficial ownership of such entity.

+

+      "You" (or "Your") shall mean an individual or Legal Entity

+      exercising permissions granted by this License.

+

+      "Source" form shall mean the preferred form for making modifications,

+      including but not limited to software source code, documentation

+      source, and configuration files.

+

+      "Object" form shall mean any form resulting from mechanical

+      transformation or translation of a Source form, including but

+      not limited to compiled object code, generated documentation,

+      and conversions to other media types.

+

+      "Work" shall mean the work of authorship, whether in Source or

+      Object form, made available under the License, as indicated by a

+      copyright notice that is included in or attached to the work

+      (an example is provided in the Appendix below).

+

+      "Derivative Works" shall mean any work, whether in Source or Object

+      form, that is based on (or derived from) the Work and for which the

+      editorial revisions, annotations, elaborations, or other modifications

+      represent, as a whole, an original work of authorship. For the purposes

+      of this License, Derivative Works shall not include works that remain

+      separable from, or merely link (or bind by name) to the interfaces of,

+      the Work and Derivative Works thereof.

+

+      "Contribution" shall mean any work of authorship, including

+      the original version of the Work and any modifications or additions

+      to that Work or Derivative Works thereof, that is intentionally

+      submitted to Licensor for inclusion in the Work by the copyright owner

+      or by an individual or Legal Entity authorized to submit on behalf of

+      the copyright owner. For the purposes of this definition, "submitted"

+      means any form of electronic, verbal, or written communication sent

+      to the Licensor or its representatives, including but not limited to

+      communication on electronic mailing lists, source code control systems,

+      and issue tracking systems that are managed by, or on behalf of, the

+      Licensor for the purpose of discussing and improving the Work, but

+      excluding communication that is conspicuously marked or otherwise

+      designated in writing by the copyright owner as "Not a Contribution."

+

+      "Contributor" shall mean Licensor and any individual or Legal Entity

+      on behalf of whom a Contribution has been received by Licensor and

+      subsequently incorporated within the Work.

+

+   2. Grant of Copyright License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      copyright license to reproduce, prepare Derivative Works of,

+      publicly display, publicly perform, sublicense, and distribute the

+      Work and such Derivative Works in Source or Object form.

+

+   3. Grant of Patent License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      (except as stated in this section) patent license to make, have made,

+      use, offer to sell, sell, import, and otherwise transfer the Work,

+      where such license applies only to those patent claims licensable

+      by such Contributor that are necessarily infringed by their

+      Contribution(s) alone or by combination of their Contribution(s)

+      with the Work to which such Contribution(s) was submitted. If You

+      institute patent litigation against any entity (including a

+      cross-claim or counterclaim in a lawsuit) alleging that the Work

+      or a Contribution incorporated within the Work constitutes direct

+      or contributory patent infringement, then any patent licenses

+      granted to You under this License for that Work shall terminate

+      as of the date such litigation is filed.

+

+   4. Redistribution. You may reproduce and distribute copies of the

+      Work or Derivative Works thereof in any medium, with or without

+      modifications, and in Source or Object form, provided that You

+      meet the following conditions:

+

+      (a) You must give any other recipients of the Work or

+          Derivative Works a copy of this License; and

+

+      (b) You must cause any modified files to carry prominent notices

+          stating that You changed the files; and

+

+      (c) You must retain, in the Source form of any Derivative Works

+          that You distribute, all copyright, patent, trademark, and

+          attribution notices from the Source form of the Work,

+          excluding those notices that do not pertain to any part of

+          the Derivative Works; and

+

+      (d) If the Work includes a "NOTICE" text file as part of its

+          distribution, then any Derivative Works that You distribute must

+          include a readable copy of the attribution notices contained

+          within such NOTICE file, excluding those notices that do not

+          pertain to any part of the Derivative Works, in at least one

+          of the following places: within a NOTICE text file distributed

+          as part of the Derivative Works; within the Source form or

+          documentation, if provided along with the Derivative Works; or,

+          within a display generated by the Derivative Works, if and

+          wherever such third-party notices normally appear. The contents

+          of the NOTICE file are for informational purposes only and

+          do not modify the License. You may add Your own attribution

+          notices within Derivative Works that You distribute, alongside

+          or as an addendum to the NOTICE text from the Work, provided

+          that such additional attribution notices cannot be construed

+          as modifying the License.

+

+      You may add Your own copyright statement to Your modifications and

+      may provide additional or different license terms and conditions

+      for use, reproduction, or distribution of Your modifications, or

+      for any such Derivative Works as a whole, provided Your use,

+      reproduction, and distribution of the Work otherwise complies with

+      the conditions stated in this License.

+

+   5. Submission of Contributions. Unless You explicitly state otherwise,

+      any Contribution intentionally submitted for inclusion in the Work

+      by You to the Licensor shall be under the terms and conditions of

+      this License, without any additional terms or conditions.

+      Notwithstanding the above, nothing herein shall supersede or modify

+      the terms of any separate license agreement you may have executed

+      with Licensor regarding such Contributions.

+

+   6. Trademarks. This License does not grant permission to use the trade

+      names, trademarks, service marks, or product names of the Licensor,

+      except as required for reasonable and customary use in describing the

+      origin of the Work and reproducing the content of the NOTICE file.

+

+   7. Disclaimer of Warranty. Unless required by applicable law or

+      agreed to in writing, Licensor provides the Work (and each

+      Contributor provides its Contributions) on an "AS IS" BASIS,

+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

+      implied, including, without limitation, any warranties or conditions

+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

+      PARTICULAR PURPOSE. You are solely responsible for determining the

+      appropriateness of using or redistributing the Work and assume any

+      risks associated with Your exercise of permissions under this License.

+

+   8. Limitation of Liability. In no event and under no legal theory,

+      whether in tort (including negligence), contract, or otherwise,

+      unless required by applicable law (such as deliberate and grossly

+      negligent acts) or agreed to in writing, shall any Contributor be

+      liable to You for damages, including any direct, indirect, special,

+      incidental, or consequential damages of any character arising as a

+      result of this License or out of the use or inability to use the

+      Work (including but not limited to damages for loss of goodwill,

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

+      other commercial damages or losses), even if such Contributor

+      has been advised of the possibility of such damages.

+

+   9. Accepting Warranty or Additional Liability. While redistributing

+      the Work or Derivative Works thereof, You may choose to offer,

+      and charge a fee for, acceptance of support, warranty, indemnity,

+      or other liability obligations and/or rights consistent with this

+      License. However, in accepting such obligations, You may act only

+      on Your own behalf and on Your sole responsibility, not on behalf

+      of any other Contributor, and only if You agree to indemnify,

+      defend, and hold each Contributor harmless for any liability

+      incurred by, or claims asserted against, such Contributor by reason

+      of your accepting any such warranty or additional liability.

+

+   END OF TERMS AND CONDITIONS

+

+   APPENDIX: How to apply the Apache License to your work.

+

+      To apply the Apache License to your work, attach the following

+      boilerplate notice, with the fields enclosed by brackets "[]"

+      replaced with your own identifying information. (Don't include

+      the brackets!)  The text should be enclosed in the appropriate

+      comment syntax for the file format. We also recommend that a

+      file or class name and description of purpose be included on the

+      same "printed page" as the copyright notice for easier

+      identification within third-party archives.

+

+   Copyright [yyyy] [name of copyright owner]

+

+   Licensed under the Apache License, Version 2.0 (the "License");

+   you may not use this file except in compliance with the License.

+   You may obtain a copy of the License at

+

+       http://www.apache.org/licenses/LICENSE-2.0

+

+   Unless required by applicable law or agreed to in writing, software

+   distributed under the License is distributed on an "AS IS" BASIS,

+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+   See the License for the specific language governing permissions and

+   limitations under the License.

\ No newline at end of file

new file mode 100644

@@ -0,0 +1,85 @@

+# Go gRPC Middleware

+

+[![Travis Build](https://travis-ci.org/grpc-ecosystem/go-grpc-middleware.svg?branch=master)](https://travis-ci.org/grpc-ecosystem/go-grpc-middleware)

+[![Go Report Card](https://goreportcard.com/badge/github.com/grpc-ecosystem/go-grpc-middleware)](https://goreportcard.com/report/github.com/grpc-ecosystem/go-grpc-middleware)

+[![GoDoc](http://img.shields.io/badge/GoDoc-Reference-blue.svg)](https://godoc.org/github.com/grpc-ecosystem/go-grpc-middleware)

+[![SourceGraph](https://sourcegraph.com/github.com/grpc-ecosystem/go-grpc-middleware/-/badge.svg)](https://sourcegraph.com/github.com/grpc-ecosystem/go-grpc-middleware/?badge)

+[![codecov](https://codecov.io/gh/grpc-ecosystem/go-grpc-middleware/branch/master/graph/badge.svg)](https://codecov.io/gh/grpc-ecosystem/go-grpc-middleware)

+[![Apache 2.0 License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)

+[![quality: production](https://img.shields.io/badge/quality-production-orange.svg)](#status)

+[![Slack](https://img.shields.io/badge/slack-%23grpc--middleware-brightgreen)](https://slack.com/share/IRUQCFC23/9Tm7hxRFVKKNoajQfMOcUiIk/enQtODc4ODI4NTIyMDcxLWM5NDA0ZTE4Njg5YjRjYWZkMTI5MzQwNDY3YzBjMzE1YzdjOGM5ZjI1NDNiM2JmNzI2YjM5ODE5OTRiNTEyOWE)

+

+[gRPC Go](https://github.com/grpc/grpc-go) Middleware: interceptors, helpers, utilities.

+

+## Middleware

+

+[gRPC Go](https://github.com/grpc/grpc-go) recently acquired support for

+Interceptors, i.e. [middleware](https://medium.com/@matryer/writing-middleware-in-golang-and-how-go-makes-it-so-much-fun-4375c1246e81#.gv7tdlghs) 

+that is executed either on the gRPC Server before the request is passed onto the user's application logic, or on the gRPC client either around the user call. It is a perfect way to implement

+common patterns: auth, logging, message, validation, retries or monitoring.

+

+These are generic building blocks that make it easy to build multiple microservices easily.

+The purpose of this repository is to act as a go-to point for such reusable functionality. It contains

+some of them itself, but also will link to useful external repos.

+

+`grpc_middleware` itself provides support for chaining interceptors, here's an example:

+

+```go

+import "github.com/grpc-ecosystem/go-grpc-middleware"

+

+myServer := grpc.NewServer(

+    grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(

+        grpc_ctxtags.StreamServerInterceptor(),

+        grpc_opentracing.StreamServerInterceptor(),

+        grpc_prometheus.StreamServerInterceptor,

+        grpc_zap.StreamServerInterceptor(zapLogger),

+        grpc_auth.StreamServerInterceptor(myAuthFunction),

+        grpc_recovery.StreamServerInterceptor(),

+    )),

+    grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(

+        grpc_ctxtags.UnaryServerInterceptor(),

+        grpc_opentracing.UnaryServerInterceptor(),

+        grpc_prometheus.UnaryServerInterceptor,

+        grpc_zap.UnaryServerInterceptor(zapLogger),

+        grpc_auth.UnaryServerInterceptor(myAuthFunction),

+        grpc_recovery.UnaryServerInterceptor(),

+    )),

+)

+```

+

+## Interceptors

+

+*Please send a PR to add new interceptors or middleware to this list*

+

+#### Auth

+   * [`grpc_auth`](auth) - a customizable (via `AuthFunc`) piece of auth middleware 

+

+#### Logging

+   * [`grpc_ctxtags`](tags/) - a library that adds a `Tag` map to context, with data populated from request body

+   * [`grpc_zap`](logging/zap/) - integration of [zap](https://github.com/uber-go/zap) logging library into gRPC handlers.

+   * [`grpc_logrus`](logging/logrus/) - integration of [logrus](https://github.com/sirupsen/logrus) logging library into gRPC handlers.

+   * [`grpc_kit`](logging/kit/) - integration of [go-kit](https://github.com/go-kit/kit/tree/master/log) logging library into gRPC handlers.

+

+#### Monitoring

+   * [`grpc_prometheus`⚡](https://github.com/grpc-ecosystem/go-grpc-prometheus) - Prometheus client-side and server-side monitoring middleware

+   * [`otgrpc`⚡](https://github.com/grpc-ecosystem/grpc-opentracing/tree/master/go/otgrpc) - [OpenTracing](http://opentracing.io/) client-side and server-side interceptors

+   * [`grpc_opentracing`](tracing/opentracing) - [OpenTracing](http://opentracing.io/) client-side and server-side interceptors with support for streaming and handler-returned tags

+

+#### Client

+   * [`grpc_retry`](retry/) - a generic gRPC response code retry mechanism, client-side middleware

+

+#### Server

+   * [`grpc_validator`](validator/) - codegen inbound message validation from `.proto` options

+   * [`grpc_recovery`](recovery/) - turn panics into gRPC errors

+   * [`ratelimit`](ratelimit/) - grpc rate limiting by your own limiter

+

+

+## Status

+

+This code has been running in *production* since May 2016 as the basis of the gRPC micro services stack at [Improbable](https://improbable.io).

+

+Additional tooling will be added, and contributions are welcome.

+

+## License

+

+`go-grpc-middleware` is released under the Apache 2.0 license. See the [LICENSE](LICENSE) file for details.

new file mode 100644

@@ -0,0 +1,120 @@

+// Copyright 2016 Michal Witkowski. All Rights Reserved.

+// See LICENSE for licensing terms.

+

+// gRPC Server Interceptor chaining middleware.

+

+package grpc_middleware

+

+import (

+	"context"

+

+	"google.golang.org/grpc"

+)

+

+// ChainUnaryServer creates a single interceptor out of a chain of many interceptors.

+//

+// Execution is done in left-to-right order, including passing of context.

+// For example ChainUnaryServer(one, two, three) will execute one before two before three, and three

+// will see context changes of one and two.

+func ChainUnaryServer(interceptors ...grpc.UnaryServerInterceptor) grpc.UnaryServerInterceptor {

+	n := len(interceptors)

+

+	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {

+		chainer := func(currentInter grpc.UnaryServerInterceptor, currentHandler grpc.UnaryHandler) grpc.UnaryHandler {

+			return func(currentCtx context.Context, currentReq interface{}) (interface{}, error) {

+				return currentInter(currentCtx, currentReq, info, currentHandler)

+			}

+		}

+

+		chainedHandler := handler

+		for i := n - 1; i >= 0; i-- {

+			chainedHandler = chainer(interceptors[i], chainedHandler)

+		}

+

+		return chainedHandler(ctx, req)

+	}

+}

+

+// ChainStreamServer creates a single interceptor out of a chain of many interceptors.

+//

+// Execution is done in left-to-right order, including passing of context.

+// For example ChainUnaryServer(one, two, three) will execute one before two before three.

+// If you want to pass context between interceptors, use WrapServerStream.

+func ChainStreamServer(interceptors ...grpc.StreamServerInterceptor) grpc.StreamServerInterceptor {

+	n := len(interceptors)

+

+	return func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {

+		chainer := func(currentInter grpc.StreamServerInterceptor, currentHandler grpc.StreamHandler) grpc.StreamHandler {

+			return func(currentSrv interface{}, currentStream grpc.ServerStream) error {

+				return currentInter(currentSrv, currentStream, info, currentHandler)

+			}

+		}

+

+		chainedHandler := handler

+		for i := n - 1; i >= 0; i-- {

+			chainedHandler = chainer(interceptors[i], chainedHandler)

+		}

+

+		return chainedHandler(srv, ss)

+	}

+}

+

+// ChainUnaryClient creates a single interceptor out of a chain of many interceptors.

+//

+// Execution is done in left-to-right order, including passing of context.

+// For example ChainUnaryClient(one, two, three) will execute one before two before three.

+func ChainUnaryClient(interceptors ...grpc.UnaryClientInterceptor) grpc.UnaryClientInterceptor {

+	n := len(interceptors)

+

+	return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {

+		chainer := func(currentInter grpc.UnaryClientInterceptor, currentInvoker grpc.UnaryInvoker) grpc.UnaryInvoker {

+			return func(currentCtx context.Context, currentMethod string, currentReq, currentRepl interface{}, currentConn *grpc.ClientConn, currentOpts ...grpc.CallOption) error {

+				return currentInter(currentCtx, currentMethod, currentReq, currentRepl, currentConn, currentInvoker, currentOpts...)

+			}

+		}

+

+		chainedInvoker := invoker

+		for i := n - 1; i >= 0; i-- {

+			chainedInvoker = chainer(interceptors[i], chainedInvoker)

+		}

+

+		return chainedInvoker(ctx, method, req, reply, cc, opts...)

+	}

+}

+

+// ChainStreamClient creates a single interceptor out of a chain of many interceptors.

+//

+// Execution is done in left-to-right order, including passing of context.

+// For example ChainStreamClient(one, two, three) will execute one before two before three.

+func ChainStreamClient(interceptors ...grpc.StreamClientInterceptor) grpc.StreamClientInterceptor {

+	n := len(interceptors)

+

+	return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {

+		chainer := func(currentInter grpc.StreamClientInterceptor, currentStreamer grpc.Streamer) grpc.Streamer {

+			return func(currentCtx context.Context, currentDesc *grpc.StreamDesc, currentConn *grpc.ClientConn, currentMethod string, currentOpts ...grpc.CallOption) (grpc.ClientStream, error) {

+				return currentInter(currentCtx, currentDesc, currentConn, currentMethod, currentStreamer, currentOpts...)

+			}

+		}

+

+		chainedStreamer := streamer

+		for i := n - 1; i >= 0; i-- {

+			chainedStreamer = chainer(interceptors[i], chainedStreamer)

+		}

+

+		return chainedStreamer(ctx, desc, cc, method, opts...)

+	}

+}

+

+// Chain creates a single interceptor out of a chain of many interceptors.

+//

+// WithUnaryServerChain is a grpc.Server config option that accepts multiple unary interceptors.

+// Basically syntactic sugar.

+func WithUnaryServerChain(interceptors ...grpc.UnaryServerInterceptor) grpc.ServerOption {

+	return grpc.UnaryInterceptor(ChainUnaryServer(interceptors...))

+}

+

+// WithStreamServerChain is a grpc.Server config option that accepts multiple stream interceptors.

+// Basically syntactic sugar.

+func WithStreamServerChain(interceptors ...grpc.StreamServerInterceptor) grpc.ServerOption {

+	return grpc.StreamInterceptor(ChainStreamServer(interceptors...))

+}

new file mode 100644

@@ -0,0 +1,69 @@

+// Copyright 2016 Michal Witkowski. All Rights Reserved.

+// See LICENSE for licensing terms.

+

+/*

+`grpc_middleware` is a collection of gRPC middleware packages: interceptors, helpers and tools.

+

+Middleware

+

+gRPC is a fantastic RPC middleware, which sees a lot of adoption in the Golang world. However, the

+upstream gRPC codebase is relatively bare bones.

+

+This package, and most of its child packages provides commonly needed middleware for gRPC:

+client-side interceptors for retires, server-side interceptors for input validation and auth,

+functions for chaining said interceptors, metadata convenience methods and more.

+

+Chaining

+

+By default, gRPC doesn't allow one to have more than one interceptor either on the client nor on

+the server side. `grpc_middleware` provides convenient chaining methods

+

+Simple way of turning a multiple interceptors into a single interceptor. Here's an example for

+server chaining:

+

+	myServer := grpc.NewServer(

+	    grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(loggingStream, monitoringStream, authStream)),

+	    grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(loggingUnary, monitoringUnary, authUnary),

+	)

+

+These interceptors will be executed from left to right: logging, monitoring and auth.

+

+Here's an example for client side chaining:

+

+	clientConn, err = grpc.Dial(

+	    address,

+	        grpc.WithUnaryInterceptor(grpc_middleware.ChainUnaryClient(monitoringClientUnary, retryUnary)),

+	        grpc.WithStreamInterceptor(grpc_middleware.ChainStreamClient(monitoringClientStream, retryStream)),

+	)

+	client = pb_testproto.NewTestServiceClient(clientConn)

+	resp, err := client.PingEmpty(s.ctx, &myservice.Request{Msg: "hello"})

+

+These interceptors will be executed from left to right: monitoring and then retry logic.

+

+The retry interceptor will call every interceptor that follows it whenever when a retry happens.

+

+Writing Your Own

+

+Implementing your own interceptor is pretty trivial: there are interfaces for that. But the interesting

+bit exposing common data to handlers (and other middleware), similarly to HTTP Middleware design.

+For example, you may want to pass the identity of the caller from the auth interceptor all the way

+to the handling function.

+

+For example, a client side interceptor example for auth looks like:

+

+	func FakeAuthUnaryInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {

+	   newCtx := context.WithValue(ctx, "user_id", "john@example.com")

+	   return handler(newCtx, req)

+	}

+

+Unfortunately, it's not as easy for streaming RPCs. These have the `context.Context` embedded within

+the `grpc.ServerStream` object. To pass values through context, a wrapper (`WrappedServerStream`) is

+needed. For example:

+

+	func FakeAuthStreamingInterceptor(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {

+	   newStream := grpc_middleware.WrapServerStream(stream)

+	   newStream.WrappedContext = context.WithValue(ctx, "user_id", "john@example.com")

+	   return handler(srv, stream)

+	}

+*/

+package grpc_middleware

new file mode 100644

@@ -0,0 +1,22 @@

+module github.com/grpc-ecosystem/go-grpc-middleware

+

+require (

+	github.com/go-kit/kit v0.9.0

+	github.com/go-logfmt/logfmt v0.4.0 // indirect

+	github.com/go-stack/stack v1.8.0 // indirect

+	github.com/gogo/protobuf v1.2.1

+	github.com/golang/protobuf v1.3.2

+	github.com/opentracing/opentracing-go v1.1.0

+	github.com/pkg/errors v0.8.1 // indirect

+	github.com/sirupsen/logrus v1.4.2

+	github.com/stretchr/testify v1.4.0

+	go.uber.org/atomic v1.4.0 // indirect

+	go.uber.org/multierr v1.1.0 // indirect

+	go.uber.org/zap v1.10.0

+	golang.org/x/net v0.0.0-20190311183353-d8887717615a

+	golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be

+	google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55 // indirect

+	google.golang.org/grpc v1.19.0

+)

+

+go 1.13

new file mode 100644

@@ -0,0 +1,30 @@

+// Copyright 2016 Michal Witkowski. All Rights Reserved.

+// See LICENSE for licensing terms.

+

+package grpc_middleware

+

+import (

+	"context"

+

+	"google.golang.org/grpc"

+)

+

+// WrappedServerStream is a thin wrapper around grpc.ServerStream that allows modifying context.

+type WrappedServerStream struct {

+	grpc.ServerStream

+	// WrappedContext is the wrapper's own Context. You can assign it.

+	WrappedContext context.Context

+}

+

+// Context returns the wrapper's WrappedContext, overwriting the nested grpc.ServerStream.Context()

+func (w *WrappedServerStream) Context() context.Context {

+	return w.WrappedContext

+}

+

+// WrapServerStream returns a ServerStream that has the ability to overwrite context.

+func WrapServerStream(stream grpc.ServerStream) *WrappedServerStream {

+	if existing, ok := stream.(*WrappedServerStream); ok {

+		return existing

+	}

+	return &WrappedServerStream{ServerStream: stream, WrappedContext: stream.Context()}

+}

@@ -86,6 +86,7 @@ BuildKit is used by the following projects:

 -   [PouchContainer](https://github.com/alibaba/pouch)

 -   [Docker buildx](https://github.com/docker/buildx)

 -   [Okteto Cloud](https://okteto.com/)

+-   [Earthly earthfiles](https://github.com/vladaionescu/earthly)

 ## Quick start

@@ -148,6 +149,7 @@ Currently, the following high-level languages has been implemented for LLB:

 -   [Buildpacks](https://github.com/tonistiigi/buildkit-pack)

 -   [Mockerfile](https://matt-rickard.com/building-a-new-dockerfile-frontend/)

 -   [Gockerfile](https://github.com/po3rin/gockerfile)

+-   [bldr (Pkgfile)](https://github.com/talos-systems/bldr/)

 -   (open a PR to add your own language)

 ### Exploring Dockerfiles

@@ -1,9 +1,10 @@

 package contenthash

 import (

-	"errors"

 	"os"

 	"path/filepath"

+

+	"github.com/pkg/errors"

 )

 var (

@@ -52,7 +53,7 @@ func walkLink(root, path string, linksWalked *int, cb onSymlinkFunc) (newpath st

 	fi, err := os.Lstat(realPath)

 	if err != nil {

 		// If path does not yet exist, treat as non-symlink

-		if os.IsNotExist(err) {

+		if errors.Is(err, os.ErrNotExist) {

 			return path, false, nil

 		}

 		return "", false, err

@@ -39,7 +39,7 @@ func v1TarHeaderSelect(h *tar.Header) (orderedHeaders [][2]string) {

 	// Get extended attributes.

 	xAttrKeys := make([]string, len(h.Xattrs))

 	for k := range h.Xattrs {

-		if !strings.HasPrefix(k, "security.") && !strings.HasPrefix(k, "system.") {

+		if k == "security.capability" || !strings.HasPrefix(k, "security.") && !strings.HasPrefix(k, "system.") {

 			xAttrKeys = append(xAttrKeys, k)

 		}

 	}

@@ -16,7 +16,7 @@ import (

 	"github.com/moby/buildkit/client"

 	"github.com/moby/buildkit/identity"

 	"github.com/moby/buildkit/snapshot"

-	"github.com/opencontainers/go-digest"

+	digest "github.com/opencontainers/go-digest"

 	imagespecidentity "github.com/opencontainers/image-spec/identity"

 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"

 	"github.com/pkg/errors"

@@ -143,7 +143,7 @@ func (cm *cacheManager) GetByBlob(ctx context.Context, desc ocispec.Descriptor,

 	for _, si := range sis {

 		ref, err := cm.get(ctx, si.ID(), opts...)

-		if err != nil && errors.Cause(err) != errNotFound {

+		if err != nil && !IsNotFound(err) {

 			return nil, errors.Wrapf(err, "failed to get record %s by blobchainid", si.ID())

 		}

 		if p != nil {

@@ -160,7 +160,7 @@ func (cm *cacheManager) GetByBlob(ctx context.Context, desc ocispec.Descriptor,

 	var link ImmutableRef

 	for _, si := range sis {

 		ref, err := cm.get(ctx, si.ID(), opts...)

-		if err != nil && errors.Cause(err) != errNotFound {

+		if err != nil && !IsNotFound(err) {

 			return nil, errors.Wrapf(err, "failed to get record %s by chainid", si.ID())

 		}

 		link = ref

@@ -338,7 +338,7 @@ func (cm *cacheManager) getRecord(ctx context.Context, id string, opts ...RefOpt

 		mutable, err := cm.getRecord(ctx, mutableID)

 		if err != nil {

 			// check loading mutable deleted record from disk

-			if errors.Cause(err) == errNotFound {

+			if IsNotFound(err) {

 				cm.md.Clear(id)

 			}

 			return nil, err

@@ -906,12 +906,8 @@ func (cm *cacheManager) DiskUsage(ctx context.Context, opt client.DiskUsageInfo)

 	return du, nil

 }

-func IsLocked(err error) bool {

-	return errors.Cause(err) == ErrLocked

-}

-

 func IsNotFound(err error) bool {

-	return errors.Cause(err) == errNotFound

+	return errors.Is(err, errNotFound)

 }

 type RefOption interface{}

@@ -13,7 +13,7 @@ import (

 	"github.com/containerd/containerd/snapshots"

 	"github.com/moby/buildkit/cache/metadata"

 	"github.com/moby/buildkit/snapshot"

-	"github.com/opencontainers/go-digest"

+	digest "github.com/opencontainers/go-digest"

 	"github.com/pkg/errors"

 	"github.com/sirupsen/logrus"

 )

@@ -56,7 +56,7 @@ func migrateChainID(si *metadata.StorageItem, all map[string]*metadata.StorageIt

 func MigrateV2(ctx context.Context, from, to string, cs content.Store, s snapshot.Snapshotter, lm leases.Manager) error {

 	_, err := os.Stat(to)

 	if err != nil {

-		if !os.IsNotExist(errors.Cause(err)) {

+		if !errors.Is(err, os.ErrNotExist) {

 			return errors.WithStack(err)

 		}

 	} else {

@@ -65,7 +65,7 @@ func MigrateV2(ctx context.Context, from, to string, cs content.Store, s snapsho

 	_, err = os.Stat(from)

 	if err != nil {

-		if !os.IsNotExist(errors.Cause(err)) {

+		if !errors.Is(err, os.ErrNotExist) {

 			return errors.WithStack(err)

 		}

 		return nil

@@ -180,7 +180,7 @@ func MigrateV2(ctx context.Context, from, to string, cs content.Store, s snapsho

 		})

 		if err != nil {

 			// if we are running the migration twice

-			if errdefs.IsAlreadyExists(err) {

+			if errors.Is(err, errdefs.ErrAlreadyExists) {

 				continue

 			}

 			return errors.Wrap(err, "failed to create lease")

@@ -205,19 +205,22 @@ func MigrateV2(ctx context.Context, from, to string, cs content.Store, s snapsho

 	// remove old root labels

 	for _, item := range byID {

-		if _, err := s.Update(ctx, snapshots.Info{

-			Name: getSnapshotID(item),

-		}, "labels.containerd.io/gc.root"); err != nil {

-			if !errdefs.IsNotFound(errors.Cause(err)) {

-				return err

+		em := getEqualMutable(item)

+		if em == "" {

+			if _, err := s.Update(ctx, snapshots.Info{

+				Name: getSnapshotID(item),

+			}, "labels.containerd.io/gc.root"); err != nil {

+				if !errors.Is(err, errdefs.ErrNotFound) {

+					return err

+				}

 			}

-		}

-		if blob := getBlob(item); blob != "" {

-			if _, err := cs.Update(ctx, content.Info{

-				Digest: digest.Digest(blob),

-			}, "labels.containerd.io/gc.root"); err != nil {

-				return err

+			if blob := getBlob(item); blob != "" {

+				if _, err := cs.Update(ctx, content.Info{

+					Digest: digest.Digest(blob),

+				}, "labels.containerd.io/gc.root"); err != nil {

+					return err

+				}

 			}

 		}

 	}

@@ -228,7 +231,7 @@ func MigrateV2(ctx context.Context, from, to string, cs content.Store, s snapsho

 			if _, err := s.Update(ctx, snapshots.Info{

 				Name: info.Name,

 			}, "labels.containerd.io/gc.root"); err != nil {

-				if !errdefs.IsNotFound(errors.Cause(err)) {

+				if !errors.Is(err, errdefs.ErrNotFound) {

 					return err

 				}

 			}

@@ -17,7 +17,7 @@ import (

 	"github.com/moby/buildkit/snapshot"

 	"github.com/moby/buildkit/util/flightcontrol"

 	"github.com/moby/buildkit/util/leaseutil"

-	"github.com/opencontainers/go-digest"

+	digest "github.com/opencontainers/go-digest"

 	imagespecidentity "github.com/opencontainers/image-spec/identity"

 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"

 	"github.com/pkg/errors"

@@ -160,7 +160,7 @@ func (cr *cacheRecord) Size(ctx context.Context) (int64, error) {

 				if isDead {

 					return int64(0), nil

 				}

-				if !errdefs.IsNotFound(err) {

+				if !errors.Is(err, errdefs.ErrNotFound) {

 					return s, errors.Wrapf(err, "failed to get usage for %s", cr.ID())

 				}

 			}

@@ -180,7 +180,10 @@ func (cr *cacheRecord) Size(ctx context.Context) (int64, error) {

 		cr.mu.Unlock()

 		return usage.Size, nil

 	})

-	return s.(int64), err

+	if err != nil {