Upgrade Notes

This page describes how to upgrade from a previous version to a new versionwhich contains backward incompatible or semi-incompatible changes and how topreserve the old behavior when this is possible.

Libcloud 2.7.0

  • AWS S3 driver has moved from “driver class per region” model to “single driverclass with region constructor argument” model. This means this driver nowfollows the same approach as other multi region drivers.

Before:

  1.   from libcloud.storage.types import Provider
  2.   from libcloud.storage.providers import get_driver
  3.  
  4.   S3_EU_CENTRAL = get_driver(Provider.S3_EU_CENTRAL)
  5.   S3_EU_WEST_1 = get_driver(Provider.S3_EU_WEST)
  6.  
  7.   driver_eu_central = S3_EU_CENTRAL('api key', 'api secret')
  8.   driver_eu_west_1 = S3_EU_WEST_1('api key', 'api secret')
  9.  
  10. After:
  1.   from libcloud.storage.types import Provider
  2.   from libcloud.storage.providers import get_driver
  3.  
  4.   S3 = get_driver(Provider.S3)
  5.  
  6.   driver_eu_central = S3('api key', 'api secret', region='eu-central-1')
  7.   driver_eu_west_1 = S3('api key', 'api secret', region='eu-west-1')
  8.  
  9. For now, old approach will still work, but it will be deprecated and fully
  10. removed in a future release. Deprecation and removal will be announced well in
  11. advance.
  • New start_node and stop_node methods have been added to the baseLibcloud compute API NodeDriver class.

A lot of the existing compute drivers already implemented that functionalityvia extension methods (ex_start_node, ex_stop_node) so it was decidedto promote those methods to be part of the standard Libcloud compute API andupdate all the affected drivers.

For backward compatibility reasons, existing ex_start and ex_stop_nodemethods will still work until a next major release.

If you are relying on code which uses exstart and ex_stop_nodemethods, you are encouraged to update it to utilize new start_node andstop_node methods since those ex methods are now deprecated and willbe removed in a future major release.

Libcloud 1.0.0

  • Per-region provider constants and related driver classes which have beendeprecated in Libcloud 0.14.0 have now been fully removed.

Those provider drivers have moved to the single provider constant +region constructor argument in Libcloud 0.14.0.

Libcloud 0.20.0

  • New optional ttl argument has been added to libcloud.dns.base.Recordclass constructor before the existing extra argument.

If you have previously manually instantiated this class and didn’t usekeyword arguments, you need to update your code to correctly pass argumentsto the constructor (you are encouraged to use keyword arguments to avoid suchissues in the future).

  • All NodeState, StorageVolumeState, VolumeSnapshotState and Provider attributesare now strings instead of integers.

If you are using the tostring and fromstring methods of NodeState,you are fine. If you are using NodeState.RUNNING and the like, you are also fine.

However, if you have previously depended on these being integers,you need to update your code to depend on strings. You should consider startingusing the tostring and fromstring methods as the output of these functionswill not change in future versions, while the implementation might.

Libcloud 0.19.0

  • The base signature of NodeDriver.create_volume has changed. The snapshotargument is now expected to be a VolumeSnapshot instead of a string.The older signature was never correct for built-in drivers, but customdrivers may break. (GCE accepted strings, names or None and still does.Other drivers did not implement creating volumes from snapshots at alluntil now.)
  • VolumeSnapshots now have a created attribute that is a _datetime_field showing the creation datetime of the snapshot. The field inVolumeSnapshot.extra containing the original string is maintained, sothis is a backwards-compatible change.
  • The OpenStack compute driver methods ex_create_snapshot andex_delete_snapshot are now deprecated by the standard methodscreate_volume_snapshot and destroy_volume_snapshot. You should update yourcode.
  • The compute base driver now considers the name argument tocreate_volume_snapshot to be optional. All official implementations of thismethods already considered it optional. You should update any customdrivers if they rely on the name being mandatory.

Libcloud 0.16.0

Changes in the OpenStack authentication and service catalog classes

Note

If you are only working with the driver classes and have never dorectlytouched the classes mentioned below, then you aren’t affected and thosechanges are fully backward compatible.

