Merge pull request #5760 from ivanov/connection-mixin

DRY out load_connection_file implementations

IPython/consoleapp.py

@@ -3,18 +3,9 b''
 This is not a complete console app, as subprocess will not be able to receive
 input, there is no real readline support, among other limitations. This is a
 refactoring of what used to be the IPython/qt/console/qtconsoleapp.py
-
-Authors:
-
-* Evan Patterson
-* Min RK
-* Erik Tollerud
-* Fernando Perez
-* Bussonnier Matthias
-* Thomas Kluyver
-* Paul Ivanov
-
 """
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 #-----------------------------------------------------------------------------
 # Imports
@@ -22,7 +13,6 b' Authors:'
 
 # stdlib imports
 import atexit
-import json
 import os
 import signal
 import sys
@@ -37,9 +27,8 b' from IPython.kernel import KernelManager'
 from IPython.kernel import tunnel_to_kernel, find_connection_file, swallow_argv
 from IPython.kernel.kernelspec import NoSuchKernel
 from IPython.utils.path import filefind
-from IPython.utils.py3compat import str_to_bytes
 from IPython.utils.traitlets import (
-    Dict, List, Unicode, CUnicode, Int, CBool, Any
+    Dict, List, Unicode, CUnicode, CBool, Any
 )
 from IPython.kernel.zmq.kernelapp import (
     kernel_flags,
@@ -155,21 +144,6 b' class IPythonConsoleApp(ConnectionFileMixin):'
     sshkey = Unicode('', config=True,
         help="""Path to the ssh key to use for logging in to the ssh server.""")
     
-    hb_port = Int(0, config=True,
-        help="set the heartbeat port [default: random]")
-    shell_port = Int(0, config=True,
-        help="set the shell (ROUTER) port [default: random]")
-    iopub_port = Int(0, config=True,
-        help="set the iopub (PUB) port [default: random]")
-    stdin_port = Int(0, config=True,
-        help="set the stdin (DEALER) port [default: random]")
-    connection_file = Unicode('', config=True,
-        help="""JSON file in which to store connection info [default: kernel-<pid>.json]
-
-        This file will contain the IP, ports, and authentication key needed to connect
-        clients to this kernel. By default, this file will be created in the security-dir
-        of the current profile, but can be specified by absolute path.
-        """)
     def _connection_file_default(self):
         return 'kernel-%i.json' % os.getpid()
 
@@ -230,6 +204,11 b' class IPythonConsoleApp(ConnectionFileMixin):'
                 else:
                     cf = self.connection_file
                 self.connection_file = cf
+        try:
+            self.connection_file = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
+        except IOError:
+            self.log.debug("Connection File not found: %s", self.connection_file)
+            return
         
         # should load_connection_file only be used for existing?
         # as it is now, this allows reusing ports if an existing
@@ -240,31 +219,6 b' class IPythonConsoleApp(ConnectionFileMixin):'
             self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
             self.exit(1)
     
-    def load_connection_file(self):
-        """load ip/port/hmac config from JSON connection file"""
-        # this is identical to IPKernelApp.load_connection_file
-        # perhaps it can be centralized somewhere?
-        try:
-            fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
-        except IOError:
-            self.log.debug("Connection File not found: %s", self.connection_file)
-            return
-        self.log.debug(u"Loading connection file %s", fname)
-        with open(fname) as f:
-            cfg = json.load(f)
-        self.transport = cfg.get('transport', 'tcp')
-        self.ip = cfg.get('ip', localhost())
-        
-        for channel in ('hb', 'shell', 'iopub', 'stdin', 'control'):
-            name = channel + '_port'
-            if getattr(self, name) == 0 and name in cfg:
-                # not overridden by config or cl_args
-                setattr(self, name, cfg[name])
-        if 'key' in cfg:
-            self.config.Session.key = str_to_bytes(cfg['key'])
-        if 'signature_scheme' in cfg:
-            self.config.Session.signature_scheme = cfg['signature_scheme']
-    
     def init_ssh(self):
         """set up ssh tunnels, if needed."""
         if not self.existing or (not self.sshserver and not self.sshkey):

IPython/kernel/connect.py

@@ -1,17 +1,11 b''
 """Utilities for connecting to kernels
 
