From e5be5af7c4813242aae3af0219b0209645691783 Mon Sep 17 00:00:00 2001 From: "Ciro S. Costa" Date: Mon, 18 Nov 2019 14:13:21 +0000 Subject: [PATCH] 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 --- go.mod | 5 +- worker/backend/backend.go | 97 +- worker/backend/backend_test.go | 132 ++- worker/backend/container.go | 4 + worker/backend/libcontainerd/client.go | 76 +- .../libcontainerdfakes/fake_client.go | 230 +++++ .../libcontainerdfakes/fake_container.go | 972 ++++++++++++++++++ worker/workercmd/containerd.go | 7 +- 8 files changed, 1497 insertions(+), 26 deletions(-) create mode 100644 worker/backend/libcontainerd/libcontainerdfakes/fake_container.go diff --git a/go.mod b/go.mod index ad1a7d378..e38c0c935 100644 --- a/go.mod +++ b/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 diff --git a/worker/backend/backend.go b/worker/backend/backend.go index a0f631f8c..14abd0f16 100644 --- a/worker/backend/backend.go +++ b/worker/backend/backend.go @@ -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 +} diff --git a/worker/backend/backend_test.go b/worker/backend/backend_test.go index 4d63a52d0..461d2efbe 100644 --- a/worker/backend/backend_test.go +++ b/worker/backend/backend_test.go @@ -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), diff --git a/worker/backend/container.go b/worker/backend/container.go index 291908d68..6ba0afa40 100644 --- a/worker/backend/container.go +++ b/worker/backend/container.go @@ -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 } diff --git a/worker/backend/libcontainerd/client.go b/worker/backend/libcontainerd/client.go index 426327b7f..f080cf39c 100644 --- a/worker/backend/libcontainerd/client.go +++ b/worker/backend/libcontainerd/client.go @@ -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 diff --git a/worker/backend/libcontainerd/libcontainerdfakes/fake_client.go b/worker/backend/libcontainerd/libcontainerdfakes/fake_client.go index 59361c5c0..c01056914 100644 --- a/worker/backend/libcontainerd/libcontainerdfakes/fake_client.go +++ b/worker/backend/libcontainerd/libcontainerdfakes/fake_client.go @@ -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{}{} diff --git a/worker/backend/libcontainerd/libcontainerdfakes/fake_container.go b/worker/backend/libcontainerd/libcontainerdfakes/fake_container.go new file mode 100644 index 000000000..884106c48 --- /dev/null +++ b/worker/backend/libcontainerd/libcontainerdfakes/fake_container.go @@ -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) diff --git a/worker/workercmd/containerd.go b/worker/workercmd/containerd.go index 1fe454bc2..078c70175 100644 --- a/worker/workercmd/containerd.go +++ b/worker/workercmd/containerd.go @@ -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,