Welcome to elasticluster’s documentation!¶

elasticluster¶

import elasticluster

# Initialise an EC2 compatible cloud provider, in this case an OpenStack
# cloud operator is chosen. To initialise the cloud provider the
# following parameters are passed:
#   url:        url to connecto to the cloud operator web service
#   region:     region to start the nodes on
#   access_key: access key of the current user to connect
#   secret_key: secret key of the current user to connect
cloud_provider = elasticluster.BotoCloudProvider(
                                        'http://uzh.ch/services/Cloud',
                                        'nova', 'access_key', 'secret_key')

# Initialising the setup provider needs a little more preparation:
# the groups dictionary specifies the kind of nodes used for this cluster.
# In this case we want a frontend and a compute kind. The frontend node
# (s) will be setup as slurm_master, the compute node(s) as slurm_clients.
# This corresponds to the documentation of the ansible playbooks
# provided with elasticluster. The kind of the node is a name specified
# by the user. This name will be used to set a new hostname on the
# instance, therefore it should meet the requirements of RFC 953
# groups['kind'] = ['andible_group1', 'ansible_group2']
groups = dict()
groups['frontend'] = ['slurm_master']
groups['compute'] = ['slurm_clients']

setup_provider = elasticluster.AnsibleSetupProvider(groups)

# cluster initialisation (note: ssh keys are same for all nodes)
# After the steps above initialising an empty cluster is a peace of cake.
# The cluster takes the following arguments:
# name:           name to identify the cluster
#   cloud_provider: cloud provider to connect to cloud
#   setup_provider: setup provider to configure the cluster
#   ssh_key_name:   name of the ssh key stored (or to be stored) on the
#                   cloud
#   ssh_key_pub:    path to public ssh key file
#   ssh_key_priv:   path to private ssh key file
#
# The ssh key files are used for all instances in this cluster.
cluster = elasticluster.Cluster('my-cluster', cloud_provider,
                                setup_provider, 'ssh_key_name',
                                '~/ssh/keys/my_ssh_key.pub',
                                '~/ssh/keys/my_ssh_key')

# To add nodes to the cluster we can use the add_node. This
# only initialises a new node, but does not start it yet.
# The add node function is basically a factory method to make it easy to
# add nodes to a cluster. It takes the following arguments:
#   kind:   kind of the node in this cluster. This corresponds to the
#           groups defined in the cloud_provider.
cluster.add_node('frontend', 'ami-00000048', 'gc3-user',
                 'm1.tiny', 'all_tcp_ports')

# We can also add multiple nodes with the add_nodes method.
# The following command will add 2 nodes of the kind `compute` to the
# cluster
cluster.add_nodes('compute', 2, 'ami-00000048', 'gc3-user', 'm1.tiny',
                  'all_tcp_ports')

# Since we initialised all the nodes for this computing cluster,
# we can finally start the cluster.
# The start method is blocking and does the following tasks:
#   * call the cloud provider to start an instance for each node in a
#     seperate thread.
#   * to make sure elasticluster is not stopped during creation of an
#     instance, it will overwrite the sigint handler
#   * waits until all nodes are alive (meaning ssh connection
#     works)
#   * If the startup timeout is reached and not all nodes are alive,
#     the cluster will stop and destroy all instances
cluster.start()

# Now, all the nodes are started and we can call the setup method to
# configure slurm on the nodes.
cluster.setup()

# retrieve all nodes from the cluster
nodes = cluster.get_all_nodes()

# start each node
# The start method on the node is non blocking and will return as soon
# as the cloud provider is contacted to start a new instance
for node in nodes:
    node.start()

# wait until all nodes are alive
starting_nodes = nodes[:]
while starting_nodes:
    starting_nodes = [n for n in starting_nodes if not n.is_alive()]

# The cluster repository uses pickle to store clusters each in a
# seperate file in the provided storage directory.
repository = elasticluster.ClusterRepository('/path/to/storage/dir')