-Authors:
-
-* Min Ragan-Kelley
-
+Notable contents: 
+- ConnectionFileMixin class
+    encapsulates the logic related to writing and reading connections files.
 """
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2013  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 #-----------------------------------------------------------------------------
 # Imports
@@ -392,7 +386,13 b' class ConnectionFileMixin(Configurable):'
     """Mixin for configurable classes that work with connection files"""
 
     # The addresses for the communication channels
-    connection_file = Unicode('')
+    connection_file = Unicode('', config=True, 
+    help="""JSON file in which to store connection info [default: kernel-<pid>.json]
+    
+    This file will contain the IP, ports, and authentication key needed to connect
+    clients to this kernel. By default, this file will be created in the security dir
+    of the current profile, but can be specified by absolute path.
+    """)
     _connection_file_written = Bool(False)
 
     transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
@@ -419,11 +419,16 b' class ConnectionFileMixin(Configurable):'
 
     # protected traits
 
-    shell_port = Integer(0)
-    iopub_port = Integer(0)
-    stdin_port = Integer(0)
-    control_port = Integer(0)
-    hb_port = Integer(0)
+    hb_port = Integer(0, config=True,
+            help="set the heartbeat port [default: random]")
+    shell_port = Integer(0, config=True,
+            help="set the shell (ROUTER) port [default: random]")
+    iopub_port = Integer(0, config=True,
+            help="set the iopub (PUB) port [default: random]")
+    stdin_port = Integer(0, config=True,
+            help="set the stdin (ROUTER) port [default: random]")
+    control_port = Integer(0, config=True,
+            help="set the control (ROUTER) port [default: random]")
 
     @property
     def ports(self):
@@ -491,18 +496,20 b' class ConnectionFileMixin(Configurable):'
 
     def load_connection_file(self):
         """Load connection info from JSON dict in self.connection_file."""
+        self.log.debug(u"Loading connection file %s", self.connection_file)
         with open(self.connection_file) as f:
-            cfg = json.loads(f.read())
-
-        self.transport = cfg.get('transport', 'tcp')
-        self.ip = cfg['ip']
+            cfg = json.load(f)
+        self.transport = cfg.get('transport', self.transport)
+        self.ip = cfg.get('ip', self._ip_default())
+        
         for name in port_names:
-            setattr(self, name, cfg[name])
+            if getattr(self, name) == 0 and name in cfg:
+                # not overridden by config or cl_args
+                setattr(self, name, cfg[name])
         if 'key' in cfg:
-            self.session.key = str_to_bytes(cfg['key'])
-        if cfg.get('signature_scheme'):
-            self.session.signature_scheme = cfg['signature_scheme']
-
+            self.config.Session.key = str_to_bytes(cfg['key'])
+        if 'signature_scheme' in cfg:
+            self.config.Session.signature_scheme = cfg['signature_scheme']
     #--------------------------------------------------------------------------
     # Creating connected sockets
     #--------------------------------------------------------------------------

IPython/kernel/zmq/kernelapp.py

@@ -1,15 +1,7 b''
 """An Application for launching a kernel
