Sign upLogin

distributed-system-analysis/run-perf

View on GitHub
Star
runperf/machine.py

Summary

Maintainability
A
2 hrs
Test Coverage
D
68%

Try, Except, Pass detected.
Wontfix

                    except Exception:   # pylint: disable=W0703
Severity: Info
Found in runperf/machine.py by bandit

Cyclomatic complexity is too high in method cleanup. (12)
Open

    def cleanup(self):
        """Destroy the machine and close host connection"""
        errs = []
        if not self._started:
            if self._host_session:
Severity: Minor
Found in runperf/machine.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method for_each_host. (11)
Open

    @staticmethod
    def for_each_host(hosts, method, args=tuple(), kwargs=None):
        """
        Perform action in parallel on each host, signal RebootRequest if
        necessary.
Severity: Minor
Found in runperf/machine.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function __init__ has 9 arguments (exceeds 4 allowed). Consider refactoring.
Open

    def __init__(self, host, name, distro, base_image, smp, mem,
Severity: Major
Found in runperf/machine.py - About 1 hr to fix

    Function __init__ has 7 arguments (exceeds 4 allowed). Consider refactoring.
    Open

        def __init__(self, parent_log, name, addr, distro, args, hop=None):
    Severity: Major
    Found in runperf/machine.py - About 50 mins to fix

      Function for_each_host_retry has 6 arguments (exceeds 4 allowed). Consider refactoring.
      Open

          def for_each_host_retry(self, attempts, hosts, method, args=tuple(),
      Severity: Minor
      Found in runperf/machine.py - About 45 mins to fix

        Function apply_profile has 5 arguments (exceeds 4 allowed). Consider refactoring.
        Wontfix

            def apply_profile(self, profile, extra, setup_script, rp_paths):
        Severity: Minor
        Found in runperf/machine.py - About 35 mins to fix

          Method "__init__" has 9 parameters, which is greater than the 7 authorized.
          Open

              def __init__(self, host, name, distro, base_image, smp, mem,
                 default_passwords=None, extra_params=None):
          Severity: Major
          Found in runperf/machine.py by sonar-python

          A long parameter list can indicate that a new structure should be created to wrap the numerous parameters or that the function is doing too many things.

          Noncompliant Code Example

          With a maximum number of 4 parameters:

          def do_something(param1, param2, param3, param4, param5):
    ...

          Compliant Solution

          def do_something(param1, param2, param3, param4):
    ...

          Refactor this function to reduce its Cognitive Complexity from 21 to the 15 allowed.
          Open

              def get_session(self, timeout=60, hop=None):
          Severity: Critical
          Found in runperf/machine.py by sonar-python

          Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

          See

          There are no issues that match your filters.

          Category
          Status