# On cluster initialisation we can pass the repository as optional
# argument.
cluster = elasticluster.Cluster('my-cluster', cloud_provider,
                                setup_provider, 'ssh_key_name',
                                '~/ssh/keys/my_ssh_key.pub',
                                '~/ssh/keys/my_ssh_key',
                                repository=repository)

# When starting the cluster, it will safe its state using the repository.
cluster.start()

repository = elasticluster.ClusterRepository('/path/to/storage/dir')

# retrieve the cluster from the repository
cluster = repository.get('my-cluster')

# or retrieve all clusters that are stored in the repository
clusters = repository.get_all()

import logging

import elasticluster

log = elasticluster.log
level = logging.getLevelName('INFO')
log.setLevel(level)

elasticluster.cluster¶

class elasticluster.cluster.Cluster(name, cloud_provider, setup_provider, user_key_name, user_key_public, user_key_private, repository=None, **extra)[source]¶

This is the heart of elasticluster and handles all cluster relevant behavior. You can basically start, setup and stop a cluster. Also it provides factory methods to add nodes to the cluster. A typical workflow is as follows:

• create a new cluster
• add nodes to fit your computing needs
• start cluster; start all instances in the cloud
• setup cluster; configure all nodes to fit your computing cluster
• eventually stop cluster; destroys all instances in the cloud

Parameters:

name (str) – unique identifier of the cluster cloud_provider (elasticluster.providers.AbstractCloudProvider) – access to the cloud to manage nodes setup_provider (elasticluster.providers.AbstractSetupProvider) – provider to setup cluster user_key_name (str) – name of the ssh key to connect to cloud user_key_public (str) – path to ssh public key file user_key_private (str) – path to ssh private key file repository (elasticluster.repository.AbstractClusterRepository) – by default the elasticluster.repository.MemRepository is used to store the cluster in memory. Provide another repository to store the cluster in a persistent state. extra – tbd.

Variables:

nodes – dict [node_type] = [Node] that represents all nodes in this cluster

add_node(kind, image_id, image_user, flavor, security_group, image_userdata='', name=None, **extra)[source]¶

Adds a new node to the cluster. This factory method provides an easy way to add a new node to the cluster by specifying all relevant parameters. The node does not get started nor setup automatically, this has to be done manually afterwards.

Parameters:	kind (str) – kind of node to start. this refers to the groups defined in the ansible setup provider elasticluster.providers.AnsibleSetupProvider Please note that this must match the [a-zA-Z0-9-] regexp, as it is used to build a valid hostname image_id (str) – image id to use for the cloud instance (e.g. ami on amazon) image_user (str) – user to login on given image flavor (str) – machine type to use for cloud instance security_group (str) – security group that defines firewall rules to the instance image_userdata (str) – commands to execute after instance starts name (str) – name of this node, automatically generated if None
Raises:	ValueError: kind argument is an invalid string.
Returns:	created Node

add_nodes(kind, num, image_id, image_user, flavor, security_group, image_userdata='', **extra)[source]¶

Helper method to add multiple nodes of the same kind to a cluster.

Parameters:

kind (str) – kind of node to start. this refers to the groups defined in the ansible setup provider elasticluster.providers.AnsibleSetupProvider num (int) – number of nodes to add of this kind image_id (str) – image id to use for the cloud instance (e.g. ami on amazon) image_user (str) – user to login on given image flavor (str) – machine type to use for cloud instance security_group (str) – security group that defines firewall rules to the instance image_userdata (str) – commands to execute after instance starts

get_all_nodes()[source]¶

Returns a list of all nodes in this cluster as a mixed list of different node kinds.

Returns:	list of Node

get_frontend_node()[source]¶

Returns the first node of the class specified in the configuration file as ssh_to, or the first node of the first class in alphabetic order.

Returns:	Node
Raise:	elasticluster.exceptions.NodeNotFound if no valid frontend node is found

remove_node(node)[source]¶

Removes a node from the cluster, but does not stop it. Use this method with caution.

Parameters:	node (Node) – node to remove

setup()[source]¶

