Merge pull request #32448 from aaronlehmann/vendor-swarmkit-d5232280

Vendor swarmkit d5232280

vendor.conf

@@ -105,7 +105,7 @@ github.com/docker/containerd 9048e5e50717ea4497b757314bad98ea3763c145
 github.com/tonistiigi/fifo 1405643975692217d6720f8b54aeee1bf2cd5cf4
 
 # cluster
-github.com/docker/swarmkit d2e48a332063ccd4ea26b6262ee717de997de560
+github.com/docker/swarmkit d5232280c510d70755ab11305d46a5704735371a
 github.com/golang/mock bd3c8e81be01eef76d4b503f5e687d2d1354d2d9
 github.com/gogo/protobuf 8d70fb3182befc465c4a1eac8ad4d38ff49778e2
 github.com/cloudflare/cfssl 7fb22c8cba7ecaf98e4082d22d65800cf45e042a

vendor/github.com/docker/swarmkit/agent/exec/controller_stub.go

@@ -0,0 +1,75 @@
+package exec
+
+import (
+	"github.com/docker/swarmkit/api"
+	"golang.org/x/net/context"
+	"runtime"
+	"strings"
+)
+
+// StubController implements the Controller interface,
+// but allows you to specify behaviors for each of its methods.
+type StubController struct {
+	Controller
+	UpdateFn    func(ctx context.Context, t *api.Task) error
+	PrepareFn   func(ctx context.Context) error
+	StartFn     func(ctx context.Context) error
+	WaitFn      func(ctx context.Context) error
+	ShutdownFn  func(ctx context.Context) error
+	TerminateFn func(ctx context.Context) error
+	RemoveFn    func(ctx context.Context) error
+	CloseFn     func() error
+	calls       map[string]int
+	cstatus     *api.ContainerStatus
+}
+
+// NewStubController returns an initialized StubController
+func NewStubController() *StubController {
+	return &StubController{
+		calls: make(map[string]int),
+	}
+}
+
+// If function A calls updateCountsForSelf,
+// The callCount[A] value will be incremented
+func (sc *StubController) called() {
+	pc, _, _, ok := runtime.Caller(1)
+	if !ok {
+		panic("Failed to find caller of function")
+	}
+	// longName looks like 'github.com/docker/swarmkit/agent/exec.(*StubController).Prepare:1'
+	longName := runtime.FuncForPC(pc).Name()
+	parts := strings.Split(longName, ".")
+	tail := strings.Split(parts[len(parts)-1], ":")
+	sc.calls[tail[0]]++
+}
+
+// Update is part of the Controller interface
+func (sc *StubController) Update(ctx context.Context, t *api.Task) error {
+	sc.called()
+	return sc.UpdateFn(ctx, t)
+}
+
+// Prepare is part of the Controller interface
+func (sc *StubController) Prepare(ctx context.Context) error { sc.called(); return sc.PrepareFn(ctx) }
+
+// Start is part of the Controller interface
+func (sc *StubController) Start(ctx context.Context) error { sc.called(); return sc.StartFn(ctx) }
+
+// Wait is part of the Controller interface
+func (sc *StubController) Wait(ctx context.Context) error { sc.called(); return sc.WaitFn(ctx) }
+
+// Shutdown is part of the Controller interface
+func (sc *StubController) Shutdown(ctx context.Context) error { sc.called(); return sc.ShutdownFn(ctx) }
+
+// Terminate is part of the Controller interface
+func (sc *StubController) Terminate(ctx context.Context) error {
+	sc.called()
+	return sc.TerminateFn(ctx)
+}
+
+// Remove is part of the Controller interface
+func (sc *StubController) Remove(ctx context.Context) error { sc.called(); return sc.RemoveFn(ctx) }
+
+// Close is part of the Controller interface
+func (sc *StubController) Close() error { sc.called(); return sc.CloseFn() }

vendor/github.com/docker/swarmkit/agent/exec/controller_test.mock.go