To make OpenStack authentication and identity related classes more extensible,easier to main and easier to use, those classes have been refactored. All ofthe changes are described below.

  • New libcloud.common.openstack_identity module has been added. This modulecontains code for working with OpenStack Identity (Keystone) service.
  • OpenStackAuthConnection class has been removed and replaced with oneconnection class per Keystone API version(OpenStackIdentity_1_0_Connection, OpenStackIdentity_2_0_Connection,OpenStackIdentity_3_0_Connection).
  • New get_auth_class method has been added to OpenStackBaseConnectionclass. This method allows you to retrieve an instance of the authenticationclass which is used with the current connection.
  • OpenStackServiceCatalog class has been refactored to store parsed catalogentries in a structured format (OpenStackServiceCatalogEntry andOpenStackServiceCatalogEntryEndpoint class). Previously entries werestored in an unstructured form in a dictionary. All the catalog entries canbe retrieved by using OpenStackServiceCatalog.get_entris method.
  • ex_force_auth_version argument in OpenStackServiceCatalog constructormethod has been renamed to auth_version
  • get_regions, get_service_types and get_service_names methods onthe OpenStackServiceCatalog class have been modified to always return theresult in the same order (result values are sorted beforehand).

For more information and examples, please refer to theLibcloud now supports OpenStack Identity (Keystone) API v3 blog post.

Libcloud 0.14.1

Fix record name inconsistencies in the Rackspace DNS driver

Record.name attribute is now correctly set to None for records whichrefer to the bare domain name. Previously, Record.name attribute for suchrecords was set to the domain name.

For example, lets have a look at a record which points to the domainexample.com.

New Record.name attribute value for such record: None

Old Record.name attribute value for such record: example.com

This was done to make the Rackspace driver consistent with the other ones.

Libcloud 0.14.0

To make drivers with multiple regions easier to use, one of the big changes inthis version is move away from the old “one class per region” model to a newsingle class plus region argument model.

More information on how this affects existing drivers and your code can befound below.

Default Content-Type is now provided if none is supplied and none can be guessed

In older versions, Libcloud would throw an exception when a content type is notsupplied and none can’t be automatically detected when uploading an object.

This has changed with the 0.14.0 release. Now if no content type is specifiedand none can’t be detected, a default content type ofapplication/octet-stream is used.

If you want to preserve the old behavior, you can set strict_mode attributeon the driver object to True.

  1. from libcloud.storage.types import Provider
  2. from libcloud.stoage.providers import get_driver
  3.  
  4. cls = get_driver(Provider.CLOUDFILES)
  5. driver = cls('username', 'api key')
  6.  
  7. driver.strict_mode = True

If you are not using strict mode and you are uploading a binary object, westill encourage you to practice Python’s “explicit is better than implicit”mantra and explicitly specify Content-Type of application/octet-stream.

SSH Key pair management functionality has been promoted to the base API

SSH key pair management functionality has been promoted to be a part of thebase compute API.

As such, the following new classes and methods have been added:

  • libcloud.compute.base.KeyPair
  • libcloud.compute.base.NodeDriver.list_key_pairs
  • libcloud.compute.base.NodeDriver.create_key_pair
  • libcloud.compute.base.NodeDriver.import_key_pair_from_string
  • libcloud.compute.base.NodeDriver.import_key_pair_from_file
  • libcloud.compute.base.NodeDriver.delete_key_pair

Previously, this functionality was available in some of the provider drivers(CloudStack, EC2, OpenStack) via the following extension methods:

  • ex_list_keypairs
  • ex_create_keypair
  • ex_import_keypair_from_string
  • ex_import_keypair
  • ex_delete_keypair

Existing extension methods will continue to work until the next major release,but you are strongly encouraged to start using new methods which are now partof the base compute API and are guaranteed to work the same across differentproviders.

New default kernel versions used when creating Linode servers

Kernel versions which are used by default when creating Linode servers have beenupdated.

