Sign upLogin

saltstack/salt

View on GitHub
Star
salt/cloud/clouds/proxmox.py

Summary

Maintainability
F
3 wks
Test Coverage

Function create has a Cognitive Complexity of 155 (exceeds 5 allowed). Consider refactoring.
Open

def create(vm_):
    '''
    Create a single VM from a data dict

    CLI Example:
Severity: Minor
Found in salt/cloud/clouds/proxmox.py - About 3 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

File proxmox.py has 992 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# -*- coding: utf-8 -*-
'''
Proxmox Cloud Module
======================
Severity: Major
Found in salt/cloud/clouds/proxmox.py - About 2 days to fix

    Cyclomatic complexity is too high in function create. (55)
    Open

    def create(vm_):
    '''
    Create a single VM from a data dict

    CLI Example:
    Severity: Minor
    Found in salt/cloud/clouds/proxmox.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 create_node has a Cognitive Complexity of 48 (exceeds 5 allowed). Consider refactoring.
    Open

    def create_node(vm_, newid):
    '''
    Build and submit the requestdata to create a new node
    '''
    newnode = {}
    Severity: Minor
    Found in salt/cloud/clouds/proxmox.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

    Cyclomatic complexity is too high in function create_node. (29)
    Open

    def create_node(vm_, newid):
    '''
    Build and submit the requestdata to create a new node
    '''
    newnode = {}
    Severity: Minor
    Found in salt/cloud/clouds/proxmox.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 get_resources_vms has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
    Open

    def get_resources_vms(call=None, resFilter=None, includeConfig=True):
    '''
    Retrieve all VMs available on this environment

    CLI Example:
    Severity: Minor
    Found in salt/cloud/clouds/proxmox.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 list_nodes has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
    Open

    def list_nodes(call=None):
    '''
    Return a list of the VMs that are managed by the provider

    CLI Example:
    Severity: Minor
    Found in salt/cloud/clouds/proxmox.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 _get_properties has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    def _get_properties(path="", method="GET", forced_params=None):
    '''
    Return the parameter list from api for defined path and HTTP method
    '''
    if api is None:
    Severity: Minor
    Found in salt/cloud/clouds/proxmox.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 get_vmconfig has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
    Open

    def get_vmconfig(vmid, node=None, node_type='openvz'):
    '''
    Get VM configuration
    '''
    if node is None:
    Severity: Minor
    Found in salt/cloud/clouds/proxmox.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

    Avoid deeply nested control flow statements.
    Open

                        if 'gw' in _stringlist_to_dictionary(vm_[setting]):
                        new_setting.update(_stringlist_to_dictionary(
                            'ip={0}/24,gw={1}'.format(
                                vm_['ip_address'], _stringlist_to_dictionary(vm_[setting])['gw'])))
                    else:
    Severity: Major
    Found in salt/cloud/clouds/proxmox.py - About 45 mins to fix

      Avoid deeply nested control flow statements.
      Open

                              for if_addr in interface['ip-addresses']:
                            ip_addr = if_addr['ip-address']
                            # Ensure interface has a valid IPv4 address
                            if if_addr['ip-address-type'] == 'ipv4' and ip_addr is not None:
                                return six.text_type(ip_addr)
      Severity: Major
      Found in salt/cloud/clouds/proxmox.py - About 45 mins to fix

        Avoid deeply nested control flow statements.
        Open

                            if setting_storage != vm_disk_storage:
                        postParams = {}
                        postParams['disk'] = setting
                        postParams['storage'] = setting_storage
                        postParams['delete'] = 1
        Severity: Major
        Found in salt/cloud/clouds/proxmox.py - About 45 mins to fix

          Avoid deeply nested control flow statements.
          Open

                              if setting_storage != vm_disk_storage:
                        postParams = {}
                        postParams['disk'] = setting
                        postParams['storage'] = setting_storage
                        postParams['delete'] = 1
          Severity: Major
          Found in salt/cloud/clouds/proxmox.py - About 45 mins to fix

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

            def destroy(name, call=None):
    '''
    Destroy a node.

    CLI Example:
            Severity: Minor
            Found in salt/cloud/clouds/proxmox.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 setting_size != vm_disk_size:
                        postParams = {}
                        postParams['disk'] = setting
                        postParams['size'] = setting_size
                        query('put', 'nodes/{0}/qemu/{1}/resize'.format(
            Severity: Major
            Found in salt/cloud/clouds/proxmox.py - About 45 mins to fix

              Avoid deeply nested control flow statements.
              Open

                                  if setting_size != vm_disk_size:
                        postParams = {}
                        postParams['disk'] = setting
                        postParams['size'] = setting_size
                        query('put', 'nodes/{0}/qemu/{1}/resize'.format(
              Severity: Major
              Found in salt/cloud/clouds/proxmox.py - About 45 mins to fix

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

                def query(conn_type, option, post_data=None):
    '''
    Execute the HTTP request to the API
    '''
    if ticket is None or csrf is None or url is None:
                Severity: Minor
                Found in salt/cloud/clouds/proxmox.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 {'Error': 'Unable to move disk {0}, command timed out'.format(
                Severity: Major
                Found in salt/cloud/clouds/proxmox.py - About 30 mins to fix

                  Avoid too many return statements within this function.
                  Open

                          return {'Error': 'Unable to start {0}, command timed out'.format(name)}
                  Severity: Major
                  Found in salt/cloud/clouds/proxmox.py - About 30 mins to fix

                    Avoid too many return statements within this function.
                    Open

                        return ret
                    Severity: Major
                    Found in salt/cloud/clouds/proxmox.py - About 30 mins to fix

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

                      def _lookup_proxmox_task(upid):
    '''
    Retrieve the (latest) logs and retrieve the status for a UPID.
    This can be used to verify whether a task has completed.
    '''
                      Severity: Minor
                      Found in salt/cloud/clouds/proxmox.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 wait_for_created has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                      Open

                      def wait_for_created(upid, timeout=300):
    '''
    Wait until a the vm has been created successfully
    '''
    start_time = time.time()
                      Severity: Minor
                      Found in salt/cloud/clouds/proxmox.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 wait_for_state has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                      Open

                      def wait_for_state(vmid, state, timeout=300):
    '''
    Wait until a specific state has been reached on a node
    '''
    start_time = time.time()
                      Severity: Minor
                      Found in salt/cloud/clouds/proxmox.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 wait_for_task has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                      Open

                      def wait_for_task(upid, timeout=300):
    '''
    Wait until a the task has been finished successfully
    '''
    start_time = time.time()
                      Severity: Minor
                      Found in salt/cloud/clouds/proxmox.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 set_vm_status has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                      Open

                      def set_vm_status(status, name=None, vmid=None):
    '''
    Convenience function for setting VM status
    '''
    log.debug('Set status to %s for %s (%s)', status, name, vmid)
                      Severity: Minor
                      Found in salt/cloud/clouds/proxmox.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 setting_number in range(13):
            setting = 'scsi{0}'.format(setting_number)
            if setting in vm_:
                vm_config = query('get', 'nodes/{0}/qemu/{1}/config'.format(vm_['host'], vmid))
                if setting in vm_config:
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 3 days to fix
                      salt/cloud/clouds/proxmox.py on lines 668..702

                      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 371.

                      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 setting_number in range(5):
            setting = 'sata{0}'.format(setting_number)
            if setting in vm_:
                vm_config = query('get', 'nodes/{0}/qemu/{1}/config'.format(vm_['host'], vmid))
                if setting in vm_config:
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 3 days to fix
                      salt/cloud/clouds/proxmox.py on lines 704..738

                      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 371.

                      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 wait_for_task(upid, timeout=300):
    '''
    Wait until a the task has been finished successfully
    '''
    start_time = time.time()
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 1 day to fix
                      salt/cloud/clouds/proxmox.py on lines 1076..1095

                      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 143.

                      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 wait_for_created(upid, timeout=300):
    '''
    Wait until a the vm has been created successfully
    '''
    start_time = time.time()
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 1 day to fix
                      salt/cloud/clouds/proxmox.py on lines 1122..1141

                      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 143.

                      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

                      def script(vm_):
    '''
    Return the script deployment object
    '''
    script_name = config.get_cloud_config_value('script', vm_, __opts__)
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 3 hrs to fix
                      salt/cloud/clouds/vmware.py on lines 210..223

                      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 72.

                      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

                              try:
            ip_address = __utils__['cloud.wait_for_fun'](
                __find_agent_ip,
                vm_=vm_
            )
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 2 hrs to fix
                      salt/cloud/clouds/openstack.py on lines 722..734

                      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 68.

                      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 38 locations. Consider refactoring.
                      Open

                          __utils__['cloud.fire_event'](
        'event',
        'starting create',
        'salt/cloud/{0}/creating'.format(vm_['name']),
        args=__utils__['cloud.filter_event'](
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 37 other locations - About 2 hrs to fix
                      salt/cloud/clouds/aliyun.py on lines 625..631
                      salt/cloud/clouds/aliyun.py on lines 732..738
                      salt/cloud/clouds/azurearm.py on lines 1349..1359
                      salt/cloud/clouds/azurearm.py on lines 1398..1406
                      salt/cloud/clouds/azurearm.py on lines 1480..1489
                      salt/cloud/clouds/digitalocean.py on lines 287..293
                      salt/cloud/clouds/digitalocean.py on lines 537..543
                      salt/cloud/clouds/dimensiondata.py on lines 207..213
                      salt/cloud/clouds/dimensiondata.py on lines 337..343
                      salt/cloud/clouds/ec2.py on lines 2579..2585
                      salt/cloud/clouds/gce.py on lines 2461..2467
                      salt/cloud/clouds/gce.py on lines 2551..2557
                      salt/cloud/clouds/gce.py on lines 2635..2641
                      salt/cloud/clouds/gogrid.py on lines 96..102
                      salt/cloud/clouds/gogrid.py on lines 180..186
                      salt/cloud/clouds/joyent.py on lines 274..280
                      salt/cloud/clouds/joyent.py on lines 325..331
                      salt/cloud/clouds/lxc.py on lines 440..446
                      salt/cloud/clouds/lxc.py on lines 460..466
                      salt/cloud/clouds/lxc.py on lines 488..494
                      salt/cloud/clouds/msazure.py on lines 429..435
                      salt/cloud/clouds/msazure.py on lines 683..689
                      salt/cloud/clouds/nova.py on lines 961..967
                      salt/cloud/clouds/opennebula.py on lines 1006..1012
                      salt/cloud/clouds/openstack.py on lines 684..690
                      salt/cloud/clouds/packet.py on lines 347..353
                      salt/cloud/clouds/parallels.py on lines 287..293
                      salt/cloud/clouds/parallels.py on lines 356..362
                      salt/cloud/clouds/qingcloud.py on lines 668..674
                      salt/cloud/clouds/qingcloud.py on lines 738..744
                      salt/cloud/clouds/scaleway.py on lines 200..206
                      salt/cloud/clouds/scaleway.py on lines 304..310
                      salt/cloud/clouds/virtualbox.py on lines 176..182
                      salt/cloud/clouds/vmware.py on lines 2543..2549
                      salt/cloud/clouds/vmware.py on lines 3072..3078
                      salt/cloud/clouds/vultrpy.py on lines 292..298
                      salt/cloud/clouds/vultrpy.py on lines 465..471

                      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 66.

                      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 6 locations. Consider refactoring.
                      Open

                      def show_instance(name, call=None):
    '''
    Show the details from Proxmox concerning an instance
    '''
    if call != 'action':
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 5 other locations - About 2 hrs to fix
                      salt/cloud/clouds/oneandone.py on lines 578..593
                      salt/cloud/clouds/profitbricks.py on lines 661..676
                      salt/cloud/clouds/softlayer.py on lines 586..597
                      salt/cloud/clouds/softlayer_hw.py on lines 488..499
                      salt/cloud/libcloudfuncs.py on lines 505..516

                      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 66.

                      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

                          __utils__['cloud.fire_event'](
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(vm_['name']),
        args=__utils__['cloud.filter_event'](
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 2 hrs to fix
                      salt/cloud/clouds/opennebula.py on lines 1170..1175

                      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 57.

                      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 shutdown(name=None, vmid=None, call=None):
    '''
    Shutdown a node via ACPI.

    CLI Example:
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 2 hrs to fix
                      salt/cloud/clouds/proxmox.py on lines 1286..1307

                      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 65.

                      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 stop(name, vmid=None, call=None):
    '''
    Stop a node ("pulling the plug").

    CLI Example:
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 2 hrs to fix
                      salt/cloud/clouds/proxmox.py on lines 1310..1331

                      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 65.

                      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 3 locations. Consider refactoring.
                      Open

                                  if setting in vm_:
                postParams = {}
                postParams[setting] = vm_[setting]
                query('post', 'nodes/{0}/qemu/{1}/config'.format(vm_['host'], vmid), postParams)
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 2 other locations - About 2 hrs to fix
                      salt/cloud/clouds/proxmox.py on lines 648..652
                      salt/cloud/clouds/proxmox.py on lines 655..659

                      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

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

                              for setting in 'sockets', 'cores', 'cpulimit', 'memory', 'onboot', 'agent':
            if setting in vm_:  # if the property is set, use it for the VM request
                postParams = {}
                postParams[setting] = vm_[setting]
                query('post', 'nodes/{0}/qemu/{1}/config'.format(vm_['host'], vmid), postParams)
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 2 other locations - About 2 hrs to fix
                      salt/cloud/clouds/proxmox.py on lines 655..659
                      salt/cloud/clouds/proxmox.py on lines 663..666

                      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

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

                              for setting in 'ciuser', 'cipassword', 'sshkeys', 'nameserver', 'searchdomain':
            if setting in vm_:  # if the property is set, use it for the VM request
                postParams = {}
                postParams[setting] = vm_[setting]
                query('post', 'nodes/{0}/qemu/{1}/config'.format(vm_['host'], vmid), postParams)
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 2 other locations - About 2 hrs to fix
                      salt/cloud/clouds/proxmox.py on lines 648..652
                      salt/cloud/clouds/proxmox.py on lines 663..666

                      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

                          __utils__['cloud.fire_event'](
        'event',
        'requesting instance',
        'salt/cloud/{0}/requesting'.format(vm_['name']),
        args={
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 1 other location - About 2 hrs to fix
                      salt/cloud/clouds/opennebula.py on lines 1029..1036

                      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 60.

                      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 18 locations. Consider refactoring.
                      Open

                          try:
        # Check for required profile parameters before sending any API calls.
        if vm_['profile'] and config.is_profile_configured(__opts__,
                                                           __active_provider_name__ or 'proxmox',
                                                           vm_['profile'],
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 17 other locations - About 1 hr to fix
                      salt/cloud/clouds/aliyun.py on lines 615..622
                      salt/cloud/clouds/azurearm.py on lines 1384..1392
                      salt/cloud/clouds/cloudstack.py on lines 270..277
                      salt/cloud/clouds/digitalocean.py on lines 277..284
                      salt/cloud/clouds/ec2.py on lines 2554..2561
                      salt/cloud/clouds/gce.py on lines 2451..2458
                      salt/cloud/clouds/gogrid.py on lines 86..93
                      salt/cloud/clouds/joyent.py on lines 260..267
                      salt/cloud/clouds/linode.py on lines 328..335
                      salt/cloud/clouds/msazure.py on lines 419..426
                      salt/cloud/clouds/nova.py on lines 938..945
                      salt/cloud/clouds/parallels.py on lines 277..284
                      salt/cloud/clouds/qingcloud.py on lines 658..665
                      salt/cloud/clouds/scaleway.py on lines 190..197
                      salt/cloud/clouds/softlayer.py on lines 248..255
                      salt/cloud/clouds/softlayer_hw.py on lines 216..223
                      salt/cloud/clouds/vmware.py on lines 2532..2540

                      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 23 locations. Consider refactoring.
                      Open

                              if __opts__.get('update_cachedir', False) is True:
            __utils__['cloud.delete_minion_cachedir'](
                name, __active_provider_name__.split(':')[0], __opts__)
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 22 other locations - About 50 mins to fix
                      salt/cloud/clouds/azurearm.py on lines 1528..1532
                      salt/cloud/clouds/digitalocean.py on lines 868..869
                      salt/cloud/clouds/ec2.py on lines 3417..3418
                      salt/cloud/clouds/gce.py on lines 2377..2378
                      salt/cloud/clouds/gogrid.py on lines 421..422
                      salt/cloud/clouds/joyent.py on lines 429..430
                      salt/cloud/clouds/linode.py on lines 758..759
                      salt/cloud/clouds/lxc.py on lines 415..416
                      salt/cloud/clouds/msazure.py on lines 947..948
                      salt/cloud/clouds/nova.py on lines 569..570
                      salt/cloud/clouds/oneandone.py on lines 918..922
                      salt/cloud/clouds/opennebula.py on lines 1226..1230
                      salt/cloud/clouds/openstack.py on lines 816..817
                      salt/cloud/clouds/parallels.py on lines 561..562
                      salt/cloud/clouds/profitbricks.py on lines 1023..1027
                      salt/cloud/clouds/scaleway.py on lines 456..458
                      salt/cloud/clouds/softlayer.py on lines 637..638
                      salt/cloud/clouds/softlayer_hw.py on lines 547..548
                      salt/cloud/clouds/vagrant.py on lines 308..310
                      salt/cloud/clouds/vmware.py on lines 2513..2514
                      salt/cloud/clouds/xen.py on lines 1046..1050
                      salt/cloud/libcloudfuncs.py on lines 403..404

                      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 15 locations. Consider refactoring.
                      Open

                      def __virtual__():
    '''
    Check for PROXMOX configurations
    '''
    if get_configured_provider() is False:
                      Severity: Major
                      Found in salt/cloud/clouds/proxmox.py and 14 other locations - About 30 mins to fix
                      salt/cloud/clouds/aliyun.py on lines 90..100
                      salt/cloud/clouds/cloudstack.py on lines 78..88
                      salt/cloud/clouds/digitalocean.py on lines 68..78
                      salt/cloud/clouds/ec2.py on lines 186..196
                      salt/cloud/clouds/msazure.py on lines 79..89
                      salt/cloud/clouds/oneandone.py on lines 156..166
                      salt/cloud/clouds/opennebula.py on lines 98..108
                      salt/cloud/clouds/openstack.py on lines 248..256
                      salt/cloud/clouds/profitbricks.py on lines 138..148
                      salt/cloud/clouds/pyrax.py on lines 29..39
                      salt/cloud/clouds/qingcloud.py on lines 71..81
                      salt/cloud/clouds/softlayer.py on lines 55..65
                      salt/cloud/clouds/softlayer_hw.py on lines 53..63
                      salt/cloud/clouds/vmware.py on lines 173..183

                      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 40.

                      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