Cloudwatt Compute Driver Documentation

RunAbove is a public cloud offer created by OVH Group with datacenters in North America and Europe.

../../_images/runabove.png

RunAbove driver uses the OVH/RunAbove API so for more information about that, please refer to RunAbove knowledge base page and API console.

Instantiating a driver

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

  • user_id - Application key
  • secret - Application secret
  • ex_consumer_key - Consumer key

For get application key and secret, you must first register an application at https://api.runabove.com/createApp/. Next step, create a consumer key with following command:

curl -X POST \
    -H 'X-Ra-Application: youApplicationKey' \
    -H 'Content-Type: application/json' \
    -d '{
        "accessRules":
            [
                {"method":"GET","path":"/*"},
                {"method":"POST","path":"/*"},
                {"method":"DELETE","path":"/*"},
                {"method":"PUT","path":"/*"},
            ],
            "redirection":"http://runabove.com"
        }' \
    "https://api.runabove.com/1.0/auth/credential"

This will answer a JSON like below with inside your Consumer Key and validationUrl. Follow this link for valid your key.

{
  "validationUrl":"https://api.runabove.com/login/?credentialToken=fIDK6KCVHfEMuSTP3LV84D3CsHTq4T3BhOrmEEdd2hQ0CNcfVgGVWZRqIlolDJ3W",
  "consumerKey":"y7epYeHCIqoO17BzBgxluvB4XLedpba9",
  "state":"pendingValidation"
}

Now you have and can use you credentials with Libcloud.

Examples

Create instance

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

RunAbove = get_driver(Provider.RUNABOVE)
driver = RunAbove('yourAppKey', 'yourAppSecret', 'YourConsumerKey')

image = [i for i in driver.list_images() if 'Debian 8' == i.name][0]
size = [s for s in driver.list_sizes() if s.name == 'ra.s'][0]
location = [l for l in driver.list_locations() if l.id == 'SBG-1'][0]

node = driver.create_node(name='yournode', size=size, image=image,
                          location=location)

API Docs

class libcloud.compute.drivers.runabove.RunAboveNodeDriver(key, secret, ex_consumer_key=None)[source]

Libcloud driver for the RunAbove API

Rough mapping of which is which:

list_nodes linode.list reboot_node linode.reboot destroy_node linode.delete create_node linode.create, linode.update,

linode.disk.createfromdistribution, linode.disk.create, linode.config.create, linode.ip.addprivate, linode.boot

list_sizes avail.linodeplans list_images avail.distributions list_locations avail.datacenters list_volumes linode.disk.list destroy_volume linode.disk.delete

For more information on the Linode API, be sure to read the reference:

Instantiate the driver with the given API key

Parameters:key (str) – the API key to use (required)
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 RunAboveConnection

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.
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 (VolumeSnapshot) – 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(name, location)[source]

Delete an existing key pair.

Parameters:key_pair (:class.KeyPair` or int) – Key pair object or ID.
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 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_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
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, location)[source]

Import a new public key.

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

Imported key pair object.

Return type:

KeyPair

list_images(location=None, size=None)[source]

List available Linux distributions

Retrieve all Linux distributions that can be deployed to a Linode.

Return type:list of NodeImage
list_locations()[source]

List available facilities for deployment

Retrieve all facilities that a Linode can be deployed in.

Return type:list of NodeLocation
list_nodes(location=None)[source]

List all Linodes that the API key can access

This call will return all Linodes that the API key in use has access to. If a node is in this list, rebooting will work; however, creation and destruction are a separate grant.

Returns:List of node objects that the API key can access
Return type:list of Node
list_sizes(location=None)[source]

List available RunAbove flavors.

Parameters:location (NodeLocation) – the facility to retrieve plans in
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)

Reboot a node.

Parameters:node (Node) – The node to be rebooted
Returns:True if the reboot was successful, otherwise False
Return type:bool
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