<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    

    <meta name="author" content="The Apache Software Foundation">

    
      <meta name="keywords" content="news,release announcement" />
    

    
      <title>Libcloud 2.0.0rc2 released | Apache Libcloud</title>
    

    <!-- fav icons -->
    <link rel="shortcut icon" href="/images/favicon.png" />
    <link rel="apple-touch-icon" href="/images/apple-touch-icon.png" />
    <link rel="apple-touch-icon-precomposed" href="/images/apple-touch-icon.png" />

    <link href="/blog/atom.xml" type="application/atom+xml" rel="alternate" title="Apache Libcloud Blog Feed" />

    <!-- Facebook OpenGraph tags -->
    <meta content="Apache Libcloud" property="og:site_name">
    
      <meta content="Libcloud 2.0.0rc2 released" property="og:title">
    

    

    

    
      <meta content="article" property="og:type">
    

    
      <meta content="https://libcloud.apache.org/blog/2017/04/07/libcloud-2-0-0-rc2-released.html" property="og:url">
    
    
      <meta content="2017-04-07T00:00:00+00:00" property="article:published_time">
      <meta content="https://libcloud.apache.org/about.html" property="article:author">
    

    
      
      <meta content="news" property="article:tag">
      
      <meta content="release announcement" property="article:tag">
      
    

    <link href='/assets/global-ed18a3a42c0009b2b40cccc5a72f38fc.css' rel='stylesheet' type='text/css' />
  </head>

  <body data-spy="scroll" data-target=".sidebar-nav" data-offset="80">
    <nav class="navbar navbar-fixed-top navbar-inverse" role="navigation">
      <div class="container">
        <div class="navbar-header">
          <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-ex1-collapse">
            <span class="sr-only">Toggle navigation</span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
          </button>
          <a class="navbar-brand" href="/"><img src="/images/libcloud_logo.png" class="navbar-logo" /> Apache Libcloud</a>
        </div>
        <div class="collapse navbar-collapse navbar-ex1-collapse">
          <ul class="nav navbar-nav">
            
            
              
              <li ><a href="/" >Home</a></li>
            
              
              <li ><a href="/about.html" >About</a></li>
            
              
              <li ><a href="/getting-started.html" >Quick Start</a></li>
            
              
              <li ><a href="https://libcloud.readthedocs.org/en/stable/" target="_blank">Documentation</a></li>
            
              
              <li ><a href="/downloads.html" >Downloads</a></li>
            
              
              <li ><a href="/community.html" >Community</a></li>
            
              
              <li ><a href="/blog/" >Blog</a></li>
            
          </ul>

          <div class="material-switch pull-right">
              <input id="theme-switch" name="theme-switch" type="checkbox" onclick="modeSwitcher()"/>
              <label for="theme-switch" class="label-default"></label>
              <span id="theme-toggle" class="theme-switch">Dark mode</span>
          </div>

        </div><!-- /.navbar-collapse -->
      </div><!-- /.container -->
    </nav>

    <div class="container main-container">
      <div class="row section page-content">
  <div class="col-lg-8 col-lg-offset-2">
    
<div class="post">
  
    <h2>Libcloud 2.0.0rc2 released</h2>
  
  <span class="post-date-author">By Anthony Shaw on Apr 07, 2017</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.0.0rc2.</p>

<p>This release brings many new features, improvements, bug-fixes, and drivers.</p>

<h2 id="release-highlights">Release highlights</h2>

<ul>
  <li>Apache Libcloud 2.0 series replaces the use of Python httplib with a hard dependency on the <code class="language-plaintext highlighter-rouge">requests</code> package. Users’ no longer
have to specific Certificate Authority bundles when using Apache Libcloud</li>
  <li>10% performance improvement through the use of HTTP sessions</li>
  <li>Support for buffered IO streams for storage drivers</li>
  <li>Support for Python 3.6, deprecation of Python 3.2</li>
</ul>

<p>A detailed description of the 2.0 changes is documented <a href="http://libcloud.readthedocs.io/en/latest/other/changes_in_2_0.html">here</a></p>

<p>Note that 2.0.0rc1 was not released to PyPi as 4 breaking issues were discovered by users. The changelog for both 2.0.0rc2 and rc1 is below.</p>

<h2 id="release-highlights-for-200rc2">Release highlights for 2.0.0rc2</h2>

<h3 id="compute">Compute</h3>

<ul>
  <li>Fix a bug in profitbricks driver where listing snapshots would request a malformed URL</li>
  <li>Fix LIBCLOUD-806 bug where vsphere driver cannot be instantiated</li>
  <li>[google compute] Improve performance of list nodes by caching volume information.</li>
</ul>

<h3 id="common">Common</h3>

<ul>
  <li>Fix LIBCLOUD_DEBUG trying to decompress already decompressed responses</li>
  <li>Added an integration test API and a test suite for validating functionality
