Sign upLogin

freepn/fpnd

View on GitHub
Star

Showing 23 of 37 total issues

File helper_funcs.py has 466 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# coding: utf-8

"""Miscellaneous helper functions."""
from __future__ import print_function
Severity: Minor
Found in node_tools/helper_funcs.py - About 7 hrs to fix

    File async_funcs.py has 399 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    # coding: utf-8

"""asyncio-specific wrapper functions."""

import asyncio
    Severity: Minor
    Found in node_tools/async_funcs.py - About 5 hrs to fix

      File network_funcs.py has 363 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      # coding: utf-8

"""Network helper functions."""
from __future__ import print_function
      Severity: Minor
      Found in node_tools/network_funcs.py - About 4 hrs to fix

        File trie_funcs.py has 332 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        # coding: utf-8

"""trie-specific helper functions."""

import logging
        Severity: Minor
        Found in node_tools/trie_funcs.py - About 4 hrs to fix

          File node_funcs.py has 326 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          # coding: utf-8

"""Node-specific fpn helper functions."""
from __future__ import print_function
          Severity: Minor
          Found in node_tools/node_funcs.py - About 3 hrs to fix

            Function check_return_status has a Cognitive Complexity of 30 (exceeds 18 allowed). Consider refactoring.
            Open

            def check_return_status(obj):
    # ordering is important here (silly ad-hoc function)
    if obj is False:
        return False
    # we want to accept '0' as Success, otherwise 'not' is False
            Severity: Minor
            Found in node_tools/sched_funcs.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 get_neighbor_ids has a Cognitive Complexity of 30 (exceeds 18 allowed). Consider refactoring.
            Open

            def get_neighbor_ids(trie, node_id):
    """
    Given the node ID, get the payloads from the net trie and return
    the attached network and neighbor node IDs.
    :param trie: net data trie
            Severity: Minor
            Found in node_tools/trie_funcs.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 get_state has a Cognitive Complexity of 27 (exceeds 18 allowed). Consider refactoring.
            Open

            def get_state(cache):
    """
    Get state data from cache to build node state and update it.

    """
            Severity: Minor
            Found in node_tools/cache_funcs.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 do_net_check has a Cognitive Complexity of 24 (exceeds 18 allowed). Consider refactoring.
            Open

            def do_net_check(path=None):
    """
    Try and get the geoip location using fpn route.
    :param path: path to script dir
    """
            Severity: Minor
            Found in node_tools/network_funcs.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 do_net_cmd has a Cognitive Complexity of 22 (exceeds 18 allowed). Consider refactoring.
            Open

            def do_net_cmd(cmd):
    """
    Actual net command runner (see above).
    """
    import os
            Severity: Minor
            Found in node_tools/network_funcs.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 'result' in reply[0]:
                                st.fpnState['wdg_ref'] = True
                            logger.error('HEALTH: network is unreachable!!')
            Severity: Major
            Found in node_tools/nodestate.py - About 45 mins to fix

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

              def load_id_trie(net_trie, id_trie, nw_id, node_id, needs=[], nw=False):
              Severity: Minor
              Found in node_tools/trie_funcs.py - About 45 mins to fix

                Function do_cleanup has a Cognitive Complexity of 21 (exceeds 18 allowed). Consider refactoring.
                Open

                def do_cleanup(path=None, addr=None):
    """
    Run network cleanup commands via daemon cleanup hook.
    :param path: path to scripts dir
    :param addr: moon address if known
                Severity: Minor
                Found in node_tools/node_funcs.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

                Function update_id_trie has 5 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                def update_id_trie(trie, nw_id, node_id, needs=[], nw=False):
                Severity: Minor
                Found in node_tools/trie_funcs.py - About 35 mins to fix

                  Function cleanup_state_tries has 5 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                  def cleanup_state_tries(net_trie, id_trie, nw_id, node_id, mbr_only=False):
                  Severity: Minor
                  Found in node_tools/trie_funcs.py - About 35 mins to fix

                    Function drain_msg_queue has 5 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                    def drain_msg_queue(reg_q, pub_q=None, tmp_q=None, addr=None, method='handle_node'):
                    Severity: Minor
                    Found in node_tools/network_funcs.py - About 35 mins to fix

                      Function get_peer_status has a Cognitive Complexity of 20 (exceeds 18 allowed). Consider refactoring.
                      Open

                      def get_peer_status(cache):
    """
    Get status data for 'peer' endpoint from cache, return a
    list of dictionaries.
    """
                      Severity: Minor
                      Found in node_tools/cache_funcs.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 load_cache_by_type has a Cognitive Complexity of 20 (exceeds 18 allowed). Consider refactoring.
                      Open

                      def load_cache_by_type(cache, data, key_str):
    """Load or update cache by key type string (uses find_keys)."""
    from itertools import zip_longest
    key_list = find_keys(cache, key_str)
    if not key_list:
                      Severity: Minor
                      Found in node_tools/cache_funcs.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 node_tools/sched_funcs.py - About 30 mins to fix

                        Avoid too many return statements within this function.
                        Open

                                                return True
                        Severity: Major
                        Found in node_tools/sched_funcs.py - About 30 mins to fix
                          Severity
                          Category
                          Status
                          Source
                          Language