Public Member Functions
def	__new__
def	__call__
def	__init__
def	start_engine
def	start_cluster
def	stop_engine
def	stop_node
def	stop_cluster
def	wash_logs
def	reset_cluster
def	get_casalogs
def	read_casalogs
def	pad_task_id
def	one_to_n
def	n_to_n
def	split_int
def	split_channel
def	pgc
def	parallel_go_commands
def	pgk
def	make_command
def	parallel_go_keywords
def	hello
def	get_ids
def	get_nodes
def	get_engines
def	get_stdout
def	pdo
def	odo
def	execute
def	queue_status
def	clear_queue
def	get_timer
def	set_timer
def	del_timer
def	get_properties
def	set_properties
def	keys
def	push
def	pull
def	get_result
def	activate
def	parallel_go_task
def	pgt
def	check_job
def	howto
def	use_often
def	example
Private Member Functions
def	_ip
def	_cp
def	_do
def	__start_controller
def	__write_start_engine
def	__write_start_controller
def	__write_stop_node
def	__write_stop_controller
def	__write_bashrc
def	__stop_controller
def	__init_nodes
def	__update_cluster_info
def	__set_cwds
Private Attributes
	__engines
	__ipythondir
	__homepath
	__new_engs
Static Private Attributes
	_instance
	__client
	jagonzal (CAS-4292): Code below is deprecated ###
	__controller
	__timestamp
list	__engines
list	__ipythondir
list	__homepath
string	__start_controller_file
string	__start_engine_file
string	__stop_node_file
string	__stop_engine_file
string	__stop_controller_file
string	__cluster_rc_file
tuple	__user
string	__prefix
	__init_now
list	__new_engs

Detailed Description

Definition at line 36 of file parallel_go.py.

Constructor & Destructor Documentation

def parallel_go.cluster.__init__ ( self )

Initialize a Cluster.

A Cluster enables parallel and distributed execution of CASA tasks and tools on a set of networked computers. A culster consists of one controller and one or more engines. Each engine is an independent Python instance that takes Python commands over a network connection. The controller provides an interface for working with a set of engines. A user uses casapy console to command the controller. A password-less ssh access to the computers that hosts engines is required for the communication between controller and engines.

Definition at line 72 of file parallel_go.py.

References parallel_go.cluster.__client, parallel_go.cluster.__controller, and parallel_go.cluster.__timestamp.

Member Function Documentation

def parallel_go.cluster.__call__ ( self )

Definition at line 67 of file parallel_go.py.

def parallel_go.cluster.__init_nodes	(	self,
		i
	)	`[private]`

(Internal) Initialize engines

@param i The list of the engine ids
An engine is a Python interpreter. To make an engine capable of running CASA tasks and tools, we must setup the environment and import necessary modules. This function effectively make every engine a running CASA instance (except that it is a non-interactive CASA running in Python, in contrast the casapy that is an interactive CASA running in IPython).

Definition at line 601 of file parallel_go.py.

Referenced by parallel_go.cluster.__update_cluster_info(), parallel_go.cluster.reset_cluster(), and parallel_go.cluster.start_cluster().

def parallel_go.cluster.__new__	(	cls,
		args,
		kwargs
	)

Definition at line 61 of file parallel_go.py.

def parallel_go.cluster.__set_cwds	(	self,
		clusterdir
	)	`[private]`

Set current working dir for all engines

Definition at line 1231 of file parallel_go.py.

def parallel_go.cluster.__start_controller ( self ) [private]

(Internal) Start the controller.

A user does not need to call this function directly. When a user runs either start_cluster or start_engine, it will check the existence of a valid controller. If the controller does not exist, this function will be called auto matically. All engines will connect to the valid controller.

Definition at line 236 of file parallel_go.py.

References parallel_go.cluster.__client, parallel_go.cluster.__controller, parallel_go.cluster.__ipythondir, parallel_go.cluster.__start_controller_file, parallel_go.cluster.__timestamp, parallel_go.cluster.__write_bashrc(), parallel_go.cluster.__write_start_controller(), parallel_go.cluster.__write_start_engine(), parallel_go.cluster.__write_stop_controller(), and parallel_go.cluster.__write_stop_node().