without mocking any libcloud subsystems</li>
  <li>Fix for Linode classes since 2.0x</li>
  <li>Fix CertificateConnection not correctly signing requests in 2.0rc1, impacted
Azure classic driver, OpenStack and Docker driver</li>
  <li>Change Cloudscale to cloudscale.ch.</li>
  <li>Explicitly check if response is None in RawResponse class</li>
</ul>

<h3 id="compute-1">Compute</h3>

<ul>
  <li>Outscale SAS doc improvements and logo update</li>
  <li>[GCE] Allow preemptible instances to be created</li>
  <li>Add support for forcing detachment of EBS volumes to EC2 driver</li>
  <li>Fix Public IP not assigned when creating NIC on Azure ARM</li>
  <li>[ONAPP] Add list images support for OnApp driver</li>
  <li>[EC2] Add r4 instance types for AWS</li>
  <li>[EC2] support for AWS eu-west-2 and ca-central-1 regions</li>
  <li>[EC2] Add P2 GPU instance types</li>
  <li>[EC2] Add method to modify snapshot attribute for EC2</li>
  <li>[Linode] Add start, stop instance methods and fix incorrect state TERMINATED to STOPPED</li>
  <li>[EC2] Add ENA support for EC2 compute images</li>
  <li>[Azure ARM] fix typeerror on ex_list_nics</li>
  <li>[GCE] allow delete instances from managed group</li>
</ul>

<h3 id="storage">Storage</h3>

<ul>
  <li>Reintroduce S3 multipart upload support with signature v4</li>
</ul>

<h2 id="changes-apache-libcloud-200rc1">Changes Apache Libcloud 2.0.0rc1</h2>

<h3 id="common-1">Common</h3>

<ul>
  <li>Fix DEBUG mode, also add support for using io.StringIO as the file handle when calling libcloud.enable_debug</li>
  <li>Introduction of the requests package as the mechanism for making HTTP requests for all drivers</li>
  <li>Fix bug where custom port and secure flag would not get propagated to connection class</li>
  <li>Fix bug where custom port would not get propagated to connection</li>
  <li>Fix bug where instantiating a connection from URL and then requesting an action with a leading / would lead to
a malformed URL</li>
</ul>

<h3 id="compute-2">Compute</h3>

<ul>
  <li>Fix a bug in profitbricks driver where listing snapshots would request a malformed URL</li>
  <li>Fix LIBCLOUD-806 bug where vsphere driver cannot be instantiated</li>
  <li>[google compute] Improve performance of list nodes by caching volume information.</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="special-thank-you">Special thank you</h3>

<p>I would like to wish a special thank you to all of our community contributors
for their ongoing support to the project.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.0.0rc2
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.0.0rc2
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</a>.</p>


  </div>

  <div class="row section post-meta">
    <div class="col-md-12 post-tags">
      <p>Tags: <a href="/blog/tags/news.html" rel="tag">news</a>, <a href="/blog/tags/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

Share : <a href="https://twitter.com/share" class="twitter-share-button"{count} data-via="libcloud" data-size="large" data-hashtags="cloud">Tweet</a>
<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>

  </div>
</div>


      <hr />

      <footer>
        <div class="row">
          <div class="col-lg-12 text-center">
            <div class="footer-links">
  <p><a href="http://www.apache.org/licenses/">License</a> | <a
  href="/security.html">Security</a> | <a
  href="http://www.apache.org/foundation/sponsorship.html">Sponsorship</a> |
  <a href="http://www.apache.org/foundation/thanks.html">Thanks</a> |
  <a href="/credits.html">Credits</a> | <a href="/media.html">Media</a>
</div>

<div class="footer-text">
  <p class="">Copyright &copy; 2009-2022 <a href="https://www.apache.org/" target="_blank">The Apache Software Foundation</a></p>
  <p class="">Apache Libcloud, Libcloud, Apache, the Apache feather, and the Apache Libcloud project logo are trademarks of the Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners.</p>
  <p class="">Site last updated on 2022-03-30 08:27:56 +0000</p>
</div>

          </div>
        </div>
      </footer>

    </div><!-- /.container -->

    <!-- JavaScript -->
    <script src='/assets/global-23549af89e29254587a07d91b7eb9749.js' type='text/javascript'></script>

    

    <script type="text/javascript">
  var _paq = window._paq = window._paq || [];
  /* tracker methods like "setCustomDimension" should be called before
"trackPageView" */
  /* We explicitly disable cookie tracking to avoid privacy issues */
  _paq.push(['disableCookies']);
  _paq.push(['trackPageView']);
  _paq.push(['enableLinkTracking']);
  (function() {
    var u="https://analytics.apache.org/";
    _paq.push(['setTrackerUrl', u+'matomo.php']);
    _paq.push(['setSiteId', '7']);
    var d=document, g=d.createElement('script'),
s=d.getElementsByTagName('script')[0];
    g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s);
  })();
</script>

  </body>
</html>
