#!/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, '') from optparse import OptionParser import os import time import tempfile 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 # Create various ipython directories if they don't exist. # This must be done before IPython.kernel.config is imported. from IPython.iplib import user_setup from IPython.genutils import get_ipython_dir, get_log_dir, get_security_dir if os.name == 'posix': rc_suffix = '' else: rc_suffix = '.ini' user_setup(get_ipython_dir(), rc_suffix, mode='install', interactive=False) get_log_dir() get_security_dir() from IPython.kernel.config import config_manager as kernel_config_manager from IPython.config.cutils import import_item #------------------------------------------------------------------------------- # Code #------------------------------------------------------------------------------- def get_temp_furlfile(filename): 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 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/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) 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): # We create and then move to make sure that when the file # appears to other processes, the buffer has the flushed # and the file has been closed temp_furl_file = get_temp_furlfile(furl_file) client_tub.registerReference(ref, furlFile=temp_furl_file) os.rename(temp_furl_file, 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): # We create and then move to make sure that when the file # appears to other processes, the buffer has the flushed # and the file has been closed temp_furl_file = get_temp_furlfile(furl_file) engine_tub.registerReference(ref, furlFile=temp_furl_file) os.rename(temp_furl_file, 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) # Delete old furl files unless the reuse_furls is set reuse = config['controller']['reuse_furls'] if not reuse: paths = (config['controller']['engine_furl_file'], config['controller']['controller_interfaces']['task']['furl_file'], config['controller']['controller_interfaces']['multiengine']['furl_file'] ) for p in paths: if os.path.isfile(p): os.remove(p) # 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("""ipcontroller [options] Start an IPython controller. Use the IPYTHONDIR environment variable to change your IPython directory from the default of .ipython or _ipython. The log and security subdirectories of your IPython directory will be used by this script for log files and security files.""") # 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( "-r", action="store_true", dest="reuse_furls", help="try to reuse all furl files" ) (options, args) = parser.parse_args() 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.reuse_furls is not None: config['controller']['reuse_furls'] = options.reuse_furls 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()