File client.go has 628 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package remote // import "github.com/docker/docker/libcontainerd/remote"

import (
    "context"
    "encoding/json"

Method container.createIO has a Cognitive Complexity of 36 (exceeds 20 allowed). Consider refactoring.

Open

func (c *container) createIO(fifos *cio.FIFOSet, stdinCloseSync chan containerd.Process, attachStdio libcontainerdtypes.StdioCallback) (cio.IO, error) {
    var (
        io  *cio.DirectIO
        err error
    )

• Read up
  Read up

Method client.processEventStream has 89 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *client) processEventStream(ctx context.Context, ns string) {
    // Create a new context specifically for this subscription.
    // The context must be cancelled to cancel the subscription.
    // In cases where we have to restart event stream processing,
    //   we'll need the original context b/c this one will be cancelled

Method container.NewTask has 77 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *container) NewTask(ctx context.Context, checkpointDir string, withStdin bool, attachStdio libcontainerdtypes.StdioCallback) (libcontainerdtypes.Task, error) {
    var (
        checkpoint     *types.Descriptor
        t              containerd.Task
        rio            cio.IO

Method client.processEventStream has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.

Open

func (c *client) processEventStream(ctx context.Context, ns string) {
    // Create a new context specifically for this subscription.
    // The context must be cancelled to cancel the subscription.
    // In cases where we have to restart event stream processing,
    //   we'll need the original context b/c this one will be cancelled

• Read up
  Read up

Method container.createIO has 52 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *container) createIO(fifos *cio.FIFOSet, stdinCloseSync chan containerd.Process, attachStdio libcontainerdtypes.StdioCallback) (cio.IO, error) {
    var (
        io  *cio.DirectIO
        err error
    )

Method container.NewTask has 9 return statements (exceeds 4 allowed).

Open

func (c *container) NewTask(ctx context.Context, checkpointDir string, withStdin bool, attachStdio libcontainerdtypes.StdioCallback) (libcontainerdtypes.Task, error) {
    var (
        checkpoint     *types.Descriptor
        t              containerd.Task
        rio            cio.IO

Method task.CreateCheckpoint has 7 return statements (exceeds 4 allowed).

Open

func (t *task) CreateCheckpoint(ctx context.Context, checkpointDir string, exit bool) error {
    img, err := t.Task.Checkpoint(ctx, t.ctr.getCheckpointOptions(exit))
    if err != nil {
        return wrapError(err)
    }

Method client.NewContainer has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (c *client) NewContainer(ctx context.Context, id string, ociSpec *specs.Spec, shim string, runtimeOptions interface{}, opts ...containerd.NewContainerOpts) (libcontainerdtypes.Container, error) {

Avoid deeply nested control flow statements.

Open

                    if c.waitServe(ctx) {
                        go c.processEventStream(ctx, ns)
                        return
                    }

Method task.Exec has 6 return statements (exceeds 4 allowed).

Open

func (t *task) Exec(ctx context.Context, processID string, spec *specs.Process, withStdin bool, attachStdio libcontainerdtypes.StdioCallback) (libcontainerdtypes.Process, error) {
    var (
        p              containerd.Process
        rio            cio.IO
        stdinCloseSync = make(chan containerd.Process, 1)

Method task.Exec has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (t *task) Exec(ctx context.Context, processID string, spec *specs.Process, withStdin bool, attachStdio libcontainerdtypes.StdioCallback) (libcontainerdtypes.Process, error) {

Method container.createIO has 5 return statements (exceeds 4 allowed).

Open

func (c *container) createIO(fifos *cio.FIFOSet, stdinCloseSync chan containerd.Process, attachStdio libcontainerdtypes.StdioCallback) (cio.IO, error) {
    var (
        io  *cio.DirectIO
        err error
    )

Method container.NewTask has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (c *container) NewTask(ctx context.Context, checkpointDir string, withStdin bool, attachStdio libcontainerdtypes.StdioCallback) (libcontainerdtypes.Task, error) {
    var (
        checkpoint     *types.Descriptor
        t              containerd.Task
        rio            cio.IO

• Read up
  Read up