Configure the cluster nodes with the specified This is delegated to the provided elasticluster.providers.AbstractSetupProvider

Returns:	bool - True on success, False otherwise

start(min_nodes=None)[source]¶

Starts up all the instances in the cloud. To speed things up all instances are started in a seperate thread. To make sure elasticluster is not stopped during creation of an instance, it will overwrite the sigint handler. As soon as the last started instance is returned and saved to the repository, sigint is executed as usual. An instance is up and running as soon as a ssh connection can be established. If the startup timeout is reached before all instances are started, the cluster will stop and destroy all instances.

This method is blocking and might take some time depending on the amount of instances to start.

Parameters:	min_nodes (dict [node_kind] = number) – minimum number of nodes to start in case the quota is reached before all instances are up

startup_timeout = 600¶

timeout in seconds to start all nodes

stop(force=False)[source]¶

Destroys all instances of this cluster and calls delete on the repository.

Parameters:	force (bool) – force termination of instances in any case

update()[source]¶

Update all connection information of the nodes of this cluster. It occurs for example public ip’s are not available imediatly, therefore calling this method might help.

class elasticluster.cluster.Node(name, cluster_name, kind, cloud_provider, user_key_public, user_key_private, user_key_name, image_user, security_group, image, flavor, image_userdata=None, **extra)[source]¶

The node represents an instance in a cluster. It holds all information to connect to the nodes also manages the cloud instance. It provides the basic functionality to interact with the cloud instance, such as start, stop, check if the instance is up and ssh connect.

Parameters:

name (str) – identifier of the node kind (str) – kind of node in regard to cluster. this usually refers to a specified group in the elasticluster.providers.AbstractSetupProvider cloud_provider (elasticluster.providers.AbstractCloudProvider) – cloud provider to manage the instance user_key_public (str) – path to the ssh public key user_key_private (str) – path to the ssh private key user_key_name (str) – name of the ssh key image_user (str) – user to connect to the instance via ssh security_group (str) – security group to setup firewall rules image (str) – image id to launch instance with flavor (str) – machine type to launch instance image_userdata (str) – commands to execute after instance start

Variables:

instance_id – id of the node instance on the cloud preferred_ip – IP address used to connect to the node. ips – list of all the IPs defined for this node.

connect()[source]¶

Connect to the node via ssh using the paramiko library.

Returns:	paramiko.SSHClient - ssh connection or None on failure

connection_ip()[source]¶

Returns the IP to be used to connect to this node.

If the instance has a public IP address, then this is returned, otherwise, its private IP is returned.

connection_timeout = 5¶

timeout in seconds to connect to host via ssh

is_alive()[source]¶

Checks if the current node is up and running in the cloud. It only checks the status provided by the cloud interface. Therefore a node might be running, but not yet ready to ssh into it.

pprint()[source]¶

Pretty print information about the node.

Returns:	str - representaion of a node in pretty print

start()[source]¶

Starts the node on the cloud using the given instance properties. This method is non-blocking, as soon as the node id is returned from the cloud provider, it will return. Therefore the is_alive and update_ips methods can be used to further gather details about the state of the node.

stop()[source]¶

Destroys the instance launched on the cloud for this specific node.

update_ips()[source]¶

Retrieves the public and private ip of the instance by using the cloud provider. In some cases the public ip assignment takes some time, but this method is non blocking. To check for a public ip, consider calling this method multiple times during a certain timeout.

elasticluster.conf¶

class elasticluster.conf.ConfigReader(configfile)[source]¶

Reads the configuration properties from a ini file.

Parameters:	configfile (str) – path to configfile

read_config()[source]¶

Reads the configuration properties from the ini file and links the section to comply with the cluster config dictionary format.

Returns:	dictionary containing all configuration properties from the ini file in compliance to the cluster config format
Raises:	voluptuous.MultipleInvalid if not all sections present or broken links between secitons

class elasticluster.conf.ConfigValidator(config)[source]¶

Validator for the cluster configuration dictionary.

