Method StreamRaftMessageResponse.Unmarshal has 9 return statements (exceeds 4 allowed).

Open

func (m *StreamRaftMessageResponse) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx

Method LeaveResponse.Unmarshal has 9 return statements (exceeds 4 allowed).

Open

func (m *LeaveResponse) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx

Method raftProxyRaftServer.ProcessRaftMessage has 9 return statements (exceeds 4 allowed).

Open

func (p *raftProxyRaftServer) ProcessRaftMessage(ctx context.Context, r *ProcessRaftMessageRequest) (*ProcessRaftMessageResponse, error) {

    conn, err := p.connSelector.LeaderConn(ctx)
    if err != nil {
        if err == raftselector.ErrIsLeader {

Method Server.ListVolumes has 9 return statements (exceeds 4 allowed).

Open

func (s *Server) ListVolumes(ctx context.Context, request *api.ListVolumesRequest) (*api.ListVolumesResponse, error) {
    var (
        volumes []*api.Volume
        err     error
    )

Method Server.CreateVolume has 9 return statements (exceeds 4 allowed).

Open

func (s *Server) CreateVolume(ctx context.Context, request *api.CreateVolumeRequest) (*api.CreateVolumeResponse, error) {
    if request.Spec == nil {
        return nil, status.Errorf(codes.InvalidArgument, "spec must not be nil")
    }

Function validateTaskSpec has 9 return statements (exceeds 4 allowed).

Open

func validateTaskSpec(taskSpec api.TaskSpec) error {
    if err := validateResourceRequirements(taskSpec.Resources); err != nil {
        return err
    }

Method PluginFilter.Check has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (f *PluginFilter) Check(n *NodeInfo) bool {
    if n.Description == nil || n.Description.Engine == nil {
        // If the node is not running Engine, plugins are not
        // supported.
        return true

• Read up
  Read up

Function WatchFrom has 9 return statements (exceeds 4 allowed).

Open

func WatchFrom(store *MemoryStore, version *api.Version, specifiers ...api.Event) (chan events.Event, func(), error) {
    if version == nil {
        ch, cancel := state.Watch(store.WatchQueue(), specifiers...)
        return ch, cancel, nil
    }

Method Allocator.doNetworkInit has 9 return statements (exceeds 4 allowed).

Open

func (a *Allocator) doNetworkInit(ctx context.Context) (err error) {
    nc := &networkContext{
        nwkAllocator:        a.nwkAllocator,
        portAllocator:       newPortAllocator(),
        pendingTasks:        make(map[string]*api.Task),

Method Allocator.doTaskAlloc has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (a *Allocator) doTaskAlloc(ctx context.Context, ev events.Event) {
    var (
        isDelete bool
        t        *api.Task
    )

• Read up
  Read up

Method Collector.Run has 9 return statements (exceeds 4 allowed).

Open

func (c *Collector) Run(ctx context.Context) error {
    defer close(c.doneChan)

    watcher, cancel, err := store.ViewAndWatch(c.store, func(readTx store.ReadTx) error {
        nodes, err := store.FindNodes(readTx, store.All)

Method subscription.match has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (s *subscription) match() {
    s.mu.Lock()
    defer s.mu.Unlock()

    add := func(t *api.Task) {

• Read up
  Read up

Function updateNode has 8 return statements (exceeds 4 allowed).

Open

func updateNode(cmd *cobra.Command, args []string) error {
    if len(args) == 0 {
        return errors.New("node ID missing")
    }

Method controller.Prepare has 8 return statements (exceeds 4 allowed).

Open

func (r *controller) Prepare(ctx context.Context) error {
    if err := r.checkClosed(); err != nil {
        return err
    }

Function reconcileTaskState has 8 return statements (exceeds 4 allowed).

Open

func reconcileTaskState(ctx context.Context, w *worker, assignments []*api.AssignmentChange, fullSnapshot bool) error {
    var (
        updatedTasks []*api.Task
        removedTasks []*api.Task
    )

Method worker.Subscribe has 8 return statements (exceeds 4 allowed).

Open

func (w *worker) Subscribe(ctx context.Context, subscription *api.SubscriptionMessage) error {
    log.G(ctx).Debugf("Received subscription %s (selector: %v)", subscription.ID, subscription.Selector)

    publisher, cancel, err := w.publisherProvider.Publisher(ctx, subscription.ID)
    if err != nil {

Method Resolver.get has 8 return statements (exceeds 4 allowed).

Open

func (r *Resolver) get(t interface{}, id string) string {
    switch t.(type) {
    case api.Node:
        res, err := r.c.GetNode(r.ctx, &api.GetNodeRequest{NodeID: id})
        if err != nil {

Function processIPAMOptions has 8 return statements (exceeds 4 allowed).

Open

func processIPAMOptions(cmd *cobra.Command) (*api.IPAMOptions, error) {
    flags := cmd.Flags()

    var ipamOpts *api.IPAMOptions
    if flags.Changed("ipam-driver") {

Function ConvertResourceWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertResourceWatch(action WatchActionKind, filters []*SelectBy, kind string) ([]Event, error) {
    var (
        m          Resource
        checkFuncs []ResourceCheckFunc
    )

Function ConvertExtensionWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertExtensionWatch(action WatchActionKind, filters []*SelectBy) ([]Event, error) {
    var (
        m          Extension
        checkFuncs []ExtensionCheckFunc
    )