VMware vCloud Driver Documentation¶

API Docs¶

class libcloud.compute.drivers.vcloud.VCloudNodeDriver(key, secret=None, secure=True, host=None, port=None, api_version=None, region=None, **kwargs)[source]¶

vCloud node driver

Parameters:

key (str) – API key or username to be used (required)
secret (str) – Secret password to be used (required)
secure (bool) – Whether to use HTTPS or HTTP. Note: Some providers only support HTTPS, and it is on by default.
host (str) – Override hostname used for connections.
port (int) – Override port used for connections.
api_version (str) – Optional API version. Only used by drivers which support multiple API versions.
region (str) – Optional driver region. Only used by drivers which support multiple regions.

Return type:

None

attach_volume(node, volume, device=None)¶

Attaches volume to node.

Parameters:	node (`Node`) – Node to attach volume to. volume (`StorageVolume`) – Volume to attach. device (`str`) – Where the device is exposed, e.g. ‘/dev/sdb’
Rytpe:	`bool`

connectionCls¶: alias of VCloudConnection

copy_image(source_region, node_image, name, description=None)¶

Copies an image from a source region to the current region.

Parameters:	source_region (`str`) – Region to copy the node from. node_image (`NodeImage`:) – NodeImage to copy. name (`str`) – name for new image. description – description for new image.
Return type:	`NodeImage`:
Returns:	NodeImage instance on success.

create_image(node, name, description=None)¶

Creates an image from a node object.

Parameters:	node (`Node`) – Node to run the task on. name (`description`) – name for new image. description – description for new image.
Return type:	`NodeImage`:
Returns:	NodeImage instance on success.

create_key_pair(name)¶

Create a new key pair object.

Parameters:	name (`str`) – Key pair name.
Return type:	`KeyPair` object

create_node(name, size, image, auth=None, ex_network=None, ex_vdc=None, ex_cpus=1, ex_row=None, ex_group=None)[source]¶

Creates and returns node.

Parameters:	ex_network (`str`) – link to a “Network” e.g., `https://services.vcloudexpress...` ex_vdc (`str`) – Name of organisation’s virtual data center where vApp VMs will be deployed. ex_cpus (`int`) – number of virtual cpus (limit depends on provider)

create_volume(size, name, location=None, snapshot=None)¶

Create a new volume.

Parameters:	size (`int`) – Size of volume in gigabytes (required) name (`str`) – Name of the volume to be created location (`NodeLocation`) – Which data center to create a volume in. If empty, undefined behavior will be selected. (optional) snapshot (`VolumeSnapshot`) – Snapshot from which to create the new volume. (optional)
Returns:	The newly created volume.
Return type:	`StorageVolume`

create_volume_snapshot(volume, name=None)¶

Creates a snapshot of the storage volume.

Parameters:	volume (`StorageVolume`) – The StorageVolume to create a VolumeSnapshot from name (str) – Name of created snapshot (optional)
Return type:	`VolumeSnapshot`

delete_image(node_image)¶

Deletes a node image from a provider.

Parameters:	node_image (`NodeImage`) – Node image object.
Returns:	`True` if delete_image was successful, `False` otherwise.
Return type:	`bool`

delete_key_pair(key_pair)¶

Delete an existing key pair.

Parameters:	key_pair (`KeyPair`) – Key pair object.
Return type:	`bool`

deploy_node(deploy, ssh_username='root', ssh_alternate_usernames=None, ssh_port=22, ssh_timeout=10, ssh_key=None, auth=None, timeout=300, max_tries=3, ssh_interface='public_ips', **create_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 available 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]¶

Destroy a node.

Depending upon the provider, this may destroy all data associated with the node, including backups.

Parameters:	node (`Node`) – The node to be destroyed
Returns:	True if the destroy was successful, False otherwise.
Return type:	`bool`

destroy_volume(volume)¶

Destroys a storage volume.

Parameters:	volume (`StorageVolume`) – Volume to be destroyed
Return type:	`bool`

destroy_volume_snapshot(snapshot)¶

Destroys a snapshot.

Parameters:	snapshot (`VolumeSnapshot`) – The snapshot to delete
Return type:	`bool`

detach_volume(volume)¶

Detaches a volume from a node.

Parameters:	volume (`StorageVolume`) – Volume to be detached
Return type:	`bool`

ex_list_nodes(vdcs=None)[source]¶

List all nodes across all vDCs. Using ‘vdcs’ you can specify which vDCs should be queried.

Parameters:	vdcs (`Vdc`) – None, vDC or a list of vDCs to query. If None all vDCs will be queried.
Return type:	`list` of `Node`

get_image(image_id)¶

Returns a single node image from a provider.

Parameters:	image_id (`str`) – Node to run the task on.

:rtype NodeImage: :return: NodeImage instance on success.

get_key_pair(name)¶

Retrieve a single key pair.

Parameters:	name (`str`) – Name of the key pair to retrieve.
Return type:	`KeyPair`

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)¶

Import a new public key from string.

Parameters:	name (`str`) – Key pair name. key_material (`str`) – Public key material.
Return type:	`KeyPair` object

list_images(location=None)[source]¶

List images on a provider.

Parameters:	location (`NodeLocation`) – The location at which to list images.
Returns:	list of node image objects.
Return type:	`list` of `NodeImage`

list_key_pairs()¶

List all the available key pair objects.

Return type:	`list` of `KeyPair` objects

list_locations()¶

List data centers for a provider

Returns:	list of node location objects
Return type:	`list` of `NodeLocation`

list_nodes()[source]¶

List all nodes.

Returns:	list of node objects
Return type:	`list` of `Node`

list_sizes(location=None)[source]¶

List sizes on a provider

Parameters:	location (`NodeLocation`) – The location at which to list sizes
Returns:	list of node size objects
Return type:	`list` of `NodeSize`

list_volume_snapshots(volume)¶

List snapshots for a storage volume.

Return type:	`list` of `VolumeSnapshot`

list_volumes()¶

List storage volumes.

Return type:	`list` of `StorageVolume`

reboot_node(node)[source]¶

Reboot a node.

Parameters:	node (`Node`) – The node to be rebooted
Returns:	True if the reboot was successful, otherwise False
Return type:	`bool`

start_node(node)¶

Start a node.

Parameters:	node (`Node`) – The node to be started
Returns:	True if the start was successful, otherwise False
Return type:	`bool`

stop_node(node)¶

Stop a node

Parameters:	node (`Node`) – The node to be stopped.
Returns:	True if the stop was successful, otherwise False
Return type:	`bool`

vdcs¶

vCloud virtual data centers (vDCs).

Returns:	list of vDC objects
Return type:	`list` of `Vdc`

wait_until_running(nodes, wait_period=3, timeout=600, ssh_interface='public_ips', force_ipv4=True, ex_list_nodes_kwargs=None)¶

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). ex_list_nodes_kwargs (`dict`) – Optional driver-specific keyword arguments which are passed to the `list_nodes` method.
Returns:	`[(Node, ip_addresses)]` list of tuple of Node instance and list of ip_address on success.
Return type:	`list` of `tuple`