Referenced by parallel_go.cluster.start_cluster(), and parallel_go.cluster.start_engine().

def parallel_go.cluster.__stop_controller ( self ) [private]

(Internal) Stop the controller.

This is the last thing for quiting the cluster gracely.

Definition at line 462 of file parallel_go.py.

References parallel_go.cluster.__cluster_rc_file, parallel_go.cluster.__controller, parallel_go.cluster.__ipythondir, parallel_go.cluster.__prefix, parallel_go.cluster.__start_engine_file, parallel_go.cluster.__stop_controller_file, parallel_go.cluster.__stop_engine_file, parallel_go.cluster.__stop_node_file, parallel_go.cluster._cp(), and parallel_go.cluster._do().

Referenced by parallel_go.cluster.stop_cluster().

def parallel_go.cluster.__update_cluster_info	(	self,
		num_engine,
		work_dir = `None`,
		omp_num_nthreads = `1`
	)	`[private]`

(Internal) Construct the list of engines.

@param num_engine The number of new engines 
@param work_dir The initial working directory 
This function appends num_engine engines to the engine list and setup initial Python environment on them. Before further initialization, an engine can only run Python programs (it can not run CASA tasks or tools).

Definition at line 690 of file parallel_go.py.

References parallel_go.cluster.__client, parallel_go.cluster.__engines, parallel_go.cluster.__init_nodes(), parallel_go.cluster.__init_now, and parallel_go.cluster.__new_engs.

Referenced by parallel_go.cluster.start_engine(), parallel_go.cluster.stop_engine(), and parallel_go.cluster.stop_node().

def parallel_go.cluster.__write_bashrc ( self ) [private]

(Internal) Create file containning bash startup instructions for the engine host.

When the controller startup, the necessary environment information for running cluster is extracted from the user's current shell (that runs this casapy session) and written to a rc file. The created script will be stored in the user's $IPYTHONDIR. The start_cluster and start_engine will upload the rc file to the nodes and establish the engine environment.

Definition at line 353 of file parallel_go.py.

References parallel_go.cluster.__cluster_rc_file, and parallel_go.cluster.__ipythondir.

Referenced by parallel_go.cluster.__start_controller().

def parallel_go.cluster.__write_start_controller	(	self,
		timestamp
	)	`[private]`

Definition at line 306 of file parallel_go.py.

References parallel_go.cluster.__cluster_rc_file, parallel_go.cluster.__ipythondir, and parallel_go.cluster.__start_controller_file.

Referenced by parallel_go.cluster.__start_controller().

def parallel_go.cluster.__write_start_engine ( self ) [private]

(Internal) Create script for starting engines.

The created script will be stored in the user's $IPYTHONDIR. The start_cluster and start_engine will upload the script to the node and execute it in the proper shell.

Definition at line 289 of file parallel_go.py.

References parallel_go.cluster.__cluster_rc_file, parallel_go.cluster.__controller, parallel_go.cluster.__ipythondir, parallel_go.cluster.__prefix, parallel_go.cluster.__start_engine_file, and parallel_go.cluster.__timestamp.

Referenced by parallel_go.cluster.__start_controller().

def parallel_go.cluster.__write_stop_controller ( self ) [private]

(Internal) Create script for stoping the controller.

The created script will be stored in the user's $IPYTHONDIR. The stop_cluster will execute it in the proper shell.

Definition at line 341 of file parallel_go.py.

References parallel_go.cluster.__ipythondir, and parallel_go.cluster.__stop_controller_file.

Referenced by parallel_go.cluster.__start_controller().

def parallel_go.cluster.__write_stop_node ( self ) [private]

(Internal) Create script for stoping a node.

The created script will be stored in the user's $IPYTHONDIR. The stop_cluster and stop_engine will upload the script to the node and execute it in the proper shell.

