#!/usr/bin/env python
# encoding: utf-8
"""The IPython controller."""
__docformat__ = "restructuredtext en"
#-------------------------------------------------------------------------------
# Copyright (C) 2008 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
#-------------------------------------------------------------------------------
# Python looks for an empty string at the beginning of sys.path to enable
# importing from the cwd.
import sys
sys.path.insert(0, '')
import sys, time, os
from optparse import OptionParser
from twisted.application import internet, service
from twisted.internet import reactor, error, defer
from twisted.python import log
from IPython.kernel.fcutil import Tub, UnauthenticatedTub, have_crypto
# from IPython.tools import growl
# growl.start("IPython1 Controller")
from IPython.kernel.error import SecurityError
from IPython.kernel import controllerservice
from IPython.kernel.fcutil import check_furl_file_security
from IPython.kernel.config import config_manager as kernel_config_manager
from IPython.config.cutils import import_item
#-------------------------------------------------------------------------------
# Code
#-------------------------------------------------------------------------------
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 that the tub should listen on. Empty means all
port : int
The port that the tub should listen on. A value of 0 means
pick a random port
secure: boolean
Will the connection be secure (in the foolscap sense)
cert_file:
A filename of a file to be used for theSSL certificate
"""
if secure:
if have_crypto:
tub = Tub(certFile=cert_file)
else:
raise SecurityError("OpenSSL is not available, so we can't run in secure mode, aborting")
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)
listener = tub.listenOn(strport)
return tub, listener
def make_client_service(controller_service, config):
"""
Create a service that will listen for clients.
This service is simply a `foolscap.Tub` instance that has a set of Referenceables
registered with it.
"""
# Now create the foolscap tub
ip = config['controller']['client_tub']['ip']
port = config['controller']['client_tub'].as_int('port')
location = config['controller']['client_tub']['location']
secure = config['controller']['client_tub']['secure']
cert_file = config['controller']['client_tub']['cert_file']
client_tub, client_listener = make_tub(ip, port, secure, cert_file)
# Set the location in the trivial case of localhost
if ip == 'localhost' or ip == '127.0.0.1':
location = "127.0.0.1"
if not secure:
log.msg("WARNING: you are running the controller with no client security")
def set_location_and_register():
"""Set the location for the tub and return a deferred."""
def register(empty, ref, furl_file):
client_tub.registerReference(ref, furlFile=furl_file)
if location == '':
d = client_tub.setLocationAutomatically()
else:
d = defer.maybeDeferred(client_tub.setLocation, "%s:%i" % (location, client_listener.getPortnum()))
for ciname, ci in config['controller']['controller_interfaces'].iteritems():
log.msg("Adapting Controller to interface: %s" % ciname)
furl_file = ci['furl_file']
log.msg("Saving furl for interface [%s] to file: %s" % (ciname, furl_file))
check_furl_file_security(furl_file, secure)
adapted_controller = import_item(ci['controller_interface'])(controller_service)
d.addCallback(register, import_item(ci['fc_interface'])(adapted_controller),
furl_file=ci['furl_file'])
reactor.callWhenRunning(set_location_and_register)
return client_tub
def make_engine_service(controller_service, config):
"""
Create a service that will listen for engines.
This service is simply a `foolscap.Tub` instance that has a set of Referenceables
registered with it.
"""
# Now create the foolscap tub
ip = config['controller']['engine_tub']['ip']
port = config['controller']['engine_tub'].as_int('port')
location = config['controller']['engine_tub']['location']
secure = config['controller']['engine_tub']['secure']
cert_file = config['controller']['engine_tub']['cert_file']
engine_tub, engine_listener = make_tub(ip, port, secure, cert_file)
# Set the location in the trivial case of localhost
if ip == 'localhost' or ip == '127.0.0.1':
location = "127.0.0.1"
if not secure:
log.msg("WARNING: you are running the controller with no engine security")
def set_location_and_register():
"""Set the location for the tub and return a deferred."""
def register(empty, ref, furl_file):
engine_tub.registerReference(ref, furlFile=furl_file)
if location == '':
d = engine_tub.setLocationAutomatically()
else:
d = defer.maybeDeferred(engine_tub.setLocation, "%s:%i" % (location, engine_listener.getPortnum()))
furl_file = config['controller']['engine_furl_file']
engine_fc_interface = import_item(config['controller']['engine_fc_interface'])
log.msg("Saving furl for the engine to file: %s" % furl_file)
check_furl_file_security(furl_file, secure)
fc_controller = engine_fc_interface(controller_service)
d.addCallback(register, fc_controller, furl_file=furl_file)
reactor.callWhenRunning(set_location_and_register)
return engine_tub
def start_controller():
"""
Start the controller by creating the service hierarchy and starting the reactor.
This method does the following:
* It starts the controller logging
* In execute an import statement for the controller
* It creates 2 `foolscap.Tub` instances for the client and the engines
and registers `foolscap.Referenceables` with the tubs to expose the
controller to engines and clients.
"""
config = kernel_config_manager.get_config_obj()
# Start logging
logfile = config['controller']['logfile']
if logfile:
logfile = logfile + str(os.getpid()) + '.log'
try:
openLogFile = open(logfile, 'w')
except:
openLogFile = sys.stdout
else:
openLogFile = sys.stdout
log.startLogging(openLogFile)
# Execute any user defined import statements
cis = config['controller']['import_statement']
if cis:
try:
exec cis in globals(), locals()
except:
log.msg("Error running import_statement: %s" % cis)
# Create the service hierarchy
main_service = service.MultiService()
# The controller service
controller_service = controllerservice.ControllerService()
controller_service.setServiceParent(main_service)
# The client tub and all its refereceables
client_service = make_client_service(controller_service, config)
client_service.setServiceParent(main_service)
# The engine tub
engine_service = make_engine_service(controller_service, config)
engine_service.setServiceParent(main_service)
# Start the controller service and set things running
main_service.startService()
reactor.run()
def init_config():
"""
Initialize the configuration using default and command line options.
"""
parser = OptionParser()
# Client related options
parser.add_option(
"--client-ip",
type="string",
dest="client_ip",
help="the IP address or hostname the controller will listen on for client connections"
)
parser.add_option(
"--client-port",
type="int",
dest="client_port",
help="the port the controller will listen on for client connections"
)
parser.add_option(
'--client-location',
type="string",
dest="client_location",
help="hostname or ip for clients to connect to"
)
parser.add_option(
"-x",
action="store_false",
dest="client_secure",
help="turn off all client security"
)
parser.add_option(
'--client-cert-file',
type="string",
dest="client_cert_file",
help="file to store the client SSL certificate"
)
parser.add_option(
'--task-furl-file',
type="string",
dest="task_furl_file",
help="file to store the FURL for task clients to connect with"
)
parser.add_option(
'--multiengine-furl-file',
type="string",
dest="multiengine_furl_file",
help="file to store the FURL for multiengine clients to connect with"
)
# Engine related options
parser.add_option(
"--engine-ip",
type="string",
dest="engine_ip",
help="the IP address or hostname the controller will listen on for engine connections"
)
parser.add_option(
"--engine-port",
type="int",
dest="engine_port",
help="the port the controller will listen on for engine connections"
)
parser.add_option(
'--engine-location',
type="string",
dest="engine_location",
help="hostname or ip for engines to connect to"
)
parser.add_option(
"-y",
action="store_false",
dest="engine_secure",
help="turn off all engine security"
)
parser.add_option(
'--engine-cert-file',
type="string",
dest="engine_cert_file",
help="file to store the engine SSL certificate"
)
parser.add_option(
'--engine-furl-file',
type="string",
dest="engine_furl_file",
help="file to store the FURL for engines to connect with"
)
parser.add_option(
"-l", "--logfile",
type="string",
dest="logfile",
help="log file name (default is stdout)"
)
parser.add_option(
"--ipythondir",
type="string",
dest="ipythondir",
help="look for config files and profiles in this directory"
)
(options, args) = parser.parse_args()
kernel_config_manager.update_config_obj_from_default_file(options.ipythondir)
config = kernel_config_manager.get_config_obj()
# Update with command line options
if options.client_ip is not None:
config['controller']['client_tub']['ip'] = options.client_ip
if options.client_port is not None:
config['controller']['client_tub']['port'] = options.client_port
if options.client_location is not None:
config['controller']['client_tub']['location'] = options.client_location
if options.client_secure is not None:
config['controller']['client_tub']['secure'] = options.client_secure
if options.client_cert_file is not None:
config['controller']['client_tub']['cert_file'] = options.client_cert_file
if options.task_furl_file is not None:
config['controller']['controller_interfaces']['task']['furl_file'] = options.task_furl_file
if options.multiengine_furl_file is not None:
config['controller']['controller_interfaces']['multiengine']['furl_file'] = options.multiengine_furl_file
if options.engine_ip is not None:
config['controller']['engine_tub']['ip'] = options.engine_ip
if options.engine_port is not None:
config['controller']['engine_tub']['port'] = options.engine_port
if options.engine_location is not None:
config['controller']['engine_tub']['location'] = options.engine_location
if options.engine_secure is not None:
config['controller']['engine_tub']['secure'] = options.engine_secure
if options.engine_cert_file is not None:
config['controller']['engine_tub']['cert_file'] = options.engine_cert_file
if options.engine_furl_file is not None:
config['controller']['engine_furl_file'] = options.engine_furl_file
if options.logfile is not None:
config['controller']['logfile'] = options.logfile
kernel_config_manager.update_config_obj(config)
def main():
"""
After creating the configuration information, start the controller.
"""
init_config()
start_controller()
if __name__ == "__main__":
main()