Method Server.signNodeCert has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (s *Server) signNodeCert(ctx context.Context, node *api.Node) error {
    s.signingMu.Lock()
    rootCA := s.localRootCA
    externalCA := s.externalCA
    s.signingMu.Unlock()

• Read up
  Read up

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

Open

func (s *Server) NodeCertificateStatus(ctx context.Context, request *api.NodeCertificateStatusRequest) (*api.NodeCertificateStatusResponse, error) {
    if request.NodeID == "" {
        return nil, status.Errorf(codes.InvalidArgument, codes.InvalidArgument.String())
    }

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

Open

func makeExternalSignRequest(ctx context.Context, client *http.Client, url string, csrJSON []byte) (cert []byte, err error) {
    resp, err := ctxhttp.Post(ctx, client, url, "application/json", bytes.NewReader(csrJSON))
    if err != nil {
        return nil, recoverableErr{err: errors.Wrap(err, "unable to perform certificate signing request")}
    }

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

Open

func (p *raftProxyRaftServer) StreamRaftMessage(stream Raft_StreamRaftMessageServer) error {
    ctx := stream.Context()
    conn, err := p.connSelector.LeaderConn(ctx)
    if err != nil {
        if err == raftselector.ErrIsLeader {

Method raftProxyRaftMembershipServer.Leave has 9 return statements (exceeds 4 allowed).

Open

func (p *raftProxyRaftMembershipServer) Leave(ctx context.Context, r *LeaveRequest) (*LeaveResponse, error) {

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

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

Open

func (s *Server) signNodeCert(ctx context.Context, node *api.Node) error {
    s.signingMu.Lock()
    rootCA := s.localRootCA
    externalCA := s.externalCA
    s.signingMu.Unlock()

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

Similar blocks of code found in 9 locations. Consider refactoring.

Open

        case "service":
            if selector.id != "" {
                object := store.GetService(tx, selector.id)
                if object != nil {
                    objects = append(objects, object)

• Read up
  Read up

Similar blocks of code found in 9 locations. Consider refactoring.

Open

        case "config":
            if selector.id != "" {
                object := store.GetConfig(tx, selector.id)
                if object != nil {
                    objects = append(objects, object)

• Read up
  Read up