parallel: Use utils.localinterfaces.LOCALHOST

IPython/parallel/apps/logwatcher.py

@@ -26,6 +26,7 b' import zmq'
 from zmq.eventloop import ioloop, zmqstream
 
 from IPython.config.configurable import LoggingConfigurable
+from IPython.utils.localinterfaces import LOCALHOST
 from IPython.utils.traitlets import Int, Unicode, Instance, List
 
 #-----------------------------------------------------------------------------
@@ -43,7 +44,7 b' class LogWatcher(LoggingConfigurable):'
     # configurables
     topics = List([''], config=True,
         help="The ZMQ topics to subscribe to. Default is to subscribe to all messages")
-    url = Unicode('tcp://127.0.0.1:20202', config=True,
+    url = Unicode('tcp://%s:20202' % LOCALHOST, config=True,
         help="ZMQ url on which to listen for log messages")
     
     # internals

IPython/parallel/client/client.py

@@ -36,7 +36,7 b' from IPython.core.profiledir import ProfileDir, ProfileDirError'
 
 from IPython.utils.coloransi import TermColors
 from IPython.utils.jsonutil import rekey
-from IPython.utils.localinterfaces import LOCAL_IPS
+from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 from IPython.utils.path import get_ipython_dir
 from IPython.utils.py3compat import cast_bytes
 from IPython.utils.traitlets import (HasTraits, Integer, Instance, Unicode,
@@ -427,7 +427,7 b' class Client(HasTraits):'
         
         url = cfg['registration']
         
-        if location is not None and addr == '127.0.0.1':
+        if location is not None and addr == LOCALHOST:
             # location specified, and connection is expected to be local
             if location not in LOCAL_IPS and not sshserver:
                 # load ssh from JSON *only* if the controller is not on

IPython/parallel/controller/hub.py

@@ -30,6 +30,7 b' from zmq.eventloop.zmqstream import ZMQStream'
 
 # internal:
 from IPython.utils.importstring import import_item
+from IPython.utils.localinterfaces import LOCALHOST
 from IPython.utils.py3compat import cast_bytes
 from IPython.utils.traitlets import (
         HasTraits, Instance, Integer, Unicode, Dict, Set, Tuple, CBytes, DottedObjectName
@@ -176,17 +177,17 b' class HubFactory(RegistrationFactory):'
     def _notifier_port_default(self):
         return util.select_random_ports(1)[0]
 
-    engine_ip = Unicode('127.0.0.1', config=True,
+    engine_ip = Unicode(LOCALHOST, config=True,
         help="IP on which to listen for engine connections. [default: loopback]")
     engine_transport = Unicode('tcp', config=True,
         help="0MQ transport for engine connections. [default: tcp]")
 
-    client_ip = Unicode('127.0.0.1', config=True,
+    client_ip = Unicode(LOCALHOST, config=True,
         help="IP on which to listen for client connections. [default: loopback]")
     client_transport = Unicode('tcp', config=True,
         help="0MQ transport for client connections. [default : tcp]")
 
-    monitor_ip = Unicode('127.0.0.1', config=True,
+    monitor_ip = Unicode(LOCALHOST, config=True,
         help="IP on which to listen for monitor messages. [default: loopback]")
     monitor_transport = Unicode('tcp', config=True,
         help="0MQ transport for monitor messages. [default : tcp]")

IPython/parallel/engine/engine.py

@@ -24,6 +24,7 b' from zmq.eventloop import ioloop, zmqstream'
 
 from IPython.external.ssh import tunnel
 # internal
+from IPython.utils.localinterfaces import LOCALHOST
 from IPython.utils.traitlets import (
     Instance, Dict, Integer, Type, Float, Integer, Unicode, CBytes, Bool
 )
@@ -182,13 +183,13 b' class EngineFactory(RegistrationFactory):'
             if self.max_heartbeat_misses > 0:
                 # Add a monitor socket which will record the last time a ping was seen
                 mon = self.context.socket(zmq.SUB)
-                mport = mon.bind_to_random_port('tcp://127.0.0.1')
+                mport = mon.bind_to_random_port('tcp://%s' % LOCALHOST)
                 mon.setsockopt(zmq.SUBSCRIBE, b"")
                 self._hb_listener = zmqstream.ZMQStream(mon, self.loop)
                 self._hb_listener.on_recv(self._report_ping)
             
             
-                hb_monitor = "tcp://127.0.0.1:%i"%mport
+                hb_monitor = "tcp://%s:%i" % (LOCALHOST, mport)
 
             heart = Heart(hb_ping, hb_pong, hb_monitor , heart_id=identity)
             heart.start()

IPython/parallel/factory.py

@@ -24,6 +24,7 b' import zmq'
 from zmq.eventloop.ioloop import IOLoop
 
 from IPython.config.configurable import Configurable
+from IPython.utils.localinterfaces import LOCALHOST
 from IPython.utils.traitlets import Integer, Instance, Unicode
 
 from IPython.parallel.util import select_random_ports
@@ -39,15 +40,16 b' class RegistrationFactory(SessionFactory):'
     
     url = Unicode('', config=True,
         help="""The 0MQ url used for registration. This sets transport, ip, and port
-        in one variable. For example: url='tcp://127.0.0.1:12345' or
-        url='epgm://*:90210'""") # url takes precedence over ip,regport,transport
+        in one variable. For example: url='tcp://%s:12345' or
+        url='epgm://*:90210'"""
+                  % LOCALHOST) # url takes precedence over ip,regport,transport
     transport = Unicode('tcp', config=True,
         help="""The 0MQ transport for communications.  This will likely be
         the default of 'tcp', but other values include 'ipc', 'epgm', 'inproc'.""")
-    ip = Unicode('127.0.0.1', config=True,
+    ip = Unicode(LOCALHOST, config=True,
         help="""The IP address for registration.  This is generally either
         '127.0.0.1' for loopback only or '*' for all interfaces.
-        [default: '127.0.0.1']""")
+        [default: '%s']""" % LOCALHOST)
     regport = Integer(config=True,
         help="""The port on which the Hub listens for registration.""")
     def _regport_default(self):