From 05e1b6cea138bb2d9775e16d33995e2feac60e1d 2009-10-18 19:10:34 From: Brian Granger Date: 2009-10-18 19:10:34 Subject: [PATCH] Removing old ipcontroller.py --- diff --git a/IPython/kernel/scripts/ipcontroller.py b/IPython/kernel/scripts/ipcontroller.py deleted file mode 100755 index 0958be1..0000000 --- a/IPython/kernel/scripts/ipcontroller.py +++ /dev/null @@ -1,416 +0,0 @@ -#!/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.utils 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.core.oldusersetup import user_setup -from IPython.utils.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.utils.importstring 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()