@@ -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

new file mode 100644

@@ -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() }

deleted file mode 100644

@@ -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)

-}

@@ -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()

@@ -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)

deleted file mode 100644

@@ -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.

deleted file mode 100644

@@ -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

deleted file mode 100644

@@ -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.