Parameters:	config – dictionary containing cluster configuration properties

validate()[source]¶

Validates the given configuration self.config to comply with elasticluster. As well all types are converted to the expected format if possible.

Raisegs:	voluptuous.MultipleInvalid if multiple properties are not compliant
Raises:	voluptuous.Invalid if one property is invalid

class elasticluster.conf.Configurator(cluster_conf, storage_path=None)[source]¶

The Configurator is responsible for (I) keeping track of the

configuration and (II) offer factory methods to create all kind of objects that need information from the configuration.

The cluster configuration dictionary is structured in the following way: (see an example @

https://github.com/gc3-uzh-ch/elasticluster/wiki/Configuration-Module)

{ "<cluster_template>" : {
    "setup" : { properties of the setup section },
    "cloud" : { properties of the cloud section },
    "login" : { properties of the login section },
    "cluster" : { properties of the cluster section },
    "nodes": {  "<node_kind>" : { properties of the node},
                "<node_kind>" : { properties of the node},
            },
    },
 "<cluster_template>" : {
    (see above)
    }
 }

Parameters:	cluster_conf (dict) – see description above storage_path (str) – path to store data
Raises:	MultipleInvalid – configuration validation

create_cloud_provider(cluster_template)[source]¶

Creates a cloud provider by inspecting the configuration properties of the given cluster template.

Parameters:	cluster_template (str) – template to use (if not already specified on init)
Returns:	cloud provider that fulfills the contract of elasticluster.providers.AbstractSetupProvider

create_cluster(template, name=None)[source]¶

Creates a cluster by inspecting the configuration properties of the given cluster template.

Parameters:	template (str) – name of the cluster template name (str) – name of the cluster. If not defined, the cluster

will be named after the template.

Returns:	elasticluster.cluster.cluster instance
Raises:	ConfigurationError – cluster template not found in config

create_setup_provider(cluster_template, name=None)[source]¶

Creates the setup provider for the given cluster template.

Parameters:	cluster_template (str) – template of the cluster name (str) – name of the cluster to read configuration properties

classmethod fromConfig(configfile, storage_path=None)[source]¶

Helper method to initialize Configurator from an ini file.

Parameters:	configfile (str) – path to the ini file
Returns:	Configurator

load_cluster(cluster_name)[source]¶

Loads a cluster from the cluster repository.

Parameters:	cluster_name (str) – name of the cluster
Returns:	elasticluster.cluster.cluster instance

elasticluster.exceptions¶

elasticluster.gc3_config¶

elasticluster.helpers¶

class elasticluster.helpers.Singleton(decorated)[source]¶

see: http://stackoverflow.com/a/7346105 A non-thread-safe helper class to ease implementing singletons. This should be used as a decorator – not a metaclass – to the class that should be a singleton.

The decorated class can define one __init__ function that takes only the self argument. Other than that, there are no restrictions that apply to the decorated class.

To get the singleton instance, use the Instance method. Trying to use __call__ will result in a TypeError being raised.

Limitations: The decorated class cannot be inherited from.

Instance()[source]¶

Returns the singleton instance. Upon its first call, it creates a new instance of the decorated class and calls its __init__ method. On all subsequent calls, the already created instance is returned.

elasticluster.main¶

elasticluster.module¶

elasticluster.providers¶

class elasticluster.providers.AbstractCloudProvider(**config)[source]¶

Defines the contract for a cloud provider to proper function with elasticluster.

get_ips(instance_id)[source]¶

Retrieves the private and public ip addresses for a given instance.

Returns:	list (IPs)

is_instance_running(instance_id)[source]¶

Checks if the instance is up and running.

Parameters:	instance_id (str) – instance identifier
Returns:	bool - True if running, False otherwise

start_instance(key_name, public_key_path, private_key_path, security_group, flavor, image_id, image_userdata, username=None, node_name=None)[source]¶

Starts a new instance on the cloud using the given properties. Multiple instances might be started in different threads at the same time. The implementation should handle any problems regarding this itself.

Parameters:

key_name (str) – name of the ssh key to connect public_key_path (str) – path to ssh public key private_key_path (str) – path to ssh private key security_group (str) – firewall rule definition to apply on the instance flavor (str) – machine type to use for the instance image_name (str) – image type (os) to use for the instance image_userdata (str) – command to execute after startup username (str) – username for the given ssh key, default None

Returns:

str - instance id of the started instance

stop_instance(instance_id)[source]¶

Stops the instance gracefully.

Parameters:	instance_id (str) – instance identifier
Returns:	None

class elasticluster.providers.AbstractSetupProvider[source]¶

TODO: define...

cleanup()[source]¶

Cleanup any temporary file or directory created during setup. This method is called every time a cluster is stopped.

Returns:	None

setup_cluster(cluster)[source]¶

Configures all nodes of a cluster to function in respect to the given configuration.

This method must be idempotent, i.e. it should always be safe calling it multiple times..

Parameters:	cluster (elasticluster.cluster.Cluster) – cluster to configure
Returns:	True if the cluster is correctly configured, even if the method didn’t actually do anything. False if the cluster is not configured.

elasticluster.providers.ansible_provider¶

class elasticluster.providers.ansible_provider.AnsibleSetupProvider(groups, playbook_path=None, environment_vars={}, storage_path=None, sudo=True, sudo_user='root', ansible_module_dir=None, **extra_conf)[source]¶

This implementation uses ansible to configure and manage the cluster setup. See https://github.com/ansible/ansible for details.

Parameters:

groups (dict) – dictionary of node kinds with corresponding ansible groups to install on the node kind. e.g [node_kind] = [‘ansible_group1’, ‘ansible_group2’] The group defined here can be references in each node. Therefore groups can make it easier to define multiple groups for one node. playbook_path (str) – path to playbook; if empty this will use the shared playbook of elasticluster environment_vars (dict) – dictonary to define variables per node kind, e.g. [node_kind][var] = value storage_path (str) – path to store the inventory file. By default the inventory file is saved temporarily in a temporary directory and deleted when the cluster in stopped. sudo (bool) – indication whether use sudo to gain root permission sudo_user (str) – user with root permission ansible_module_dir (str) – path to addition ansible modules extra_conf – tbd.

Variables:

groups – node kind and ansible group mapping dictionary environment – additional environment variables

cleanup(cluster)[source]¶

Deletes the inventory file used last recently used.

Parameters:	cluster (elasticluster.cluster.Cluster) – cluster to clear up inventory file for

setup_cluster(cluster)[source]¶

Configures the cluster according to the node_kind to ansible group matching. This method is idempotent and therefore can be called multiple times without corrupting the cluster configuration.

Parameters:	cluster (elasticluster.cluster.Cluster) – cluster to configure
Returns:	True on success, False otherwise. Please note, if nothing has to be configures True is returned
Raises:	AnsibleError if the playbook can not be found or playbook is corrupt

elasticluster.providers.ec2_boto¶

class elasticluster.providers.ec2_boto.BotoCloudProvider(ec2_url, ec2_region, ec2_access_key, ec2_secret_key, storage_path=None, request_floating_ip=False)[source]¶

This implementation of elasticluster.providers.AbstractCloudProvider uses the boto ec2 interface to connect to ec2 compliant clouds and manage instances.

Please check https://github.com/boto/boto for further information about the supported cloud platforms.

Parameters:	ec2_url (str) – url to connect to cloud web service ec2_region (str) – region identifier ec2_access_key (str) – access key of the user account ec2_secret_key (str) – secret key of the user account storage_path (str) – path to store temporary data request_floating_ip (bool) – Whether ip are assigned automatically True or floating ips have to be assigned manually False

get_ips(instance_id)[source]¶

Retrieves the private and public ip addresses for a given instance.

Returns:	list (ips)

is_instance_running(instance_id)[source]¶

Checks if the instance is up and running.

Parameters:	instance_id (str) – instance identifier
Returns:	bool - True if running, False otherwise

start_instance(key_name, public_key_path, private_key_path, security_group, flavor, image_id, image_userdata, username=None, node_name=None, **kwargs)[source]¶

Starts a new instance on the cloud using the given properties. The following tasks are done to start an instance:

• establish a connection to the cloud web service
• check ssh keypair and upload it if it does not yet exist. This is a locked process, since this function might be called in multiple threads and we only want the key to be stored once.
• check if the security group exists
• run the instance with the given properties

Parameters:

key_name (str) – name of the ssh key to connect public_key_path (str) – path to ssh public key private_key_path (str) – path to ssh private key security_group (str) – firewall rule definition to apply on the instance flavor (str) – machine type to use for the instance image_id (str) – image type (os) to use for the instance image_userdata (str) – command to execute after startup username (str) – username for the given ssh key, default None

Returns:

str - instance id of the started instance

stop_instance(instance_id)[source]¶

Stops the instance gracefully.

Parameters:	instance_id (str) – instance identifier

elasticluster.providers.gce¶

Cloud provider for the Google Compute Engine.

See <https://code.google.com/p/google-cloud-platform-samples/source/browse/python-client-library-example/gce.py?repo=compute> for reference.

elasticluster.providers.gce.GCE_SCOPE = 'https://www.googleapis.com/auth/compute'¶

the OAuth scope for the GCE web API

class elasticluster.providers.gce.GoogleCloudProvider(gce_client_id, gce_client_secret, gce_project_id, zone='us-central1-a', network='default', email='default', storage_path=None)[source]¶

Cloud provider for the Google Compute Engine.

Parameters:

gce_client_id (str) – Client ID to use in OAuth authentication. gce_client_secret (str) – Client secret (password) to use in OAuth authentication. gce_project_id (str) – Project name to log in to GCE. zone (str) – gce zone, default is us-central1-a network (str) – network to use, default is default email (str) – service email to use, default is default storage_path (str) – path to store authentication data (oauth.dat file). If no path is specified, the login data has to be entered after every request.

get_ips(instance_id)[source]¶

Retrieves the ip addresses (private and public) from the cloud provider by the given instance id.

Parameters:	instance_id (str) – id of the instance
Returns:	list (ips)
Raises:	InstanceError if the ip could not be retrieved.

is_instance_running(instance_id)[source]¶

Check whether the instance is up and running.

Parameters:	instance_id (str) – instance identifier
Reutrn:	True if instance is running, False otherwise

list_instances(filter=None)[source]¶

List instances on GCE, optionally filtering the results.

Parameters:	filter (str) – Filter specification; see https://developers.google.com/compute/docs/reference/latest/instances/list for details.
Returns:	list of instances

start_instance(key_name, public_key_path, private_key_path, security_group, flavor, image_id, image_userdata, username=None, instance_name=None, **kwargs)[source]¶

Starts a new instance with the given properties and returns the instance id.

Parameters:

key_name (str) – name of the ssh key to connect public_key_path (str) – path to ssh public key private_key_path (str) – path to ssh private key security_group (str) – firewall rule definition to apply on the instance flavor (str) – machine type to use for the instance image_id (str) – image type (os) to use for the instance image_userdata (str) – command to execute after startup username (str) – username for the given ssh key, default None instance_name (str) – name of the instance

Returns:

str - instance id of the started instance

stop_instance(instance_id)[source]¶

Stops the instance gracefully.

Parameters:	instance_id (str) – instance identifier
Raises:	InstanceError if instance can not be stopped

elasticluster.repository¶

class elasticluster.repository.AbstractClusterRepository[source]¶

Defines the contract for a cluster repository to store clusters in a persistent state.

delete(cluster)[source]¶

Deletes the cluster from persistent state.

Parameters:	cluster (elasticluster.cluster.Cluster) – cluster to delete from persistent state

get(name)[source]¶

Retrieves the cluster by the given name.

Parameters:	name (str) – name of the cluster (identifier)
Returns:	instance of elasticluster.cluster.Cluster that matches the given name

get_all()[source]¶

Retrieves all stored clusters from the persistent state.

Returns:	list of elasticluster.cluster.Cluster

save_or_update(cluster)[source]¶

Save or update the cluster in a persistent state. Elasticluster will call this method multiple times, so the implementation should handle save and update seamlessly

Parameters:	cluster (elasticluster.cluster.Cluster) – cluster object to store

class elasticluster.repository.ClusterRepository(storage_path)[source]¶

This implementation of AbstractClusterRepository stores the cluster on the local disc using pickle. Therefore the cluster object and all its dependencies will be saved in a pickle (binary) file.

Parameters:	storage_path (str) – path to the folder to store the cluster information

delete(cluster)[source]¶

Deletes the cluster from persistent state.

Parameters:	cluster (elasticluster.cluster.Cluster) – cluster to delete from persistent state

get(name)[source]¶

Retrieves the cluster with the given name.

Parameters:	name (str) – name of the cluster (identifier)
Returns:	elasticluster.cluster.Cluster

get_all()[source]¶

Retrieves all clusters from the persistent state.

Returns:	list of elasticluster.cluster.Cluster

save_or_update(cluster)[source]¶

Save or update the cluster to persistent state.

Parameters:	cluster (elasticluster.cluster.Cluster) – cluster to save or update

class elasticluster.repository.MemRepository[source]¶

This implementation of AbstractClusterRepository stores the clusters in memory, without actually saving the data on disk.

delete(cluster)[source]¶

Deletes the cluster from memory.

Parameters:	cluster (elasticluster.cluster.Cluster) – cluster to delete

get(name)[source]¶

Retrieves the cluster by the given name.

Parameters:	name (str) – name of the cluster (identifier)
Returns:	instance of elasticluster.cluster.Cluster that matches the given name

get_all()[source]¶

Retrieves all stored clusters from the memory.

Returns:	list of elasticluster.cluster.Cluster

save_or_update(cluster)[source]¶

Save or update the cluster in a memory.

Parameters:	cluster (elasticluster.cluster.Cluster) – cluster object to store

elasticluster.subcommands¶

class elasticluster.subcommands.AbstractCommand(params)[source]¶

Defines the general contract every command has to fulfill in order to be recognized by the arguments list and executed afterwards.

execute()[source]¶

This method is executed after a command was recognized and may vary in its behavior.

pre_run()[source]¶

Overrides this method to execute any pre-run code, especially to check any command line options.

setup(subparsers)[source]¶

This method handles the setup of the subcommand. In order to do so, every command has to add a parser to the subparsers reference given as parameter. The following example is the minimum implementation of such a setup procedure: parser = subparsers.add_parser(“start”) parser.set_defaults(func=self.execute)

class elasticluster.subcommands.ListClusters(params)[source]¶

Print a list of all clusters that have been started.

class elasticluster.subcommands.ListNodes(params)[source]¶

Show some information on all the nodes belonging to a given cluster.

execute()[source]¶

Lists all nodes within the specified cluster with certain information like id and ip.

class elasticluster.subcommands.ListTemplates(params)[source]¶

List the available templates defined in the configuration file.

class elasticluster.subcommands.ResizeCluster(params)[source]¶

Resize the cluster by adding or removing compute nodes.

class elasticluster.subcommands.SetupCluster(params)[source]¶

Setup the given cluster by calling the setup provider defined for this cluster.

class elasticluster.subcommands.SftpFrontend(params)[source]¶

Open an SFTP session to the cluster frontend host.

class elasticluster.subcommands.SshFrontend(params)[source]¶

Connect to the frontend of the cluster using ssh.

class elasticluster.subcommands.Start(params)[source]¶

Create a new cluster using the given cluster template.

execute()[source]¶

Starts a new cluster.

class elasticluster.subcommands.Stop(params)[source]¶

Stop a cluster and terminate all associated virtual machines.

execute()[source]¶

Stops the cluster if it’s running.

setup(subparsers)[source]¶

@see abstract_command contract