Part of libcloud.compute.drivers.linode View Source View In Hierarchy
libcloud driver for the Linode 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
For more information on the Linode API, be sure to read the reference:
http://www.linode.com/api/
| Method | __init__ | Instantiate the driver with the given API key |
| Method | list_nodes | List all Linodes that the API key can access |
| Method | reboot_node | Reboot the given Linode |
| Method | destroy_node | Destroy the given Linode |
| Method | create_node | Create a new Linode, deploy a Linux distribution, and boot |
| Method | list_sizes | List available Linode plans |
| Method | list_images | List available Linux distributions |
| Method | list_locations | List available facilities for deployment |
| Method | linode_set_datacenter | Set the default datacenter for Linode creation |
| Method | _to_nodes | Convert returned JSON Linodes into Node instances |
Inherited from NodeDriver:
| Method | deploy_node | Create a new node, and start deployment. |
| Method | create_volume | Create a new volume. |
| Method | destroy_volume | Destroys a storage volume. |
| Method | attach_volume | Attaches volume to node. |
| Method | detach_volume | Detaches a volume from a node. |
| Method | wait_until_running | Block until the given nodes are fully booted and have an IP address assigned. |
| Method | _wait_until_running | Undocumented |
| Method | _ssh_client_connect | Try to connect to the remote SSH server. If a connection times out or is refused it is retried up to timeout number of seconds. |
| Method | _run_deployment_script | Run the deployment script on the provided node. At this point it is assumed that SSH connection has already been established. |
| Method | _get_size_price | Undocumented |
Inherited from BaseDriver (via NodeDriver):
| Method | _ex_connection_class_kwargs | Return extra connection keyword arguments which are passed to the Connection class constructor. |
Instantiate the driver with the given API key
@param key: the API key to use (required)
@type key: C{str}
@rtype: C{None}
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.
@return: List of node objects that the API key can access
@rtype: C{list} of L{Node}
Reboot the given Linode
Will issue a shutdown job followed by a boot job, using the last booted
configuration. In most cases, this will be the only configuration.
@param node: the Linode to reboot
@type node: L{Node}
@rtype: C{bool}
Destroy the given Linode
Will remove the Linode from the account and issue a prorated credit. A
grant for removing Linodes from the account is required, otherwise this
method will fail.
In most cases, all disk images must be removed from a Linode before the
Linode can be removed; however, this call explicitly skips those
safeguards. There is no going back from this method.
@param node: the Linode to destroy
@type node: L{Node}
@rtype: C{bool}
Create a new Linode, deploy a Linux distribution, and boot
This call abstracts much of the functionality of provisioning a Linode
and getting it booted. A global grant to add Linodes to the account is
required, as this call will result in a billing charge.
Note that there is a safety valve of 5 Linodes per hour, in order to
prevent a runaway script from ruining your day.
@keyword name: the name to assign the Linode (mandatory)
@type name: C{str}
@keyword image: which distribution to deploy on the Linode (mandatory)
@type image: L{NodeImage}
@keyword size: the plan size to create (mandatory)
@type size: L{NodeSize}
@keyword auth: an SSH key or root password (mandatory)
@type auth: L{NodeAuthSSHKey} or L{NodeAuthPassword}
@keyword location: which datacenter to create the Linode in
@type location: L{NodeLocation}
@keyword ex_swap: size of the swap partition in MB (128)
@type ex_swap: C{int}
@keyword ex_rsize: size of the root partition in MB (plan size - swap).
@type ex_rsize: C{int}
@keyword ex_kernel: a kernel ID from avail.kernels (Latest 2.6 Stable).
@type ex_kernel: C{str}
@keyword ex_payment: one of 1, 12, or 24; subscription length (1)
@type ex_payment: C{int}
@keyword ex_comment: a small comment for the configuration (libcloud)
@type ex_comment: C{str}
@keyword ex_private: whether or not to request a private IP (False)
@type ex_private: C{bool}
@keyword lconfig: what to call the configuration (generated)
@type lconfig: C{str}
@keyword lroot: what to call the root image (generated)
@type lroot: C{str}
@keyword lswap: what to call the swap space (generated)
@type lswap: C{str}
@return: Node representing the newly-created Linode
@rtype: L{Node}
List available Linode plans
Gets the sizes that can be used for creating a Linode. Since available
Linode plans vary per-location, this method can also be passed a
location to filter the availability.
@keyword location: the facility to retrieve plans in
@type location: L{NodeLocation}
@rtype: C{list} of L{NodeSize}
List available Linux distributions
Retrieve all Linux distributions that can be deployed to a Linode.
@rtype: C{list} of L{NodeImage}
List available facilities for deployment
Retrieve all facilities that a Linode can be deployed in.
@rtype: C{list} of L{NodeLocation}
Set the default datacenter for Linode creation
Since Linodes must be created in a facility, this function sets the
default that L{create_node} will use. If a C{location} keyword is not
passed to L{create_node}, this method must have already been used.
@keyword dc: the datacenter to create Linodes in unless specified
@type dc: L{NodeLocation}
@rtype: C{bool}
Convert returned JSON Linodes into Node instances
@keyword objs: C{list} of JSON dictionaries representing the Linodes
@type objs: C{list}
@return: C{list} of L{Node}s