saltstack/salt

View on GitHub
salt/config/__init__.py

Summary

Maintainability
F
1 mo
Test Coverage

File __init__.py has 2868 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# -*- coding: utf-8 -*-
'''
All salt configuration loading and defaults should be in this module
'''

Severity: Major
Found in salt/config/__init__.py - About 1 wk to fix

    Function apply_cloud_providers_config has a Cognitive Complexity of 105 (exceeds 5 allowed). Consider refactoring.
    Open

    def apply_cloud_providers_config(overrides, defaults=None):
        '''
        Apply the loaded cloud providers configuration.
        '''
        if defaults is None:
    Severity: Minor
    Found in salt/config/__init__.py - About 2 days 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

    Function _validate_opts has a Cognitive Complexity of 58 (exceeds 5 allowed). Consider refactoring.
    Open

    def _validate_opts(opts):
        '''
        Check that all of the types of values passed into the config are
        of the right types
        '''
    Severity: Minor
    Found in salt/config/__init__.py - About 1 day 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

    Function get_cloud_config_value has a Cognitive Complexity of 47 (exceeds 5 allowed). Consider refactoring.
    Open

    def get_cloud_config_value(name, vm_, opts, default=None, search_global=True):
        '''
        Search and return a setting in a known order:
    
            1. In the virtual machine's configuration
    Severity: Minor
    Found in salt/config/__init__.py - About 7 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

    Function apply_cloud_config has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.
    Open

    def apply_cloud_config(overrides, defaults=None):
        '''
        Return a cloud config
        '''
        if defaults is None:
    Severity: Minor
    Found in salt/config/__init__.py - 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

    Cyclomatic complexity is too high in function cloud_config. (45)
    Open

    def cloud_config(path=None, env_var='SALT_CLOUD_CONFIG', defaults=None,
                     master_config_path=None, master_config=None,
                     providers_config_path=None, providers_config=None,
                     profiles_config_path=None, profiles_config=None):
        '''
    Severity: Minor
    Found in salt/config/__init__.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 apply_master_config has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.
    Open

    def apply_master_config(overrides=None, defaults=None):
        '''
        Returns master configurations dict.
        '''
        if defaults is None:
    Severity: Minor
    Found in salt/config/__init__.py - About 5 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

    Function apply_vm_profiles_config has a Cognitive Complexity of 36 (exceeds 5 allowed). Consider refactoring.
    Open

    def apply_vm_profiles_config(providers, overrides, defaults=None):
        if defaults is None:
            defaults = VM_CONFIG_DEFAULTS
    
        config = defaults.copy()
    Severity: Minor
    Found in salt/config/__init__.py - About 5 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

    Function is_provider_configured has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
    Open

    def is_provider_configured(opts, provider, required_keys=(), log_message=True, aliases=()):
        '''
        Check and return the first matching and fully configured cloud provider
        configuration.
        '''
    Severity: Minor
    Found in salt/config/__init__.py - About 5 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

    Function cloud_config has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
    Open

    def cloud_config(path=None, env_var='SALT_CLOUD_CONFIG', defaults=None,
                     master_config_path=None, master_config=None,
                     providers_config_path=None, providers_config=None,
                     profiles_config_path=None, profiles_config=None):
        '''
    Severity: Minor
    Found in salt/config/__init__.py - About 5 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

    Cyclomatic complexity is too high in function apply_cloud_providers_config. (40)
    Open

    def apply_cloud_providers_config(overrides, defaults=None):
        '''
        Apply the loaded cloud providers configuration.
        '''
        if defaults is None:
    Severity: Minor
    Found in salt/config/__init__.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 apply_minion_config has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
    Open

    def apply_minion_config(overrides=None,
                            defaults=None,
                            cache_minion_id=False,
                            minion_id=None):
        '''
    Severity: Minor
    Found in salt/config/__init__.py - About 4 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

    Function include_config has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
    Open

    def include_config(include, orig_path, verbose, exit_on_config_errors=False):
        '''
        Parses extra configuration file(s) specified in an include list in the
        main config file.
        '''
    Severity: Minor
    Found in salt/config/__init__.py - About 4 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

    Function prepend_root_dir has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
    Open

    def prepend_root_dir(opts, path_options):
        '''
        Prepends the options that represent filesystem paths with value of the
        'root_dir' option.
        '''
    Severity: Minor
    Found in salt/config/__init__.py - About 3 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

    Cyclomatic complexity is too high in function apply_master_config. (30)
    Open

    def apply_master_config(overrides=None, defaults=None):
        '''
        Returns master configurations dict.
        '''
        if defaults is None:
    Severity: Minor
    Found in salt/config/__init__.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 is_profile_configured has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

    def is_profile_configured(opts, provider, profile_name, vm_=None):
        '''
        Check if the requested profile contains the minimum required parameters for
        a profile.
    
    
    Severity: Minor
    Found in salt/config/__init__.py - About 3 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

    Function get_id has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.
    Open

    def get_id(opts, cache_minion_id=False):
        '''
        Guess the id of the minion.
    
        If CONFIG_DIR/minion_id exists, use the cached minion ID from that file.
    Severity: Minor
    Found in salt/config/__init__.py - About 2 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

    Cyclomatic complexity is too high in function apply_minion_config. (24)
    Open

    def apply_minion_config(overrides=None,
                            defaults=None,
                            cache_minion_id=False,
                            minion_id=None):
        '''
    Severity: Minor
    Found in salt/config/__init__.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 function get_cloud_config_value. (24)
    Open

    def get_cloud_config_value(name, vm_, opts, default=None, search_global=True):
        '''
        Search and return a setting in a known order:
    
            1. In the virtual machine's configuration
    Severity: Minor
    Found in salt/config/__init__.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 function is_profile_configured. (23)
    Open

    def is_profile_configured(opts, provider, profile_name, vm_=None):
        '''
        Check if the requested profile contains the minimum required parameters for
        a profile.
    
    
    Severity: Minor
    Found in salt/config/__init__.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 apply_sdb has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
    Open

    def apply_sdb(opts, sdb_opts=None):
        '''
        Recurse for sdb:// links for opts
        '''
        # Late load of SDB to keep CLI light
    Severity: Minor
    Found in salt/config/__init__.py - About 2 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

    Function load_config has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
    Open

    def load_config(path, env_var, default_path=None, exit_on_config_errors=True):
        '''
        Returns configuration dict from parsing either the file described by
        ``path`` or the environment variable described by ``env_var`` as YAML.
        '''
    Severity: Minor
    Found in salt/config/__init__.py - About 1 hr 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

    Function _update_discovery_config has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
    Open

    def _update_discovery_config(opts):
        '''
        Update discovery config for all instances.
    
        :param opts:
    Severity: Minor
    Found in salt/config/__init__.py - About 1 hr 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

    Function call_id_function has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
    Open

    def call_id_function(opts):
        '''
        Evaluate the function that determines the ID if the 'id_function'
        option is set and return the result
        '''
    Severity: Minor
    Found in salt/config/__init__.py - About 1 hr 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

    Function apply_master_config has 32 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    def apply_master_config(overrides=None, defaults=None):
        '''
        Returns master configurations dict.
        '''
        if defaults is None:
    Severity: Minor
    Found in salt/config/__init__.py - About 1 hr to fix

      Function master_config has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

      def master_config(path, env_var='SALT_MASTER_CONFIG', defaults=None, exit_on_config_errors=False):
          '''
          Reads in the master configuration file and sets up default options
      
          This is useful for running the actual master daemon. For running
      Severity: Minor
      Found in salt/config/__init__.py - About 1 hr 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

      Function apply_minion_config has 26 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      def apply_minion_config(overrides=None,
                              defaults=None,
                              cache_minion_id=False,
                              minion_id=None):
          '''
      Severity: Minor
      Found in salt/config/__init__.py - About 1 hr to fix

        Function client_config has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
        Open

        def client_config(path, env_var='SALT_CLIENT_CONFIG', defaults=None):
            '''
            Load Master configuration data
        
            Usage:
        Severity: Minor
        Found in salt/config/__init__.py - About 55 mins 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

        Avoid deeply nested control flow statements.
        Open

                                if None in VALID_OPTS[key]:
                                    continue
                            except TypeError:
        Severity: Major
        Found in salt/config/__init__.py - About 45 mins to fix

          Avoid deeply nested control flow statements.
          Open

                              if ':' in driver:
                                  # Weird, but...
                                  alias, driver = driver.split(':')
          
          
          Severity: Major
          Found in salt/config/__init__.py - About 45 mins to fix

            Avoid deeply nested control flow statements.
            Open

                                if 'extends' not in details:
                                    log.error(
                                        'Please check your cloud providers configuration. '
                                        'There\'s no \'driver\' nor \'extends\' definition '
                                        'referenced.'
            Severity: Major
            Found in salt/config/__init__.py - About 45 mins to fix

              Avoid deeply nested control flow statements.
              Open

                                  if driver in providers.get(extends):
                                      details['extends'] = '{0}:{1}'.format(extends, driver)
                                  elif '-only-extendable-' in providers.get(extends):
                                      details['extends'] = '{0}:{1}'.format(
                                          extends, '-only-extendable-{0}'.format(ext_count)
              Severity: Major
              Found in salt/config/__init__.py - About 45 mins to fix

                Avoid deeply nested control flow statements.
                Open

                                    if isinstance(value, dict):
                                        value.update(details[name].copy())
                                    else:
                                        value = deepcopy(details[name])
                        elif len(opts['providers'].get(vm_['driver'], ())) > 1:
                Severity: Major
                Found in salt/config/__init__.py - About 45 mins to fix

                  Avoid deeply nested control flow statements.
                  Open

                                      if alias not in providers:
                                          raise salt.exceptions.SaltCloudConfigError(
                                              'The \'{0}\' cloud provider entry in \'{1}\' is '
                                              'trying to extend data from \'{2}\' though '
                                              '\'{2}\' is not defined in the salt cloud '
                  Severity: Major
                  Found in salt/config/__init__.py - About 45 mins to fix

                    Function _update_ssl_config has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                    Open

                    def _update_ssl_config(opts):
                        '''
                        Resolves string names to integer constant in ssl configuration.
                        '''
                        if opts['ssl'] in (None, False):
                    Severity: Minor
                    Found in salt/config/__init__.py - About 45 mins 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

                    Avoid deeply nested control flow statements.
                    Open

                                        if log_message is True:
                                            # This provider does not include all necessary keys,
                                            # continue to next one.
                                            log.warning(
                                                "The required '%s' configuration setting is "
                    Severity: Major
                    Found in salt/config/__init__.py - About 45 mins to fix

                      Function old_to_new has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                      Open

                      def old_to_new(opts):
                          providers = (
                              'AWS',
                              'CLOUDSTACK',
                              'DIGITALOCEAN',
                      Severity: Minor
                      Found in salt/config/__init__.py - About 45 mins 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

                      Avoid deeply nested control flow statements.
                      Open

                                          if alias not in config['providers']:
                                              config['providers'][alias] = {}
                      
                      
                      Severity: Major
                      Found in salt/config/__init__.py - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                            if provider not in providers.get(alias):
                                                raise salt.exceptions.SaltCloudConfigError(
                                                    'The \'{0}\' cloud provider entry in \'{1}\' is '
                                                    'trying to extend data from \'{2}:{3}\' though '
                                                    '\'{3}\' is not defined in \'{1}\''.format(
                        Severity: Major
                        Found in salt/config/__init__.py - About 45 mins to fix

                          Avoid deeply nested control flow statements.
                          Open

                                              if 'driver' not in detail:
                                                  raise salt.exceptions.SaltCloudConfigError(
                                                      'The cloud provider alias \'{0}\' has an entry '
                                                      'missing the required setting of \'driver\'.'.format(
                                                          alias
                          Severity: Major
                          Found in salt/config/__init__.py - About 45 mins to fix

                            Function _validate_ssh_minion_opts has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                            def _validate_ssh_minion_opts(opts):
                                '''
                                Ensure we're not using any invalid ssh_minion_opts. We want to make sure
                                that the ssh_minion_opts does not override any pillar or fileserver options
                                inherited from the master config. To add other items, modify the if
                            Severity: Minor
                            Found in salt/config/__init__.py - About 35 mins 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

                            Function minion_config has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                            def minion_config(path,
                                              env_var='SALT_MINION_CONFIG',
                                              defaults=None,
                                              cache_minion_id=False,
                                              ignore_config_errors=True,
                            Severity: Minor
                            Found in salt/config/__init__.py - About 35 mins 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

                            Function _adjust_log_file_override has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                            def _adjust_log_file_override(overrides, default_log_file):
                                '''
                                Adjusts the log_file based on the log_dir override
                                '''
                                if overrides.get('log_dir'):
                            Severity: Minor
                            Found in salt/config/__init__.py - About 35 mins 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

                            Function proxy_config has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                            def proxy_config(path,
                                             env_var='SALT_PROXY_CONFIG',
                                             defaults=None,
                                             cache_minion_id=False,
                                             ignore_config_errors=True,
                            Severity: Minor
                            Found in salt/config/__init__.py - About 35 mins 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

                            Avoid too many return statements within this function.
                            Open

                                return False
                            Severity: Major
                            Found in salt/config/__init__.py - About 30 mins to fix

                              Avoid too many return statements within this function.
                              Open

                                          return provider_details
                              Severity: Major
                              Found in salt/config/__init__.py - About 30 mins to fix

                                Function _expand_glob_path has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                Open

                                def _expand_glob_path(file_roots):
                                    '''
                                    Applies shell globbing to a set of directories and returns
                                    the expanded paths
                                    '''
                                Severity: Minor
                                Found in salt/config/__init__.py - About 25 mins 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

                                Function remove_domain_from_fqdn has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                Open

                                def remove_domain_from_fqdn(opts, newid):
                                    '''
                                    Depending on the values of `minion_id_remove_domain`,
                                    remove all domains or a single domain from a FQDN, effectivly generating a hostname.
                                    '''
                                Severity: Minor
                                Found in salt/config/__init__.py - About 25 mins 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

                                Function _read_conf_file has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                Open

                                def _read_conf_file(path):
                                    '''
                                    Read in a config file from a given path and process it into a dictionary
                                    '''
                                    log.debug('Reading configuration from %s', path)
                                Severity: Minor
                                Found in salt/config/__init__.py - About 25 mins 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

                                Function apply_spm_config has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                Open

                                def apply_spm_config(overrides, defaults):
                                    '''
                                    Returns the spm configurations dict.
                                
                                    .. versionadded:: 2015.8.1
                                Severity: Minor
                                Found in salt/config/__init__.py - About 25 mins 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

                                Function _cache_id has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                Open

                                def _cache_id(minion_id, cache_file):
                                    '''
                                    Helper function, writes minion id to a cache file.
                                    '''
                                    path = os.path.dirname(cache_file)
                                Severity: Minor
                                Found in salt/config/__init__.py - About 25 mins 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

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                                for detail in details:
                                                    if 'driver' not in detail:
                                                        raise salt.exceptions.SaltCloudConfigError(
                                                            'The cloud provider alias \'{0}\' has an entry '
                                                            'missing the required setting of \'driver\'.'.format(
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 day to fix
                                salt/config/__init__.py on lines 2859..2877

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 137.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                            elif isinstance(details, dict):
                                                if 'driver' not in details:
                                                    raise salt.exceptions.SaltCloudConfigError(
                                                        'The cloud provider alias \'{0}\' has an entry '
                                                        'missing the required setting of \'driver\''.format(
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 day to fix
                                salt/config/__init__.py on lines 2839..2858

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 137.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    if 'environment' in opts:
                                        if opts['saltenv'] is not None:
                                            log.warning(
                                                'The \'saltenv\' and \'environment\' master config options '
                                                'cannot both be used. Ignoring \'environment\' in favor of '
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 4 hrs to fix
                                salt/config/__init__.py on lines 3758..3774

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 86.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    if 'environment' in opts:
                                        if opts['saltenv'] is not None:
                                            log.warning(
                                                'The \'saltenv\' and \'environment\' minion config options '
                                                'cannot both be used. Ignoring \'environment\' in favor of '
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 4 hrs to fix
                                salt/config/__init__.py on lines 3957..3973

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 86.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 3 locations. Consider refactoring.
                                Open

                                    if not os.environ.get(env_var, None):
                                        # No valid setting was given using the configuration variable.
                                        # Lets see is SALT_CONFIG_DIR is of any use
                                        salt_config_dir = os.environ.get('SALT_CONFIG_DIR', None)
                                        if salt_config_dir:
                                Severity: Major
                                Found in salt/config/__init__.py and 2 other locations - About 3 hrs to fix
                                salt/config/__init__.py on lines 2411..2420
                                salt/config/__init__.py on lines 2464..2473

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 79.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 3 locations. Consider refactoring.
                                Open

                                    if not os.environ.get(env_var, None):
                                        # No valid setting was given using the configuration variable.
                                        # Lets see is SALT_CONFIG_DIR is of any use
                                        salt_config_dir = os.environ.get('SALT_CONFIG_DIR', None)
                                        if salt_config_dir:
                                Severity: Major
                                Found in salt/config/__init__.py and 2 other locations - About 3 hrs to fix
                                salt/config/__init__.py on lines 2411..2420
                                salt/config/__init__.py on lines 3903..3912

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 79.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 3 locations. Consider refactoring.
                                Open

                                    if not os.environ.get(env_var, None):
                                        # No valid setting was given using the configuration variable.
                                        # Lets see is SALT_CONFIG_DIR is of any use
                                        salt_config_dir = os.environ.get('SALT_CONFIG_DIR', None)
                                        if salt_config_dir:
                                Severity: Major
                                Found in salt/config/__init__.py and 2 other locations - About 3 hrs to fix
                                salt/config/__init__.py on lines 2464..2473
                                salt/config/__init__.py on lines 3903..3912

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 79.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    if profiles_config_path is not None and profiles_config is not None:
                                        raise salt.exceptions.SaltCloudConfigError(
                                            'Only pass `profiles_config` or `profiles_config_path`, not both.'
                                        )
                                    elif profiles_config_path is None and profiles_config is None:
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 3 hrs to fix
                                salt/config/__init__.py on lines 2734..2744

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 79.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    if providers_config_path is not None and providers_config is not None:
                                        raise salt.exceptions.SaltCloudConfigError(
                                            'Only pass `providers_config` or `providers_config_path`, '
                                            'not both.'
                                        )
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 3 hrs to fix
                                salt/config/__init__.py on lines 2747..2756

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 79.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    for idx, val in enumerate(opts['fileserver_backend']):
                                        if val in ('git', 'hg', 'svn', 'minion'):
                                            new_val = val + 'fs'
                                            log.debug(
                                                'Changed %s to %s in master opts\' fileserver_backend list',
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 3 hrs to fix
                                salt/config/__init__.py on lines 3776..3783

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 73.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    for idx, val in enumerate(opts['fileserver_backend']):
                                        if val in ('git', 'hg', 'svn', 'minion'):
                                            new_val = val + 'fs'
                                            log.debug(
                                                'Changed %s to %s in minion opts\' fileserver_backend list',
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 3 hrs to fix
                                salt/config/__init__.py on lines 3979..3986

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 73.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 3 locations. Consider refactoring.
                                Open

                                    if 'master_config' in overrides and master_config_path is None:
                                        # The configuration setting is being specified in the main cloud
                                        # configuration file
                                        master_config_path = overrides['master_config']
                                    elif 'master_config' not in overrides and not master_config \
                                Severity: Major
                                Found in salt/config/__init__.py and 2 other locations - About 3 hrs to fix
                                salt/config/__init__.py on lines 2641..2647
                                salt/config/__init__.py on lines 2652..2658

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 71.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 3 locations. Consider refactoring.
                                Open

                                    if 'profiles_config' in overrides and profiles_config_path is None:
                                        # The configuration setting is being specified in the main cloud
                                        # configuration file
                                        profiles_config_path = overrides['profiles_config']
                                    elif 'profiles_config' not in overrides and not profiles_config \
                                Severity: Major
                                Found in salt/config/__init__.py and 2 other locations - About 3 hrs to fix
                                salt/config/__init__.py on lines 2628..2636
                                salt/config/__init__.py on lines 2641..2647

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 71.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 3 locations. Consider refactoring.
                                Open

                                    if 'providers_config' in overrides and providers_config_path is None:
                                        # The configuration setting is being specified in the main cloud
                                        # configuration file
                                        providers_config_path = overrides['providers_config']
                                    elif 'providers_config' not in overrides and not providers_config \
                                Severity: Major
                                Found in salt/config/__init__.py and 2 other locations - About 3 hrs to fix
                                salt/config/__init__.py on lines 2628..2636
                                salt/config/__init__.py on lines 2652..2658

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 71.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Identical blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    if len(opts['sock_dir']) > len(opts['cachedir']) + 10:
                                        opts['sock_dir'] = os.path.join(opts['cachedir'], '.salt-unix')
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 3 hrs to fix
                                salt/config/__init__.py on lines 3988..3989

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 62.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Identical blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    if len(opts['sock_dir']) > len(opts['cachedir']) + 10:
                                        opts['sock_dir'] = os.path.join(opts['cachedir'], '.salt-unix')
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 3 hrs to fix
                                salt/config/__init__.py on lines 3820..3821

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 62.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Identical blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    for config_key in ('log_file', 'key_logfile', 'ssh_log_file'):
                                        log_setting = opts.get(config_key, '')
                                        if log_setting is None:
                                            continue
                                
                                
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 hr to fix
                                salt/config/__init__.py on lines 4247..4253

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 49.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Identical blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    for config_key in ('spm_logfile',):
                                        log_setting = opts.get(config_key, '')
                                        if log_setting is None:
                                            continue
                                
                                
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 hr to fix
                                salt/config/__init__.py on lines 4033..4039

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 49.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                def _validate_file_roots(file_roots):
                                    '''
                                    If the file_roots option has a key that is None then we will error out,
                                    just replace it with an empty list
                                    '''
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 hr to fix
                                salt/config/__init__.py on lines 1976..1985

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 55.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                def _validate_pillar_roots(pillar_roots):
                                    '''
                                    If the pillar_roots option has a key that is None then we will error out,
                                    just replace it with an empty list
                                    '''
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 hr to fix
                                salt/config/__init__.py on lines 1988..1997

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 55.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                                if name in details:
                                                    if isinstance(value, dict):
                                                        value.update(details[name].copy())
                                                    else:
                                                        value = deepcopy(details[name])
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 hr to fix
                                salt/config/__init__.py on lines 3351..3357

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 54.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                            if alias not in providers or driver not in providers[alias]:
                                                log.trace(
                                                    'The profile \'%s\' is defining \'%s\' as '
                                                    'the provider. Since there is no valid configuration '
                                                    'for that provider, the profile will be removed from '
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 hr to fix
                                salt/config/__init__.py on lines 2975..2984

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 54.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                            if name in provider_driver_defs:
                                                # The setting name exists in the VM's provider configuration.
                                                # Return it!
                                                if isinstance(value, dict):
                                                    value.update(provider_driver_defs[name].copy())
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 hr to fix
                                salt/config/__init__.py on lines 3329..3333

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 54.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                                if alias not in providers or driver not in providers[alias]:
                                                    log.trace(
                                                        'The profile \'%s\' is defining \'%s\' '
                                                        'as the provider. Since there is no valid '
                                                        'configuration for that provider, the profile will be '
                                Severity: Major
                                Found in salt/config/__init__.py and 1 other location - About 1 hr to fix
                                salt/config/__init__.py on lines 3042..3050

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 54.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                    if six.PY2 and 'rest_cherrypy' in opts:
                                        # CherryPy is not unicode-compatible
                                        opts['rest_cherrypy'] = salt.utils.data.encode(opts['rest_cherrypy'])
                                Severity: Minor
                                Found in salt/config/__init__.py and 1 other location - About 50 mins to fix
                                salt/utils/timed_subprocess.py on lines 74..77

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 44.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                            if details['provider'] not in providers:
                                                log.trace(
                                                    'The profile \'%s\' is defining \'%s\' as the '
                                                    'provider. Since there is no valid configuration for '
                                                    'that provider, the profile will be removed from the '
                                Severity: Minor
                                Found in salt/config/__init__.py and 1 other location - About 45 mins to fix
                                salt/config/__init__.py on lines 3025..3033

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 43.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                Similar blocks of code found in 2 locations. Consider refactoring.
                                Open

                                            if extended['provider'] not in providers:
                                                log.trace(
                                                    'The profile \'%s\' is defining \'%s\' as the '
                                                    'provider. Since there is no valid configuration for '
                                                    'that provider, the profile will be removed from the '
                                Severity: Minor
                                Found in salt/config/__init__.py and 1 other location - About 45 mins to fix
                                salt/config/__init__.py on lines 2990..2998

                                Duplicated Code

                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                Tuning

                                This issue has a mass of 43.

                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                Refactorings

                                Further Reading

                                There are no issues that match your filters.

                                Category
                                Status