CloudStack Compute Driver Documentation

CloudStack is an Apache Software Foundation open source software designed to deploy and manage large networks of virtual machines, as a highly available, highly scalable Infrastructure as a Service (IaaS) cloud computing platform. CloudStack is used by a number of service providers to offer public cloud services, and by many companies to provide an on-premises (private) cloud offering, or as part of a hybrid cloud solution.

../../_images/cloudstack.png

CloudStack has its own non-standard API , libcloud provides a Python wrapper on top of this API with common methods with other IaaS solutions and Public cloud providers. Therefore, you can use use the CloudStack libcloud driver to communicate with your local CloudStack based private cloud as well as CloudStack based public clouds.

Instantiating a driver

When you instantiate a driver you need to pass the following arguments to the driver constructor:

  • key - Your CloudStack API key
  • secret - Your CloudStack secret key
  • host - The host of your CloudStack endpoint (e.g localhost for http://localhost:8080/client/api)
  • path - The path to your CloudStack endpoint (e.g /client/api for http://localhost:8080/client/api)
  • url - The url to your CloudStack endpoint, mutually exclusive with host and path
  • secure - True or False. True by default

Typically this will lead to:

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

apikey = 'your api key'
secretkey = 'your secret key'
host = 'example.com'
path = '/path/to/api'

Driver = get_driver(Provider.CLOUDSTACK)
conn = Driver(key=apikey, secret=secretkey, host=host, path=path)

A complete url can be used instead:

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

apikey = 'your api key'
secretkey = 'your secret key'
url = 'http://example.com/path/to/api'

Driver = get_driver(Provider.CLOUDSTACK)
conn = Driver(key=apikey, secret=secretkey, url=url)

In the testing scenario where you are running CloudStack locally, the connection may be insecure and you may run it on a specific port. In that case, the instantiation would look like this

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

apikey = 'your api key'
secretkey = 'your secret key'
host = 'localhost'
path = '/path/to/api'
port = 8080

Driver = get_driver(Provider.CLOUDSTACK)
conn = Driver(key=apikey, secret=secretkey, host=host,
              path=path, port=port, secure=False)

If you are making a connection to a secure cloud that does not use a trusted certificate, you will have to disable the SSL verification like so:

import libcloud.security as sec
sec.VERIFY_SSL_CERT = False

For more information on how SSL certificate validation works in Libcloud, see the SSL Certificate Validation page.

libcloud now features CloudStack based drivers for the exoscale and ikoula public clouds. Instantiating drivers to those clouds is shown in the example section below.

The base libcloud API allows you to:

  • list nodes, images, instance types, locations
  • list, create, attach, detach, delete volumes

Non-standard functionality and extension methods

The CloudStack driver exposes a lot of libcloud non-standard functionalities through extension methods and arguments.

These functionalities include:

  • start and stop a node
  • list disk offerings
  • list networks
  • list, allocate and release public IPs,
  • list, create and delete port forwarding rules
  • list, create and delete IP forwarding rules
  • list, create, delete and authorize security groups

Some methods are only valid for CloudStack advanced zones, while others are suited for basic zones.

For information on how to use these functionalities please see the method docstrings below. You can also use an interactive shell for exploration as shown in the examples.

Basic Zone Examples

To start experimenting with libcloud, starting an ipython interactive shell can be very handy. Tab completion and shell history are available. Below is an example of starting such an interactive shell for the exoscale public cloud. Once started you can explore the libcloud API.

1. Start an interactive shell on Exoscale public cloud

import os

from IPython.terminal.embed import InteractiveShellEmbed

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

apikey = os.getenv('EXOSCALE_API_KEY')
secretkey = os.getenv('EXOSCALE_SECRET_KEY')

Driver = get_driver(Provider.EXOSCALE)

conn = Driver(key=apikey, secret=secretkey)

shell = InteractiveShellEmbed(banner1='Hello from Libcloud Shell !!')
shell()

After experimenting through an interactive shell, you can write scripts that will directly execute libcloud commands. For instance starting a node with a specific ssh keypair and a couple of security groups can be done as shown in the following example:

2. SSH Keypairs management on Exoscale public cloud

The base libcloud API has been extended to handle management of ssh keypairs. This is very useful for CloudStack basic zones. SSH Keypairs, can be listed, created, deleted and imported. This new base API is only available in libcloud trunk.

import os
from pprint import pprint

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

cls = get_driver(Provider.EXOSCALE)
driver = cls('api key', 'api secret key')

# Create a new key pair. Most providers will return generated private key in
# the response which can be accessed at key_pair.private_key
key_pair = driver.create_key_pair(name='test-key-pair-1')
pprint(key_pair)

# Import an existing public key from a file. If you have public key as a
# string, you can use import_key_pair_from_string method instead.
key_file_path = os.path.expanduser('~/.ssh/id_rsa_test.pub')
key_pair = driver.import_key_pair_from_file(name='test-key-pair-2',
                                            key_file_path=key_file_path)
pprint(key_pair)

# Retrieve information about previously created key pair
key_pair = driver.get_key_pair(name='test-key-pair-1')
pprint(key_pair)

# Delete a key pair we have previously created
status = driver.delete_key_pair(key_pair=key_pair)
pprint(status)

3. Security Groups management on Exoscale public cloud

Currently there is no security group class defined, hence the result of ex_list_securitry_groups() is a list of dictionaries and not classes.

from pprint import pprint

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

cls = get_driver(Provider.EXOSCALE)
driver = cls('api key', 'api secret key')

# List all security groups
sg = driver.ex_list_security_groups()
pprint(sg)

# Create a new security group.
security_group = driver.ex_create_security_group(name='test-security-group')
pprint(security_group)

# Authorize an ingress rule on a security group
# If `startport` is used alone, this will be the only port open
# If `endport` is also used then the entire range will be authorized
sg = driver.ex_authorize_security_group_ingress(securitygroupname=
                                                'test-security-group',
                                                protocol='tcp',
                                                startport='22',
                                                cidrlist='0.0.0.0/0')
pprint(sg)

# Delete a security group we have previously created
status = driver.ex_delete_security_group(name='test-security-group')
pprint(status)

4. Create a node with a keypair and a list of security groups

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

ACCESS_ID = 'your access id'
SECRET_KEY = 'your secret key'
HOST = 'hostname or ip address of your management server'
PATH = 'path to the api endpoint, e.g: /client/api'

SIZE_ID = 'id of the computer offering you want to use'
IMAGE_ID = 'id of the template you want to use'

# Name of the existing keypair you want to use
KEYPAIR_NAME = 'keypairname'

# The security groups you want this node to be added to
SECURITY_GROUP_NAMES = ['secgroup1', 'secgroup2']

cls = get_driver(Provider.CLOUDSTACK)
driver = cls(key=ACCESS_ID, secret=SECRET_KEY, secure=True,
             host=HOST, path=PATH)

sizes = driver.list_sizes()
images = driver.list_images()
size = [s for s in sizes if s.id == SIZE_ID][0]
image = [i for i in images if i.id == IMAGE_ID][0]

node = driver.create_node(name='test-node-1', image=image, size=size,
                          ex_security_groups=SECURITY_GROUP_NAMES,
                          ex_keyname=KEYPAIR_NAME)

5. Deploying a node with a keypair

Executing deployment scripts when creating node is currently only supported in basic zones. The deploy_node method is used instead of the create_node, ssh key are passed as arguments as well as a list of scripts.

from pprint import pprint

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

# Import the deployment specific modules
from libcloud.compute.deployment import ScriptDeployment
from libcloud.compute.deployment import MultiStepDeployment

cls = get_driver(Provider.EXOSCALE)
driver = cls('api key', 'api secret key')

image = driver.list_images()[0]
size = driver.list_sizes()[0]

# Define the scripts that you want to run during deployment
script = ScriptDeployment('/bin/date')
msd = MultiStepDeployment([script])

node = driver.deploy_node(name='test', image=image, size=size,
                          ssh_key='~/.ssh/id_rsa_test',
                          ex_keyname='test-keypair',
                          deploy=msd)

# The stdout of the deployment can be checked on the `script` object
pprint(script.stdout)

Advanced Zone examples

Advanced zones in CloudStack provide tenant isolation via VLANs or SDN technologies like GRE/STT meshes. In a typical advanced zones, users will deploy nodes on a private network and will use NAT to access their nodes. Therefore one needs to specifiy the network a node needs to be deployed on, and needs to setup port forwarding or IP forwarding rules.

1. Start an interactive shell on Ikoula public cloud

Instantiation of driver for an advanced zone is the same as with a basic zone, for example on the ikoula cloud:

import os

from IPython.terminal.embed import InteractiveShellEmbed

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

apikey = os.getenv('IKOULA_API_KEY')
secretkey = os.getenv('IKOULA_SECRET_KEY')

Driver = get_driver(Provider.IKOULA)

conn = Driver(key=apikey, secret=secretkey)

shell = InteractiveShellEmbed(banner1='Hello from Libcloud Shell !!')
shell()

2. Create a node on a guest network and allocate an IP

Starting a node requires a specific guest network.

from pprint import pprint

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

apikey = 'your api key'
secretkey = 'your secret key'

Driver = get_driver(Provider.IKOULA)
driver = Driver(key=apikey, secret=secretkey)

# This returns a list of CloudStackNetwork objects
nets = driver.ex_list_networks()

# List the images/templates available
# This returns a list of NodeImage objects
images = driver.list_images()

# List the instance types
# This returns a list of NodeSize objects
sizes = driver.list_sizes()

# Create the node
# This returns a Node object
node = driver.create_node(name='libcloud', image=images[0],
                          size=sizes[0], networks=[nets[0]])

# The node has a private IP in the guest network used
# No public IPs and no rules
pprint(node.extra)
pprint(node.private_ips)

3. List, create and delete a Port forwarding rule

To access the node via ssh you need you can create a port forwarding rule like so:

from pprint import pprint

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

cls = get_driver(Provider.EXOSCALE)
driver = cls('api key', 'api secret key')

# Allocate a public IP
# This returns a CloudStackAddress object
driver.ex_allocate_public_ip()

# You can now see this address when listing public IPs
ip = driver.ex_list_public_ips()[0]

node = driver.list_nodes()[0]

# Create a port forwarding rule for the node
# This returns a CloudStackPortForwardingRule object
rule = driver.ex_create_port_forwarding_rule(ip, 22, 22, 'TCP', node)
pprint(rule)


# The node now has a public IP and a rule associated to it
print node
print node.extra

API Docs

class libcloud.compute.drivers.cloudstack.CloudStackNodeDriver(key, secret=None, secure=True, host=None, path=None, port=None, url=None, *args, **kwargs)[source]

Driver for the CloudStack API.

Variables:
  • host – The host where the API can be reached.
  • path – The path where the API can be reached.
  • async_poll_frequency – How often (in seconds) to poll for async job completion.
Inherits:

NodeDriver.__init__

Parameters:
  • host (str) – The host where the API can be reached. (required)
  • path (str) – The path where the API can be reached. (required)
  • url (str) – Full URL to the API endpoint. Mutually exclusive with host and path argument.
attach_volume(node, volume, device=None)[source]

@inherits: NodeDriver.attach_volume :type node: CloudStackNode

Return type:bool
create_key_pair(name, **kwargs)[source]

Create a new key pair object.

Parameters:
  • name (str) – Key pair name.
  • name – Name of the keypair (required)
  • projectid (str) – An optional project for the ssh key
  • domainid (str) – An optional domainId for the ssh key. If the account parameter is used, domainId must also be used.
  • account (str) – An optional account for the ssh key. Must be used with domainId.
Returns:

Created key pair object.

Return type:

libcloud.compute.base.KeyPair

create_node(**kwargs)[source]

Create a new node

@inherits: NodeDriver.create_node

Parameters:
  • networks (list of CloudStackNetwork) – Optional list of networks to launch the server into.
  • ex_keyname (str) – Name of existing keypair
  • ex_userdata (str) – String containing user data
  • ex_security_groups (list of str) – List of security groups to assign to the node
Return type:

CloudStackNode

create_volume(size, name, location=None, snapshot=None)[source]

Creates a data volume Defaults to the first location

create_volume_snapshot(volume, name)

Creates a snapshot of the storage volume.

Return type:VolumeSnapshot
delete_key_pair(key_pair, **kwargs)[source]

Delete an existing key pair.

Parameters:
  • key_pair (:class`libcloud.compute.base.KeyPair`) – Key pair object.
  • projectid (str) – The project associated with keypair
  • domainid (str) – The domain ID associated with the keypair
  • account (str) – The account associated with the keypair. Must be used with the domainId parameter.
Returns:

True of False based on success of Keypair deletion

Return type:

bool

deploy_node(**kwargs)

Create a new node, and start deployment.

In order to be able to SSH into a created node access credentials are required.

A user can pass either a NodeAuthPassword or NodeAuthSSHKey to the auth argument. If the create_node implementation supports that kind if credential (as declared in self.features['create_node']) then it is passed on to create_node. Otherwise it is not passed on to create_node and it is only used for authentication.

If the auth parameter is not supplied but the driver declares it supports generates_password then the password returned by create_node will be used to SSH into the server.

Finally, if the ssh_key_file is supplied that key will be used to SSH into the server.

This function may raise a DeploymentException, if a create_node call was successful, but there is a later error (like SSH failing or timing out). This exception includes a Node object which you may want to destroy if incomplete deployments are not desirable.

>>> from libcloud.compute.drivers.dummy import DummyNodeDriver
>>> from libcloud.compute.deployment import ScriptDeployment
>>> from libcloud.compute.deployment import MultiStepDeployment
>>> from libcloud.compute.base import NodeAuthSSHKey
>>> driver = DummyNodeDriver(0)
>>> key = NodeAuthSSHKey('...') # read from file
>>> script = ScriptDeployment("yum -y install emacs strace tcpdump")
>>> msd = MultiStepDeployment([key, script])
>>> def d():
...     try:
...         driver.deploy_node(deploy=msd)
...     except NotImplementedError:
...         print ("not implemented for dummy driver")
>>> d()
not implemented for dummy driver

Deploy node is typically not overridden in subclasses. The existing implementation should be able to handle most such.

Parameters:
  • deploy (Deployment) – Deployment to run once machine is online and availble to SSH.
  • ssh_username (str) – Optional name of the account which is used when connecting to SSH server (default is root)
  • ssh_alternate_usernames (list) – Optional list of ssh usernames to try to connect with if using the default one fails
  • ssh_port (int) – Optional SSH server port (default is 22)
  • ssh_timeout (float) – Optional SSH connection timeout in seconds (default is 10)
  • auth (NodeAuthSSHKey or NodeAuthPassword) – Initial authentication information for the node (optional)
  • ssh_key (str or list of str) – A path (or paths) to an SSH private key with which to attempt to authenticate. (optional)
  • timeout (int) – How many seconds to wait before timing out. (default is 600)
  • max_tries (int) – How many times to retry if a deployment fails before giving up (default is 3)
  • ssh_interface (str) – The interface to wait for. Default is ‘public_ips’, other option is ‘private_ips’.
destroy_node(node)[source]

@inherits: NodeDriver.reboot_node :type node: CloudStackNode

Return type:bool
destroy_volume(volume)[source]
Return type:bool
destroy_volume_snapshot(snapshot)

Destroys a snapshot.

Return type:bool
detach_volume(volume)[source]
Return type:bool
ex_allocate_public_ip(location=None)[source]

Allocate a public IP.

Parameters:location (NodeLocation) – Zone
Return type:CloudStackAddress
ex_authorize_security_group_ingress(securitygroupname, protocol, cidrlist, startport, endport=None)[source]

Creates a new Security Group Ingress rule

Parameters:
  • domainid (str) – An optional domainId for the security group. If the account parameter is used, domainId must also be used.
  • startport (int) – Start port for this ingress rule
  • securitygroupid (str) – The ID of the security group. Mutually exclusive with securityGroupName parameter
  • cidrlist (list) – The cidr list associated
  • usersecuritygrouplist (dict) – user to security group mapping
  • securitygroupname (str) – The name of the security group. Mutually exclusive with securityGroupName parameter
  • account (str) – An optional account for the security group. Must be used with domainId.
  • icmpcode (int) – Error code for this icmp message
  • protocol (str) – TCP is default. UDP is the other supported protocol
  • icmptype (int) – type of the icmp message being sent
  • projectid (str) – An optional project of the security group
  • endport (int) – end port for this ingress rule
Return type:

list

ex_create_ip_forwarding_rule(node, address, protocol, start_port, end_port=None)[source]

“Add a NAT/firewall forwarding rule.

Parameters:
  • node (CloudStackNode) – Node which should be used
  • address (CloudStackAddress) – CloudStackAddress which should be used
  • protocol (str) – Protocol which should be used (TCP or UDP)
  • start_port (int) – Start port which should be used
  • end_port (int) – End port which should be used
Return type:

CloudStackForwardingRule

ex_create_keypair(name, **kwargs)[source]

Creates a SSH KeyPair, returns fingerprint and private key

Parameters:
  • name (str) – Name of the keypair (required)
  • projectid (str) – An optional project for the ssh key
  • domainid (str) – An optional domainId for the ssh key. If the account parameter is used, domainId must also be used.
  • account (str) – An optional account for the ssh key. Must be used with domainId.
Returns:

A keypair dictionary

Return type:

dict

ex_create_port_forwarding_rule(node, address, private_port, public_port, protocol, public_end_port=None, private_end_port=None, openfirewall=True)[source]

Creates a Port Forwarding Rule, used for Source NAT

Parameters:
  • address (CloudStackAddress) – IP address of the Source NAT
  • private_port (int) – Port of the virtual machine
  • protocol (str) – Protocol of the rule
  • public_port (int) – Public port on the Source NAT address
  • node (CloudStackNode) – The virtual machine
Return type:

CloudStackPortForwardingRule

ex_create_security_group(name, **kwargs)[source]

Creates a new Security Group

Parameters:
  • name (str) – name of the security group (required)
  • account (str) – An optional account for the security group. Must be used with domainId.
  • domainid (str) – An optional domainId for the security group. If the account parameter is used, domainId must also be used.
  • description (str) – The description of the security group
  • projectid (str) – Deploy vm for the project
Return type:

dict

ex_delete_ip_forwarding_rule(node, rule)[source]

Remove a NAT/firewall forwarding rule.

Parameters:
  • node (CloudStackNode) – Node which should be used
  • rule (CloudStackForwardingRule) – Forwarding rule which should be used
Return type:

bool

ex_delete_keypair(keypair, **kwargs)[source]

Deletes an existing SSH KeyPair

Parameters:
  • keypair (str) – Name of the keypair (required)
  • projectid (str) – The project associated with keypair
  • domainid (str) – The domain ID associated with the keypair
  • account (str) – The account associated with the keypair. Must be used with the domainId parameter.
Returns:

True of False based on success of Keypair deletion

Return type:

bool

ex_delete_port_forwarding_rule(node, rule)[source]

Remove a Port forwarding rule.

Parameters:
  • node (CloudStackNode) – Node used in the rule
  • rule (CloudStackPortForwardingRule) – Forwarding rule which should be used
Return type:

bool

ex_delete_security_group(name)[source]

Deletes a given Security Group

Parameters:
  • domainid (str) – The domain ID of account owning the security group
  • id (str) – The ID of the security group. Mutually exclusive with name parameter
  • name (str) – The ID of the security group. Mutually exclusive with id parameter
  • account (str) – The account of the security group. Must be specified with domain ID
  • projectid (str) – The project of the security group
Return type:

bool

ex_import_keypair(name, keyfile)[source]

Imports a new public key where the public key is passed via a filename

Parameters:
  • name (str) – The name of the public key to import.
  • keyfile (str) – The filename with path of the public key to import.
Return type:

dict

ex_import_keypair_from_string(name, key_material)[source]

Imports a new public key where the public key is passed in as a string

Parameters:
  • name (str) – The name of the public key to import.
  • key_material (str) – The contents of a public key file.
Return type:

dict

ex_list_disk_offerings()[source]

Fetch a list of all available disk offerings.

Return type:list of CloudStackDiskOffering
ex_list_keypairs(**kwargs)[source]

List Registered SSH Key Pairs

Parameters:
  • projectid (str) – list objects by project
  • page (int) – The page to list the keypairs from
  • keyword (str) – List by keyword
  • listall (bool) – If set to false, list only resources belonging to the command’s caller; if set to true - list resources that the caller is authorized to see. Default value is false
  • pagesize (int) – The number of results per page
  • account (str) – List resources by account. Must be used with the domainId parameter
  • isrecursive (bool) – Defaults to false, but if true, lists all resources from the parent specified by the domainId till leaves.
  • fingerprint (str) – A public key fingerprint to look for
  • name (str) – A key pair name to look for
  • domainid (str) – List only resources belonging to the domain specified
Returns:

A list of keypair dictionaries

Return type:

list of dict

ex_list_networks()[source]

List the available networks

:rtype list of CloudStackNetwork

ex_list_port_forwarding_rules()[source]

Lists all Port Forwarding Rules

Return type:list of CloudStackPortForwardingRule
ex_list_public_ips()[source]

Lists all Public IP Addresses.

Return type:list of CloudStackAddress
ex_list_security_groups(**kwargs)[source]

Lists Security Groups

Parameters:
  • domainid (str) – List only resources belonging to the domain specified
  • account (str) – List resources by account. Must be used with the domainId parameter.
  • listall (bool) – If set to false, list only resources belonging to the command’s caller; if set to true list resources that the caller is authorized to see. Default value is false
  • pagesize (int) – Number of entries per page
  • keyword (str) – List by keyword
  • tags (dict) – List resources by tags (key/value pairs)
  • id (str) – list the security group by the id provided
  • securitygroupname (str) – lists security groups by name
  • virtualmachineid (str) – lists security groups by virtual machine id
  • projectid (str) – list objects by project
  • isrecursive (bool) – (boolean) defaults to false, but if true, lists all resources from the parent specified by the domainId till leaves.
  • page (int) – (integer)

:rtype list

ex_register_iso(name, url, location=None, **kwargs)[source]

Registers an existing ISO by URL.

Parameters:
  • name (str) – Name which should be used
  • url (str) – Url should be used
  • location (NodeLocation) – Location which should be used
Return type:

str

ex_release_public_ip(address)[source]

Release a public IP.

Parameters:address (CloudStackAddress) – CloudStackAddress which should be used
Return type:bool
ex_start(node)[source]

Starts/Resumes a stopped virtual machine

Parameters:
  • id (str) – The ID of the virtual machine (required)
  • hostid (str) – destination Host ID to deploy the VM to parameter available for root admin only

:rtype str

ex_stop(node)[source]

Stops/Suspends a running virtual machine

Parameters:node (CloudStackNode) – Node to stop.
Return type:str
import_key_pair_from_file(name, key_file_path)

Import a new public key from string.

Parameters:
  • name (str) – Key pair name.
  • key_file_path (str) – Path to the public key file.
Return type:

KeyPair object

import_key_pair_from_string(name, key_material)[source]

Import a new public key from string.

Parameters:
  • name (str) – Key pair name.
  • key_material (str) – Public key material.
Returns:

Imported key pair object.

Return type:

libcloud.compute.base.KeyPair

list_key_pairs(**kwargs)[source]

List registered key pairs.

Parameters:
  • projectid (str) – list objects by project
  • page (int) – The page to list the keypairs from
  • keyword (str) – List by keyword
  • listall (bool) – If set to false, list only resources belonging to the command’s caller; if set to true - list resources that the caller is authorized to see. Default value is false
  • pagesize (int) – The number of results per page
  • account (str) – List resources by account. Must be used with the domainId parameter
  • isrecursive (bool) – Defaults to false, but if true, lists all resources from the parent specified by the domainId till leaves.
  • fingerprint (str) – A public key fingerprint to look for
  • name (str) – A key pair name to look for
  • domainid (str) – List only resources belonging to the domain specified
Returns:

A list of key par objects.

Return type:

list of libcloud.compute.base.KeyPair

list_locations()[source]

:rtype list of NodeLocation

list_nodes()[source]

@inherits: NodeDriver.list_nodes :rtype: list of CloudStackNode

list_sizes(location=None)[source]

:rtype list of NodeSize

list_volume_snapshots(volume)

List snapshots for a storage volume.

Return type:list of VolumeSnapshot
list_volumes(node=None)[source]

List all volumes

Parameters:node (CloudStackNode) – Only return volumes for the provided node.
Return type:list of StorageVolume
reboot_node(node)[source]

@inherits: NodeDriver.reboot_node :type node: CloudStackNode

Return type:bool
wait_until_running(nodes, wait_period=3, timeout=600, ssh_interface='public_ips', force_ipv4=True)

Block until the provided nodes are considered running.

Node is considered running when it’s state is “running” and when it has at least one IP address assigned.

Parameters:
  • nodes (list of Node) – List of nodes to wait for.
  • wait_period (int) – How many seconds to wait between each loop iteration. (default is 3)
  • timeout (int) – How many seconds to wait before giving up. (default is 600)
  • ssh_interface (str) – Which attribute on the node to use to obtain an IP address. Valid options: public_ips, private_ips. Default is public_ips.
  • force_ipv4 (bool) – Ignore IPv6 addresses (default is True).
Returns:

[(Node, ip_addresses)] list of tuple of Node instance and list of ip_address on success.

Return type:

list of tuple