|
|
#!/usr/bin/env python
|
|
|
# encoding: utf-8
|
|
|
"""
|
|
|
Foolscap related utilities.
|
|
|
"""
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Copyright (C) 2008-2009 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.
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Imports
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
from __future__ import with_statement
|
|
|
|
|
|
import os
|
|
|
import tempfile
|
|
|
|
|
|
from twisted.internet import reactor, defer
|
|
|
from twisted.python import log
|
|
|
|
|
|
import foolscap
|
|
|
try:
|
|
|
from foolscap.api import Tub, UnauthenticatedTub
|
|
|
except ImportError:
|
|
|
from foolscap import Tub, UnauthenticatedTub
|
|
|
|
|
|
from IPython.config.loader import Config
|
|
|
from IPython.kernel.configobjfactory import AdaptedConfiguredObjectFactory
|
|
|
from IPython.kernel.error import SecurityError
|
|
|
|
|
|
from IPython.utils.importstring import import_item
|
|
|
from IPython.utils.path import expand_path
|
|
|
from IPython.utils.traitlets import Int, Str, Bool, Instance
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Code
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
# We do this so if a user doesn't have OpenSSL installed, it will try to use
|
|
|
# an UnauthenticatedTub. But, they will still run into problems if they
|
|
|
# try to use encrypted furls.
|
|
|
try:
|
|
|
import OpenSSL
|
|
|
except:
|
|
|
Tub = UnauthenticatedTub
|
|
|
have_crypto = False
|
|
|
else:
|
|
|
have_crypto = True
|
|
|
|
|
|
|
|
|
class FURLError(Exception):
|
|
|
pass
|
|
|
|
|
|
|
|
|
def check_furl_file_security(furl_file, secure):
|
|
|
"""Remove the old furl_file if changing security modes."""
|
|
|
furl_file = expand_path(furl_file)
|
|
|
if os.path.isfile(furl_file):
|
|
|
with open(furl_file, 'r') as f:
|
|
|
oldfurl = f.read().strip()
|
|
|
if (oldfurl.startswith('pb://') and not secure) or (oldfurl.startswith('pbu://') and secure):
|
|
|
os.remove(furl_file)
|
|
|
|
|
|
|
|
|
def is_secure(furl):
|
|
|
"""Is the given FURL secure or not."""
|
|
|
if is_valid_furl(furl):
|
|
|
if furl.startswith("pb://"):
|
|
|
return True
|
|
|
elif furl.startswith("pbu://"):
|
|
|
return False
|
|
|
else:
|
|
|
raise FURLError("invalid FURL: %s" % furl)
|
|
|
|
|
|
|
|
|
def is_valid_furl(furl):
|
|
|
"""Is the str a valid FURL or not."""
|
|
|
if isinstance(furl, str):
|
|
|
if furl.startswith("pb://") or furl.startswith("pbu://"):
|
|
|
return True
|
|
|
else:
|
|
|
return False
|
|
|
else:
|
|
|
return False
|
|
|
|
|
|
|
|
|
def is_valid_furl_file(furl_or_file):
|
|
|
"""See if furl_or_file exists and contains a valid FURL.
|
|
|
|
|
|
This doesn't try to read the contents because often we have to validate
|
|
|
FURL files that are created, but don't yet have a FURL written to them.
|
|
|
"""
|
|
|
if isinstance(furl_or_file, (str, unicode)):
|
|
|
path, furl_filename = os.path.split(furl_or_file)
|
|
|
if os.path.isdir(path) and furl_filename.endswith('.furl'):
|
|
|
return True
|
|
|
return False
|
|
|
|
|
|
|
|
|
def find_furl(furl_or_file):
|
|
|
"""Find, validate and return a FURL in a string or file.
|
|
|
|
|
|
This calls :func:`IPython.utils.path.expand_path` on the argument to
|
|
|
properly handle ``~`` and ``$`` variables in the path.
|
|
|
"""
|
|
|
if is_valid_furl(furl_or_file):
|
|
|
return furl_or_file
|
|
|
furl_or_file = expand_path(furl_or_file)
|
|
|
if is_valid_furl_file(furl_or_file):
|
|
|
with open(furl_or_file, 'r') as f:
|
|
|
furl = f.read().strip()
|
|
|
if is_valid_furl(furl):
|
|
|
return furl
|
|
|
raise FURLError("Not a valid FURL or FURL file: %r" % furl_or_file)
|
|
|
|
|
|
|
|
|
def is_valid_furl_or_file(furl_or_file):
|
|
|
"""Validate a FURL or a FURL file.
|
|
|
|
|
|
If ``furl_or_file`` looks like a file, we simply make sure its directory
|
|
|
exists and that it has a ``.furl`` file extension. We don't try to see
|
|
|
if the FURL file exists or to read its contents. This is useful for
|
|
|
cases where auto re-connection is being used.
|
|
|
"""
|
|
|
if is_valid_furl(furl_or_file) or is_valid_furl_file(furl_or_file):
|
|
|
return True
|
|
|
else:
|
|
|
return False
|
|
|
|
|
|
|
|
|
def validate_furl_or_file(furl_or_file):
|
|
|
"""Like :func:`is_valid_furl_or_file`, but raises an error."""
|
|
|
if not is_valid_furl_or_file(furl_or_file):
|
|
|
raise FURLError('Not a valid FURL or FURL file: %r' % furl_or_file)
|
|
|
|
|
|
|
|
|
def get_temp_furlfile(filename):
|
|
|
"""Return a temporary FURL file."""
|
|
|
return tempfile.mktemp(dir=os.path.dirname(filename),
|
|
|
prefix=os.path.basename(filename))
|
|
|
|
|
|
|
|
|
def make_tub(ip, port, secure, cert_file):
|
|
|
"""Create a listening tub given an ip, port, and cert_file location.
|
|
|
|
|
|
Parameters
|
|
|
----------
|
|
|
ip : str
|
|
|
The ip address or hostname that the tub should listen on.
|
|
|
Empty means all interfaces.
|
|
|
port : int
|
|
|
The port that the tub should listen on. A value of 0 means
|
|
|
pick a random port
|
|
|
secure: bool
|
|
|
Will the connection be secure (in the Foolscap sense).
|
|
|
cert_file: str
|
|
|
A filename of a file to be used for theSSL certificate.
|
|
|
|
|
|
Returns
|
|
|
-------
|
|
|
A tub, listener tuple.
|
|
|
"""
|
|
|
if secure:
|
|
|
if have_crypto:
|
|
|
tub = Tub(certFile=cert_file)
|
|
|
else:
|
|
|
raise SecurityError("OpenSSL/pyOpenSSL is not available, so we "
|
|
|
"can't run in secure mode. Try running without "
|
|
|
"security using 'ipcontroller -xy'.")
|
|
|
else:
|
|
|
tub = UnauthenticatedTub()
|
|
|
|
|
|
# Set the strport based on the ip and port and start listening
|
|
|
if ip == '':
|
|
|
strport = "tcp:%i" % port
|
|
|
else:
|
|
|
strport = "tcp:%i:interface=%s" % (port, ip)
|
|
|
log.msg("Starting listener with [secure=%r] on: %s" % (secure, strport))
|
|
|
listener = tub.listenOn(strport)
|
|
|
|
|
|
return tub, listener
|
|
|
|
|
|
|
|
|
class FCServiceFactory(AdaptedConfiguredObjectFactory):
|
|
|
"""This class creates a tub with various services running in it.
|
|
|
|
|
|
The basic idea is that :meth:`create` returns a running :class:`Tub`
|
|
|
instance that has a number of Foolscap references registered in it.
|
|
|
This class is a subclass of :class:`IPython.core.component.Component`
|
|
|
so the IPython configuration and component system are used.
|
|
|
|
|
|
Attributes
|
|
|
----------
|
|
|
interfaces : Config
|
|
|
A Config instance whose values are sub-Config objects having two
|
|
|
keys: furl_file and interface_chain.
|
|
|
|
|
|
The other attributes are the standard ones for Foolscap.
|
|
|
"""
|
|
|
|
|
|
ip = Str('', config=True)
|
|
|
port = Int(0, config=True)
|
|
|
secure = Bool(True, config=True)
|
|
|
cert_file = Str('', config=True)
|
|
|
location = Str('', config=True)
|
|
|
reuse_furls = Bool(False, config=True)
|
|
|
interfaces = Instance(klass=Config, kw={}, allow_none=False, config=True)
|
|
|
|
|
|
def __init__(self, config, adaptee):
|
|
|
super(FCServiceFactory, self).__init__(config, adaptee)
|
|
|
self._check_reuse_furls()
|
|
|
|
|
|
def _ip_changed(self, name, old, new):
|
|
|
if new == 'localhost' or new == '127.0.0.1':
|
|
|
self.location = '127.0.0.1'
|
|
|
|
|
|
def _check_reuse_furls(self):
|
|
|
furl_files = [i.furl_file for i in self.interfaces.values()]
|
|
|
for ff in furl_files:
|
|
|
fullfile = self._get_security_file(ff)
|
|
|
if self.reuse_furls:
|
|
|
if self.port==0:
|
|
|
raise FURLError("You are trying to reuse the FURL file "
|
|
|
"for this connection, but the port for this connection "
|
|
|
"is set to 0 (autoselect). To reuse the FURL file "
|
|
|
"you need to specify specific port to listen on."
|
|
|
)
|
|
|
else:
|
|
|
log.msg("Reusing FURL file: %s" % fullfile)
|
|
|
else:
|
|
|
if os.path.isfile(fullfile):
|
|
|
log.msg("Removing old FURL file: %s" % fullfile)
|
|
|
os.remove(fullfile)
|
|
|
|
|
|
def _get_security_file(self, filename):
|
|
|
return os.path.join(self.config.Global.security_dir, filename)
|
|
|
|
|
|
def create(self):
|
|
|
"""Create and return the Foolscap tub with everything running."""
|
|
|
|
|
|
self.tub, self.listener = make_tub(
|
|
|
self.ip, self.port, self.secure,
|
|
|
self._get_security_file(self.cert_file)
|
|
|
)
|
|
|
# log.msg("Interfaces to register [%r]: %r" % \
|
|
|
# (self.__class__, self.interfaces))
|
|
|
if not self.secure:
|
|
|
log.msg("WARNING: running with no security: %s" % \
|
|
|
self.__class__.__name__)
|
|
|
reactor.callWhenRunning(self.set_location_and_register)
|
|
|
return self.tub
|
|
|
|
|
|
def set_location_and_register(self):
|
|
|
"""Set the location for the tub and return a deferred."""
|
|
|
|
|
|
if self.location == '':
|
|
|
d = self.tub.setLocationAutomatically()
|
|
|
else:
|
|
|
d = defer.maybeDeferred(self.tub.setLocation,
|
|
|
"%s:%i" % (self.location, self.listener.getPortnum()))
|
|
|
self.adapt_to_interfaces(d)
|
|
|
|
|
|
def adapt_to_interfaces(self, d):
|
|
|
"""Run through the interfaces, adapt and register."""
|
|
|
|
|
|
for ifname, ifconfig in self.interfaces.iteritems():
|
|
|
ff = self._get_security_file(ifconfig.furl_file)
|
|
|
log.msg("Adapting [%s] to interface: %s" % \
|
|
|
(self.adaptee.__class__.__name__, ifname))
|
|
|
log.msg("Saving FURL for interface [%s] to file: %s" % (ifname, ff))
|
|
|
check_furl_file_security(ff, self.secure)
|
|
|
adaptee = self.adaptee
|
|
|
for i in ifconfig.interface_chain:
|
|
|
adaptee = import_item(i)(adaptee)
|
|
|
d.addCallback(self.register, adaptee, furl_file=ff)
|
|
|
|
|
|
def register(self, empty, ref, furl_file):
|
|
|
"""Register the reference with the FURL file.
|
|
|
|
|
|
The FURL file is created and then moved to make sure that when the
|
|
|
file appears, the buffer has been flushed and the file closed. This
|
|
|
is not done if we are re-using FURLS however.
|
|
|
"""
|
|
|
if self.reuse_furls:
|
|
|
self.tub.registerReference(ref, furlFile=furl_file)
|
|
|
else:
|
|
|
temp_furl_file = get_temp_furlfile(furl_file)
|
|
|
self.tub.registerReference(ref, furlFile=temp_furl_file)
|
|
|
os.rename(temp_furl_file, furl_file)
|
|
|
|
|
|
|