@@ -1,270 +0,0 @@
-// Automatically generated by MockGen. DO NOT EDIT!
-// Source: controller.go
-
-package exec
-
-import (
-	api "github.com/docker/swarmkit/api"
-	gomock "github.com/golang/mock/gomock"
-	context "golang.org/x/net/context"
-)
-
-// Mock of Controller interface
-type MockController struct {
-	ctrl     *gomock.Controller
-	recorder *_MockControllerRecorder
-}
-
-// Recorder for MockController (not exported)
-type _MockControllerRecorder struct {
-	mock *MockController
-}
-
-func NewMockController(ctrl *gomock.Controller) *MockController {
-	mock := &MockController{ctrl: ctrl}
-	mock.recorder = &_MockControllerRecorder{mock}
-	return mock
-}
-
-func (_m *MockController) EXPECT() *_MockControllerRecorder {
-	return _m.recorder
-}
-
-func (_m *MockController) Update(ctx context.Context, t *api.Task) error {
-	ret := _m.ctrl.Call(_m, "Update", ctx, t)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockControllerRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1)
-}
-
-func (_m *MockController) Prepare(ctx context.Context) error {
-	ret := _m.ctrl.Call(_m, "Prepare", ctx)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockControllerRecorder) Prepare(arg0 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Prepare", arg0)
-}
-
-func (_m *MockController) Start(ctx context.Context) error {
-	ret := _m.ctrl.Call(_m, "Start", ctx)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockControllerRecorder) Start(arg0 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Start", arg0)
-}
-
-func (_m *MockController) Wait(ctx context.Context) error {
-	ret := _m.ctrl.Call(_m, "Wait", ctx)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockControllerRecorder) Wait(arg0 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Wait", arg0)
-}
-
-func (_m *MockController) Shutdown(ctx context.Context) error {
-	ret := _m.ctrl.Call(_m, "Shutdown", ctx)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockControllerRecorder) Shutdown(arg0 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Shutdown", arg0)
-}
-
-func (_m *MockController) Terminate(ctx context.Context) error {
-	ret := _m.ctrl.Call(_m, "Terminate", ctx)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockControllerRecorder) Terminate(arg0 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Terminate", arg0)
-}
-
-func (_m *MockController) Remove(ctx context.Context) error {
-	ret := _m.ctrl.Call(_m, "Remove", ctx)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockControllerRecorder) Remove(arg0 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Remove", arg0)
-}
-
-func (_m *MockController) Close() error {
-	ret := _m.ctrl.Call(_m, "Close")
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockControllerRecorder) Close() *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Close")
-}
-
-// Mock of ControllerLogs interface
-type MockControllerLogs struct {
-	ctrl     *gomock.Controller
-	recorder *_MockControllerLogsRecorder
-}
-
-// Recorder for MockControllerLogs (not exported)
-type _MockControllerLogsRecorder struct {
-	mock *MockControllerLogs
-}
-
-func NewMockControllerLogs(ctrl *gomock.Controller) *MockControllerLogs {
-	mock := &MockControllerLogs{ctrl: ctrl}
-	mock.recorder = &_MockControllerLogsRecorder{mock}
-	return mock
-}
-
-func (_m *MockControllerLogs) EXPECT() *_MockControllerLogsRecorder {
-	return _m.recorder
-}
-
-func (_m *MockControllerLogs) Logs(ctx context.Context, publisher LogPublisher, options api.LogSubscriptionOptions) error {
-	ret := _m.ctrl.Call(_m, "Logs", ctx, publisher, options)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockControllerLogsRecorder) Logs(arg0, arg1, arg2 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Logs", arg0, arg1, arg2)
-}
-
-// Mock of LogPublisher interface
-type MockLogPublisher struct {
-	ctrl     *gomock.Controller
-	recorder *_MockLogPublisherRecorder
-}
-
-// Recorder for MockLogPublisher (not exported)
-type _MockLogPublisherRecorder struct {
-	mock *MockLogPublisher
-}
-
-func NewMockLogPublisher(ctrl *gomock.Controller) *MockLogPublisher {
-	mock := &MockLogPublisher{ctrl: ctrl}
-	mock.recorder = &_MockLogPublisherRecorder{mock}
-	return mock
-}
-
-func (_m *MockLogPublisher) EXPECT() *_MockLogPublisherRecorder {
-	return _m.recorder
-}
-
-func (_m *MockLogPublisher) Publish(ctx context.Context, message api.LogMessage) error {
-	ret := _m.ctrl.Call(_m, "Publish", ctx, message)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-func (_mr *_MockLogPublisherRecorder) Publish(arg0, arg1 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Publish", arg0, arg1)
-}
-
-// Mock of LogPublisherProvider interface
-type MockLogPublisherProvider struct {
-	ctrl     *gomock.Controller
-	recorder *_MockLogPublisherProviderRecorder
-}
-
-// Recorder for MockLogPublisherProvider (not exported)
-type _MockLogPublisherProviderRecorder struct {
-	mock *MockLogPublisherProvider
-}
-
-func NewMockLogPublisherProvider(ctrl *gomock.Controller) *MockLogPublisherProvider {
-	mock := &MockLogPublisherProvider{ctrl: ctrl}
-	mock.recorder = &_MockLogPublisherProviderRecorder{mock}
-	return mock
-}
-
-func (_m *MockLogPublisherProvider) EXPECT() *_MockLogPublisherProviderRecorder {
-	return _m.recorder
-}
-
-func (_m *MockLogPublisherProvider) Publisher(ctx context.Context, subscriptionID string) (LogPublisher, func(), error) {
-	ret := _m.ctrl.Call(_m, "Publisher", ctx, subscriptionID)
-	ret0, _ := ret[0].(LogPublisher)
-	ret1, _ := ret[1].(func())
-	ret2, _ := ret[2].(error)
-	return ret0, ret1, ret2
-}
-
-func (_mr *_MockLogPublisherProviderRecorder) Publisher(arg0, arg1 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "Publisher", arg0, arg1)
-}
-
-// Mock of ContainerStatuser interface
-type MockContainerStatuser struct {
-	ctrl     *gomock.Controller
-	recorder *_MockContainerStatuserRecorder
-}
-
-// Recorder for MockContainerStatuser (not exported)
-type _MockContainerStatuserRecorder struct {
-	mock *MockContainerStatuser
-}
-
-func NewMockContainerStatuser(ctrl *gomock.Controller) *MockContainerStatuser {
-	mock := &MockContainerStatuser{ctrl: ctrl}
-	mock.recorder = &_MockContainerStatuserRecorder{mock}
-	return mock
-}
-
-func (_m *MockContainerStatuser) EXPECT() *_MockContainerStatuserRecorder {
-	return _m.recorder
-}
-
-func (_m *MockContainerStatuser) ContainerStatus(ctx context.Context) (*api.ContainerStatus, error) {
-	ret := _m.ctrl.Call(_m, "ContainerStatus", ctx)
-	ret0, _ := ret[0].(*api.ContainerStatus)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-func (_mr *_MockContainerStatuserRecorder) ContainerStatus(arg0 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "ContainerStatus", arg0)
-}
-
-// Mock of PortStatuser interface
-type MockPortStatuser struct {
-	ctrl     *gomock.Controller
-	recorder *_MockPortStatuserRecorder
-}
-
-// Recorder for MockPortStatuser (not exported)
-type _MockPortStatuserRecorder struct {
-	mock *MockPortStatuser
-}
-
-func NewMockPortStatuser(ctrl *gomock.Controller) *MockPortStatuser {
-	mock := &MockPortStatuser{ctrl: ctrl}
-	mock.recorder = &_MockPortStatuserRecorder{mock}
-	return mock
-}
-
-func (_m *MockPortStatuser) EXPECT() *_MockPortStatuserRecorder {
-	return _m.recorder
-}
-
-func (_m *MockPortStatuser) PortStatus(ctx context.Context) (*api.PortStatus, error) {
-	ret := _m.ctrl.Call(_m, "PortStatus", ctx)
-	ret0, _ := ret[0].(*api.PortStatus)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-func (_mr *_MockPortStatuserRecorder) PortStatus(arg0 interface{}) *gomock.Call {
-	return _mr.mock.ctrl.RecordCall(_mr.mock, "PortStatus", arg0)
-}

vendor/github.com/docker/swarmkit/manager/dispatcher/dispatcher.go

@@ -148,8 +148,6 @@ func New(cluster Cluster, c *Config) *Dispatcher {
 		downNodes:             newNodeStore(defaultNodeDownPeriod, 0, 1, 0),
 		store:                 cluster.MemoryStore(),
 		cluster:               cluster,
-		taskUpdates:           make(map[string]*api.TaskStatus),
-		nodeUpdates:           make(map[string]nodeUpdate),
 		processUpdatesTrigger: make(chan struct{}, 1),
 		config:                c,
 	}
@@ -181,6 +179,14 @@ func getWeightedPeers(cluster Cluster) []*api.WeightedPeer {
 // Run runs dispatcher tasks which should be run on leader dispatcher.
 // Dispatcher can be stopped with cancelling ctx or calling Stop().
 func (d *Dispatcher) Run(ctx context.Context) error {
+	d.taskUpdatesLock.Lock()
+	d.taskUpdates = make(map[string]*api.TaskStatus)
+	d.taskUpdatesLock.Unlock()
+
+	d.nodeUpdatesLock.Lock()
+	d.nodeUpdates = make(map[string]nodeUpdate)
+	d.nodeUpdatesLock.Unlock()
+
 	d.mu.Lock()
 	if d.isRunning() {
 		d.mu.Unlock()

vendor/github.com/docker/swarmkit/manager/orchestrator/update/updater.go

@@ -155,18 +155,23 @@ func (u *Updater) Run(ctx context.Context, slots []orchestrator.Slot) {
 		u.startUpdate(ctx, service.ID)
 	}
 
-	var monitoringPeriod time.Duration
+	var (
+		monitoringPeriod time.Duration
+		updateConfig     *api.UpdateConfig
+	)
 
-	updateConfig := service.Spec.Update
 	if service.UpdateStatus != nil && service.UpdateStatus.State == api.UpdateStatus_ROLLBACK_STARTED {
 		monitoringPeriod, _ = gogotypes.DurationFromProto(defaults.Service.Rollback.Monitor)
 		updateConfig = service.Spec.Rollback
 		if updateConfig == nil {
 			updateConfig = defaults.Service.Rollback
 		}
-	} else if updateConfig == nil {
+	} else {
 		monitoringPeriod, _ = gogotypes.DurationFromProto(defaults.Service.Update.Monitor)
-		updateConfig = defaults.Service.Update
+		updateConfig = service.Spec.Update
+		if updateConfig == nil {
+			updateConfig = defaults.Service.Update
+		}
 	}
 
 	parallelism := int(updateConfig.Parallelism)

vendor/github.com/golang/mock/LICENSE

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

vendor/github.com/golang/mock/README.md

@@ -1,81 +0,0 @@
-GoMock is a mocking framework for the [Go programming language][golang]. It
-integrates well with Go's built-in `testing` package, but can be used in other
-contexts too.
-
-
-Installation
-------------
-
-Once you have [installed Go][golang-install], run these commands
-to install the `gomock` package and the `mockgen` tool:
-
-    go get github.com/golang/mock/gomock
-    go get github.com/golang/mock/mockgen
-
-
-Documentation
--------------
-
-After installing, you can use `go doc` to get documentation:
-
-    go doc github.com/golang/mock/gomock
-
-Alternatively, there is an online reference for the package hosted on GoPkgDoc
-[here][gomock-ref].
-
-
-Running mockgen
----------------
-
-`mockgen` has two modes of operation: source and reflect.
-Source mode generates mock interfaces from a source file.
-It is enabled by using the -source flag. Other flags that
-may be useful in this mode are -imports and -aux_files.
-
-Example:
-
-	mockgen -source=foo.go [other options]
-
-Reflect mode generates mock interfaces by building a program
-that uses reflection to understand interfaces. It is enabled
-by passing two non-flag arguments: an import path, and a
-comma-separated list of symbols.
-
-Example:
-
-	mockgen database/sql/driver Conn,Driver
-
-The `mockgen` command is used to generate source code for a mock
-class given a Go source file containing interfaces to be mocked.
-It supports the following flags:
-
- *  `-source`: A file containing interfaces to be mocked.
-
- *  `-destination`: A file to which to write the resulting source code. If you
-    don't set this, the code is printed to standard output.
-
- *  `-package`: The package to use for the resulting mock class
-    source code. If you don't set this, the package name is `mock_` concatenated
-    with the package of the input file.
-
- *  `-imports`: A list of explicit imports that should be used in the resulting
-    source code, specified as a comma-separated list of elements of the form
-    `foo=bar/baz`, where `bar/baz` is the package being imported and `foo` is
-    the identifier to use for the package in the generated source code.
-
- *  `-aux_files`: A list of additional files that should be consulted to
-    resolve e.g. embedded interfaces defined in a different file. This is
-    specified as a comma-separated list of elements of the form
-    `foo=bar/baz.go`, where `bar/baz.go` is the source file and `foo` is the
-    package name of that file used by the -source file.
-
-For an example of the use of `mockgen`, see the `sample/` directory. In simple
-cases, you will need only the `-source` flag.
-
-
-TODO: Brief overview of how to create mock objects and set up expectations, and
-an example.
-
-[golang]: http://golang.org/
-[golang-install]: http://golang.org/doc/install.html#releases
-[gomock-ref]: http://godoc.org/github.com/golang/mock/gomock

vendor/github.com/golang/mock/gomock/call.go

@@ -1,268 +0,0 @@
-// Copyright 2010 Google 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 gomock
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-)
-
-// Call represents an expected call to a mock.
-type Call struct {
-	t TestReporter // for triggering test failures on invalid call setup
-
-	receiver interface{}   // the receiver of the method call
-	method   string        // the name of the method
-	args     []Matcher     // the args
-	rets     []interface{} // the return values (if any)
-
-	preReqs []*Call // prerequisite calls
-
-	// Expectations
-	minCalls, maxCalls int
-
-	numCalls int // actual number made
-
-	// Actions
-	doFunc  reflect.Value
-	setArgs map[int]reflect.Value
-}
-
-// AnyTimes allows the expectation to be called 0 or more times
-func (c *Call) AnyTimes() *Call {
-	c.minCalls, c.maxCalls = 0, 1e8 // close enough to infinity
-	return c
-}
-
-// MinTimes requires the call to occur at least n times. If AnyTimes or MaxTimes have not been called, MinTimes also
-// sets the maximum number of calls to infinity.
-func (c *Call) MinTimes(n int) *Call {
-	c.minCalls = n
-	if c.maxCalls == 1 {
-		c.maxCalls = 1e8
-	}
-	return c
-}
-
-// MaxTimes limits the number of calls to n times. If AnyTimes or MinTimes have not been called, MaxTimes also
-// sets the minimum number of calls to 0.
-func (c *Call) MaxTimes(n int) *Call {
-	c.maxCalls = n
-	if c.minCalls == 1 {
-		c.minCalls = 0
-	}
-	return c
-}
-
-// Do declares the action to run when the call is matched.
-// It takes an interface{} argument to support n-arity functions.
-func (c *Call) Do(f interface{}) *Call {
-	// TODO: Check arity and types here, rather than dying badly elsewhere.
-	c.doFunc = reflect.ValueOf(f)
-	return c
-}
-
-func (c *Call) Return(rets ...interface{}) *Call {
-	mt := c.methodType()
-	if len(rets) != mt.NumOut() {
-		c.t.Fatalf("wrong number of arguments to Return for %T.%v: got %d, want %d",
-			c.receiver, c.method, len(rets), mt.NumOut())
-	}
-	for i, ret := range rets {
-		if got, want := reflect.TypeOf(ret), mt.Out(i); got == want {
-			// Identical types; nothing to do.
-		} else if got == nil {
-			// Nil needs special handling.
-			switch want.Kind() {
-			case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-				// ok
-			default:
-				c.t.Fatalf("argument %d to Return for %T.%v is nil, but %v is not nillable",
-					i, c.receiver, c.method, want)
-			}
-		} else if got.AssignableTo(want) {
-			// Assignable type relation. Make the assignment now so that the generated code
-			// can return the values with a type assertion.
-			v := reflect.New(want).Elem()
-			v.Set(reflect.ValueOf(ret))
-			rets[i] = v.Interface()
-		} else {
-			c.t.Fatalf("wrong type of argument %d to Return for %T.%v: %v is not assignable to %v",
-				i, c.receiver, c.method, got, want)
-		}
-	}
-
-	c.rets = rets
-	return c
-}
-
-func (c *Call) Times(n int) *Call {
-	c.minCalls, c.maxCalls = n, n
-	return c
-}
-
-// SetArg declares an action that will set the nth argument's value,
-// indirected through a pointer.
-func (c *Call) SetArg(n int, value interface{}) *Call {
-	if c.setArgs == nil {
-		c.setArgs = make(map[int]reflect.Value)
-	}
-	mt := c.methodType()
-	// TODO: This will break on variadic methods.
-	// We will need to check those at invocation time.
-	if n < 0 || n >= mt.NumIn() {
-		c.t.Fatalf("SetArg(%d, ...) called for a method with %d args", n, mt.NumIn())
-	}
-	// Permit setting argument through an interface.
-	// In the interface case, we don't (nay, can't) check the type here.
-	at := mt.In(n)
-	switch at.Kind() {
-	case reflect.Ptr:
-		dt := at.Elem()
-		if vt := reflect.TypeOf(value); !vt.AssignableTo(dt) {
-			c.t.Fatalf("SetArg(%d, ...) argument is a %v, not assignable to %v", n, vt, dt)
-		}
-	case reflect.Interface:
-		// nothing to do
-	default:
-		c.t.Fatalf("SetArg(%d, ...) referring to argument of non-pointer non-interface type %v", n, at)
-	}
-	c.setArgs[n] = reflect.ValueOf(value)
-	return c
-}
-
-// isPreReq returns true if other is a direct or indirect prerequisite to c.
-func (c *Call) isPreReq(other *Call) bool {
-	for _, preReq := range c.preReqs {
-		if other == preReq || preReq.isPreReq(other) {
-			return true
-		}
-	}
-	return false
-}
-
-// After declares that the call may only match after preReq has been exhausted.
-func (c *Call) After(preReq *Call) *Call {
-	if preReq.isPreReq(c) {
-		msg := fmt.Sprintf(
-			"Loop in call order: %v is a prerequisite to %v (possibly indirectly).",
-			c, preReq,
-		)
-		panic(msg)
-	}
-
-	c.preReqs = append(c.preReqs, preReq)
-	return c
-}
-
-// Returns true iff the minimum number of calls have been made.
-func (c *Call) satisfied() bool {
-	return c.numCalls >= c.minCalls
-}
-
-// Returns true iff the maximum number of calls have been made.
-func (c *Call) exhausted() bool {
-	return c.numCalls >= c.maxCalls
-}
-
-func (c *Call) String() string {
-	args := make([]string, len(c.args))
-	for i, arg := range c.args {
-		args[i] = arg.String()
-	}
-	arguments := strings.Join(args, ", ")
-	return fmt.Sprintf("%T.%v(%s)", c.receiver, c.method, arguments)
-}
-
-// Tests if the given call matches the expected call.
-func (c *Call) matches(args []interface{}) bool {
-	if len(args) != len(c.args) {
-		return false
-	}
-	for i, m := range c.args {
-		if !m.Matches(args[i]) {
-			return false
-		}
-	}
-
-	// Check that all prerequisite calls have been satisfied.
-	for _, preReqCall := range c.preReqs {
-		if !preReqCall.satisfied() {
-			return false
-		}
-	}
-
-	return true
-}
-
-// dropPrereqs tells the expected Call to not re-check prerequite calls any
-// longer, and to return its current set.
-func (c *Call) dropPrereqs() (preReqs []*Call) {
-	preReqs = c.preReqs
-	c.preReqs = nil
-	return
-}
-
-func (c *Call) call(args []interface{}) (rets []interface{}, action func()) {
-	c.numCalls++
-
-	// Actions
-	if c.doFunc.IsValid() {
-		doArgs := make([]reflect.Value, len(args))
-		ft := c.doFunc.Type()
-		for i := 0; i < ft.NumIn(); i++ {
-			if args[i] != nil {
-				doArgs[i] = reflect.ValueOf(args[i])
-			} else {
-				// Use the zero value for the arg.
-				doArgs[i] = reflect.Zero(ft.In(i))
-			}
-		}
-		action = func() { c.doFunc.Call(doArgs) }
-	}
-	for n, v := range c.setArgs {
-		reflect.ValueOf(args[n]).Elem().Set(v)
-	}
-
-	rets = c.rets
-	if rets == nil {
-		// Synthesize the zero value for each of the return args' types.
-		mt := c.methodType()
-		rets = make([]interface{}, mt.NumOut())
-		for i := 0; i < mt.NumOut(); i++ {
-			rets[i] = reflect.Zero(mt.Out(i)).Interface()
-		}
-	}
-
-	return
-}
-
-func (c *Call) methodType() reflect.Type {
-	recv := reflect.ValueOf(c.receiver)
-	for i := 0; i < recv.Type().NumMethod(); i++ {
-		if recv.Type().Method(i).Name == c.method {
-			return recv.Method(i).Type()
-		}
-	}
-	panic(fmt.Sprintf("gomock: failed finding method %s on %T", c.method, c.receiver))
-}
-
-// InOrder declares that the given calls should occur in order.
-func InOrder(calls ...*Call) {
-	for i := 1; i < len(calls); i++ {
-		calls[i].After(calls[i-1])
-	}
-}

vendor/github.com/golang/mock/gomock/callset.go

@@ -1,76 +0,0 @@
-// Copyright 2011 Google 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 gomock
-
-// callSet represents a set of expected calls, indexed by receiver and method
-// name.
-type callSet map[interface{}]map[string][]*Call
-
-// Add adds a new expected call.
-func (cs callSet) Add(call *Call) {
-	methodMap, ok := cs[call.receiver]
-	if !ok {
-		methodMap = make(map[string][]*Call)
-		cs[call.receiver] = methodMap
-	}
-	methodMap[call.method] = append(methodMap[call.method], call)
-}
-
-// Remove removes an expected call.
-func (cs callSet) Remove(call *Call) {
-	methodMap, ok := cs[call.receiver]
-	if !ok {
-		return
-	}
-	sl := methodMap[call.method]
-	for i, c := range sl {
-		if c == call {
-			// quick removal; we don't need to maintain call order
-			if len(sl) > 1 {
-				sl[i] = sl[len(sl)-1]
-			}
-			methodMap[call.method] = sl[:len(sl)-1]
-			break
-		}
-	}
-}
-
-// FindMatch searches for a matching call. Returns nil if no call matched.
-func (cs callSet) FindMatch(receiver interface{}, method string, args []interface{}) *Call {
-	methodMap, ok := cs[receiver]
-	if !ok {
-		return nil
-	}
-	calls, ok := methodMap[method]
-	if !ok {
-		return nil
-	}
-
-	// Search through the unordered set of calls expected on a method on a
-	// receiver.
-	for _, call := range calls {
-		// A call should not normally still be here if exhausted,
-		// but it can happen if, for instance, .Times(0) was used.
-		// Pretend the call doesn't match.
-		if call.exhausted() {
-			continue
-		}
-		if call.matches(args) {
-			return call
-		}
-	}
-
-	return nil
-}

vendor/github.com/golang/mock/gomock/controller.go

@@ -1,167 +0,0 @@
-// Copyright 2010 Google 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.
-
-// GoMock - a mock framework for Go.
-//
-// Standard usage:
-//   (1) Define an interface that you wish to mock.
-//         type MyInterface interface {
-//           SomeMethod(x int64, y string)
-//         }
-//   (2) Use mockgen to generate a mock from the interface.
-//   (3) Use the mock in a test:
-//         func TestMyThing(t *testing.T) {
-//           mockCtrl := gomock.NewController(t)
-//           defer mockCtrl.Finish()
-//
-//           mockObj := something.NewMockMyInterface(mockCtrl)
-//           mockObj.EXPECT().SomeMethod(4, "blah")
-//           // pass mockObj to a real object and play with it.
-//         }
-//
-// By default, expected calls are not enforced to run in any particular order.
-// Call order dependency can be enforced by use of InOrder and/or Call.After.
-// Call.After can create more varied call order dependencies, but InOrder is
-// often more convenient.
-//
-// The following examples create equivalent call order dependencies.
-//
-// Example of using Call.After to chain expected call order:
-//
-//     firstCall := mockObj.EXPECT().SomeMethod(1, "first")
-//     secondCall := mockObj.EXPECT().SomeMethod(2, "second").After(firstCall)
-//     mockObj.EXPECT().SomeMethod(3, "third").After(secondCall)
-//
-// Example of using InOrder to declare expected call order:
-//
-//     gomock.InOrder(
-//         mockObj.EXPECT().SomeMethod(1, "first"),
-//         mockObj.EXPECT().SomeMethod(2, "second"),
-//         mockObj.EXPECT().SomeMethod(3, "third"),
-//     )
-//
-// TODO:
-//	- Handle different argument/return types (e.g. ..., chan, map, interface).
-package gomock
-
-import "sync"
-
-// A TestReporter is something that can be used to report test failures.
-// It is satisfied by the standard library's *testing.T.
-type TestReporter interface {
-	Errorf(format string, args ...interface{})
-	Fatalf(format string, args ...interface{})
-}
-
-// A Controller represents the top-level control of a mock ecosystem.
-// It defines the scope and lifetime of mock objects, as well as their expectations.
-// It is safe to call Controller's methods from multiple goroutines.
-type Controller struct {
-	mu            sync.Mutex
-	t             TestReporter
-	expectedCalls callSet
-}
-
-func NewController(t TestReporter) *Controller {
-	return &Controller{
-		t:             t,
-		expectedCalls: make(callSet),
-	}
-}
-
-func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...interface{}) *Call {
-	// TODO: check arity, types.
-	margs := make([]Matcher, len(args))
-	for i, arg := range args {
-		if m, ok := arg.(Matcher); ok {
-			margs[i] = m
-		} else if arg == nil {
-			// Handle nil specially so that passing a nil interface value
-			// will match the typed nils of concrete args.
-			margs[i] = Nil()
-		} else {
-			margs[i] = Eq(arg)
-		}
-	}
-
-	ctrl.mu.Lock()
-	defer ctrl.mu.Unlock()
-
-	call := &Call{t: ctrl.t, receiver: receiver, method: method, args: margs, minCalls: 1, maxCalls: 1}
-
-	ctrl.expectedCalls.Add(call)
-	return call
-}
-
-func (ctrl *Controller) Call(receiver interface{}, method string, args ...interface{}) []interface{} {
-	ctrl.mu.Lock()
-	defer ctrl.mu.Unlock()
-
-	expected := ctrl.expectedCalls.FindMatch(receiver, method, args)
-	if expected == nil {
-		ctrl.t.Fatalf("no matching expected call: %T.%v(%v)", receiver, method, args)
-	}
-
-	// Two things happen here:
-	// * the matching call no longer needs to check prerequite calls,
-	// * and the prerequite calls are no longer expected, so remove them.
-	preReqCalls := expected.dropPrereqs()
-	for _, preReqCall := range preReqCalls {
-		ctrl.expectedCalls.Remove(preReqCall)
-	}
-
-	rets, action := expected.call(args)
-	if expected.exhausted() {
-		ctrl.expectedCalls.Remove(expected)
-	}
-
-	// Don't hold the lock while doing the call's action (if any)
-	// so that actions may execute concurrently.
-	// We use the deferred Unlock to capture any panics that happen above;
-	// here we add a deferred Lock to balance it.
-	ctrl.mu.Unlock()
-	defer ctrl.mu.Lock()
-	if action != nil {
-		action()
-	}
-
-	return rets
-}
-
-func (ctrl *Controller) Finish() {
-	ctrl.mu.Lock()
-	defer ctrl.mu.Unlock()
-
-	// If we're currently panicking, probably because this is a deferred call,
-	// pass through the panic.
-	if err := recover(); err != nil {
-		panic(err)
-	}
-
-	// Check that all remaining expected calls are satisfied.
-	failures := false
-	for _, methodMap := range ctrl.expectedCalls {
-		for _, calls := range methodMap {
-			for _, call := range calls {
-				if !call.satisfied() {
-					ctrl.t.Errorf("missing call(s) to %v", call)
-					failures = true
-				}
-			}
-		}
-	}
-	if failures {
-		ctrl.t.Fatalf("aborting test due to missing call(s)")
-	}
-}

vendor/github.com/golang/mock/gomock/matchers.go

@@ -1,97 +0,0 @@
-// Copyright 2010 Google 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 gomock
-
-import (
-	"fmt"
-	"reflect"
-)
-
-// A Matcher is a representation of a class of values.
-// It is used to represent the valid or expected arguments to a mocked method.
-type Matcher interface {
-	// Matches returns whether y is a match.
-	Matches(x interface{}) bool
-
-	// String describes what the matcher matches.
-	String() string
-}
-
-type anyMatcher struct{}
-
-func (anyMatcher) Matches(x interface{}) bool {
-	return true
-}
-
-func (anyMatcher) String() string {
-	return "is anything"
-}
-
-type eqMatcher struct {
-	x interface{}
-}
-
-func (e eqMatcher) Matches(x interface{}) bool {
-	return reflect.DeepEqual(e.x, x)
-}
-
-func (e eqMatcher) String() string {
-	return fmt.Sprintf("is equal to %v", e.x)
-}
-
-type nilMatcher struct{}
-
-func (nilMatcher) Matches(x interface{}) bool {
-	if x == nil {
-		return true
-	}
-
-	v := reflect.ValueOf(x)
-	switch v.Kind() {
-	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map,
-		reflect.Ptr, reflect.Slice:
-		return v.IsNil()
-	}
-
-	return false
-}
-
-func (nilMatcher) String() string {
-	return "is nil"
-}
-
-type notMatcher struct {
-	m Matcher
-}
-
-func (n notMatcher) Matches(x interface{}) bool {
-	return !n.m.Matches(x)
-}
-
-func (n notMatcher) String() string {
-	// TODO: Improve this if we add a NotString method to the Matcher interface.
-	return "not(" + n.m.String() + ")"
-}
-
-// Constructors
-func Any() Matcher             { return anyMatcher{} }
-func Eq(x interface{}) Matcher { return eqMatcher{x} }
-func Nil() Matcher             { return nilMatcher{} }
-func Not(x interface{}) Matcher {
-	if m, ok := x.(Matcher); ok {
-		return notMatcher{m}
-	}
-	return notMatcher{Eq(x)}
-}