various formatting, including mixes of tab and spaces detected in py3

diff --git a/src/nepi/execution/ec.py b/src/nepi/execution/ec.py
index 021e06e..3f8d42f 100644 (file)
--- a/src/nepi/execution/ec.py
+++ b/src/nepi/execution/ec.py
@@ -1053,7 +1053,7 @@ class ExperimentController(object):
 
         """
         if self._state == ECState.RELEASED:
-           return 
+            return 
 
         if isinstance(guids, int):
             guids = [guids]

diff --git a/src/nepi/util/netgraph.py b/src/nepi/util/netgraph.py
index 744a95b..8a36d15 100644 (file)
--- a/src/nepi/util/netgraph.py
+++ b/src/nepi/util/netgraph.py
@@ -72,14 +72,14 @@ class NetGraph(object):
             :param assign_st: Select source and target nodes on the graph.
             :type assign_st: bool
 
-           :param sources_targets: dictionary with the list of sources (key =
+            :param sources_targets: dictionary with the list of sources (key =
             "sources") and list of targets (key = "targets") if defined, ignore
             assign_st
-           :type sources_targets: dictionary of lists
+            :type sources_targets: dictionary of lists
 
-           :param leaf_source: if True, random sources will be selected only 
+            :param leaf_source: if True, random sources will be selected only 
             from leaf nodes.
-           :type leaf_source: bool
+            :type leaf_source: bool
 
         NOTE: Only point-to-point like network topologies are supported for now.
                 (Wireless and Ethernet networks were several nodes share the same
@@ -107,11 +107,11 @@ class NetGraph(object):
             self.assign_p2p_ips(network = network, prefix = prefix, 
                     version = version)
 
-       sources_targets = kwargs.get("sources_targets")
-       if sources_targets:
+        sources_targets = kwargs.get("sources_targets")
+        if sources_targets:
             [self.set_source(n) for n in sources_targets["sources"]]
-           [self.set_target(n) for n in sources_targets["targets"]]
-       elif kwargs.get("assign_st"):
+            [self.set_target(n) for n in sources_targets["targets"]]
+        elif kwargs.get("assign_st"):
             self.select_target_zero()
             self.select_random_source(is_leaf = kwargs.get("leaf_source"))
 

diff --git a/src/nepi/util/sshfuncs.py b/src/nepi/util/sshfuncs.py
index 176afd3..12c2138 100644 (file)
--- a/src/nepi/util/sshfuncs.py
+++ b/src/nepi/util/sshfuncs.py
@@ -38,13 +38,11 @@ _re_inet = re.compile("\d+:\s+(?P<name>[a-z0-9_-]+)\s+inet6?\s+(?P<inet>[a-f0-9.
 
 logger = logging.getLogger("sshfuncs")
 
-def log(msg, level, out = None, err = None):
+def log(msg, level = logging.DEBUG, out = None, err = None):
     if out:
         msg += " - OUT: %s " % out
-
     if err:
         msg += " - ERROR: %s " % err
-
     logger.log(level, msg)
 
 if hasattr(os, "devnull"):
@@ -59,6 +57,7 @@ class STDOUT:
     Special value that when given to rspawn in stderr causes stderr to 
     redirect to whatever stdout was redirected to.
     """
+    pass
 
 class ProcStatus:
     """
@@ -80,8 +79,12 @@ def resolve_hostname(host):
     ip = None
 
     if host in ["localhost", "127.0.0.1", "::1"]:
-        p = subprocess.Popen("ip -o addr list", shell=True,
-                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        p = subprocess.Popen(
+            "ip -o addr list",
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
         stdout, stderr = p.communicate()
         m = _re_inet.findall(stdout)
         ip = m[0][1].split("/")[0]
@@ -117,10 +120,12 @@ def openssh_has_persist():
     """
     global OPENSSH_HAS_PERSIST
     if OPENSSH_HAS_PERSIST is None:
-        proc = subprocess.Popen(["ssh","-v"],
+        proc = subprocess.Popen(
+            ["ssh", "-v"],
             stdout = subprocess.PIPE,
             stderr = subprocess.STDOUT,
-            stdin = open("/dev/null","r") )
+            stdin = open("/dev/null"),
+        )
         out,err = proc.communicate()
         proc.wait()
         
