Method nodePlugin.NodePublishVolume has 5 return statements (exceeds 4 allowed).

Open

func (np *nodePlugin) NodePublishVolume(ctx context.Context, req *api.VolumeAssignment) error {
    err := capability.CheckArguments(req)
    if err != nil {
        return err
    }

Method Node.MarshalToSizedBuffer has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    _ = i
    var l int
    _ = l

• Read up
  Read up

Method Network.MarshalToSizedBuffer has 5 return statements (exceeds 4 allowed).

Open

func (m *Network) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    _ = i
    var l int
    _ = l

Method Volume.MarshalToSizedBuffer has 5 return statements (exceeds 4 allowed).

Open

func (m *Volume) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    _ = i
    var l int
    _ = l

Method NetworkSpec.MarshalToSizedBuffer has 5 return statements (exceeds 4 allowed).

Open

func (m *NetworkSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    _ = i
    var l int
    _ = l

Method TLSRenewer.Start has 5 return statements (exceeds 4 allowed).

Open

func (t *TLSRenewer) Start(ctx context.Context) <-chan CertificateUpdate {
    updates := make(chan CertificateUpdate)

    go func() {
        var (

Method VolumeEnforcer.rejectNoncompliantTasks has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (ve *VolumeEnforcer) rejectNoncompliantTasks(v *api.Volume) {
    if v.Spec.Availability != api.VolumeAvailabilityDrain {
        return
    }

• Read up
  Read up

Function ConvertToECPrivateKeyPEM has 5 return statements (exceeds 4 allowed).

Open

func ConvertToECPrivateKeyPEM(inPEM []byte) ([]byte, error) {
    block, _ := pem.Decode(inPEM)
    if block == nil {
        return nil, errors.New("invalid pem bytes")
    }

Function GetAndValidateCertificateSubject has 5 return statements (exceeds 4 allowed).

Open

func GetAndValidateCertificateSubject(certs []tls.Certificate) (pkix.Name, error) {
    for i := range certs {
        cert := &certs[i]
        x509Cert, err := x509.ParseCertificate(cert.Certificate[0])
        if err != nil {

Method Updater.useExistingTask has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (u *Updater) useExistingTask(ctx context.Context, slot orchestrator.Slot, existing *api.Task) error {
    var removeTasks []*api.Task
    for _, t := range slot {
        if t != existing {
            removeTasks = append(removeTasks, t)

• Read up
  Read up

Method Orchestrator.Run has 5 return statements (exceeds 4 allowed).

Open

func (r *Orchestrator) Run(ctx context.Context) error {
    defer close(r.doneChan)

    // Watch changes to services and tasks
    queue := r.store.WatchQueue()

Method SecurityConfig.updateTLSCredentials has 5 return statements (exceeds 4 allowed).

Open

func (s *SecurityConfig) updateTLSCredentials(certificate *tls.Certificate, issuerInfo *IssuerInfo) error {
    certs := []tls.Certificate{*certificate}
    clientConfig, err := NewClientTLSConfig(certs, s.rootCA.Pool, ManagerRole)
    if err != nil {
        return errors.Wrap(err, "failed to create a new client config using the new root CA")

Method Supervisor.waitRestart has 5 return statements (exceeds 4 allowed).

Open

func (r *Supervisor) waitRestart(ctx context.Context, oldDelay *delayedStart, cluster *api.Cluster, taskID string) {
    // Wait for the last restart delay to elapse.
    select {
    case <-oldDelay.doneCh:
    case <-ctx.Done():

Function SetServiceTasksRemove has 5 return statements (exceeds 4 allowed).

Open

func SetServiceTasksRemove(ctx context.Context, s *store.MemoryStore, service *api.Service) {
    var (
        tasks []*api.Task
        err   error
    )

Method Supervisor.UpdatableTasksInSlot has 5 return statements (exceeds 4 allowed).

Open

func (r *Supervisor) UpdatableTasksInSlot(ctx context.Context, slot orchestrator.Slot, service *api.Service) orchestrator.Slot {
    if len(slot) < 1 {
        return nil
    }

Method Server.UpdateRootCA has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (s *Server) UpdateRootCA(ctx context.Context, cluster *api.Cluster, reconciler *rootRotationReconciler) error {
    s.mu.Lock()
    s.joinTokens = cluster.RootCA.JoinTokens.Copy()
    s.mu.Unlock()
    rCA := cluster.RootCA.Copy()

• Read up
  Read up

Function ConvertECPrivateKeyPEM has 5 return statements (exceeds 4 allowed).

Open

func ConvertECPrivateKeyPEM(inPEM []byte) ([]byte, error) {
    block, _ := pem.Decode(inPEM)
    if block == nil {
        return nil, errors.New("invalid pem bytes")
    }

Method tasksByCreationTimestamp.Less has 5 return statements (exceeds 4 allowed).

Open

func (t tasksByCreationTimestamp) Less(i, j int) bool {
    if t[i].Meta.CreatedAt == nil {
        return true
    }
    if t[j].Meta.CreatedAt == nil {

Function DownloadRootCA has 5 return statements (exceeds 4 allowed).

Open

func DownloadRootCA(ctx context.Context, paths CertPaths, token string, connBroker *connectionbroker.Broker) (RootCA, error) {
    var rootCA RootCA
    // Get a digest for the optional CA hash string that we've been provided
    // If we were provided a non-empty string, and it is an invalid hash, return
    // otherwise, allow the invalid digest through.

Function updateRootThenUpdateCert has 5 return statements (exceeds 4 allowed).

Open

func updateRootThenUpdateCert(ctx context.Context, s *SecurityConfig, connBroker *connectionbroker.Broker, rootPaths CertPaths, failedCert *x509.Certificate) (*tls.Certificate, *IssuerInfo, error) {
    if len(failedCert.Subject.OrganizationalUnit) == 0 || failedCert.Subject.OrganizationalUnit[0] != WorkerRole {
        return nil, nil, errors.New("cannot update root CA since this is not a worker")
    }
    // try downloading a new root CA if it's an unknown authority issue, in case there was a root rotation completion