Definition at line 328 of file parallel_go.py.

References parallel_go.cluster.__ipythondir, parallel_go.cluster.__stop_node_file, and parallel_go.cluster.__timestamp.

Referenced by parallel_go.cluster.__start_controller().

def parallel_go.cluster._cp	(	self,
		source,
		host,
		destination
	)	`[private]`

Creates the command to copy the source file to the destination file and destination host,
using either scp or cp for the localhost. This is to avoid the requirement of password-less ssh
in a single host environment.

Definition at line 107 of file parallel_go.py.

References parallel_go.cluster._ip().

Referenced by parallel_go.cluster.__stop_controller(), parallel_go.cluster.start_engine(), parallel_go.cluster.stop_engine(), and parallel_go.cluster.stop_node().

def parallel_go.cluster._do	(	self,
		host,
		cmd
	)	`[private]`

Creates the command line to execute the give command on the given host.
If and only if the host is not localhost, ssh is used.

Definition at line 119 of file parallel_go.py.

References parallel_go.cluster._ip().

Referenced by parallel_go.cluster.__stop_controller(), parallel_go.cluster.start_engine(), parallel_go.cluster.stop_engine(), and parallel_go.cluster.stop_node().

def parallel_go.cluster._ip	(	self,
		host
	)	`[private]`

Returns a unique IP address of the given hostname,
i.e. not 127.0.0.1 for localhost but localhost's global IP

Definition at line 96 of file parallel_go.py.

Referenced by parallel_go.cluster._cp(), and parallel_go.cluster._do().

def parallel_go.cluster.activate ( self )

set the cluster to parallel execution mode

Definition at line 1531 of file parallel_go.py.

References parallel_go.cluster.parallel_go_task().

def parallel_go.cluster.check_job	(	self,
		job,
		verbose = `True`
	)

check the status of an asynch job

Definition at line 1641 of file parallel_go.py.

def parallel_go.cluster.clear_queue ( self )

remove all jobs from the queue

Definition at line 1312 of file parallel_go.py.

def parallel_go.cluster.del_timer	(	self,
		timer = `['']`
	)

delete a timer

Definition at line 1365 of file parallel_go.py.

References parallel_go.cluster.get_ids().

def parallel_go.cluster.example ( self )

Definition at line 1730 of file parallel_go.py.

def parallel_go.cluster.execute	(	self,
		job,
		nodes
	)

execute a job on a subset of engines in blocking mode

Definition at line 1298 of file parallel_go.py.

def parallel_go.cluster.get_casalogs ( self )

Get a list of the casa logs for all the current cluster engines.

Each working engine is a CASA instance and saves its own log. This function retrun the list of logs with their full path. One can view the log contents with casalogviewer.

Definition at line 765 of file parallel_go.py.

Referenced by parallel_go.cluster.read_casalogs().

def parallel_go.cluster.get_engines ( self )

get current status of the engines

Definition at line 1270 of file parallel_go.py.

References parallel_go.cluster.__engines.

Referenced by parallel_go.cluster.hello().

def parallel_go.cluster.get_ids ( self )

get ids for all available engines

Definition at line 1247 of file parallel_go.py.

Referenced by parallel_go.cluster.del_timer(), and parallel_go.cluster.get_timer().

def parallel_go.cluster.get_nodes ( self )

get hostnames for all available engines

Definition at line 1259 of file parallel_go.py.

References parallel_go.cluster.__engines, and tests.test_imcontsub.list.

Referenced by parallel_go.cluster.stop_node().

def parallel_go.cluster.get_properties ( self )

get the set properties from all engines

Definition at line 1378 of file parallel_go.py.

References parallel_go.cluster.set_properties().

def parallel_go.cluster.get_result	(	self,
		i
	)

get the result of previous execution

Definition at line 1509 of file parallel_go.py.

Referenced by simple_cluster.simple_cluster.get_output().

def parallel_go.cluster.get_stdout	(	self,
		cmd
	)

get the standard output from all engines for execting a comment

