worker: add Create, Containers, and Stop
Stop Add the counterpart to `Init()` so that we're able to gracefully close the connection to containerd, properly freeing resources on shutdown (mainly, the underlying `grpc` connection). Containers The implementation consists of two steps: - preparing `garden.Properties` to become a list of `k=v` strings that serve as filters to `containerd` - reaching out to containerd's containerservice, effectively listing the containers it manages in a given namespace. Also, as we have `Ping` implemented (which is used by the worker's own healthchecker), and `backend.Containers` is the very next thing to be constantly used right after registration (TSA's Healthcheckers try to list both volumes and containers), it made sense to implement this one right now. Create Add the ability to create a container from the backend. It largely relies on the fact that we can convert between `garden.ContainerSpec` down to an OCI-based configuration that `containerd` expects (via the `spec` package). The process is essentially of: 1. creating the container (oci bundle) 2. create a task 3. arrange networking step `3` is not implemented yet though. At the moment, it lacks: - limits - networking ps.: this commit might seem huuuuge, but it's mostly due to the addition of the faking of `containerd.Container`. Signed-off-by: Ciro S. Costa <cscosta@pivotal.io>
This commit is contained in:
Ciro S. Costa
parent
dd3037f07c
commit
e5be5af7c4
5
go.mod
5
go.mod
|
|
@ -84,6 +84,7 @@ require (
|
|||
github.com/gobuffalo/packr v1.13.7
|
||||
github.com/gocql/gocql v0.0.0-20180920092337-799fb0373110 // indirect
|
||||
github.com/gogo/googleapis v1.3.0 // indirect
|
||||
github.com/gogo/protobuf v1.3.0
|
||||
github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6 // indirect
|
||||
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
|
||||
github.com/google/go-cmp v0.3.1 // indirect
|
||||
|
|
@ -129,7 +130,7 @@ require (
|
|||
github.com/hashicorp/vault-plugin-secrets-gcpkms v0.0.0-20181212182553-6cd991800a6d // indirect
|
||||
github.com/hashicorp/vault-plugin-secrets-kv v0.0.0-20180825215324-5a464a61f7de // indirect
|
||||
github.com/hashicorp/yamux v0.0.0-20180917205041-7221087c3d28 // indirect
|
||||
github.com/imdario/mergo v0.3.6 // indirect
|
||||
github.com/imdario/mergo v0.3.6
|
||||
github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf
|
||||
github.com/influxdata/influxdb1-client v0.0.0-20190118215656-f8cdb5d5f175
|
||||
github.com/jeffchao/backoff v0.0.0-20140404060208-9d7fd7aa17f2 // indirect
|
||||
|
|
@ -161,7 +162,7 @@ require (
|
|||
github.com/opencontainers/go-digest v1.0.0-rc1 // indirect
|
||||
github.com/opencontainers/image-spec v1.0.1 // indirect
|
||||
github.com/opencontainers/runc v0.1.1 // indirect
|
||||
github.com/opencontainers/runtime-spec v1.0.1 // indirect
|
||||
github.com/opencontainers/runtime-spec v1.0.1
|
||||
github.com/ory-am/common v0.4.0 // indirect
|
||||
github.com/ory/dockertest v3.3.2+incompatible // indirect
|
||||
github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c // indirect
|
||||
|
|
|
|||
|
|
@ -7,21 +7,27 @@ import (
|
|||
|
||||
"code.cloudfoundry.org/garden"
|
||||
"github.com/concourse/concourse/worker/backend/libcontainerd"
|
||||
bespec "github.com/concourse/concourse/worker/backend/spec"
|
||||
"github.com/containerd/containerd/cio"
|
||||
"github.com/containerd/containerd/namespaces"
|
||||
specs "github.com/opencontainers/runtime-spec/specs-go"
|
||||
)
|
||||
|
||||
var _ garden.Backend = (*Backend)(nil)
|
||||
|
||||
type Backend struct {
|
||||
client libcontainerd.Client
|
||||
client libcontainerd.Client
|
||||
namespace string
|
||||
}
|
||||
|
||||
func New(client libcontainerd.Client) Backend {
|
||||
func New(client libcontainerd.Client, namespace string) Backend {
|
||||
return Backend{
|
||||
client: client,
|
||||
namespace: namespace,
|
||||
client: client,
|
||||
}
|
||||
}
|
||||
|
||||
// Start sets up the connectivity to `containerd`.
|
||||
// Start initializes the client.
|
||||
//
|
||||
func (b *Backend) Start() (err error) {
|
||||
err = b.client.Init()
|
||||
|
|
@ -33,7 +39,12 @@ func (b *Backend) Start() (err error) {
|
|||
return
|
||||
}
|
||||
|
||||
func (b *Backend) Stop() {}
|
||||
// Stop closes the client's underlying connections and frees any resources
|
||||
// associated with it.
|
||||
//
|
||||
func (b *Backend) Stop() {
|
||||
_ = b.client.Stop()
|
||||
}
|
||||
|
||||
func (b *Backend) GraceTime(container garden.Container) (duration time.Duration) {
|
||||
return
|
||||
|
|
@ -41,13 +52,6 @@ func (b *Backend) GraceTime(container garden.Container) (duration time.Duration)
|
|||
|
||||
// Pings the garden server in order to check connectivity.
|
||||
//
|
||||
// The server may, optionally, respond with specific errors indicating health
|
||||
// issues.
|
||||
//
|
||||
// Errors:
|
||||
// * garden.UnrecoverableError indicates that the garden server has entered an error state from which it cannot recover
|
||||
//
|
||||
// TODO - we might use the `version` service here as a proxy to "ping"
|
||||
func (b *Backend) Ping() (err error) {
|
||||
err = b.client.Version(context.Background())
|
||||
return
|
||||
|
|
@ -61,11 +65,32 @@ func (b *Backend) Capacity() (capacity garden.Capacity, err error) { return }
|
|||
|
||||
// Create creates a new container.
|
||||
//
|
||||
// Errors:
|
||||
// * When the handle, if specified, is already taken.
|
||||
// * When one of the bind_mount paths does not exist.
|
||||
// * When resource allocations fail (subnet, user ID, etc).
|
||||
func (b *Backend) Create(spec garden.ContainerSpec) (container garden.Container, err error) {
|
||||
func (b *Backend) Create(gdnSpec garden.ContainerSpec) (container garden.Container, err error) {
|
||||
var (
|
||||
oci *specs.Spec
|
||||
ctx = namespaces.WithNamespace(context.Background(), b.namespace)
|
||||
)
|
||||
|
||||
oci, err = bespec.OciSpec(gdnSpec)
|
||||
if err != nil {
|
||||
err = fmt.Errorf("failed to convert garden spec to oci spec: %w", err)
|
||||
return
|
||||
}
|
||||
|
||||
cont, err := b.client.NewContainer(ctx,
|
||||
gdnSpec.Handle, map[string]string(gdnSpec.Properties), oci,
|
||||
)
|
||||
if err != nil {
|
||||
err = fmt.Errorf("failed to create a container in containerd: %w", err)
|
||||
return
|
||||
}
|
||||
|
||||
_, err = cont.NewTask(ctx, cio.NullIO)
|
||||
if err != nil {
|
||||
err = fmt.Errorf("failed to create a task in container: %w", err)
|
||||
return
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -88,6 +113,24 @@ func (b *Backend) Destroy(handle string) (err error) { return }
|
|||
// Errors:
|
||||
// * None.
|
||||
func (b *Backend) Containers(properties garden.Properties) (containers []garden.Container, err error) {
|
||||
var ctx = namespaces.WithNamespace(context.Background(), b.namespace)
|
||||
|
||||
filters, err := propertiesToFilterList(properties)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
res, err := b.client.Containers(ctx, filters...)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
containers = make([]garden.Container, len(res))
|
||||
for idx := range res {
|
||||
gContainer := NewContainer()
|
||||
containers[idx] = &gContainer
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -106,3 +149,23 @@ func (b *Backend) BulkMetrics(handles []string) (metrics map[string]garden.Conta
|
|||
// Errors:
|
||||
// * Container not found.
|
||||
func (b *Backend) Lookup(handle string) (container garden.Container, err error) { return }
|
||||
|
||||
// propertiesToFilterList converts a set of garden properties to a list of
|
||||
// filters as expected by containerd.
|
||||
//
|
||||
func propertiesToFilterList(properties garden.Properties) (filters []string, err error) {
|
||||
filters = make([]string, len(properties))
|
||||
|
||||
idx := 0
|
||||
for k, v := range properties {
|
||||
if k == "" || v == "" {
|
||||
err = fmt.Errorf("key or value must not be empty")
|
||||
return
|
||||
}
|
||||
|
||||
filters[idx] = k + "=" + v
|
||||
idx++
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,8 +4,11 @@ import (
|
|||
"errors"
|
||||
"testing"
|
||||
|
||||
"code.cloudfoundry.org/garden"
|
||||
"github.com/concourse/concourse/worker/backend"
|
||||
"github.com/concourse/concourse/worker/backend/libcontainerd/libcontainerdfakes"
|
||||
"github.com/containerd/containerd"
|
||||
"github.com/containerd/containerd/namespaces"
|
||||
"github.com/stretchr/testify/require"
|
||||
"github.com/stretchr/testify/suite"
|
||||
)
|
||||
|
|
@ -18,9 +21,11 @@ type BackendSuite struct {
|
|||
client *libcontainerdfakes.FakeClient
|
||||
}
|
||||
|
||||
const testNamespace = "test-namespace"
|
||||
|
||||
func (s *BackendSuite) SetupTest() {
|
||||
s.client = new(libcontainerdfakes.FakeClient)
|
||||
s.backend = backend.New(s.client)
|
||||
s.backend = backend.New(s.client, testNamespace)
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestPing() {
|
||||
|
|
@ -54,6 +59,131 @@ func (s *BackendSuite) TestPing() {
|
|||
}
|
||||
}
|
||||
|
||||
var (
|
||||
invalidGdnSpec = garden.ContainerSpec{}
|
||||
minimumValidGdnSpec = garden.ContainerSpec{
|
||||
Handle: "handle", RootFSPath: "raw:///rootfs",
|
||||
}
|
||||
)
|
||||
|
||||
func (s *BackendSuite) TestCreateWithInvalidSpec() {
|
||||
_, err := s.backend.Create(invalidGdnSpec)
|
||||
|
||||
s.Error(err)
|
||||
s.Equal(0, s.client.NewContainerCallCount())
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestCreateWithNewContainerFailure() {
|
||||
s.client.NewContainerReturns(nil, errors.New("err"))
|
||||
|
||||
_, err := s.backend.Create(minimumValidGdnSpec)
|
||||
s.Error(err)
|
||||
|
||||
s.Equal(1, s.client.NewContainerCallCount())
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestCreateSetsNamespace() {
|
||||
fakeContainer := new(libcontainerdfakes.FakeContainer)
|
||||
s.client.NewContainerReturns(fakeContainer, nil)
|
||||
|
||||
_, _ = s.backend.Create(minimumValidGdnSpec)
|
||||
s.Equal(1, s.client.NewContainerCallCount())
|
||||
|
||||
ctx, _, _, _ := s.client.NewContainerArgsForCall(0)
|
||||
namespace, ok := namespaces.Namespace(ctx)
|
||||
s.True(ok)
|
||||
s.Equal(testNamespace, namespace)
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestCreateContainerNewTaskFailure() {
|
||||
fakeContainer := new(libcontainerdfakes.FakeContainer)
|
||||
fakeContainer.NewTaskReturns(nil, errors.New("err"))
|
||||
|
||||
s.client.NewContainerReturns(fakeContainer, nil)
|
||||
|
||||
_, err := s.backend.Create(minimumValidGdnSpec)
|
||||
s.Error(err)
|
||||
|
||||
s.Equal(1, fakeContainer.NewTaskCallCount())
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestContainersWithContainerdFailure() {
|
||||
s.client.ContainersReturns(nil, errors.New("err"))
|
||||
|
||||
_, err := s.backend.Containers(nil)
|
||||
s.Error(err)
|
||||
s.Equal(1, s.client.ContainersCallCount())
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestContainersSetsNamespace() {
|
||||
_, _ = s.backend.Containers(nil)
|
||||
s.Equal(1, s.client.ContainersCallCount())
|
||||
|
||||
ctx, _ := s.client.ContainersArgsForCall(0)
|
||||
namespace, ok := namespaces.Namespace(ctx)
|
||||
s.True(ok)
|
||||
s.Equal(testNamespace, namespace)
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestContainersWithInvalidPropertyFilters() {
|
||||
for _, tc := range []struct {
|
||||
desc string
|
||||
filter map[string]string
|
||||
}{
|
||||
{
|
||||
desc: "empty key",
|
||||
filter: map[string]string{
|
||||
"": "bar",
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "empty value",
|
||||
filter: map[string]string{
|
||||
"foo": "",
|
||||
},
|
||||
},
|
||||
} {
|
||||
s.T().Run(tc.desc, func(t *testing.T) {
|
||||
_, err := s.backend.Containers(tc.filter)
|
||||
|
||||
s.Error(err)
|
||||
s.Equal(0, s.client.ContainersCallCount())
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestContainersWithProperProperties() {
|
||||
_, _ = s.backend.Containers(map[string]string{"foo": "bar", "caz": "zaz"})
|
||||
s.Equal(1, s.client.ContainersCallCount())
|
||||
|
||||
_, labelSet := s.client.ContainersArgsForCall(0)
|
||||
s.ElementsMatch([]string{"foo=bar", "caz=zaz"}, labelSet)
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestContainersConversion() {
|
||||
fakeContainer1 := new(libcontainerdfakes.FakeContainer)
|
||||
fakeContainer2 := new(libcontainerdfakes.FakeContainer)
|
||||
|
||||
s.client.ContainersReturns([]containerd.Container{
|
||||
fakeContainer1, fakeContainer2,
|
||||
}, nil)
|
||||
|
||||
containers, err := s.backend.Containers(nil)
|
||||
s.NoError(err)
|
||||
s.Equal(1, s.client.ContainersCallCount())
|
||||
s.Len(containers, 2)
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestStart() {
|
||||
s.backend.Start()
|
||||
s.Equal(1, s.client.InitCallCount())
|
||||
}
|
||||
|
||||
func (s *BackendSuite) TestStop() {
|
||||
s.backend.Stop()
|
||||
s.Equal(1, s.client.StopCallCount())
|
||||
}
|
||||
|
||||
func TestSuite(t *testing.T) {
|
||||
suite.Run(t, &BackendSuite{
|
||||
Assertions: require.New(t),
|
||||
|
|
|
|||
|
|
@ -9,6 +9,10 @@ import (
|
|||
|
||||
type Container struct{}
|
||||
|
||||
func NewContainer() Container {
|
||||
return Container{}
|
||||
}
|
||||
|
||||
var _ garden.Container = (*Container)(nil)
|
||||
|
||||
func (c *Container) Handle() (handle string) { return }
|
||||
|
|
|
|||
|
|
@ -5,24 +5,64 @@ import (
|
|||
"fmt"
|
||||
|
||||
"github.com/containerd/containerd"
|
||||
"github.com/opencontainers/runtime-spec/specs-go"
|
||||
)
|
||||
|
||||
//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 . Client
|
||||
//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 github.com/containerd/containerd.Container
|
||||
|
||||
// Client represents the minimum interface used to communicate with containerd
|
||||
// to manage containers.
|
||||
//
|
||||
type Client interface {
|
||||
|
||||
// Init provides the initialization of internal structures necessary by
|
||||
// the client, e.g., instantiation of the gRPC client.
|
||||
//
|
||||
Init() (err error)
|
||||
|
||||
// Version queries containerd's version service in order to verify
|
||||
// connectivity.
|
||||
//
|
||||
Version(ctx context.Context) (err error)
|
||||
|
||||
// Stop deallocates any initialization performed by `Init()` and
|
||||
// subsequent calls to methods of this interface.
|
||||
//
|
||||
Stop() (err error)
|
||||
|
||||
// NewContainer creates a container in containerd.
|
||||
//
|
||||
NewContainer(
|
||||
ctx context.Context,
|
||||
id string,
|
||||
labels map[string]string,
|
||||
oci *specs.Spec,
|
||||
) (
|
||||
container containerd.Container, err error,
|
||||
)
|
||||
|
||||
// Containers lists containers available in containerd matching a given
|
||||
// labelset.
|
||||
//
|
||||
Containers(
|
||||
ctx context.Context,
|
||||
labels ...string,
|
||||
) (
|
||||
containers []containerd.Container, err error,
|
||||
)
|
||||
}
|
||||
|
||||
type client struct {
|
||||
addr string
|
||||
addr string
|
||||
|
||||
containerd *containerd.Client
|
||||
}
|
||||
|
||||
var _ Client = (*client)(nil)
|
||||
|
||||
func New(addr string) *client {
|
||||
return &client{
|
||||
addr: addr,
|
||||
}
|
||||
return &client{addr: addr}
|
||||
}
|
||||
|
||||
func (c *client) Init() (err error) {
|
||||
|
|
@ -35,6 +75,34 @@ func (c *client) Init() (err error) {
|
|||
return
|
||||
}
|
||||
|
||||
func (c *client) Stop() (err error) {
|
||||
if c.containerd == nil {
|
||||
return
|
||||
}
|
||||
|
||||
err = c.containerd.Close()
|
||||
return
|
||||
}
|
||||
|
||||
func (c *client) NewContainer(
|
||||
ctx context.Context, id string, labels map[string]string, oci *specs.Spec,
|
||||
) (
|
||||
containerd.Container, error,
|
||||
) {
|
||||
return c.containerd.NewContainer(ctx, id,
|
||||
containerd.WithSpec(oci),
|
||||
containerd.WithContainerLabels(labels),
|
||||
)
|
||||
}
|
||||
|
||||
func (c *client) Containers(
|
||||
ctx context.Context, labels ...string,
|
||||
) (
|
||||
[]containerd.Container, error,
|
||||
) {
|
||||
return c.containerd.Containers(ctx, labels...)
|
||||
}
|
||||
|
||||
func (c *client) Version(ctx context.Context) (err error) {
|
||||
_, err = c.containerd.Version(ctx)
|
||||
return
|
||||
|
|
|
|||
|
|
@ -6,9 +6,25 @@ import (
|
|||
"sync"
|
||||
|
||||
"github.com/concourse/concourse/worker/backend/libcontainerd"
|
||||
"github.com/containerd/containerd"
|
||||
specs "github.com/opencontainers/runtime-spec/specs-go"
|
||||
)
|
||||
|
||||
type FakeClient struct {
|
||||
ContainersStub func(context.Context, ...string) ([]containerd.Container, error)
|
||||
containersMutex sync.RWMutex
|
||||
containersArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 []string
|
||||
}
|
||||
containersReturns struct {
|
||||
result1 []containerd.Container
|
||||
result2 error
|
||||
}
|
||||
containersReturnsOnCall map[int]struct {
|
||||
result1 []containerd.Container
|
||||
result2 error
|
||||
}
|
||||
InitStub func() error
|
||||
initMutex sync.RWMutex
|
||||
initArgsForCall []struct {
|
||||
|
|
@ -19,6 +35,32 @@ type FakeClient struct {
|
|||
initReturnsOnCall map[int]struct {
|
||||
result1 error
|
||||
}
|
||||
NewContainerStub func(context.Context, string, map[string]string, *specs.Spec) (containerd.Container, error)
|
||||
newContainerMutex sync.RWMutex
|
||||
newContainerArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 string
|
||||
arg3 map[string]string
|
||||
arg4 *specs.Spec
|
||||
}
|
||||
newContainerReturns struct {
|
||||
result1 containerd.Container
|
||||
result2 error
|
||||
}
|
||||
newContainerReturnsOnCall map[int]struct {
|
||||
result1 containerd.Container
|
||||
result2 error
|
||||
}
|
||||
StopStub func() error
|
||||
stopMutex sync.RWMutex
|
||||
stopArgsForCall []struct {
|
||||
}
|
||||
stopReturns struct {
|
||||
result1 error
|
||||
}
|
||||
stopReturnsOnCall map[int]struct {
|
||||
result1 error
|
||||
}
|
||||
VersionStub func(context.Context) error
|
||||
versionMutex sync.RWMutex
|
||||
versionArgsForCall []struct {
|
||||
|
|
@ -34,6 +76,70 @@ type FakeClient struct {
|
|||
invocationsMutex sync.RWMutex
|
||||
}
|
||||
|
||||
func (fake *FakeClient) Containers(arg1 context.Context, arg2 ...string) ([]containerd.Container, error) {
|
||||
fake.containersMutex.Lock()
|
||||
ret, specificReturn := fake.containersReturnsOnCall[len(fake.containersArgsForCall)]
|
||||
fake.containersArgsForCall = append(fake.containersArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 []string
|
||||
}{arg1, arg2})
|
||||
fake.recordInvocation("Containers", []interface{}{arg1, arg2})
|
||||
fake.containersMutex.Unlock()
|
||||
if fake.ContainersStub != nil {
|
||||
return fake.ContainersStub(arg1, arg2...)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.containersReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeClient) ContainersCallCount() int {
|
||||
fake.containersMutex.RLock()
|
||||
defer fake.containersMutex.RUnlock()
|
||||
return len(fake.containersArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeClient) ContainersCalls(stub func(context.Context, ...string) ([]containerd.Container, error)) {
|
||||
fake.containersMutex.Lock()
|
||||
defer fake.containersMutex.Unlock()
|
||||
fake.ContainersStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeClient) ContainersArgsForCall(i int) (context.Context, []string) {
|
||||
fake.containersMutex.RLock()
|
||||
defer fake.containersMutex.RUnlock()
|
||||
argsForCall := fake.containersArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeClient) ContainersReturns(result1 []containerd.Container, result2 error) {
|
||||
fake.containersMutex.Lock()
|
||||
defer fake.containersMutex.Unlock()
|
||||
fake.ContainersStub = nil
|
||||
fake.containersReturns = struct {
|
||||
result1 []containerd.Container
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeClient) ContainersReturnsOnCall(i int, result1 []containerd.Container, result2 error) {
|
||||
fake.containersMutex.Lock()
|
||||
defer fake.containersMutex.Unlock()
|
||||
fake.ContainersStub = nil
|
||||
if fake.containersReturnsOnCall == nil {
|
||||
fake.containersReturnsOnCall = make(map[int]struct {
|
||||
result1 []containerd.Container
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.containersReturnsOnCall[i] = struct {
|
||||
result1 []containerd.Container
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeClient) Init() error {
|
||||
fake.initMutex.Lock()
|
||||
ret, specificReturn := fake.initReturnsOnCall[len(fake.initArgsForCall)]
|
||||
|
|
@ -86,6 +192,124 @@ func (fake *FakeClient) InitReturnsOnCall(i int, result1 error) {
|
|||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeClient) NewContainer(arg1 context.Context, arg2 string, arg3 map[string]string, arg4 *specs.Spec) (containerd.Container, error) {
|
||||
fake.newContainerMutex.Lock()
|
||||
ret, specificReturn := fake.newContainerReturnsOnCall[len(fake.newContainerArgsForCall)]
|
||||
fake.newContainerArgsForCall = append(fake.newContainerArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 string
|
||||
arg3 map[string]string
|
||||
arg4 *specs.Spec
|
||||
}{arg1, arg2, arg3, arg4})
|
||||
fake.recordInvocation("NewContainer", []interface{}{arg1, arg2, arg3, arg4})
|
||||
fake.newContainerMutex.Unlock()
|
||||
if fake.NewContainerStub != nil {
|
||||
return fake.NewContainerStub(arg1, arg2, arg3, arg4)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.newContainerReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeClient) NewContainerCallCount() int {
|
||||
fake.newContainerMutex.RLock()
|
||||
defer fake.newContainerMutex.RUnlock()
|
||||
return len(fake.newContainerArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeClient) NewContainerCalls(stub func(context.Context, string, map[string]string, *specs.Spec) (containerd.Container, error)) {
|
||||
fake.newContainerMutex.Lock()
|
||||
defer fake.newContainerMutex.Unlock()
|
||||
fake.NewContainerStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeClient) NewContainerArgsForCall(i int) (context.Context, string, map[string]string, *specs.Spec) {
|
||||
fake.newContainerMutex.RLock()
|
||||
defer fake.newContainerMutex.RUnlock()
|
||||
argsForCall := fake.newContainerArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
|
||||
}
|
||||
|
||||
func (fake *FakeClient) NewContainerReturns(result1 containerd.Container, result2 error) {
|
||||
fake.newContainerMutex.Lock()
|
||||
defer fake.newContainerMutex.Unlock()
|
||||
fake.NewContainerStub = nil
|
||||
fake.newContainerReturns = struct {
|
||||
result1 containerd.Container
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeClient) NewContainerReturnsOnCall(i int, result1 containerd.Container, result2 error) {
|
||||
fake.newContainerMutex.Lock()
|
||||
defer fake.newContainerMutex.Unlock()
|
||||
fake.NewContainerStub = nil
|
||||
if fake.newContainerReturnsOnCall == nil {
|
||||
fake.newContainerReturnsOnCall = make(map[int]struct {
|
||||
result1 containerd.Container
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.newContainerReturnsOnCall[i] = struct {
|
||||
result1 containerd.Container
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeClient) Stop() error {
|
||||
fake.stopMutex.Lock()
|
||||
ret, specificReturn := fake.stopReturnsOnCall[len(fake.stopArgsForCall)]
|
||||
fake.stopArgsForCall = append(fake.stopArgsForCall, struct {
|
||||
}{})
|
||||
fake.recordInvocation("Stop", []interface{}{})
|
||||
fake.stopMutex.Unlock()
|
||||
if fake.StopStub != nil {
|
||||
return fake.StopStub()
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
fakeReturns := fake.stopReturns
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeClient) StopCallCount() int {
|
||||
fake.stopMutex.RLock()
|
||||
defer fake.stopMutex.RUnlock()
|
||||
return len(fake.stopArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeClient) StopCalls(stub func() error) {
|
||||
fake.stopMutex.Lock()
|
||||
defer fake.stopMutex.Unlock()
|
||||
fake.StopStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeClient) StopReturns(result1 error) {
|
||||
fake.stopMutex.Lock()
|
||||
defer fake.stopMutex.Unlock()
|
||||
fake.StopStub = nil
|
||||
fake.stopReturns = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeClient) StopReturnsOnCall(i int, result1 error) {
|
||||
fake.stopMutex.Lock()
|
||||
defer fake.stopMutex.Unlock()
|
||||
fake.StopStub = nil
|
||||
if fake.stopReturnsOnCall == nil {
|
||||
fake.stopReturnsOnCall = make(map[int]struct {
|
||||
result1 error
|
||||
})
|
||||
}
|
||||
fake.stopReturnsOnCall[i] = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeClient) Version(arg1 context.Context) error {
|
||||
fake.versionMutex.Lock()
|
||||
ret, specificReturn := fake.versionReturnsOnCall[len(fake.versionArgsForCall)]
|
||||
|
|
@ -149,8 +373,14 @@ func (fake *FakeClient) VersionReturnsOnCall(i int, result1 error) {
|
|||
func (fake *FakeClient) Invocations() map[string][][]interface{} {
|
||||
fake.invocationsMutex.RLock()
|
||||
defer fake.invocationsMutex.RUnlock()
|
||||
fake.containersMutex.RLock()
|
||||
defer fake.containersMutex.RUnlock()
|
||||
fake.initMutex.RLock()
|
||||
defer fake.initMutex.RUnlock()
|
||||
fake.newContainerMutex.RLock()
|
||||
defer fake.newContainerMutex.RUnlock()
|
||||
fake.stopMutex.RLock()
|
||||
defer fake.stopMutex.RUnlock()
|
||||
fake.versionMutex.RLock()
|
||||
defer fake.versionMutex.RUnlock()
|
||||
copiedInvocations := map[string][][]interface{}{}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,972 @@
|
|||
// Code generated by counterfeiter. DO NOT EDIT.
|
||||
package libcontainerdfakes
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync"
|
||||
|
||||
"github.com/containerd/containerd"
|
||||
"github.com/containerd/containerd/cio"
|
||||
"github.com/containerd/containerd/containers"
|
||||
"github.com/gogo/protobuf/types"
|
||||
specs "github.com/opencontainers/runtime-spec/specs-go"
|
||||
)
|
||||
|
||||
type FakeContainer struct {
|
||||
CheckpointStub func(context.Context, string, ...containerd.CheckpointOpts) (containerd.Image, error)
|
||||
checkpointMutex sync.RWMutex
|
||||
checkpointArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 string
|
||||
arg3 []containerd.CheckpointOpts
|
||||
}
|
||||
checkpointReturns struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
}
|
||||
checkpointReturnsOnCall map[int]struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
}
|
||||
DeleteStub func(context.Context, ...containerd.DeleteOpts) error
|
||||
deleteMutex sync.RWMutex
|
||||
deleteArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 []containerd.DeleteOpts
|
||||
}
|
||||
deleteReturns struct {
|
||||
result1 error
|
||||
}
|
||||
deleteReturnsOnCall map[int]struct {
|
||||
result1 error
|
||||
}
|
||||
ExtensionsStub func(context.Context) (map[string]types.Any, error)
|
||||
extensionsMutex sync.RWMutex
|
||||
extensionsArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
}
|
||||
extensionsReturns struct {
|
||||
result1 map[string]types.Any
|
||||
result2 error
|
||||
}
|
||||
extensionsReturnsOnCall map[int]struct {
|
||||
result1 map[string]types.Any
|
||||
result2 error
|
||||
}
|
||||
IDStub func() string
|
||||
iDMutex sync.RWMutex
|
||||
iDArgsForCall []struct {
|
||||
}
|
||||
iDReturns struct {
|
||||
result1 string
|
||||
}
|
||||
iDReturnsOnCall map[int]struct {
|
||||
result1 string
|
||||
}
|
||||
ImageStub func(context.Context) (containerd.Image, error)
|
||||
imageMutex sync.RWMutex
|
||||
imageArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
}
|
||||
imageReturns struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
}
|
||||
imageReturnsOnCall map[int]struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
}
|
||||
InfoStub func(context.Context, ...containerd.InfoOpts) (containers.Container, error)
|
||||
infoMutex sync.RWMutex
|
||||
infoArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 []containerd.InfoOpts
|
||||
}
|
||||
infoReturns struct {
|
||||
result1 containers.Container
|
||||
result2 error
|
||||
}
|
||||
infoReturnsOnCall map[int]struct {
|
||||
result1 containers.Container
|
||||
result2 error
|
||||
}
|
||||
LabelsStub func(context.Context) (map[string]string, error)
|
||||
labelsMutex sync.RWMutex
|
||||
labelsArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
}
|
||||
labelsReturns struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
}
|
||||
labelsReturnsOnCall map[int]struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
}
|
||||
NewTaskStub func(context.Context, cio.Creator, ...containerd.NewTaskOpts) (containerd.Task, error)
|
||||
newTaskMutex sync.RWMutex
|
||||
newTaskArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 cio.Creator
|
||||
arg3 []containerd.NewTaskOpts
|
||||
}
|
||||
newTaskReturns struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
}
|
||||
newTaskReturnsOnCall map[int]struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
}
|
||||
SetLabelsStub func(context.Context, map[string]string) (map[string]string, error)
|
||||
setLabelsMutex sync.RWMutex
|
||||
setLabelsArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 map[string]string
|
||||
}
|
||||
setLabelsReturns struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
}
|
||||
setLabelsReturnsOnCall map[int]struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
}
|
||||
SpecStub func(context.Context) (*specs.Spec, error)
|
||||
specMutex sync.RWMutex
|
||||
specArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
}
|
||||
specReturns struct {
|
||||
result1 *specs.Spec
|
||||
result2 error
|
||||
}
|
||||
specReturnsOnCall map[int]struct {
|
||||
result1 *specs.Spec
|
||||
result2 error
|
||||
}
|
||||
TaskStub func(context.Context, cio.Attach) (containerd.Task, error)
|
||||
taskMutex sync.RWMutex
|
||||
taskArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 cio.Attach
|
||||
}
|
||||
taskReturns struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
}
|
||||
taskReturnsOnCall map[int]struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
}
|
||||
UpdateStub func(context.Context, ...containerd.UpdateContainerOpts) error
|
||||
updateMutex sync.RWMutex
|
||||
updateArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 []containerd.UpdateContainerOpts
|
||||
}
|
||||
updateReturns struct {
|
||||
result1 error
|
||||
}
|
||||
updateReturnsOnCall map[int]struct {
|
||||
result1 error
|
||||
}
|
||||
invocations map[string][][]interface{}
|
||||
invocationsMutex sync.RWMutex
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Checkpoint(arg1 context.Context, arg2 string, arg3 ...containerd.CheckpointOpts) (containerd.Image, error) {
|
||||
fake.checkpointMutex.Lock()
|
||||
ret, specificReturn := fake.checkpointReturnsOnCall[len(fake.checkpointArgsForCall)]
|
||||
fake.checkpointArgsForCall = append(fake.checkpointArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 string
|
||||
arg3 []containerd.CheckpointOpts
|
||||
}{arg1, arg2, arg3})
|
||||
fake.recordInvocation("Checkpoint", []interface{}{arg1, arg2, arg3})
|
||||
fake.checkpointMutex.Unlock()
|
||||
if fake.CheckpointStub != nil {
|
||||
return fake.CheckpointStub(arg1, arg2, arg3...)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.checkpointReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) CheckpointCallCount() int {
|
||||
fake.checkpointMutex.RLock()
|
||||
defer fake.checkpointMutex.RUnlock()
|
||||
return len(fake.checkpointArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) CheckpointCalls(stub func(context.Context, string, ...containerd.CheckpointOpts) (containerd.Image, error)) {
|
||||
fake.checkpointMutex.Lock()
|
||||
defer fake.checkpointMutex.Unlock()
|
||||
fake.CheckpointStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) CheckpointArgsForCall(i int) (context.Context, string, []containerd.CheckpointOpts) {
|
||||
fake.checkpointMutex.RLock()
|
||||
defer fake.checkpointMutex.RUnlock()
|
||||
argsForCall := fake.checkpointArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) CheckpointReturns(result1 containerd.Image, result2 error) {
|
||||
fake.checkpointMutex.Lock()
|
||||
defer fake.checkpointMutex.Unlock()
|
||||
fake.CheckpointStub = nil
|
||||
fake.checkpointReturns = struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) CheckpointReturnsOnCall(i int, result1 containerd.Image, result2 error) {
|
||||
fake.checkpointMutex.Lock()
|
||||
defer fake.checkpointMutex.Unlock()
|
||||
fake.CheckpointStub = nil
|
||||
if fake.checkpointReturnsOnCall == nil {
|
||||
fake.checkpointReturnsOnCall = make(map[int]struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.checkpointReturnsOnCall[i] = struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Delete(arg1 context.Context, arg2 ...containerd.DeleteOpts) error {
|
||||
fake.deleteMutex.Lock()
|
||||
ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)]
|
||||
fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 []containerd.DeleteOpts
|
||||
}{arg1, arg2})
|
||||
fake.recordInvocation("Delete", []interface{}{arg1, arg2})
|
||||
fake.deleteMutex.Unlock()
|
||||
if fake.DeleteStub != nil {
|
||||
return fake.DeleteStub(arg1, arg2...)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
fakeReturns := fake.deleteReturns
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) DeleteCallCount() int {
|
||||
fake.deleteMutex.RLock()
|
||||
defer fake.deleteMutex.RUnlock()
|
||||
return len(fake.deleteArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) DeleteCalls(stub func(context.Context, ...containerd.DeleteOpts) error) {
|
||||
fake.deleteMutex.Lock()
|
||||
defer fake.deleteMutex.Unlock()
|
||||
fake.DeleteStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) DeleteArgsForCall(i int) (context.Context, []containerd.DeleteOpts) {
|
||||
fake.deleteMutex.RLock()
|
||||
defer fake.deleteMutex.RUnlock()
|
||||
argsForCall := fake.deleteArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) DeleteReturns(result1 error) {
|
||||
fake.deleteMutex.Lock()
|
||||
defer fake.deleteMutex.Unlock()
|
||||
fake.DeleteStub = nil
|
||||
fake.deleteReturns = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) DeleteReturnsOnCall(i int, result1 error) {
|
||||
fake.deleteMutex.Lock()
|
||||
defer fake.deleteMutex.Unlock()
|
||||
fake.DeleteStub = nil
|
||||
if fake.deleteReturnsOnCall == nil {
|
||||
fake.deleteReturnsOnCall = make(map[int]struct {
|
||||
result1 error
|
||||
})
|
||||
}
|
||||
fake.deleteReturnsOnCall[i] = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Extensions(arg1 context.Context) (map[string]types.Any, error) {
|
||||
fake.extensionsMutex.Lock()
|
||||
ret, specificReturn := fake.extensionsReturnsOnCall[len(fake.extensionsArgsForCall)]
|
||||
fake.extensionsArgsForCall = append(fake.extensionsArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
}{arg1})
|
||||
fake.recordInvocation("Extensions", []interface{}{arg1})
|
||||
fake.extensionsMutex.Unlock()
|
||||
if fake.ExtensionsStub != nil {
|
||||
return fake.ExtensionsStub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.extensionsReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ExtensionsCallCount() int {
|
||||
fake.extensionsMutex.RLock()
|
||||
defer fake.extensionsMutex.RUnlock()
|
||||
return len(fake.extensionsArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ExtensionsCalls(stub func(context.Context) (map[string]types.Any, error)) {
|
||||
fake.extensionsMutex.Lock()
|
||||
defer fake.extensionsMutex.Unlock()
|
||||
fake.ExtensionsStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ExtensionsArgsForCall(i int) context.Context {
|
||||
fake.extensionsMutex.RLock()
|
||||
defer fake.extensionsMutex.RUnlock()
|
||||
argsForCall := fake.extensionsArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ExtensionsReturns(result1 map[string]types.Any, result2 error) {
|
||||
fake.extensionsMutex.Lock()
|
||||
defer fake.extensionsMutex.Unlock()
|
||||
fake.ExtensionsStub = nil
|
||||
fake.extensionsReturns = struct {
|
||||
result1 map[string]types.Any
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ExtensionsReturnsOnCall(i int, result1 map[string]types.Any, result2 error) {
|
||||
fake.extensionsMutex.Lock()
|
||||
defer fake.extensionsMutex.Unlock()
|
||||
fake.ExtensionsStub = nil
|
||||
if fake.extensionsReturnsOnCall == nil {
|
||||
fake.extensionsReturnsOnCall = make(map[int]struct {
|
||||
result1 map[string]types.Any
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.extensionsReturnsOnCall[i] = struct {
|
||||
result1 map[string]types.Any
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ID() string {
|
||||
fake.iDMutex.Lock()
|
||||
ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
|
||||
fake.iDArgsForCall = append(fake.iDArgsForCall, struct {
|
||||
}{})
|
||||
fake.recordInvocation("ID", []interface{}{})
|
||||
fake.iDMutex.Unlock()
|
||||
if fake.IDStub != nil {
|
||||
return fake.IDStub()
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
fakeReturns := fake.iDReturns
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) IDCallCount() int {
|
||||
fake.iDMutex.RLock()
|
||||
defer fake.iDMutex.RUnlock()
|
||||
return len(fake.iDArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) IDCalls(stub func() string) {
|
||||
fake.iDMutex.Lock()
|
||||
defer fake.iDMutex.Unlock()
|
||||
fake.IDStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) IDReturns(result1 string) {
|
||||
fake.iDMutex.Lock()
|
||||
defer fake.iDMutex.Unlock()
|
||||
fake.IDStub = nil
|
||||
fake.iDReturns = struct {
|
||||
result1 string
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) IDReturnsOnCall(i int, result1 string) {
|
||||
fake.iDMutex.Lock()
|
||||
defer fake.iDMutex.Unlock()
|
||||
fake.IDStub = nil
|
||||
if fake.iDReturnsOnCall == nil {
|
||||
fake.iDReturnsOnCall = make(map[int]struct {
|
||||
result1 string
|
||||
})
|
||||
}
|
||||
fake.iDReturnsOnCall[i] = struct {
|
||||
result1 string
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Image(arg1 context.Context) (containerd.Image, error) {
|
||||
fake.imageMutex.Lock()
|
||||
ret, specificReturn := fake.imageReturnsOnCall[len(fake.imageArgsForCall)]
|
||||
fake.imageArgsForCall = append(fake.imageArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
}{arg1})
|
||||
fake.recordInvocation("Image", []interface{}{arg1})
|
||||
fake.imageMutex.Unlock()
|
||||
if fake.ImageStub != nil {
|
||||
return fake.ImageStub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.imageReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ImageCallCount() int {
|
||||
fake.imageMutex.RLock()
|
||||
defer fake.imageMutex.RUnlock()
|
||||
return len(fake.imageArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ImageCalls(stub func(context.Context) (containerd.Image, error)) {
|
||||
fake.imageMutex.Lock()
|
||||
defer fake.imageMutex.Unlock()
|
||||
fake.ImageStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ImageArgsForCall(i int) context.Context {
|
||||
fake.imageMutex.RLock()
|
||||
defer fake.imageMutex.RUnlock()
|
||||
argsForCall := fake.imageArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ImageReturns(result1 containerd.Image, result2 error) {
|
||||
fake.imageMutex.Lock()
|
||||
defer fake.imageMutex.Unlock()
|
||||
fake.ImageStub = nil
|
||||
fake.imageReturns = struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) ImageReturnsOnCall(i int, result1 containerd.Image, result2 error) {
|
||||
fake.imageMutex.Lock()
|
||||
defer fake.imageMutex.Unlock()
|
||||
fake.ImageStub = nil
|
||||
if fake.imageReturnsOnCall == nil {
|
||||
fake.imageReturnsOnCall = make(map[int]struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.imageReturnsOnCall[i] = struct {
|
||||
result1 containerd.Image
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Info(arg1 context.Context, arg2 ...containerd.InfoOpts) (containers.Container, error) {
|
||||
fake.infoMutex.Lock()
|
||||
ret, specificReturn := fake.infoReturnsOnCall[len(fake.infoArgsForCall)]
|
||||
fake.infoArgsForCall = append(fake.infoArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 []containerd.InfoOpts
|
||||
}{arg1, arg2})
|
||||
fake.recordInvocation("Info", []interface{}{arg1, arg2})
|
||||
fake.infoMutex.Unlock()
|
||||
if fake.InfoStub != nil {
|
||||
return fake.InfoStub(arg1, arg2...)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.infoReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) InfoCallCount() int {
|
||||
fake.infoMutex.RLock()
|
||||
defer fake.infoMutex.RUnlock()
|
||||
return len(fake.infoArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) InfoCalls(stub func(context.Context, ...containerd.InfoOpts) (containers.Container, error)) {
|
||||
fake.infoMutex.Lock()
|
||||
defer fake.infoMutex.Unlock()
|
||||
fake.InfoStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) InfoArgsForCall(i int) (context.Context, []containerd.InfoOpts) {
|
||||
fake.infoMutex.RLock()
|
||||
defer fake.infoMutex.RUnlock()
|
||||
argsForCall := fake.infoArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) InfoReturns(result1 containers.Container, result2 error) {
|
||||
fake.infoMutex.Lock()
|
||||
defer fake.infoMutex.Unlock()
|
||||
fake.InfoStub = nil
|
||||
fake.infoReturns = struct {
|
||||
result1 containers.Container
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) InfoReturnsOnCall(i int, result1 containers.Container, result2 error) {
|
||||
fake.infoMutex.Lock()
|
||||
defer fake.infoMutex.Unlock()
|
||||
fake.InfoStub = nil
|
||||
if fake.infoReturnsOnCall == nil {
|
||||
fake.infoReturnsOnCall = make(map[int]struct {
|
||||
result1 containers.Container
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.infoReturnsOnCall[i] = struct {
|
||||
result1 containers.Container
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Labels(arg1 context.Context) (map[string]string, error) {
|
||||
fake.labelsMutex.Lock()
|
||||
ret, specificReturn := fake.labelsReturnsOnCall[len(fake.labelsArgsForCall)]
|
||||
fake.labelsArgsForCall = append(fake.labelsArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
}{arg1})
|
||||
fake.recordInvocation("Labels", []interface{}{arg1})
|
||||
fake.labelsMutex.Unlock()
|
||||
if fake.LabelsStub != nil {
|
||||
return fake.LabelsStub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.labelsReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) LabelsCallCount() int {
|
||||
fake.labelsMutex.RLock()
|
||||
defer fake.labelsMutex.RUnlock()
|
||||
return len(fake.labelsArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) LabelsCalls(stub func(context.Context) (map[string]string, error)) {
|
||||
fake.labelsMutex.Lock()
|
||||
defer fake.labelsMutex.Unlock()
|
||||
fake.LabelsStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) LabelsArgsForCall(i int) context.Context {
|
||||
fake.labelsMutex.RLock()
|
||||
defer fake.labelsMutex.RUnlock()
|
||||
argsForCall := fake.labelsArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) LabelsReturns(result1 map[string]string, result2 error) {
|
||||
fake.labelsMutex.Lock()
|
||||
defer fake.labelsMutex.Unlock()
|
||||
fake.LabelsStub = nil
|
||||
fake.labelsReturns = struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) LabelsReturnsOnCall(i int, result1 map[string]string, result2 error) {
|
||||
fake.labelsMutex.Lock()
|
||||
defer fake.labelsMutex.Unlock()
|
||||
fake.LabelsStub = nil
|
||||
if fake.labelsReturnsOnCall == nil {
|
||||
fake.labelsReturnsOnCall = make(map[int]struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.labelsReturnsOnCall[i] = struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) NewTask(arg1 context.Context, arg2 cio.Creator, arg3 ...containerd.NewTaskOpts) (containerd.Task, error) {
|
||||
fake.newTaskMutex.Lock()
|
||||
ret, specificReturn := fake.newTaskReturnsOnCall[len(fake.newTaskArgsForCall)]
|
||||
fake.newTaskArgsForCall = append(fake.newTaskArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 cio.Creator
|
||||
arg3 []containerd.NewTaskOpts
|
||||
}{arg1, arg2, arg3})
|
||||
fake.recordInvocation("NewTask", []interface{}{arg1, arg2, arg3})
|
||||
fake.newTaskMutex.Unlock()
|
||||
if fake.NewTaskStub != nil {
|
||||
return fake.NewTaskStub(arg1, arg2, arg3...)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.newTaskReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) NewTaskCallCount() int {
|
||||
fake.newTaskMutex.RLock()
|
||||
defer fake.newTaskMutex.RUnlock()
|
||||
return len(fake.newTaskArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) NewTaskCalls(stub func(context.Context, cio.Creator, ...containerd.NewTaskOpts) (containerd.Task, error)) {
|
||||
fake.newTaskMutex.Lock()
|
||||
defer fake.newTaskMutex.Unlock()
|
||||
fake.NewTaskStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) NewTaskArgsForCall(i int) (context.Context, cio.Creator, []containerd.NewTaskOpts) {
|
||||
fake.newTaskMutex.RLock()
|
||||
defer fake.newTaskMutex.RUnlock()
|
||||
argsForCall := fake.newTaskArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) NewTaskReturns(result1 containerd.Task, result2 error) {
|
||||
fake.newTaskMutex.Lock()
|
||||
defer fake.newTaskMutex.Unlock()
|
||||
fake.NewTaskStub = nil
|
||||
fake.newTaskReturns = struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) NewTaskReturnsOnCall(i int, result1 containerd.Task, result2 error) {
|
||||
fake.newTaskMutex.Lock()
|
||||
defer fake.newTaskMutex.Unlock()
|
||||
fake.NewTaskStub = nil
|
||||
if fake.newTaskReturnsOnCall == nil {
|
||||
fake.newTaskReturnsOnCall = make(map[int]struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.newTaskReturnsOnCall[i] = struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SetLabels(arg1 context.Context, arg2 map[string]string) (map[string]string, error) {
|
||||
fake.setLabelsMutex.Lock()
|
||||
ret, specificReturn := fake.setLabelsReturnsOnCall[len(fake.setLabelsArgsForCall)]
|
||||
fake.setLabelsArgsForCall = append(fake.setLabelsArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 map[string]string
|
||||
}{arg1, arg2})
|
||||
fake.recordInvocation("SetLabels", []interface{}{arg1, arg2})
|
||||
fake.setLabelsMutex.Unlock()
|
||||
if fake.SetLabelsStub != nil {
|
||||
return fake.SetLabelsStub(arg1, arg2)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.setLabelsReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SetLabelsCallCount() int {
|
||||
fake.setLabelsMutex.RLock()
|
||||
defer fake.setLabelsMutex.RUnlock()
|
||||
return len(fake.setLabelsArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SetLabelsCalls(stub func(context.Context, map[string]string) (map[string]string, error)) {
|
||||
fake.setLabelsMutex.Lock()
|
||||
defer fake.setLabelsMutex.Unlock()
|
||||
fake.SetLabelsStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SetLabelsArgsForCall(i int) (context.Context, map[string]string) {
|
||||
fake.setLabelsMutex.RLock()
|
||||
defer fake.setLabelsMutex.RUnlock()
|
||||
argsForCall := fake.setLabelsArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SetLabelsReturns(result1 map[string]string, result2 error) {
|
||||
fake.setLabelsMutex.Lock()
|
||||
defer fake.setLabelsMutex.Unlock()
|
||||
fake.SetLabelsStub = nil
|
||||
fake.setLabelsReturns = struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SetLabelsReturnsOnCall(i int, result1 map[string]string, result2 error) {
|
||||
fake.setLabelsMutex.Lock()
|
||||
defer fake.setLabelsMutex.Unlock()
|
||||
fake.SetLabelsStub = nil
|
||||
if fake.setLabelsReturnsOnCall == nil {
|
||||
fake.setLabelsReturnsOnCall = make(map[int]struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.setLabelsReturnsOnCall[i] = struct {
|
||||
result1 map[string]string
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Spec(arg1 context.Context) (*specs.Spec, error) {
|
||||
fake.specMutex.Lock()
|
||||
ret, specificReturn := fake.specReturnsOnCall[len(fake.specArgsForCall)]
|
||||
fake.specArgsForCall = append(fake.specArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
}{arg1})
|
||||
fake.recordInvocation("Spec", []interface{}{arg1})
|
||||
fake.specMutex.Unlock()
|
||||
if fake.SpecStub != nil {
|
||||
return fake.SpecStub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.specReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SpecCallCount() int {
|
||||
fake.specMutex.RLock()
|
||||
defer fake.specMutex.RUnlock()
|
||||
return len(fake.specArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SpecCalls(stub func(context.Context) (*specs.Spec, error)) {
|
||||
fake.specMutex.Lock()
|
||||
defer fake.specMutex.Unlock()
|
||||
fake.SpecStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SpecArgsForCall(i int) context.Context {
|
||||
fake.specMutex.RLock()
|
||||
defer fake.specMutex.RUnlock()
|
||||
argsForCall := fake.specArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SpecReturns(result1 *specs.Spec, result2 error) {
|
||||
fake.specMutex.Lock()
|
||||
defer fake.specMutex.Unlock()
|
||||
fake.SpecStub = nil
|
||||
fake.specReturns = struct {
|
||||
result1 *specs.Spec
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) SpecReturnsOnCall(i int, result1 *specs.Spec, result2 error) {
|
||||
fake.specMutex.Lock()
|
||||
defer fake.specMutex.Unlock()
|
||||
fake.SpecStub = nil
|
||||
if fake.specReturnsOnCall == nil {
|
||||
fake.specReturnsOnCall = make(map[int]struct {
|
||||
result1 *specs.Spec
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.specReturnsOnCall[i] = struct {
|
||||
result1 *specs.Spec
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Task(arg1 context.Context, arg2 cio.Attach) (containerd.Task, error) {
|
||||
fake.taskMutex.Lock()
|
||||
ret, specificReturn := fake.taskReturnsOnCall[len(fake.taskArgsForCall)]
|
||||
fake.taskArgsForCall = append(fake.taskArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 cio.Attach
|
||||
}{arg1, arg2})
|
||||
fake.recordInvocation("Task", []interface{}{arg1, arg2})
|
||||
fake.taskMutex.Unlock()
|
||||
if fake.TaskStub != nil {
|
||||
return fake.TaskStub(arg1, arg2)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.taskReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) TaskCallCount() int {
|
||||
fake.taskMutex.RLock()
|
||||
defer fake.taskMutex.RUnlock()
|
||||
return len(fake.taskArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) TaskCalls(stub func(context.Context, cio.Attach) (containerd.Task, error)) {
|
||||
fake.taskMutex.Lock()
|
||||
defer fake.taskMutex.Unlock()
|
||||
fake.TaskStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) TaskArgsForCall(i int) (context.Context, cio.Attach) {
|
||||
fake.taskMutex.RLock()
|
||||
defer fake.taskMutex.RUnlock()
|
||||
argsForCall := fake.taskArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) TaskReturns(result1 containerd.Task, result2 error) {
|
||||
fake.taskMutex.Lock()
|
||||
defer fake.taskMutex.Unlock()
|
||||
fake.TaskStub = nil
|
||||
fake.taskReturns = struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) TaskReturnsOnCall(i int, result1 containerd.Task, result2 error) {
|
||||
fake.taskMutex.Lock()
|
||||
defer fake.taskMutex.Unlock()
|
||||
fake.TaskStub = nil
|
||||
if fake.taskReturnsOnCall == nil {
|
||||
fake.taskReturnsOnCall = make(map[int]struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.taskReturnsOnCall[i] = struct {
|
||||
result1 containerd.Task
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Update(arg1 context.Context, arg2 ...containerd.UpdateContainerOpts) error {
|
||||
fake.updateMutex.Lock()
|
||||
ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)]
|
||||
fake.updateArgsForCall = append(fake.updateArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 []containerd.UpdateContainerOpts
|
||||
}{arg1, arg2})
|
||||
fake.recordInvocation("Update", []interface{}{arg1, arg2})
|
||||
fake.updateMutex.Unlock()
|
||||
if fake.UpdateStub != nil {
|
||||
return fake.UpdateStub(arg1, arg2...)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
fakeReturns := fake.updateReturns
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) UpdateCallCount() int {
|
||||
fake.updateMutex.RLock()
|
||||
defer fake.updateMutex.RUnlock()
|
||||
return len(fake.updateArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) UpdateCalls(stub func(context.Context, ...containerd.UpdateContainerOpts) error) {
|
||||
fake.updateMutex.Lock()
|
||||
defer fake.updateMutex.Unlock()
|
||||
fake.UpdateStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) UpdateArgsForCall(i int) (context.Context, []containerd.UpdateContainerOpts) {
|
||||
fake.updateMutex.RLock()
|
||||
defer fake.updateMutex.RUnlock()
|
||||
argsForCall := fake.updateArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) UpdateReturns(result1 error) {
|
||||
fake.updateMutex.Lock()
|
||||
defer fake.updateMutex.Unlock()
|
||||
fake.UpdateStub = nil
|
||||
fake.updateReturns = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) UpdateReturnsOnCall(i int, result1 error) {
|
||||
fake.updateMutex.Lock()
|
||||
defer fake.updateMutex.Unlock()
|
||||
fake.UpdateStub = nil
|
||||
if fake.updateReturnsOnCall == nil {
|
||||
fake.updateReturnsOnCall = make(map[int]struct {
|
||||
result1 error
|
||||
})
|
||||
}
|
||||
fake.updateReturnsOnCall[i] = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) Invocations() map[string][][]interface{} {
|
||||
fake.invocationsMutex.RLock()
|
||||
defer fake.invocationsMutex.RUnlock()
|
||||
fake.checkpointMutex.RLock()
|
||||
defer fake.checkpointMutex.RUnlock()
|
||||
fake.deleteMutex.RLock()
|
||||
defer fake.deleteMutex.RUnlock()
|
||||
fake.extensionsMutex.RLock()
|
||||
defer fake.extensionsMutex.RUnlock()
|
||||
fake.iDMutex.RLock()
|
||||
defer fake.iDMutex.RUnlock()
|
||||
fake.imageMutex.RLock()
|
||||
defer fake.imageMutex.RUnlock()
|
||||
fake.infoMutex.RLock()
|
||||
defer fake.infoMutex.RUnlock()
|
||||
fake.labelsMutex.RLock()
|
||||
defer fake.labelsMutex.RUnlock()
|
||||
fake.newTaskMutex.RLock()
|
||||
defer fake.newTaskMutex.RUnlock()
|
||||
fake.setLabelsMutex.RLock()
|
||||
defer fake.setLabelsMutex.RUnlock()
|
||||
fake.specMutex.RLock()
|
||||
defer fake.specMutex.RUnlock()
|
||||
fake.taskMutex.RLock()
|
||||
defer fake.taskMutex.RUnlock()
|
||||
fake.updateMutex.RLock()
|
||||
defer fake.updateMutex.RUnlock()
|
||||
copiedInvocations := map[string][][]interface{}{}
|
||||
for key, value := range fake.invocations {
|
||||
copiedInvocations[key] = value
|
||||
}
|
||||
return copiedInvocations
|
||||
}
|
||||
|
||||
func (fake *FakeContainer) recordInvocation(key string, args []interface{}) {
|
||||
fake.invocationsMutex.Lock()
|
||||
defer fake.invocationsMutex.Unlock()
|
||||
if fake.invocations == nil {
|
||||
fake.invocations = map[string][][]interface{}{}
|
||||
}
|
||||
if fake.invocations[key] == nil {
|
||||
fake.invocations[key] = [][]interface{}{}
|
||||
}
|
||||
fake.invocations[key] = append(fake.invocations[key], args)
|
||||
}
|
||||
|
||||
var _ containerd.Container = new(FakeContainer)
|
||||
|
|
@ -18,9 +18,12 @@ import (
|
|||
)
|
||||
|
||||
func containerdGardenServerRunner(logger lager.Logger, bindAddr, containerdAddr string) ifrit.Runner {
|
||||
const graceTime = 0
|
||||
const (
|
||||
graceTime = 0
|
||||
namespace = "concourse"
|
||||
)
|
||||
|
||||
backend := backend.New(libcontainerd.New(containerdAddr))
|
||||
backend := backend.New(libcontainerd.New(containerdAddr), namespace)
|
||||
|
||||
server := server.New("tcp", bindAddr,
|
||||
graceTime,
|
||||
|
|
|
|||
Loading…
Reference in New Issue