Old default kernel versions:

  • x86 (no paravirt-ops) - 2.6.18.8-x86_64-linode1 (#60)
  • x86 (paravirt-ops) - 2.6.18.8-x86_64-linode1 (#110)
  • x86_64 (no paravirt-ops) - 2.6.39.1-linode34 (#107)
  • x86 (paravirt-ops)64 - 2.6.18.8-x86_64-linode1 (#111)

New default kernel versions:

  • x86 - 3.9.3-x86-linode52 (#137)
  • x86_64 - 3.9.3-x86_64-linode33 (#138)

Those new kernel versions now come with paravirt-ops by default.

If you want to preserve the old behavior, you can pass ex_kernel argument tothe create_node method.

Keep in mind that using old kernels is strongly discouraged since they containknown security holes.

For example:

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls = get_driver(Provider.LINODE)
  5.  
  6. driver = cls('username', 'api_key')
  7. driver.create_node(..., ex_kernel=110)

Addition of new “STOPPED” node state

This version includes a new state calledlibcloud.compute.types.NodeState.STOPPED. This state represents a nodewhich has been stopped and can be started later on (unlike TERMINATED statewhich represents a node which has been terminated and can’t be started lateron).

As such, EC2 and HostVirual drivers have also been updated to recognizethis new state.

Before addition of this state, nodes in this state were mapped toNodeState.UNKNOWN.

Amazon EC2 compute driver changes

Amazon EC2 compute driver has moved to single class plus region argumentmodel. As such, the following provider constants have been deprecated:

  • EC2_US_EAST
  • EC2_US_WEST_OREGON
  • EC2_EU
  • EC2_EU_WEST
  • EC2_AP_SOUTHEAST
  • EC2_AP_SOUTHEAST2
  • EC2_AP_NORTHEAST
  • EC2_SA_EAST

And replaced with a single constant:

  • EC2 - Supported values for the region argument are: us-east-1,us-west-1, us-west-2, eu-west-1, ap-southeast-1,ap-northeast-1, sa-east-1, ap-southeast-2. Default value isus-east-1.

List which shows how old classes map to a new region argument value:

  • EC2_US_EAST -> us-east-1
  • EC2_US_WEST -> us-west-1
  • EC2_US_WEST_OREGON -> us-west-2
  • EC2_EU -> eu-west-1
  • EC2_EU_WEST -> eu-west-1
  • EC2_AP_SOUTHEAST -> ap-southeast-1
  • EC2_AP_SOUTHEAST2 -> ap-southeast-2
  • EC2_AP_NORTHEAST -> ap-northeast-1
  • EC2_SA_EAST -> sa-east-1

Old code:

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls1 = get_driver(Provider.EC2)
  5. cls2 = get_driver(Provider.EC2_EU_WEST)
  6.  
  7. driver1 = cls('username', 'api_key')
  8. driver2 = cls('username', 'api_key')

New code:

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls = get_driver(Provider.EC2)
  5.  
  6. driver1 = cls('username', 'api_key', region='us-east-1')
  7. driver2 = cls('username', 'api_key', region='eu-west-1')

Rackspace compute driver changes

Rackspace compute driver has moved to single class plus region argumentmodel. As such, the following provider constants have been removed:

  • RACKSPACE
  • RACKSPACE_UK
  • RACKSPACE_AU
  • RACKSPACE_NOVA_ORD
  • RACKSPACE_NOVA_DFW
  • RACKSPACE_NOVA_LON
  • RACKSPACE_NOVA_BETA

And replaced with two new constants:

  • RACKSPACE_FIRST_GEN - Supported values for region argument are: us, uk.Default value is us.
  • RACKSPACE - Supported values for the region argument are:dfw, ord, iad, lon, syd, hkg.Default value is dfw.

Besides that, RACKSPACE provider constant now defaults to next-generationOpenStack based servers. Previously it defaulted to first generation cloudservers.

If you want to preserve old behavior and use first-gen drivers you need to useRACKSPACE_FIRST_GEN provider constant.

First generation cloud servers now also use auth 2.0 by default. Previously theyused auth 1.0.

Because of the nature of this first-gen to next-gen change, old constants havebeen fully removed and unlike region changes in other driver, this change is notbackward compatible.

List which shows how old, first-gen classes map to a new region argumentvalue:

  • RACKSPACE -> us
  • RACKSPACE_UK -> uk

List which shows how old, next-gen classes map to a new region argumentvalue:

  • RACKSPACE_NOVA_ORD -> ord
  • RACKSPACE_NOVA_DFW -> dfw
  • RACKSPACE_NOVA_LON -> lon
  • RACKSPACE_AU -> syd

More examples which show how to update your code to work with a new version canbe found below.

Old code (connecting to a first-gen provider):

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls1 = get_driver(Provider.RACKSPACE) # US regon
  5. cls2 = get_driver(Provider.RACKSPACE_UK) # UK regon
  6.  
  7. driver1 = cls('username', 'api_key')
  8. driver2 = cls('username', 'api_key')

New code (connecting to a first-gen provider):

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls = get_driver(Provider.RACKSPACE_FIRST_GEN)
  5.  
  6. driver1 = cls('username', 'api_key', region='us')
  7. driver2 = cls('username', 'api_key', region='uk')

Old code (connecting to a next-gen provider)

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls1 = get_driver(Provider.RACKSPACE_NOVA_ORD)
  5. cls2 = get_driver(Provider.RACKSPACE_NOVA_DFW)
  6. cls3 = get_driver(Provider.RACKSPACE_NOVA_LON)
  7.  
  8. driver1 = cls('username', 'api_key')
  9. driver2 = cls('username', 'api_key')
  10. driver3 = cls('username', 'api_key')

New code (connecting to a next-gen provider)

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls = get_driver(Provider.RACKSPACE)
  5.  
  6. driver1 = cls('username', 'api_key', region='ord')
  7. driver2 = cls('username', 'api_key', region='dfw')
  8. driver3 = cls('username', 'api_key', region='lon')

CloudStack compute driver changes

CloudStack driver received a lot of changes and additions which will make itmore pleasant to use. Backward incompatible changes are listed below:

  • CloudStackForwardingRule class has been renamed toCloudStackIPForwardingRule
  • create_node method arguments are now more consistent with other drivers.Security groups are now passed as ex_security_groups, SSH keypairsare now passed as ex_keyname and userdata is now passed asex_userdata.
  • For advanced networking zones, multiple networks can now be passed to thecreate_node method instead of a single network id. These networks needto be instances of the CloudStackNetwork class.
  • The extra_args argument of the create_node method has been removed.The only arguments accepted are now the defaults name, size,image, location plus ex_keyname, ex_userdata,ex_security_groups and networks.

Joyent compute driver changes

Joyent driver has been aligned with other drivers and now the constructor takesregion instead of location argument.

For backward compatibility reasons, old argument will continue to work until thenext major release.

Old code:

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls = get_driver(Provider.JOYENT)
  5.  
  6. driver = cls('username', 'api_key', location='us-east-1')

Old code:

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls = get_driver(Provider.JOYENT)
  5.  
  6. driver = cls('username', 'api_key', region='us-east-1')

ElasticHosts compute driver changes

ElasticHosts compute driver has moved to single class plus region argumentmodel. As such, the following provider constants have been deprecated:

  • ELASTICHOSTS_UK1
  • ELASTICHOSTS_UK1
  • ELASTICHOSTS_US1
  • ELASTICHOSTS_US2
  • ELASTICHOSTS_US3
  • ELASTICHOSTS_CA1
  • ELASTICHOSTS_AU1
  • ELASTICHOSTS_CN1

And replaced with a single constant:

  • ELASTICHOSTS - Supported values for the region argument are:lon-p, lon-b, sat-p, lax-p, sjc-c, tor-p, syd-y,cn-1 Default value is sat-p.

List which shows how old classes map to a new region argument value:

  • ELASTICHOSTS_UK1 -> lon-p
  • ELASTICHOSTS_UK1 -> lon-b
  • ELASTICHOSTS_US1 -> sat-p
  • ELASTICHOSTS_US2 -> lax-p
  • ELASTICHOSTS_US3 -> sjc-c
  • ELASTICHOSTS_CA1 -> tor-p
  • ELASTICHOSTS_AU1 -> syd-y
  • ELASTICHOSTS_CN1 -> cn-1

Because of this change main driver class has also been renamed fromlibcloud.compute.drivers.elastichosts.ElasticHostsBaseNodeDriverto libcloud.compute.drivers.elastichosts.ElasticHostsNodeDriver.

Only users who directly instantiate a driver and don’t use recommendedget_driver method are affected by this change.

Old code:

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls1 = get_driver(Provider.ELASTICHOSTS_UK1)
  5. cls2 = get_driver(Provider.ELASTICHOSTS_US2)
  6.  
  7. driver1 = cls('username', 'api_key')
  8. driver2 = cls('username', 'api_key')

New code:

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls = get_driver(Provider.ELASTICHOSTS)
  5.  
  6. driver1 = cls('username', 'api_key', region='lon-p')
  7. driver2 = cls('username', 'api_key', region='lax-p')

Unification of extension arguments for security group handling in the EC2 driver

To unify extension arguments for handling security groups between drivers,ex_securitygroup argument in the EC2 create_node method has beenrenamed to ex_security_groups.

For backward compatibility reasons, old argument will continue to work foruntil a next major release.

CloudFiles Storage driver changes

CLOUDFILES_US and CLOUDFILES_UK provider constants have been deprecatedand a new CLOUDFILES constant has been added.

User can now use this single constant and specify which region to use bypassing region argument to the driver constructor.

Old code:

  1. from libcloud.storage.types import Provider
  2. from libcloud.storage.providers import get_driver
  3.  
  4. cls1 = get_driver(Provider.CLOUDFILES_US)
  5. cls2 = get_driver(Provider.CLOUDFILES_UK)
  6.  
  7. driver1 = cls1('username', 'api_key')
  8. driver2 = cls1('username', 'api_key')

New code:

  1. from libcloud.compute.types import Provider
  2. from libcloud.compute.providers import get_driver
  3.  
  4. cls = get_driver(Provider.CLOUDFILES)
  5.  
  6. driver1 = cls1('username', 'api_key', region='dfw')
  7. driver2 = cls1('username', 'api_key', region='lon')

Rackspace DNS driver changes

Rackspace DNS driver has moved to one class plus region argument model. Assuch, the following provider constants have been deprecated:

  • RACKSPACE_US
  • RACKSPACE_UK

And replaced with a single constant:

  • RACKSPACE - Supported values for region arguments are us, uk.Default value is us.

Old code:

  1. from libcloud.dns.types import Provider
  2. from libcloud.dns.providers import get_driver
  3.  
  4. cls1 = get_driver(Provider.RACKSPACE_US)
  5. cls2 = get_driver(Provider.RACKSPACE_UK)
  6.  
  7. driver1 = cls1('username', 'api_key')
  8. driver2 = cls1('username', 'api_key')

New code:

  1. from libcloud.dns.types import Provider
  2. from libcloud.dns.providers import get_driver
  3.  
  4. cls = get_driver(Provider.RACKSPACE)
  5.  
  6. driver1 = cls1('username', 'api_key', region='us')
  7. driver2 = cls1('username', 'api_key', region='uk')

Rackspace load balancer driver changes

Rackspace loadbalancer driver has moved to one class plus region argumentmodel. As such, the following provider constants have been deprecated:

  • RACKSPACE_US
  • RACKSPACE_UK

And replaced with a single constant:

  • RACKSPACE - Supported values for region arguments are dfw,ord, iad, lon, syd, hkg. Default value is dfw.

Old code:

  1. from libcloud.loadbalancer.types import Provider
  2. from libcloud.loadbalancer.providers import get_driver
  3.  
  4. cls1 = get_driver(Provider.RACKSPACE_US)
  5. cls2 = get_driver(Provider.RACKSPACE_UK)
  6.  
  7. driver1 = cls1('username', 'api_key')
  8. driver2 = cls1('username', 'api_key')

New code:

  1. from libcloud.loadbalancer.types import Provider
  2. from libcloud.loadbalancer.providers import get_driver
  3.  
  4. cls = get_driver(Provider.RACKSPACE)
  5.  
  6. driver1 = cls1('username', 'api_key', region='ord')
  7. driver2 = cls1('username', 'api_key', region='lon')

ScriptDeployment and ScriptFileDeployment constructor now takes args argument

libcloud.compute.deployment.ScriptDeployment andlibcloud.compute.deployment.ScriptFileDeployment class constructor nowtake args as a second argument.

Previously this argument was not present and the second argument was name.

If you have a code which instantiate those classes directly and passes two ormore arguments (not keyword arguments) to the constructor you need to updateit to preserve the old behavior.

Old code:

  1. sd = ScriptDeployment('#!/usr/bin/env bash echo "ponies!"', 'ponies.sh')

New code:

  1. sd = ScriptDeployment('#!/usr/bin/env bash echo "ponies!"', None,
  2.                       'ponies.sh')

Even better (using keyword arguments):

  1. sd = ScriptDeployment(script='#!/usr/bin/env bash echo "ponies!"',
  2.                       name='ponies.sh')

Pricing data changes

By default this version of Libcloud tries to read pricing data from the~/.libcloud/pricing.json file. If this file doesn’t exist, Libcloud fallsback to the old behavior and the pricing data is read from the pricing filewhich is shipped with each release.

For more information, please see Using a custom pricing file page.

RecordType ENUM value is now a string

libcloud.dns.types.RecordType ENUM value used be an integer, but fromthis version on, it’s now a string. This was done to make it simpler and removeunnecessary indirection.

If you use RecordType class in your code as recommended, no changes arerequired, but if you use integer values directly, you need to update yourcode to use RecordType class otherwise it will break.

OK:

  1. # ...
  2. record = driver.create_record(name=www, zone=zone, type=RecordType.A,
  3.                               data='127.0.0.1')

Not OK:

  1. # ...
  2. record = driver.create_record(name=www, zone=zone, type=0,
  3.                               data='127.0.0.1')

Cache busting functionality is now only enabled in Rackspace first-gen driver

Cache busting functionality has been disabled in the Rackspace next-gen driverand all of the OpenStack drivers. It’s now only enabled in the Rackspacefirst-gen driver.

Cache busting functionality works by appending a random query parameter toevery GET HTTP request. It was originally added to the Rackspace first-gendriver a long time ago to avoid excessive HTTP caching on the provider side.This excessive caching some times caused list_nodes and other calls to returnstale data.

This approach should not be needed with Rackspace next-gen and OpenStack driversso it has been disabled.

No action is required on the user’s side.

libcloud.security.VERIFY_SSL_CERT_STRICT variable has been removed

libcloud.security.VERIFY_SSL_CERT_STRICT variable has been introduced inversion 0.4.2 when we initially added support for SSL certificate verification.This variable was added to ease the migration from older versions of Libcloudwhich didn’t verify SSL certificates.

In version 0.6.0, this variable has been set to True by default anddeprecated.

In this release, this variable has been fully removed. For more informationon how SSL certificate validation works in Libcloud, see the SSLCertificate Validation page.

get_container method changes in the S3 driver

Previously, the get_container method in the S3 driver used a veryinefficient approach of using list_containers + late filterting.

The code was changed to use a more efficient approach which means usinga single HTTP HEAD request.

The only downside of this approach is that it doesn’t return containercreation date.

If you need the container creation date, you should use list_containersmethod and do the later filtering yourself.

Libcloud 0.8

  • restart_node method has been removed from the OpenNebula compute driver,because OpenNebula OCCI implementation does not support a proper restartmethod.
  • ex_save_image method in the OpenStack driver now returns a NodeImageinstance.

For a full list of changes, please see the CHANGES file.

Libcloud 0.7

  • For consistency, public_ip and private_ip attribute on the Nodeobject have been renamed to public_ips and private_ips respectively.

In 0.7 you can still access those attributes using the old way, but this optionwill be removed in the next major release.

Note: If you have places in your code where you directly instantiate aNode class, you need to update it.

Old code:

  1. node = Node(id='1', name='test node', state=NodeState.PENDING,
  2.             private_ip=['10.0.0.1'], public_ip=['88.77.66.77'],
  3.             driver=driver)

Updated code:

  1. node = Node(id='1', name='test node', state=NodeState.PENDING,
  2.             private_ips=['10.0.0.1'], public_ips=['88.77.66.77'],
  3.             driver=driver)
  • Old deprecated paths have been removed. If you still haven’t updated yourcode you need to do it now, otherwise it won’t work with 0.7 and futurereleases.

Below is a list of old paths and their new locations:

  • libcloud.base -> libcloud.compute.base
  • libcloud.deployment -> libcloud.compute.deployment
  • libcloud.drivers. -> libcloud.compute.drivers.
  • libcloud.ssh -> libcloud.compute.ssh
  • libcloud.types -> libcloud.compute.types
  • libcloud.providers -> libcloud.compute.providers

In the contrib/ directory you can also find a simple bash script which canperform a search and replace for you - migrate_paths.py.

For a full list of changes, please see the CHANGES file.

Libcloud 0.6

  • SSL certificate verification is now enabled by default and an exception isthrown if CA certificate files cannot be found.

To revert to the old behavior, set libcloud.security.VERIFY_SSL_CERT_STRICTvariable to False:

  1. libcloud.security.VERIFY_SSL_CERT_STRICT = False

Note: You are strongly discouraged from disabling SSL certificate validation.If you disable it and no CA certificates files are found on the system you arevulnerable to a man-in-the-middle attack

More information on how to acquire and install CA certificate files ondifferent operating systems can be found on SSL Certificate Validationpage

  • OpenStack driver now defaults to using OpenStack 1.1 API.

To preserve the old behavior and use OpenStack 1.0 API, passapi_version='1.0' keyword argument to the driver constructor.

For example:

  1. Cls = get_provider(Provider.OPENSTACK)
  2. driver = Cls('user_name', 'api_key', False, 'host', 8774, api_version='1.0')
  • OpenNebula driver now defaults to using OpenNebula 3.0 API

To preserve the old behavior and use OpenNebula 1.4 API, passapi_version='1.4' keyword argument to the driver constructor.

For example:

  1. Cls = get_provider(Provider.OPENNEBULA)
  2. driver = Cls('key', 'secret', api_version='1.4')

For a full list of changes, please see the CHANGES file.