Definition at line 1277 of file parallel_go.py.

def parallel_go.cluster.get_timer	(	self,
		timer = `''`
	)

get the eleapsed time for a timer

Definition at line 1319 of file parallel_go.py.

References parallel_go.cluster.get_ids(), and parallel_go.cluster.set_timer().

def parallel_go.cluster.hello ( self )

Parallel execution to print 'hello' message from all engines

Definition at line 1216 of file parallel_go.py.

References parallel_go.cluster.get_engines().

def parallel_go.cluster.howto ( self )

Definition at line 1667 of file parallel_go.py.

def parallel_go.cluster.keys ( self )

get all keys from all engines

Definition at line 1397 of file parallel_go.py.

def parallel_go.cluster.make_command	(	self,
		func,
		kwargs
	)

Make command strings to be distributed to engines

@func function name 
@kwargs **kwargs available 

Example:
x=np.ones((3,3))
c.make_command(func=None,c={1:x},d=6,t='b',s={0:'y'})
{0: 's="y"; t="b"; d=6',
 1: 'c=array([[ 1., 1., 1.],\n[ 1., 1., 1.],\n[ 1., 1., 1.]]); t="b"; d=6'}
c.make_command(func='g',c={1:x},d=6,t='b',s={0:'y'})
{0: 'g(s="y", t="b", d=6)',
 1: 'g(c=array([[1., 1., 1.],\n[1., 1., 1.],\n[1., 1., 1.]]), t="b", d=6)'}

Definition at line 1153 of file parallel_go.py.

References parallel_go.cluster.pgk().

def parallel_go.cluster.n_to_n	(	self,
		args = `[]`,
		task_id = `[]`
	)

Generate a dictionary of n varables

@param arags A list of n variables
@param task_id A list of n integer ids
One way of distributing varaibles to a set of engnines is through python a dictionary. This is a convenience function for quick generating a dictionary of a set of n variables for n keys. Example:
x=c.n_to_n(['a', 'b', 'c'], [3, 6, 7])
x
{3: 'a', 6: 'b', 7: 'c'}

Definition at line 890 of file parallel_go.py.

References parallel_go.cluster.__engines, and tests.test_imcontsub.list.

def parallel_go.cluster.odo	(	self,
		job,
		nodes
	)

execute a job on a subset of engines

Definition at line 1291 of file parallel_go.py.

def parallel_go.cluster.one_to_n	(	self,
		arg,
		task_id = `[]`
	)

Genrate a dictionary of one variable for n keys

@param arg The variable to be distributed
@param task_id The list of integer ids
One way of distributing varaibles to a set of engnines is through python a dictionary. This is a convenience function for quick generating a dictionary of same variable for n keys. Example:
x=c.one_to_n('basename', [1, 2, 7])
x
{1: 'basename', 2: 'basename', 7: 'basename'}

Definition at line 859 of file parallel_go.py.

References parallel_go.cluster.__engines, and tests.test_imcontsub.list.

def parallel_go.cluster.pad_task_id	(	self,
		b = `''`,
		task_id = `[]`
	)

Generate a dictionary of id-padded variables 

@param b The base name to be padded
@param task_id A list of integers to pad the base name 
One way of distributing varaibles to a set of engnines is through python a dictionary. This is a convenience function for quick generating a dictionary of padded names. Example:
x=c.pad_task_id('basename', [3, 5, 8])
x
{3: 'basename-3', 5: 'basename-5', 8: 'basename-8'}
x=c.pad_task_id([1,3],[0,1,2,3])
x
{0: '1-0', 1: '3-1', 2: '3-2', 3: '3-3'}
x=c.pad_task_id(['a', 'b','c','d','e'],[0,1,2,3])
x
{0: 'a-0', 1: 'b-1', 2: 'c-2', 3: 'd-3'}
y=c.pad_task_id(x)
y
{0: 'a-0-0', 1: 'b-1-1', 2: 'c-2-2', 3: 'd-3-3'}

Definition at line 797 of file parallel_go.py.