-
-Authors
--------
-* MinRK
 """
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING.txt, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 #-----------------------------------------------------------------------------
 # Imports
@@ -19,7 +11,6 b' from __future__ import print_function'
 
 # Standard library imports
 import atexit
-import json
 import os
 import sys
 import signal
@@ -39,15 +30,13 b' from IPython.core.shellapp import ('
     InteractiveShellApp, shell_flags, shell_aliases
 )
 from IPython.utils import io
-from IPython.utils.localinterfaces import localhost
 from IPython.utils.path import filefind
-from IPython.utils.py3compat import str_to_bytes
 from IPython.utils.traitlets import (
-    Any, Instance, Dict, Unicode, Integer, Bool, CaselessStrEnum,
-    DottedObjectName,
+    Any, Instance, Dict, Unicode, Integer, Bool, DottedObjectName,
 )
 from IPython.utils.importstring import import_item
 from IPython.kernel import write_connection_file
+from IPython.kernel.connect import ConnectionFileMixin
 
 # local imports
 from .heartbeat import Heartbeat
@@ -113,7 +102,8 b' To read more about this, see https://github.com/ipython/ipython/issues/2049'
 # Application class for starting an IPython Kernel
 #-----------------------------------------------------------------------------
 
-class IPKernelApp(BaseIPythonApplication, InteractiveShellApp):
+class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,
+        ConnectionFileMixin):
     name='ipkernel'
     aliases = Dict(kernel_aliases)
     flags = Dict(kernel_flags)
@@ -146,30 +136,7 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp):'
         self.config_file_specified.remove(self.config_file_name)
         
     # connection info:
-    transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
-    ip = Unicode(config=True,
-        help="Set the IP or interface on which the kernel will listen.")
-    def _ip_default(self):
-        if self.transport == 'ipc':
-            if self.connection_file:
-                return os.path.splitext(self.abs_connection_file)[0] + '-ipc'
-            else:
-                return 'kernel-ipc'
-        else:
-            return localhost()
-    
-    hb_port = Integer(0, config=True, help="set the heartbeat port [default: random]")
-    shell_port = Integer(0, config=True, help="set the shell (ROUTER) port [default: random]")
-    iopub_port = Integer(0, config=True, help="set the iopub (PUB) port [default: random]")
-    stdin_port = Integer(0, config=True, help="set the stdin (ROUTER) port [default: random]")
-    control_port = Integer(0, config=True, help="set the control (ROUTER) port [default: random]")
-    connection_file = Unicode('', config=True, 
-    help="""JSON file in which to store connection info [default: kernel-<pid>.json]
     
-    This file will contain the IP, ports, and authentication key needed to connect
-    clients to this kernel. By default, this file will be created in the security dir
-    of the current profile, but can be specified by absolute path.
-    """)
     @property
     def abs_connection_file(self):
         if os.path.basename(self.connection_file) == self.connection_file:
@@ -227,31 +194,6 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp):'
             s.bind("ipc://%s" % path)
         return port
 
-    def load_connection_file(self):
-        """load ip/port/hmac config from JSON connection file"""
-        try:
-            fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
-        except IOError:
-            self.log.debug("Connection file not found: %s", self.connection_file)
-            # This means I own it, so I will clean it up:
-            atexit.register(self.cleanup_connection_file)
-            return
-        self.log.debug(u"Loading connection file %s", fname)
-        with open(fname) as f:
-            s = f.read()
-        cfg = json.loads(s)
-        self.transport = cfg.get('transport', self.transport)
-        if self.ip == self._ip_default() and 'ip' in cfg:
-            # not overridden by config or cl_args
-            self.ip = cfg['ip']
-        for channel in ('hb', 'shell', 'iopub', 'stdin', 'control'):
-            name = channel + '_port'
-            if getattr(self, name) == 0 and name in cfg:
-                # not overridden by config or cl_args
-                setattr(self, name, cfg[name])
-        if 'key' in cfg:
-            self.config.Session.key = str_to_bytes(cfg['key'])
-    
     def write_connection_file(self):
         """write connection info to JSON file"""
         cf = self.abs_connection_file
@@ -270,21 +212,17 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp):'
         
         self.cleanup_ipc_files()
     
-    def cleanup_ipc_files(self):
-        """cleanup ipc files if we wrote them"""
-        if self.transport != 'ipc':
-            return
-        for port in (self.shell_port, self.iopub_port, self.stdin_port, self.hb_port, self.control_port):
-            ipcfile = "%s-%i" % (self.ip, port)
-            try:
-                os.remove(ipcfile)
-            except (IOError, OSError):
-                pass
-    
     def init_connection_file(self):
         if not self.connection_file:
             self.connection_file = "kernel-%s.json"%os.getpid()
         try:
+            self.connection_file = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
+        except IOError:
+            self.log.debug("Connection file not found: %s", self.connection_file)
+            # This means I own it, so I will clean it up:
+            atexit.register(self.cleanup_connection_file)
+            return
+        try:
             self.load_connection_file()
         except Exception:
             self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)