Sign upLogin

docker/swarmkit

View on GitHub
Star

Showing 1,008 of 1,820 total issues

Method StoreSnapshot.Unmarshal has 79 return statements (exceeds 4 allowed).
Open

func (m *StoreSnapshot) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
Severity: Major
Found in api/snapshot.pb.go - About 6 hrs to fix

    Method SubscribeLogsMessage.Unmarshal has a Cognitive Complexity of 59 (exceeds 20 allowed). Consider refactoring.
    Open

    func (m *SubscribeLogsMessage) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
    Severity: Minor
    Found in api/logbroker.pb.go - About 6 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Method HeartbeatResponse.Unmarshal has a Cognitive Complexity of 59 (exceeds 20 allowed). Consider refactoring.
    Open

    func (m *HeartbeatResponse) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
    Severity: Minor
    Found in api/dispatcher.pb.go - About 6 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Method TasksMessage.Unmarshal has a Cognitive Complexity of 59 (exceeds 20 allowed). Consider refactoring.
    Open

    func (m *TasksMessage) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
    Severity: Minor
    Found in api/dispatcher.pb.go - About 6 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Method ServiceSpec.Unmarshal has 79 return statements (exceeds 4 allowed).
    Open

    func (m *ServiceSpec) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
    Severity: Major
    Found in api/specs.pb.go - About 6 hrs to fix

      Method Object.Unmarshal has 79 return statements (exceeds 4 allowed).
      Open

      func (m *Object) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
      Severity: Major
      Found in api/watch.pb.go - About 6 hrs to fix

        Function dumpObject has 191 lines of code (exceeds 50 allowed). Consider refactoring.
        Open

        func dumpObject(swarmdir, unlockKey, objType string, selector objSelector) error {
    memStore := store.NewMemoryStore(nil)
    defer memStore.Close()

    walData, snapshot, err := loadData(swarmdir, unlockKey)
        Severity: Major
        Found in swarmd/cmd/swarm-rafttool/dump.go - About 6 hrs to fix

          Method LogSubscriptionOptions.Unmarshal has 191 lines of code (exceeds 50 allowed). Consider refactoring.
          Open

          func (m *LogSubscriptionOptions) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
          Severity: Major
          Found in api/logbroker.pb.go - About 6 hrs to fix

            File health.pb.go has 693 lines of code (exceeds 500 allowed). Consider refactoring.
            Open

            // Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/docker/swarmkit/api/health.proto

package api
            Severity: Minor
            Found in api/health.pb.go - About 6 hrs to fix

              Function reconcileTaskState has a Cognitive Complexity of 58 (exceeds 20 allowed). Consider refactoring.
              Open

              func reconcileTaskState(ctx context.Context, w *worker, assignments []*api.AssignmentChange, fullSnapshot bool) error {
    var (
        updatedTasks []*api.Task
        removedTasks []*api.Task
    )
              Severity: Minor
              Found in agent/worker.go - About 6 hrs to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Method Node.Unmarshal has 77 return statements (exceeds 4 allowed).
              Open

              func (m *Node) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
              Severity: Major
              Found in api/objects.pb.go - About 6 hrs to fix

                Method ConstraintEnforcer.rejectNoncompliantTasks has a Cognitive Complexity of 58 (exceeds 20 allowed). Consider refactoring.
                Open

                func (ce *ConstraintEnforcer) rejectNoncompliantTasks(node *api.Node) {
    // If the availability is "drain", the orchestrator will
    // shut down all tasks.
    // If the availability is "pause", we shouldn't touch
    // the tasks on this node.
                Severity: Minor
                Found in manager/orchestrator/constraintenforcer/constraint_enforcer.go - About 6 hrs to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Method Assignment.Unmarshal has 187 lines of code (exceeds 50 allowed). Consider refactoring.
                Open

                func (m *Assignment) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
                Severity: Major
                Found in api/dispatcher.pb.go - About 6 hrs to fix

                  Method SecretSpec.Unmarshal has 186 lines of code (exceeds 50 allowed). Consider refactoring.
                  Open

                  func (m *SecretSpec) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
                  Severity: Major
                  Found in api/specs.pb.go - About 6 hrs to fix

                    Method TaskSpec.Unmarshal has 75 return statements (exceeds 4 allowed).
                    Open

                    func (m *TaskSpec) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
                    Severity: Major
                    Found in api/specs.pb.go - About 6 hrs to fix

                      Method ContainerSpec.Size has a Cognitive Complexity of 57 (exceeds 20 allowed). Consider refactoring.
                      Open

                      func (m *ContainerSpec) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
                      Severity: Minor
                      Found in api/specs.pb.go - About 6 hrs to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Method readTx.findIterators has a Cognitive Complexity of 57 (exceeds 20 allowed). Consider refactoring.
                      Open

                      func (tx readTx) findIterators(table string, by By, checkType func(By) error) ([]memdb.ResultIterator, error) {
    switch by.(type) {
    case byAll, orCombinator: // generic types
    default: // all other types
        if err := checkType(by); err != nil {
                      Severity: Minor
                      Found in manager/state/store/memory.go - About 6 hrs to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      File scheduler.go has 684 lines of code (exceeds 500 allowed). Consider refactoring.
                      Open

                      package scheduler

import (
    "context"
    "sync"
                      Severity: Minor
                      Found in manager/scheduler/scheduler.go - About 6 hrs to fix

                        Method Service.Unmarshal has 74 return statements (exceeds 4 allowed).
                        Open

                        func (m *Service) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
                        Severity: Major
                        Found in api/objects.pb.go - About 6 hrs to fix

                          Method HealthCheckRequest.Unmarshal has a Cognitive Complexity of 56 (exceeds 20 allowed). Consider refactoring.
                          Open

                          func (m *HealthCheckRequest) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
                          Severity: Minor
                          Found in api/health.pb.go - About 6 hrs to fix

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Severity
                          Category
                          Status
                          Source
                          Language