References parallel_go.cluster.__engines, and tests.test_imcontsub.list.

def parallel_go.cluster.parallel_go_commands	(	self,
		args,
		kwargs
	)

Parallel execution of commands and/or dictionary 
   of commands

Definition at line 1099 of file parallel_go.py.

References parallel_go.cluster.pgc().

def parallel_go.cluster.parallel_go_keywords	(	self,
		kwargs
	)

Parallel execution to set keywords

Definition at line 1209 of file parallel_go.py.

References parallel_go.cluster.pgk().

def parallel_go.cluster.parallel_go_task	(	self,
		taskname = `None`,
		outfile = `''`,
		target = `[]`,
		ipython_globals = `None`
	)

Make parallel tasks using current input values

Definition at line 1540 of file parallel_go.py.

References parallel_go.cluster.pgt().

Referenced by parallel_go.cluster.activate().

def parallel_go.cluster.pdo	(	self,
		job
	)

parallel execution of a job

Definition at line 1284 of file parallel_go.py.

def parallel_go.cluster.pgc	(	self,
		args,
		kwargs
	)

Parallel execution of commands and/or dictionary 
   of commands

@param *args any number of commands or dictionary of
 commands (where the key of the dictionary is the
 engine id)
@param **kwargs available options are
 job=<str> or jobname=<str>
 block=<True/False>

Example:
c.pgc({0:'ya=3',1:'ya="b"'})
c.pull('ya')
{0: 3, 1: 'b'}

c.pgc('xa=-1')
c.pull('xa')
{0: -1, 1: -1, 2: -1, 3: -1}
c.pull('job')
Out[23]: {0:'xa=-1', 1:'xa=-1', 2:'xa=-1', 3:'xa=-1'}

Definition at line 1027 of file parallel_go.py.

References parallel_go.cluster.__engines, and nf_regression.append.

Referenced by parallel_go.cluster.parallel_go_commands().

def parallel_go.cluster.pgk	(	self,
		kwargs
	)

Parallel execution to set keywords

@param **kwargs keyword args 

Example:
x=np.zeros((3,3))
c.pgk(c={1:x},d=6,t='b',s={0:'y'})
c.pull('c')
{1: array([[ 0.,  0.,  0.],
     [ 0.,  0.,  0.],
     [ 0.,  0.,  0.]])}
c.pull('d')
{0: 6, 1: 6}
c.pull('s')
{0: 'y'}
c.pull('t')
{0: 'b', 1: 'b'}

Definition at line 1107 of file parallel_go.py.

Referenced by parallel_go.cluster.make_command(), and parallel_go.cluster.parallel_go_keywords().

def parallel_go.cluster.pgt	(	self,
		taskname = `None`,
		outfile = `''`,
		target = `[]`,
		ipython_globals = `None`
	)

Make parallel tasks using current input values 
   
taskname -- Name of task
    default: None = current active task; 
    example: taskname='bandpass'
    <Options: type tasklist() for the complete list>
outfile -- Output file for the task inputs
    default: '' = taskname.parallel;
    example: outfile=taskname.orion
target -- List of integer parallel engine ids
    default: [] = all current active engines;
    example: target=[0,2,4]

Definition at line 1548 of file parallel_go.py.

References parallel_go.cluster.__engines, and tests.test_imcontsub.list.

Referenced by parallel_go.cluster.parallel_go_task().

def parallel_go.cluster.pull	(	self,
		key,
		targets = `'all'`
	)

get the value of a key
@param key the var of interest
@param targets, the engines of interest
Example:
c.pgc({0:'ya=3',1:'ya="b"'})
c.pull('ya')
{0: 3, 1: 'b'}
c.pull('ya',[1])
{1: 'b'}
c.pull('ya',1)
{1: 'b'}

Definition at line 1463 of file parallel_go.py.

References parallel_go.cluster.__engines, and tests.test_imcontsub.list.

def parallel_go.cluster.push	(	self,
		kwargs
	)

