Method PublishLogsMessage.Unmarshal has 25 return statements (exceeds 4 allowed).

Open

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

Method NodeSpec.Unmarshal has 25 return statements (exceeds 4 allowed).

Open

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

Method WatchRequest_WatchEntry.Unmarshal has 25 return statements (exceeds 4 allowed).

Open

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

Method Updater.updateTask has a Cognitive Complexity of 32 (exceeds 20 allowed). Consider refactoring.

Open

func (u *Updater) updateTask(ctx context.Context, slot orchestrator.Slot, updated *api.Task, order api.UpdateConfig_UpdateOrder) error {
    // Kick off the watch before even creating the updated task. This is in order to avoid missing any event.
    taskUpdates, cancel := state.Watch(u.watchQueue, api.EventUpdateTask{
        Task:   &api.Task{ID: updated.ID},
        Checks: []api.TaskCheckFunc{api.TaskCheckID},

• Read up
  Read up

Method Allocator.allocateTasks has a Cognitive Complexity of 32 (exceeds 20 allowed). Consider refactoring.

Open

func (a *Allocator) allocateTasks(ctx context.Context, existingAddressesOnly bool) error {
    var (
        nc             = a.netCtx
        tasks          []*api.Task
        allocatedTasks []*api.Task

• Read up
  Read up

Method GetRootCACertificateResponse.Unmarshal has 81 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method SubscribeLogsMessage.Unmarshal has 81 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method TasksMessage.Unmarshal has 81 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method Node.loadAndStart has 81 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (n *Node) loadAndStart(ctx context.Context, forceNewCluster bool) error {
    snapshot, waldata, err := n.readFromDisk(ctx)
    if err != nil {
        return err
    }

Method HeartbeatResponse.Unmarshal has 80 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Function validateCAConfig has 80 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func validateCAConfig(ctx context.Context, securityConfig *ca.SecurityConfig, cluster *api.Cluster) (*api.RootCA, error) {
    newConfig := cluster.Spec.CAConfig.Copy()
    newConfig.SigningCACert = ca.NormalizePEMs(newConfig.SigningCACert) // ensure this is normalized before we use it

    if len(newConfig.SigningCAKey) > 0 && len(newConfig.SigningCACert) == 0 {

TaskSpec has 21 methods (exceeds 20 allowed). Consider refactoring.

Open

type TaskSpec struct {
    // Types that are valid to be assigned to Runtime:
    //    *TaskSpec_Attachment
    //    *TaskSpec_Container
    //    *TaskSpec_Generic

Method NodeCertificateStatusRequest.Unmarshal has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method HealthCheckRequest.Unmarshal has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method AttachNetworkResponse.Unmarshal has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method DetachNetworkRequest.Unmarshal has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method HeartbeatRequest.Unmarshal has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method AssignmentsRequest.Unmarshal has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method TasksRequest.Unmarshal has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method NetworkAttachmentSpec.Unmarshal has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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