@@ -189,12 +194,12 @@ def shell_escape(s):
         return s
     else:
         # unsafe string - escape
-        def escp(c):
+        def escape(c):
             if (32 <= ord(c) < 127 or c in ('\r','\n','\t')) and c not in ("'",'"'):
                 return c
             else:
                 return "'$'\\x%02x''" % (ord(c),)
-        s = ''.join(map(escp,s))
+        s = ''.join(map(escape, s))
         return "'%s'" % (s,)
 
 def eintr_retry(func):
@@ -303,13 +308,13 @@ def rexec(command, host, user,
         stdout = stderr = stdin = None
 
     return _retry_rexec(args, log_msg, 
-            stderr = stderr,
-            stdin = stdin,
-            stdout = stdout,
-            env = env, 
-            retry = retry, 
-            tmp_known_hosts = tmp_known_hosts,
-            blocking = blocking)
+                        stderr = stderr,
+                        stdin = stdin,
+                        stdout = stdout,
+                        env = env, 
+                        retry = retry, 
+                        tmp_known_hosts = tmp_known_hosts,
+                        blocking = blocking)
 
 def rcopy(source, dest,
         port = None,
@@ -403,22 +408,22 @@ def rcopy(source, dest,
             blocking = True)
 
 def rspawn(command, pidfile, 
-        stdout = '/dev/null', 
-        stderr = STDOUT, 
-        stdin = '/dev/null',
-        home = None, 
-        create_home = False, 
-        sudo = False,
-        host = None, 
-        port = None, 
-        user = None, 
-        gwuser = None,
-        gw = None,
-        agent = None, 
-        identity = None, 
-        server_key = None,
-        tty = False,
-        strict_host_checking = True):
+           stdout = '/dev/null', 
+           stderr = STDOUT, 
+           stdin = '/dev/null',
+           home = None, 
+           create_home = False, 
+           sudo = False,
+           host = None, 
+           port = None, 
+           user = None, 
+           gwuser = None,
+           gw = None,
+           agent = None, 
+           identity = None, 
+           server_key = None,
+           tty = False,
+           strict_host_checking = True):
     """
     Spawn a remote command such that it will continue working asynchronously in 
     background. 
@@ -504,15 +509,15 @@ def rspawn(command, pidfile,
 
 @eintr_retry
 def rgetpid(pidfile,
-        host = None, 
-        port = None, 
-        user = None, 
-        gwuser = None,
-        gw = None,
-        agent = None, 
-        identity = None,
-        server_key = None,
-        strict_host_checking = True):
+            host = None, 
+            port = None, 
+            user = None, 
+            gwuser = None,
+            gw = None,
+            agent = None, 
+            identity = None,
+            server_key = None,
+            strict_host_checking = True):
     """
     Returns the pid and ppid of a process from a remote file where the 
     information was stored.
@@ -683,26 +688,27 @@ fi
     return (out, err), proc
 
 def _retry_rexec(args,
-        log_msg,
-        stdout = subprocess.PIPE,
-        stdin = subprocess.PIPE, 
-        stderr = subprocess.PIPE,
-        env = None,
-        retry = 3,
-        tmp_known_hosts = None,
-        blocking = True):
+                 log_msg,
+                 stdout = subprocess.PIPE,
+                 stdin = subprocess.PIPE, 
+                 stderr = subprocess.PIPE,
+                 env = None,
+                 retry = 3,
+                 tmp_known_hosts = None,
+                 blocking = True):
 
     for x in xrange(retry):
         # display command actually invoked when debug is turned on
         message = " ".join( [ "'{}'".format(arg) for arg in args ] )
         log("sshfuncs: invoking {}".format(message), logging.DEBUG)
         # connects to the remote host and starts a remote connection
-        proc = subprocess.Popen(args,
-                env = env,
-                stdout = stdout,
-                stdin = stdin, 
-                stderr = stderr)
-        
+        proc = subprocess.Popen(
+            args,
+            env = env,
+            stdout = stdout,
+            stdin = stdin, 
+            stderr = stderr,
+        )        
         # attach tempfile object to the process, to make sure the file stays
         # alive until the process is finished with it
         proc._known_hosts = tmp_known_hosts