set values to the engines
@param kekword value to distribute
@param targets, the engines of interest
By default, this function set the keyword values to all engines.
To set values on a subset of engines, use kekword parameter targets,
whick takes integer or array of integer of engine ids.
You can also use function pgk to set values onto the engines. 
Example:
c.push(a=[1,3,7.1])
c.pull('a')
{0: [1, 3, 7.0999999999999996], 1: [1, 3, 7.0999999999999996]}
c.push(b=[1.2,3.7], targets=1)
c.pull('b',[1])
{1: [1.2, 3.7000000000000002]}
c.pull('b')
{1: [1.2, 3.7000000000000002]}

Definition at line 1404 of file parallel_go.py.

References parallel_go.cluster.__engines, and tests.test_imcontsub.list.

def parallel_go.cluster.queue_status ( self )

query to queue status

Definition at line 1305 of file parallel_go.py.

def parallel_go.cluster.read_casalogs ( self )

Read the casa log files.

The current implementation of this function is only a prototype. A multi-log viewer needs to be developed.

Definition at line 779 of file parallel_go.py.

References parallel_go.cluster.get_casalogs().

def parallel_go.cluster.reset_cluster ( self )

Re-initialize the engines.

This function reset the running environment for all the available engines.

Definition at line 665 of file parallel_go.py.

References parallel_go.cluster.__client, parallel_go.cluster.__engines, and parallel_go.cluster.__init_nodes().

def parallel_go.cluster.set_properties	(	self,
		properties,
		targets = `None`,
		block = `None`
	)

set properties for target engines

@param properties a dictionary its keys are

Definition at line 1386 of file parallel_go.py.

Referenced by parallel_go.cluster.get_properties().

def parallel_go.cluster.set_timer	(	self,
		timer = `'timer'`,
		type = `'proc'`,
		targets = `None`,
		block = `None`
	)

set a timer

Definition at line 1345 of file parallel_go.py.

References parallel_go.cluster.__client.

Referenced by parallel_go.cluster.get_timer().

def parallel_go.cluster.split_channel	(	self,
		spw,
		nchan,
		task_id = `[]`
	)

Generate a dictionary to distribute the spectral windows

@param spw The spectral window
@param nchan The number of channels to split
@param task_id The list of integer ids
One way of distributing a spectral windows to a set of engnines is through python a dictionary. This is a convenience function for quick generating a dictionary of spw expressions. Example:
x=c.split_channel(1, 127, [2,3,4])
x
{0: '1:0~42', 1: '1:43~85', 2: '1:86~128'}

Definition at line 982 of file parallel_go.py.

References parallel_go.cluster.__engines, and tests.test_imcontsub.list.

def parallel_go.cluster.split_int	(	self,
		start,
		end,
		task_id = `[]`
	)

Generate a dictionary to distribute the spectral windows

@param start The start integer value
@param end The end integer value
@param task_id The list of integer ids
This is a convenience function for quick generating a dictionary of integer start points. Example:
x=c.split_int(9, 127, [2,3,4])
x
{2: 9, 3: 49, 4: 89 }

Definition at line 930 of file parallel_go.py.

References parallel_go.cluster.__engines, and tests.test_imcontsub.list.

def parallel_go.cluster.start_cluster	(	self,
		cl_file
	)

Start engines that listed in a file

@param cl_file The name of the file that defines the engines.
The cl_file is a text file. Each line contains 3 columns with node name, number of engines and work directory separated by space. A line started with # will be ignored. Example:
#-----------------------------------------
#node_name num_of_engines work_dir
casa-dev-01 4 /home/casa-dev-01/hye/cluster
#casa-dev-02 3 /home/casa-dev-02/hye/cluster
subzero 1 /home/subzero/hye/test
#olddog  2 /home/olddog/hye
#-----------------------------------------

start_cluster and start_engine can be used multiple times.

Definition at line 179 of file parallel_go.py.

References parallel_go.cluster.__engines, parallel_go.cluster.__init_nodes(), parallel_go.cluster.__init_now, parallel_go.cluster.__new_engs, parallel_go.cluster.__start_controller(), and parallel_go.cluster.start_engine().

Referenced by simple_cluster.simple_cluster.init_cluster().

def parallel_go.cluster.start_engine	(	self,
		node_name,
		num_engine,
		work_dir = `None`,
		omp_num_nthreads = `1`
	)

Start engines on the given node.
@param node_name The name of the computer to host the engines.
@param num_engine The number of the engines to initialize for this run. 
@param work_dir The working directory where outputs and logs from the engines will be stored. If work_dir is not supplied or does not exist, the user's home directory will be used. 
Running this command multiple times on the same node is ok. The total number of the engines on the node increases for each run.
Every engine has a unique integer id. The id is the key to send the instructions to the engine. The available engine ids can be obtained by calling get_ids() or get_engines().

Definition at line 128 of file parallel_go.py.

References parallel_go.cluster.__cluster_rc_file, parallel_go.cluster.__engines, parallel_go.cluster.__ipythondir, parallel_go.cluster.__prefix, parallel_go.cluster.__start_controller(), parallel_go.cluster.__start_engine_file, parallel_go.cluster.__update_cluster_info(), parallel_go.cluster._cp(), and parallel_go.cluster._do().

Referenced by parallel_go.cluster.start_cluster().

def parallel_go.cluster.stop_cluster ( self )

Stop the cluster

This function stops all the running engines and the controller.

Definition at line 510 of file parallel_go.py.

References parallel_go.cluster.__client, parallel_go.cluster.__cluster_rc_file, parallel_go.cluster.__controller, parallel_go.cluster.__engines, parallel_go.cluster.__ipythondir, parallel_go.cluster.__prefix, parallel_go.cluster.__start_controller_file, parallel_go.cluster.__start_engine_file, parallel_go.cluster.__stop_controller(), parallel_go.cluster.__stop_controller_file, parallel_go.cluster.__stop_node_file, parallel_go.cluster.stop_node(), and parallel_go.cluster.wash_logs().

Referenced by simple_cluster.simple_cluster.cold_start().

def parallel_go.cluster.stop_engine	(	self,
		engine_id
	)

Stop an engine.

@param engine_id The id of the engine to be stopped.
If an engine with the given id is in the current cluster, running this function will stop the engine and remove it from the engine list.

Definition at line 377 of file parallel_go.py.

References parallel_go.cluster.__engines, parallel_go.cluster.__ipythondir, parallel_go.cluster.__prefix, parallel_go.cluster.__stop_engine_file, parallel_go.cluster.__update_cluster_info(), parallel_go.cluster._cp(), and parallel_go.cluster._do().

def parallel_go.cluster.stop_node	(	self,
		node_name
	)

Stop a node (a engine-host computer)

@param node_node The node to be stopped.
If a computer with the given name is in the current cluster, running this function will stop all the engines currently running on that node and remove the node and engines from the engine list. This function will not shutdown the computer.

Definition at line 424 of file parallel_go.py.

References parallel_go.cluster.__engines, parallel_go.cluster.__ipythondir, parallel_go.cluster.__prefix, parallel_go.cluster.__stop_node_file, parallel_go.cluster.__update_cluster_info(), parallel_go.cluster._cp(), parallel_go.cluster._do(), and parallel_go.cluster.get_nodes().

Referenced by parallel_go.cluster.stop_cluster().

def parallel_go.cluster.use_often ( self )

Definition at line 1706 of file parallel_go.py.

def parallel_go.cluster.wash_logs ( self )

Clean up the cluster log files.

A set of logs containing controller-engine information will be created every time a cluster is created. This function deletes all cluster log files that cumulated in the user's $IPYTHONDIR, if there is no active cluster running. (The files will be removed only before starting any engine of after stoping the whole cluster.

Definition at line 586 of file parallel_go.py.

References parallel_go.cluster.__controller, and parallel_go.cluster.__ipythondir.

Referenced by parallel_go.cluster.stop_cluster().